IntelliJ IDEA 개발 웹 응용 프로그램 데이터 삭제 수정

98141 단어
본문은 두 부분으로 나뉜다.Intellij Idea 웹 응용 프로그램 만들기;2. 삭제 수정이 가능한 WEB 응용 프로그램을 개발하여 로컬 서버에 배치한다.
     ：
        Intellij IDE
        JDK
        Tomcat
        Mysql
        Navicat for MySQL
         
         jar （c3p0，commons-beanutils，commons-collections，commons-dbutils，commons-logging，jstl，mchange-commons-java，mysql-connector-java）

새로 만들기 및 구성 프로젝트


File -> New Project -> 프로젝트 이름 "Demos"를 입력하고 Project SDK를 1.7 -> Next -> Finish로 선택합니다.
마우스 포인터에서 프로젝트 이름 demos -> 마우스 오른쪽 버튼으로 New 를 선택하고 Module -> 입력 Module 이름 "firstweb"-> 클릭 Next-> "Web Application"-> "Create web.xml"-> Finish 를 선택합니다.
웹/WEB-INF에서 두 개의 폴더를 만듭니다.classes와lib,classes는 컴파일된 출력된class 파일을 저장하고,lib는 제3자jar 패키지를 저장합니다.
폴더 경로 설정 File -> Project Structure (단축키: Ctrl + Shift + Alt + S) -> Module 선택: Paths 선택 -> 선택'Use module compile output path'-> Output path와 Test output path를 모두 방금 만든classes 폴더를 선택합니다.이어 Dependencies->를 선택하여 Module SDK를 1.7로 선택하고 오른쪽의 "+"번호를 클릭하고 ->를 선택하여 1 "Jars or Directories"->방금 만든lib 폴더 선택->"jar directory"->를 선택하고 다시 OK로 돌아가면 됩니다.
메뉴 열기 Run -> Edit Configuration 선택 -> "+"번호 클릭 -> "Tomcat Server"선택 -> "Local"선택 -> "Name"에 새 서비스 이름을 입력하고 "Application server"뒤에 있는 "Configure..."를 누르면 Tomcat Server 창을 팝업하고 로컬에 설치된 Tomcat 디렉터리 선택 -> OK
Run/Debug Configurations 창의 Server 팔레트에서 After launch 선택을 취소하고 HTTP port 및 JMX port(기본값)를 설정하고 Apply-> OK 를 클릭하여 Tomcat 구성이 완료됩니다.
Tomcat에 프로젝트 Run-> Edit Configurations 배포 및 실행, "Run/Debug Configurations"창 진입 -> 방금 만든 Tomcat 용기 선택 -> Deployment 선택 -> 오른쪽 "+"번호 클릭 -> Artifact 선택,
웹 항목 -> 응용 프로그램 context를 선택하면'/hello'> OK (이 hello는 원하는 이름으로 바꿀 수 있습니다. 이 이름은 브라우저가 접근할 때의 프로그램 루트 디렉터리입니다./tomcat 서버 루트 디렉터리를 대표합니다.)

사용자 추가 구현


여기까지 준비 작업이 끝났습니다. 우리는 코드를 쓰기 시작했습니다.
index.jsp 
"text/html;charset=UTF-8" language="java" %>
"c" uri="http://java.sun.com/jsp/jstl/core"%>
<html>
<head>
    <title> title>
head>
<frameset rows="20%,*">
    <frame src="" name="top"/>
    <frame src="" name="main"/>
frameset>
html>

index에는 top이 포함되어 있습니다.jsp, 조작이 편리하도록 top.jsp는 사용자와 상호작용하는 데 사용되며,welcome는 데이터의 표시를 책임진다.기본 welcome에 데이터가 없습니다.name='main'은 메인 화면이 이 프레임워크임을 나타냅니다.
"text/html;charset=UTF-8" language="java" %>
"c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    
    <base target="main">
    <title>My JSP 'top.jsp' starting pagetitle>
head>
<body style="text-align: center;">
    <h1> h1>
    <a href=""> a>
    <a href=""> a>
    <a href=""> a>

body>
html>

welcome.jsp 
"text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Titletitle>
head>
<body>

body>
html>

우리는 아침 탑을 보았다.jsp에는 세 가지 조작이 있는데 그것이 바로 사용자, 조회 사용자, 고급 검색이다. 우리는 사용자를 추가하는 것부터 실현한다. 왜냐하면 데이터베이스는 처음에는 데이터가 없기 때문이다.c:url은 jstl 표현식입니다. 여기는 대부분 불편합니다. 추가 사용자를 누르면add로 이동합니다.jsp
add.jsp 
"text/html;charset=UTF-8" language="java" %>
"c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Titletitle>
head>
<body>
<h3 align="center"> h3>

<form action="" method="post">
    <input type="hidden" name="method" value="add">
    <table border="1" align="center" width="40%" style="margin-left: 100px">
        <tr>
            <td width="100px"> td>
            <td width="40%">
                <input type="text" name="name"/>
            td>
            <td align="left">
                <label id="nameError" class="error"> label>
            td>
        tr>
        <tr>
            <td> td>
            <td>
                <input type="radio" name="gender" value="male" id="male"/>
                <label for="male"> label>
                <input type="radio" name="gender" value="female" id="female"/>
                <label for="female"> label>
            td>
            <td>
                <label id="genderError" class="error"> label>
            td>
        tr>
       <tr>
           <td> td>
           <td>
               <input type="text" name="phone" id="phone">
           td>
           <td>
              <label id="phoneError" class="error">&nbsp:label>
           td>
       tr>
        <tr>
            <td> td>
            <td>
                <input type="text" name="email" id="email"/>
            td>
            <td>
                <label id="emailError" class="error">label>
            td>
        tr>
        <tr>
            <td> td>
            <td>
                <textarea rows="5" cols="30" name="description">textarea>
            td>
            <td>
                <label id="discriptionError" class="error"> label>
            td>
        tr>
        <tr>
            <td>td>
            <td>
                <input type="submit" name="submit"/>
                <input type="reset" name="reset"/>
            td>
        tr>
    table>
form>

body>
html>

페이지 안에 폼이 있습니다. 그리고 폼을 제출할 때의 숨겨진 항목을 설정했습니다. method:add, 즉/Customer Servlet에 제출할 때 이 필드를 가져옵니다. 백그라운드에서 이 필드를 가져와서 어떤 동작을 수행할지 판단할 수 있습니다.이렇게 하는 것은 백엔드 코드의 통일된 관리를 편리하게 하기 위해서이다. 코드를 볼 때 입구를 찾지 못할 정도는 아니다.
/Customer Servlet에 제출된 것을 보았습니다. 그러면 Servlet: src 우클릭->new->servlet,name는 Customer Servlet,package는 servlet을 새로 만듭니다.여기 베이스 서브렛이라고 썼는데,이 servlet을 Base Servlet에 통합시키면 Base Servlet이 반사하는 방법을 잘 해 줍니다.여기 Base Servlet과 관련된 것을 붙입니다.
BaseServlet.java 
import servlet.GetRequest;
import java.io.IOException;
import java.lang.reflect.Method;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class BaseServlet extends HttpServlet {
    public BaseServlet() {
    }

    public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        if(((HttpServletRequest)request).getMethod().equalsIgnoreCase("get")) {
            if(!(request instanceof GetRequest)) {
                request = new GetRequest((HttpServletRequest)request);
            }
        } else {
            ((HttpServletRequest)request).setCharacterEncoding("utf-8");
        }

        response.setContentType("text/html;charset=UTF-8");
        String methodName = ((HttpServletRequest)request).getParameter("method");
        Method method = null;

        try {
            method = this.getClass().getMethod(methodName, new Class[]{HttpServletRequest.class, HttpServletResponse.class});
        } catch (Exception var10) {
            throw new RuntimeException(" ：" + methodName + " ！", var10);
        }

        try {
            String e = (String)method.invoke(this, new Object[]{request, response});
            if(e != null && !e.trim().isEmpty()) {
                int index = e.indexOf(":");
                if(index == -1) {
                    ((HttpServletRequest)request).getRequestDispatcher(e).forward((ServletRequest)request, response);
                } else {
                    String start = e.substring(0, index);
                    String path = e.substring(index + 1);
                    if(start.equals("f")) {
                        ((HttpServletRequest)request).getRequestDispatcher(path).forward((ServletRequest)request, response);
                    } else if(start.equals("r")) {
                        response.sendRedirect(((HttpServletRequest)request).getContextPath() + path);
                    }
                }
            }

        } catch (Exception var9) {
            throw new RuntimeException(var9);
        }
    }
}

GetRequest .java 
import java.io.UnsupportedEncodingException;
import java.util.Iterator;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

public class GetRequest extends HttpServletRequestWrapper {
    private HttpServletRequest request;

    public GetRequest(HttpServletRequest request) {
        super(request);
        this.request = request;
    }

    public String getParameter(String name) {
        String value = this.request.getParameter(name);
        if(value == null) {
            return null;
        } else {
            try {
                return new String(value.getBytes("ISO-8859-1"), "UTF-8");
            } catch (UnsupportedEncodingException var4) {
                throw new RuntimeException(var4);
            }
        }
    }

    public Map getParameterMap() {
        Map map = this.request.getParameterMap();
        if(map == null) {
            return map;
        } else {
            Iterator var3 = map.keySet().iterator();

            while(var3.hasNext()) {
                String key = (String)var3.next();
                String[] values = (String[])map.get(key);

                for(int i = 0; i < values.length; ++i) {
                    try {
                        values[i] = new String(values[i].getBytes("ISO-8859-1"), "UTF-8");
                    } catch (UnsupportedEncodingException var7) {
                        throw new RuntimeException(var7);
                    }
                }
            }

            return map;
        }
    }
}

다음은 add 방법을 실현했습니다.
public class ConstomerServlet extends BaseServlet {
private CustomerServier customerService= new CustomerServier();

    public String add(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        Customer customer = CommonUtils.toBean(request.getParameterMap(), Customer.class);
        customer.setId(CommonUtils.uuid());

        customerService.add(customer);
        request.setAttribute("msg", " ， ");
        return "/msg.jsp";
    }
 }

여기에 공공 디스플레이 페이지 msg를 새로 만들어야 합니다.jsp, 이 페이지의 작업은 msg를 추출하여 표시하는 것입니다.
"text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Titletitle>
head>
<body>
<h1 style="color:green;" align="center">${msg}h1>

body>
html>

그리고 방법은 사용자가 제출한 데이터를 저장하는 모델을 만들어 달라고 했습니다. 여기에 라이브러리를 사용했습니다. 이것은commons입니다.beanutils, 동시에 우리는 두 개의 파일을 새로 만듭니다:CommonUtils.java,DateConverter.java. 사실 위와 같은 일반적인 구성 요소는 우리가jar 패키지로 포장해서 저장할 수 있다.
CommonUtils.java 
import commons.DateConverter;
import java.util.Date;
import java.util.Map;
import java.util.UUID;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.ConvertUtils;

public class CommonUtils {
    public CommonUtils() {
    }

    public static String uuid() {
        return UUID.randomUUID().toString().replace("-", "").toUpperCase();
    }

    public static  T toBean(Map map, Class clazz) {
        try {
            Object e = clazz.newInstance();
            ConvertUtils.register(new DateConverter(), Date.class);
            BeanUtils.populate(e, map);
            return e;
        } catch (Exception var3) {
            throw new RuntimeException(var3);
        }
    }
}

DateConverter.java 
import java.text.ParseException;
import java.text.SimpleDateFormat;
import org.apache.commons.beanutils.Converter;

public class DateConverter implements Converter {
    public DateConverter() {
    }

    public Object convert(Class type, Object value) {
        if(value == null) {
            return null;
        } else if(!(value instanceof String)) {
            return value;
        } else {
            String val = (String)value;
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

            try {
                return sdf.parse(val);
            } catch (ParseException var6) {
                throw new RuntimeException(var6);
            }
        }
    }
}

Customer.java 
public class Customer
{
    private String id;
    private String name;
    private String gender;
    private String phone;
    private String email;
    private String description;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

논리를 더욱 명확하게 하기 위해서, 우리는 업무 논리 Customer Server를 처리하기 위해 서비스 클래스를 새로 만듭니다.java 
public class CustomerServier {
    CustomerDao customerDao = new CustomerDao();

    public void add(Customer customer)
    {
        customerDao.add(customer);
    }
 }

데이터베이스는 클래스를 만들어서 처리합니다. CustomerDao CustomerDao.java 
public class CustomerDao {

    private QueryRunner qr = new TxQueryRunner();


    public void add(Customer c) {
        try {
            String sql = "insert into t_customer values(?,?,?,?,?,?)";
            Object[] params = {c.getId(), c.getName(), c.getGender(),
                    c.getPhone(), c.getEmail(), c.getDescription()};

            qr.update(sql, params);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
  }

여기에는 JdbcUtils, TxQueryRunner TxQueryRunner 두 가지 도구 종류가 필요합니다.java 
import jdbc.JdbcUtils;
import java.sql.Connection;
import java.sql.SQLException;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;

public class TxQueryRunner extends QueryRunner {
    public TxQueryRunner() {
    }

    public int[] batch(String sql, Object[][] params) throws SQLException {
        Connection con = JdbcUtils.getConnection();
        int[] result = super.batch(con, sql, params);
        JdbcUtils.releaseConnection(con);
        return result;
    }

    public  T query(String sql, ResultSetHandler rsh, Object... params) throws SQLException {
        Connection con = JdbcUtils.getConnection();
        Object result = super.query(con, sql, rsh, params);
        JdbcUtils.releaseConnection(con);
        return result;
    }

    public  T query(String sql, ResultSetHandler rsh) throws SQLException {
        Connection con = JdbcUtils.getConnection();
        Object result = super.query(con, sql, rsh);
        JdbcUtils.releaseConnection(con);
        return result;
    }

    public int update(String sql) throws SQLException {
        Connection con = JdbcUtils.getConnection();
        int result = super.update(con, sql);
        JdbcUtils.releaseConnection(con);
        return result;
    }

    public int update(String sql, Object param) throws SQLException {
        Connection con = JdbcUtils.getConnection();
        int result = super.update(con, sql, param);
        JdbcUtils.releaseConnection(con);
        return result;
    }

    public int update(String sql, Object... params) throws SQLException {
        Connection con = JdbcUtils.getConnection();
        int result = super.update(con, sql, params);
        JdbcUtils.releaseConnection(con);
        return result;
    }
}

이 점에서 웹 개발을 하려면 자신의 도구 클래스 구성 요소 라이브러리가 얼마나 중요한지 알 수 있다.JdbcUtils는 데이터베이스 연결 탱크 c3p0을 사용합니다. 그러면 src 디렉터리에 xml 파일을 새로 만들어서 JdbcUtils를 설정해야 합니다.java 
import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;

public class JdbcUtils {
    private static DataSource ds = new ComboPooledDataSource();
    private static ThreadLocal tl = new ThreadLocal();

    public JdbcUtils() {
    }

    public static DataSource getDataSource() {
        return ds;
    }

    public static Connection getConnection() throws SQLException {
        Connection con = (Connection)tl.get();
        return con != null?con:ds.getConnection();
    }

    public static void beginTransaction() throws SQLException {
        Connection con = (Connection)tl.get();
        if(con != null) {
            throw new SQLException(" ， ！");
        } else {
            con = ds.getConnection();
            con.setAutoCommit(false);
            tl.set(con);
        }
    }

    public static void commitTransaction() throws SQLException {
        Connection con = (Connection)tl.get();
        if(con == null) {
            throw new SQLException(" ！");
        } else {
            con.commit();
            con.close();
            con = null;
            tl.remove();
        }
    }

    public static void rollbackTransaction() throws SQLException {
        Connection con = (Connection)tl.get();
        if(con == null) {
            throw new SQLException(" ！");
        } else {
            con.rollback();
            con.close();
            con = null;
            tl.remove();
        }
    }

    public static void releaseConnection(Connection connection) throws SQLException {
        Connection con = (Connection)tl.get();
        if(connection != con && connection != null && !connection.isClosed()) {
            connection.close();
        }

    }
}

c3p0-config.xml 이것은 나의 데이터베이스 설정으로 구체적인 설정은 모든 사람의 컴퓨터에 따라 달라진다.안의 구체적인 필드가 대표하는 의미에 대해서는 일일이 소개하지 않겠습니다.

<c3p0-config>
    <default-config>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/customerproperty>
        <property name="driverClass">com.mysql.jdbc.Driverproperty>
        <property name="user">rootproperty>
        <property name="password">rootproperty>
        <property name="acquireIncrement">3property>
        <property name="initialPoolSize">10property>
        <property name="minPoolSize">2property>
        <property name="maxPoolSize">10property>
    default-config>
c3p0-config>

여기까지, 우리 새 고객의 조작이 다 되었으니, 운행하여 효과를 좀 봅시다.실행이 바로 그 재생 키입니다.자, 효과가 나왔습니다. 우리가 새로 짓는 것도 성공했습니다.데이터베이스를 보니 확실히 삽입되었다.동창회에서 데이터베이스 코드가 아직 안 붙었다고 하던데?그래, 그럼 데이터베이스에 디자인된 시계를 붙여줄게...t_customer.sql 
/*
Navicat MySQL Data Transfer

Source Server         : larsonconn
Source Server Version : 50520
Source Host           : localhost:3306
Source Database       : customer

Target Server Type    : MYSQL
Target Server Version : 50520
File Encoding         : 65001

Date: 2017-05-18 14:54:29
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for `t_customer`
-- ----------------------------
DROP TABLE IF EXISTS `t_customer`;
CREATE TABLE `t_customer` (
  `id` varchar(50) NOT NULL,
  `name` varchar(50) DEFAULT NULL,
  `gender` varchar(20) DEFAULT NULL,
  `phone` varchar(50) DEFAULT NULL,
  `email` varchar(50) DEFAULT NULL,
  `description` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

조회 구현


우리 꼭대기 보자.jsp는 이렇게 썼습니다. 그 문은 servlet에서 이findAll 방법을 실현해야 합니다.
 public String findAll(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       /*
        *1. pc
        * 2. pr 
        * 3. pc pr service ， pageBean， request 
        * 4. list.jsp
        */
       /*
        * 1. pc
        *    pc ， pc＝1
        *    pc ， int 
        */
        int pc=getPc(request);

        int pr=10;// pr ， 10 

        PageBean pb= customerService.findAll(pc,pr);
        pb.setUrl(getUrl(request));

        request.setAttribute("pb",pb);

        return "f:/list.jsp";
    }

페이지별 조회를 사용했기 때문에 Bean, PageBean을 다시 만들어야 합니다.java 
public class PageBean
{
    private int pc;// page code
    //private int tp;// total pages
    private int tr;// tatal records
    private int pr;// page records
    private List beanList;// 
    private String url;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public int getPc() {
        return pc;
    }

    public void setPc(int pc) {
        this.pc = pc;
    }

    public int getTp()
    {
        int tp=tr/pr;
        return tr % pr == 0 ? tp : tp + 1 ;
    }



    public int getTr() {
        return tr;
    }

    public void setTr(int tr) {
        this.tr = tr;
    }

    public int getPr() {
        return pr;
    }

    public void setPr(int pr) {
        this.pr = pr;
    }

    public List getBeanList() {
        return beanList;
    }

    public void setBeanList(List beanList) {
        this.beanList = beanList;
    }
}

그리고 findAll 방법을 서비스합니다.
public PageBean findAll(int pc, int pr) {
        return customerDao.findAll(pc,pr);
    }

그 다음은 Dao층 구현: 먼저 몇 개의 기록이 있는지 조회하고 기록이 많을 때 페이지를 나누어야 한다.limit 명령을 사용하여 실행합니다.
public PageBean findAll(int pc, int pr) {
        try {
            /*
             *1. pageBean pb
             * 2. pb pc pr
             * 3. tr， pb
             * 4. beanList pb
             *  pb
             */
            PageBean pb = new PageBean<>();
            pb.setPc(pc);
            pb.setPr(pr);

            String sql = "select count(*) from t_customer";
            Number number = (Number) qr.query(sql, new ScalarHandler<>());

            int tr = number.intValue();
            pb.setTr(tr);

            sql = "select * from t_customer order by name limit ?,?";
            Object[] params = {(pc - 1) * pr, pr};
            List beanList = qr.query(sql, new BeanListHandler<>(Customer.class), params);

            pb.setBeanList(beanList);

            return pb;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

지금 우리는 데이터를 받았습니다. 이 데이터를 표시해야 합니다. jsp를 새로 만들어서 이 데이터를 표시합니다:list.jsp 
"text/html;charset=UTF-8" language="java" %>
"c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title> title>
head>
<body>
    <h3 align="center" > h3>
    <table border="1" width="70%" align="center">
        <tr>
            <th> th>
            <th> th>
            <th> th>
            <th> th>
            <th> th>
            <th> th>
        tr>
        <c:forEach items="${pb.beanList}" var="cstm">
        <tr>
            <td>${cstm.name}td>
            <td>${cstm.gender}td>
            <td>${cstm.phone}td>
            <td>${cstm.email}td>
            <td>${cstm.description}td>
            <td>
                <a href=" "> a>
                <a href=" "> a>
            td>
        tr>
        c:forEach>
    table>
<br/>
<center>
     ${pb.pc} / ${pb.tp} 
    <a href="${pb.url}&pc=1"> a>
    <c:if test="${pb.pc>1}">
        <a href="${pb.url}&pc=${pb.pc-1}"> a>
    c:if>

    <c:choose>
        <c:when test="${pb.tp<=10}">
            <c:set var="begin" value="1"/>
            <c:set var="end" value="${pb.tp}"/>
        c:when>
        <c:otherwise>
            <c:set var="begin" value="${pb.pc-5}"/>
            <c:set var="end" value="${pb.pc+4}"/>
            
            <c:if test="${begin<1}">
                <c:set var="begin" value="1"/>
                <c:set var="end" value="10"/>
            c:if>
            
            <c:if test="${end>pb.tp}">
                <c:set var="end" value="${pb.tp}"/>
                <c:set var="begin" value="${pb.tp-9}"/>
            c:if>
        c:otherwise>
    c:choose>

    
    <c:forEach var="i" begin="${begin}" end="${end}">
        <c:choose>
            <c:when test="${i eq pb.pc}">
                [${i}]
            c:when>
            <c:otherwise>
                <a href="${pb.url}&pc=${i}">[${i}]a>
            c:otherwise>
        c:choose>

    c:forEach>


    <c:if test="${pb.pc>
    <a href="${pb.url}&pc=${pb.pc+1}"> a>
    c:if>
    <a href="${pb.url}&pc=${pb.tp}"> a>

center>

body>
html>

자, 리스트.jsp는 전송된 대상에서 데이터를 읽고 표시합니다. 여기에 조회 기능이 있습니다.
그럼 조회가 끝났습니다. 고급 조회를 하겠습니다. 고급 조회는 정보 조회를 지정할 수 있습니다. top 페이지에서 들어가서/query가 있습니다.jsp, 그럼 우리/query 하나 만들자.jsp /query.jsp’ 
"text/html;charset=UTF-8" language="java" %>
"c" uri="http://java.sun.com/jsp/jstl/core"%>
<html>
<head>
    <title>title>
head>
<body>
    <h3 align="center"> h3>
    <form action="CustomerServlet"/>" method="get">
        <input type="hidden" name="method" value="query">
        <table border="0" align="center" width="40%" style="margin-left: 100px">
            <tr>
                <td width="100px"> td>
                <td width="40%">
                    <input type="text" name="name">
                td>
            tr>
            <tr>
                <td> td>
                <td>
                    <select name="gender">
                        <option value="">== ==option>
                        <option value="male">maleoption>
                        <option value="female">femaleoption>
                    select>
                td>
            tr>
            <tr>
            <td> td>
            <td>
                <input type="text" name="phone"/>
            td>
            tr>
            <tr>
                <td> td>
                <td>
                    <input type="text" name="email"/>
                td>
            tr>
            <tr>
                <td> td>
                <td>

                    <input type="submit" value=" "/>
                    <input type="reset" value=" "/>
                td>
            tr>

        table>
    form>

body>
html>

이 조회표도 다 썼습니다. 쿼리 방법을 실현하려면 서브렛으로 돌아가야 합니다.
  public String query(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        Customer customer=CommonUtils.toBean(request.getParameterMap(),Customer.class);

//        System.out.println(getUrl(request));
        customer=encoding(customer);

        int pc=getPc(request);
        int pr=10;

        PageBean pb=  customerService.query(customer,pc,pr);

        pb.setUrl(getUrl(request));

        request.setAttribute("pb",pb);
        return "/list.jsp";

    }

서비스 안에 있는query 방법을 다시 실현하겠습니다.
  public PageBean query(Customer customer, int pc, int pr) {
        return customerDao.query(customer, pc,pr);
    }

그 다음은 Dao의 조회: 루트QueryAll 차이가 많지 않아요. where 조회 한정만 했어요.
public PageBean query(Customer customer, int pc, int pr) {
        try {
            PageBean pb = new PageBean();
            pb.setPc(pc);
            pb.setPr(pr);

            StringBuilder cntSql = new StringBuilder("select count(*) from t_customer ");
            StringBuilder whereSql = new StringBuilder(" where 1=1 ");
            List params = new ArrayList();

            String name = customer.getName();

            if (name != null && !name.trim().isEmpty()) {
                whereSql.append("and name like ?");
                params.add("%" + name + "%");
            }

            String gender = customer.getGender();
            if (gender != null && !gender.trim().isEmpty()) {
                whereSql.append("and gender=?");
                params.add(gender);
            }

            String phone = customer.getPhone();
            if (phone != null && !phone.trim().isEmpty()) {
                whereSql.append("and phone like ?");
                params.add("%" + phone + "%");
            }

            String email = customer.getEmail();
            if (email != null && !email.trim().isEmpty()) {
                whereSql.append("and email like ?");
                params.add("%" + email + "%");
            }
            Number num = (Number) qr.query(cntSql.append(whereSql).toString(), new ScalarHandler<>(), params.toArray());

            pb.setTr(num.intValue());

            StringBuilder sql = new StringBuilder("select * from t_customer ");
            StringBuilder lmitSql = new StringBuilder(" limit ?,?");

            params.add((pc - 1) * pr);
            params.add(pr);

            List beanList = qr.query(sql.append(whereSql).append(lmitSql).toString(), new BeanListHandler<>(Customer.class), params.toArray());
            pb.setBeanList(beanList);

            return pb;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

우리는 조회 결과를list에 두었다.jsp 디스플레이, 디스플레이 페이지는 우리가 앞에 썼습니다. 그러면 실행해 보겠습니다.좋아, 정확하게 나왔어.다음은 수정, 삭제입니다.삭제 입구를 수정하여 목록 페이지에 놓았습니다. c:url value ='/Customer Servlet?method=preEdit&id=${cstm.id}’

고객 정보 수정

  public String preEdit(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String id = request.getParameter("id");
        Customer customer = customerService.find(id);

        request.setAttribute("customer", customer);

        return "/edit.jsp";
    }

우리는 먼저 우리가 수정해야 할 고객 id를 조회하고 데이터베이스를 통해 고객 정보를 조회한 다음에edit 페이지로 전송하여 편집한다.CustomerServier.java 
...
 public Customer find(String id) {
        return customerDao.find(id);
    }
 ...

CustomerDao.java 
...
   public Customer find(String id) {
        try {
            String sql = "select * from t_customer where id=?";
            return qr.query(sql, new BeanHandler(Customer.class), id);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
...

,edit를 새로 만듭니다.jsp 
"text/html;charset=UTF-8" language="java" %>
"c" uri ="http://java.sun.com/jsp/jstl/core"%>
<html>
<head>
    <title>Titletitle>
head>
<body>
<h3 align="center"> h3>
<form action="" method="post" >
    <input type="hidden" name="method" value="edit"/>
    <input type="hidden" name="id" value="${customer.id}"/>
    <table border="0" align="center" width="40%" style="margin-left: 100px">
        <tr>
            <td width="100px"> td>
            <td width="40%">
                <input type="text" name="name" value="${customer.name}"/>
            td>
            <td align="left">
                <label id="nameError" class="error"> label>
            td>
        tr>
        <tr>
            <td> td>
            <td>
                <input type="radio" name="gender" value="male" id="male" <c:if test="${customer.gender eq 'male'}"/>checked="checked"/>
                <label for="male"> label>
                <input type="radio" name="gender" value="female" id="female" <c:if test="${customer.gender eq 'female'}"/> checked="checked"/>
                <label for="female"> label>
            td>
            <td>
                <label id="genderError"class="error"> label>
            td>
        tr>
        <tr>
            <td> td>
            <td>
                <input type="text" name="phone" id="phone" value="${customer.phone}"/>
            td>
            <td>
                <label id="phoneError"class="error"> label>
            td>
        tr>
        <tr>
            <td> td>
            <td>
                <input type="text" name="email" id="email" value="${customer.email}"/>
            td>
            <td>
                <label id="emailError"class="error"> label>
            td>
        tr>
        <tr>
            <td> td>
            <td>
                <textarea rows="5" cols="30" name="description">${customer.description}textarea>
            td>
            <td>
                <label id="discriptionError"class="error"> label>
            td>
        tr>
        <tr>
            <td>td>
            <td>
                <input type="submit" name="submit" value=" "/>
                <input type="reset" name="reset"/>
            td>
        tr>
    table>
form>


body>
html>

자, 저희가 제출을 누르면 수정된 사용자 정보를 폼에 저장하여 servlet의 편집 방법에 대해 가르쳐 드리겠습니다. 이제 편집 방법을 실현하겠습니다.
...
  public String edit(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        Customer customer = CommonUtils.toBean(request.getParameterMap(), Customer.class);

        customerService.edit(customer);

        request.setAttribute("msg", " ， ");
        return "/msg.jsp";
    }
...

자, 여기까지. 수정 작업도 끝났어요. 하하하하하하하.그럼 삭제 작업이 하나 남았습니다.

고객 삭제


삭제 클라이언트가 servlet의 삭제 방법을 호출했습니다. c:url value ='/Customer Servlet?method=delete &id=${cstm.id} "이제 delete 방법을 구현해 보겠습니다.
...
public String delete(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        String id = request.getParameter("id");

        customerService.delete(id);

        request.setAttribute("msg", " ， ");

        return "/msg.jsp";
    }
...

, 여전히 앞과 같습니다: Customer Server.java 
...
 public void delete(String id) {
        customerDao.delete(id);
    }
...

CustomerDao.java 
...
 public void delete(String id) {
        try {
            String sql = "delete from t_customer where id=?";
            qr.update(sql, id);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
...

자, 삭제도 끝났습니다. 이로써 큰 성과를 거두면 간단한 고객 관리 시스템이 완성됩니다.여러분은 lib의 클릭이 필요합니다. 여기:
여기를 클릭하십시오:
Typescript를 사용하여 범용 유형 중 하나 구현
AWS CDK를 사용하여 기본 서버리스 애플리케이션 구축

좋은 웹페이지 즐겨찾기

개발자 우수 사이트 수집

개발자가 알아야 할 필수 사이트 100선 추천 우리는 당신을 위해 100개의 자주 사용하는 개발자 학습 사이트를 정리했습니다
best100-homepage