该实例的原型为JDBC连接数据库的学生管理系统，在此之上将其放在Servlet容器中，并实现相关的交互功能。与原内容相同的有配置文件（Properties）、连接数据库（BaseDAO）、教师类、教师接口与实现。

由于步骤较多，避免搞混淆，每个步骤的功能完全实现后再进行下一步，下文与上文呼应处会有提示，来回翻阅查看对应的方法就好。根据目录顺序依此实现！

Properties、BaseDAO 可参考：Java_Dao_MySQL_学生管理系统

连接数据库可参考：JDBC连接MySQL实例

总览

文件目录

文件目录如下：

更原来相同（一摸一样）的有 db.properyies 、BaseDAO 、TeacherDAO_Impl 。与原来不同的在下面将一一提到（根据途中目录为单位）。

实现功能

教师：注册、登录

学生：信息全查、根据姓名全查、根据ID查询、根据ID删除、学生信息修改、添加学生

Eneity

Student

实体类中的student跟原来是使用的有了稍微调整，加入了id属性。对应数据库中的属性有：

public int stu_id;
public String stu_username;
public String stu_password;

注意： 请重写get/set方法

为后期方便可写一个有参构造，同时还需要写一个无参构造。（非必须）

public Student(){};
public Student(String stu_username, String stu_password){
    this.stu_username = stu_username;
    this.stu_password = stu_password;
}

Teacher

同样，再teacher的实体类中也加入有参构造和午餐构造。（非必须）

public Teacher(){};
public Teacher(String tea_username, String tea_password){
    this.tea_username = tea_username;
    this.tea_password = tea_password;
}

DAO

在这里面定义与数据库交互的相关方法，并提供公共的接口供子类实现。

BaseDAO

BaseDAO中的内容与原来相同（一摸一样），里面的对应数据库的信息改成自己的即可使用。

TeacherDAO

TeacherDAO接口中的抽象方法与原来一样，不做赘述。

StudentDAO

这里面包含了对应学生的相关功能。（上文有提到）

public interface StudentDAO {
    public List<Student> getAll();              //全查
    public List<Student> getName(String name);  //根据姓名查询
    public int getDel(Object... id);            //根据ID删除
    public Student getId(int id);               //根据ID查询相应的信息
    public int getUpdate(Student student);      //修改
    public int Insert(Student student);         //添加学生
}

DAO_Impl

在这里面实现继承接口，并实现其中对应的抽象方法。

TeacherDAO_Impl

TeacherDAO_Impl的是实现与原来一样，不做赘述。

StudentDAO_Impl

功能：信息全查、根据姓名全查、根据ID查询、根据ID删除、学生信息修改、添加学生

功能一：信息全查

方法说明：

1. 全查返回来的是表中的所有字段，所以需要用List集合来存查询到的返回值；
2. 全查的SQL语句；
3. 调用BaseDAO里写的查询方法，并将SQL语句作为参数传过去，返回ResultSet；
4. 需要判断返回值是否有值，如果有下一个值就将值赋给student实体类（包含stu_id、stu_username、stu_password）；
5. 将循环里的每一个student实体类添加到定义的List集合中，返回该List。

/**
 * 无参
 * @return Student类型的List集合
 */
@Override
public List<Student> getAll() {
    List<Student> studentList = new ArrayList<>();
    String sql = "select * from student";
    ResultSet resultSet = BaseDAO.executeQuery(sql);
    Student student = null;
    try {
        while (resultSet.next()){
            student = new Student();
            student.setStu_id(resultSet.getInt("stu_id"));
            student.setStu_username(resultSet.getString("stu_username"));
            student.setStu_password(resultSet.getString("stu_password"));
            studentList.add(student);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return studentList;
}

功能二：根据姓名全查

方法说明：

1. 基本思想与全查相同，不同的是SQL语句；
2. 根据姓名查询或者根据名字中的某个字，来查询对应的学生信息，这时就需要用到like关键字；
3. 返回值不一定是一个，所欲需要用List集合来接收。

/**
 * @param name 获取到的姓名或名字中的某个字
 * @return Student类型的List集合
 */
@Override
public List<Student> getName(String name) {
    List<Student> studentList = new ArrayList<>();
    String sql = "SELECT * FROM student WHERE `stu_username` like '%"+ name + "%' ";
    ResultSet resultSet = BaseDAO.executeQuery(sql);
    Student student = null;
    try {
        while (resultSet.next()){
            student = new Student();
            student.setStu_id(resultSet.getInt("stu_id"));
            student.setStu_username(resultSet.getString("stu_username"));
            student.setStu_password(resultSet.getString("stu_password"));
            studentList.add(student);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return studentList;
}

功能三：根据ID查询

方法说明：=

1. 同样也是查询，只不过掺入的参数是ID，返回值只有一条，所以将返回值赋给Student的实体类。

/**
 * @param id int类型的id
 * @return 返回受影响行数，int类型
 */
@Override
public Student getId(int id) {
    ResultSet resultSet = null;
    Student student = null;
    String sql = "select * from student where stu_id = ? ";
    resultSet = BaseDAO.executeQuery(sql, id);
    try{
        if(resultSet.next()){
            student = new Student();
            student.setStu_id(resultSet.getInt("stu_id"));
            student.setStu_username(resultSet.getString("stu_username"));
            student.setStu_password(resultSet.getString("stu_password"));
        }
    }catch (SQLException e){
        e.printStackTrace();
    }finally {
        try {
            BaseDAO.GetClose(conn, null, resultSet);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    return student;
}

功能四：根据ID删除

方法说明：

1. 通过该方法能够一次性删除多条信息，所以获取到的参数应该是数组类型的，里面存放的是要删除的信息对应的ID；
2. 由上文我们知道 Object... 也是一种数组的形式，当不知ID个数的时候，完全可以应用这种数组；
3. 利用for循环遍历数组的中的ID值，根据SQL语句和ID，调用BaseDAO里的方法，返回受影响行数（int类型）。
4. 每次循环将受影响行数加一，这样最后获取到的就是一个总数

/**
 * @param id 获取数组类型的id，Object... ：该数组可为空
 * @return
 */
@Override
public int getDel(Object... id) {
    int i = 0;
    for (int j = 0; j < id.length; j++) {
        String sql = "delete from student where stu_id = ? ";
        i = BaseDAO.executeUpdate(sql, id[j]);
        i += 1;
    }
    return i;
}

考虑到新能的问题：

每次循环都需调用方法、建立数据库连接、预编译、塞值、调用executeUpate、关闭资源、返回结果，这样的繁琐的步骤，相当的消耗资源，所以可将上述的方法最进一步改进，利用SQL的in关键字将ID统一放入其中，这样繁琐的步骤一需要走依此就好了。

/**
 * @param id 获取Student类型的数组id
 * @return 返回受影响行数，int类型
 */
public int getDel(Student[] id) {
    int i = 0;
    if (id != null && id.length > 0){
        String sql = "delete from student where stu_id in (";
        for (int j = 0; j < id.length; j++){
            if (i == id.length - 1){
                sql = sql + id[j];
            }else{
                sql = sql + id[j] + ",";
            }
        }
        sql = sql + ")";
        i = BaseDAO.executeUpdate(sql);
    }
    return i;
}

功能五：学生信息修改

方法说明：

1. 获取传进来的实体类，将实体类中的值传给BaseDAO的方法；
2. 返回受影响行数。

/**
 * @param student Student类型的实体类
 * @return 返回受影响行数，int类型
 */
@Override
public int getUpdate(Student student){
    int i = 0;
    String sql = "update student set stu_username = ? , stu_password = ? where stu_id = ? ";
    i = BaseDAO.executeUpdate(sql, student.getStu_username(), student.getStu_password(), student.getStu_id());
    return i;
}

功能六：添加学生

方法说明：

1. 获取传进来的实体类，将实体类中的值传给BaseDAO的方法；
2. 返回受影响行数。

/**
 * @param student Student类型的实体类
 * @return 返回受影响行数，int类型
 */
@Override
public int Insert(Student student) {
    int i=0;
    String sql = "insert into student(stu_username, stu_password) values( ? , ? )";
    i = BaseDAO.executeUpdate(sql, student.getStu_username(), student.getStu_password());
    return i;
}

Service

现在逻辑层的实现可复制DAO里的对应的接口，并实现它，几乎不用做额外的修改，这样看似比较鸡肋。但当业务逻辑增多以后，才能体现出它的便捷处。

后期与前端页面交互是调用Service里的方法，相当于表现层只于业务逻辑层交互（解耦）。

StudentService

将StudentDAO里的抽象方法完全复制过来，不用修改。

TeaService

将TeacherDAO里的抽象方法完全复制过来，不用修改。

Service_Impl

实现Service接口。

StudentsService_Impl

实现Service对应的学生接口，每个方法的返回值为StudentDAO_Impl的方法。

public class StudentService_Impl implements StudentService {
    @Override
    public List<Student> getAll() {
        return new StudentDAO_Impl().getAll();
    }
    @Override
    public List<Student> getName(String name) {

        return new StudentDAO_Impl().getName(name);
    }
    @Override
    public int getDel(Object... id) {
        return new StudentDAO_Impl().getDel(id);
    }
    @Override
    public Student getId(int id) {
        return new StudentDAO_Impl().getId(id);
    }
    @Override
    public int getUpdate(Student student) {
        return new StudentDAO_Impl().getUpdate(student);
    }
    @Override
    public int Insert(Student student) {
        return new StudentDAO_Impl().Insert(student);
    }
}

TeaService_Impl

实现Service对应的教师接口，每个方法的返回值为TeacherDAO_Impl的方法。

public class TeaService_Impl implements TeaService {
    @Override
    public Teacher Login(String username, String password) {
        return new TeacherDAO_Impl().Login(username,password);
    }
    @Override
    public int SignIn(Teacher teacher) {
        return new TeacherDAO_Impl().SignIn(teacher);
    }
}

Servlet

Servlet是个什么东西，我也说不清，想了解的，可以看看这篇文章：servlet的本质是什么，它是如何工作的？

看完那篇，再看JSP：怎样学习JSP？

总之，在此我们可以和前端页面交互了！为了便于理解，我将servlet与jsp页面穿插在一起，看到这里不妨捋先一遍student实现的的方法再继续。

教师注册/登录

所用的文件包括：index.jsp 、SignInServlet 、Login.jsp 、LoginServlet 。

index.jsp

主页面，用于教师注册。

注册页面保函：表单、表单验证。

文件说明：

1. 表单提交到 SignInServlet ；
2. 用户名和密码赋予不同的 name ；
3. 根据表单提交来进行表单验证，判断字段是否为空，若为空则不处理。

<%--表单部分--%>
<h1>注册页面</h1>
<form id="form" method="post" action="/SignInServlet">
    用户名：<input name="teaName"><br/>
    密码：<input name="teaPass"><br/><br/>
    <input type="submit" value="确认注册">
    <input type="reset" value="重置">
</form>

<%--表单验证部分--%>
<script src="js/jquery-3.6.0.js" type="text/javascript"></script>
<script>
    $(function () {
        $("#form").submit(function () {
            var teaName = $("input[name='teaName']").val();
            var teaPass = $("input[name='teaPass']").val();
            if (teaName.trim().length == 0  && teaPass.trim().length == 0) {
                alert("字段不能为空！");
                return false;
            }
        })
    })
</script>

SignInServlet

新建一个 Servlet ，命名为 SignInServlet 的class文件。

可以通过在 web.xml 中配置 servlet 的映射，如果不想手动配置，也可以直接在类的上面写入：

@WebServlet(name = "SignInServlet", value = "/SignInServlet")

servlet流程：

1. 继承 HttpServlet ；

2. 实现其中的 doGet/doPost 方法，如果想将请求默认为post请求（非必须），在 doGet 中调用 doPost 方法；

3. 通过 request 对象的 setCharacterEncoding 方法来设置编码格式；

4. 通过 request 对象的 getParameter 方法来获取表单中对应的数据；

5. 将数据赋给 Teacher 类型的有参构造；

6. 实例化一个 TeaService_Impl 对象；

7. 调用该对象的登录方法 SignIn ，传递的参数为 Teacher 对象；（这就是上次的方法）

8. 利用 int 类型的值来获取方法的返回值；

9. 判断该值是否大于0，为真则证明注册成功，并将页面转发至登录页面 Login.jsp ；为假，则重定向到原来的注册页面。

@WebServlet(name = "SignInServlet", value = "/SignInServlet")
public class SignInServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");
        String teaName = request.getParameter("teaName");
        String teaPass = request.getParameter("teaPass");
        Teacher teacher = new Teacher(teaName, teaPass);
        TeaService_Impl userService_ = new TeaService_Impl();
        int i = userService_.SignIn(teacher);
        if(i>0){
            //跳转到登录页面
            request.getRequestDispatcher("Login.jsp").forward(request, response);
        }else{
            response.sendRedirect("index.jsp");
        }

    }
}

Login.jsp

教师登录页面，当注册成功则到此页面。

该页面与登录页面类似，登录后应当进入的是管理学生的主页面，所以点击提交后，先转到 LoginServlet 做一层判断。

<h1>登录页面</h1>
<form id="form" method="post" action="/LoginServlet">
    用户名：<input name="teaName"><br/>
    密码：<input name="teaPass"><br/><br/>
    <input type="submit" value="确认登录">
    <input type="reset" value="重置">
</form>

<script src="js/jquery-3.6.0.js" type="text/javascript"></script>
<script>
    $(function () {
        $("#form").submit(function () {
            var teaName = $("input[name='teaName']").val();
            var teaPass = $("input[name='teaPass']").val();
            if (teaName.trim().length == 0 && teaPass.trim().length == 0) {
                alert("字段不能为空！");
                return false;
            }
        })
    })
</script>

LoginServlet

该 servlet 与 SignInServlet 大致相同，只不过调用的是教师的登录方法（以前的方法），跳转的是学生管理页面对应的 AllServlet 。

@WebServlet(name = "LoginServlet", value = "/LoginServlet")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");
        String teaName = request.getParameter("teaName");
        String teaPass = request.getParameter("teaPass");
        TeaService_Impl teaService_ = new TeaService_Impl();
        Teacher teacher = teaService_.Login(teaName, teaPass);
        if(teacher != null){
            request.getRequestDispatcher("/AllServlet").forward(request, response);
        }else {
            response.sendRedirect("index.jsp");
        }

    }
}

学生管理

所用的文件包括：AllServlet 、 Main.jsp 、Insert.jsp 、Update.jsp ，这里步骤较多，那就根据功能的顺序往下说。AllServlet需要先继承HttpServlet，并重写里面的两个方法。

页面如下：

信息全查、根据姓名全查、根据ID查询、根据ID删除、添加学生、学生信息修改。

信息全查： 当教师登录成功后，就能看到所有学生的信息，如上图所示，所以全查功能应当作为主页面的功能。

根据姓名查询： 页面按钮，根据输入框输入的姓名或某个字，查询对应的学生信息，结果可以有多条。

根据ID查询： 页面按钮，根据输入框输入的ID进行查询，结果只有一条。

根据ID删除： 用户勾选需要删除的学生信息，点击删除按钮，予以删除，如果要全选，就需要勾选最上面的选择框，这实现的是全选。

添加学生： 页面按钮，跳转到添加页面，根据用户输入学生的姓名和密码，点击提添加页面的按钮，再返回来（主页面）。

学生信息修改： 每条信息都可以修改，点击修改后跳转到修改页面，默认显示用户的相应信息，可实现单改和全改。

注：页面上的刷新按钮，只是做了一个重定向。

前期说明：

• AllServlet 设置编码格式
• StudentService 实例化一个子类的对象用于使用（多态）。
• 由于有关学生的Servlet全写在 AllServlet 中，所以为了区分页面不同的功能，需要定义一个标识（action，这不是表单提交的action）来判断，就好比当用户点击和删除，那就只完成删除的功能。

request.setCharacterEncoding("utf-8");
StudentService studentService = new StudentService_Impl();
String action = request.getParameter("action");

信息全查

Servlet/JSP步骤说明：

1. 当action为空时，就实现信息全查，因为教师登录进来，这个标识就是空的；
2. 调用 studentService 里的全查方法（无参）；（可查看上文的 getAll()）
3. 全查返回的是多个条信息，需要用集合来接收；
4. 这个保存信息的集合需要体现在前端页面，所以jsp页面需要获取到这个集合；
5. 这里利用jsp对象中的session来保存改集合；
6. servlet的工作做好后，最后将页面重定向到主页面 Main.jsp ；
7. 主页面Main利用 getAttribute 方法获取到之前的集合，将其保存在新的集合里；
8. 主页面Main利用 foreach 遍历。

ALLServlet.java：

//标识为空，进行全查
if (action == null) {
    //利用Student类型的集合来接收返回值
    List<Student> studentList = studentService.getAll();
    //若返回值不为空，则将集合保存在session对象
    if (studentList != null) {
        HttpSession httpSession = request.getSession();
        httpSession.setAttribute("all", studentList);
        //重定向到 Main.jsp
        response.sendRedirect("Main.jsp");
    } 
    //若集合为空，就重定向到Login.jsp，（忽略数据库表为空的情况）
    else {
        response.sendRedirect("Login.jsp");
    }
}

Main.jsp：

<%
    List<Student>  studentList = (List<Student>) session.getAttribute("all");
%>

<%
    for (Student stu : studentList){
%>
<tr>
    <td><%=stu.getStu_id()%></td>
    <td><%=stu.getStu_username()%></td>
    <td><%=stu.getStu_password()%></td>
    <td><a href="#">修改</a></td>
</tr>
<%
    }
%>

根据姓名全查

Servlet/JSP步骤说明：

1. 判断标识，当标识的值为按钮名时，进入到 ALLServlet 中查询姓名的部分；
2. 获取到输入栏输入的信息；
3. 调用 studentService 里的全查方法（参数为输入栏信息）；（可查看上文的 getName）
4. 查询姓名返回的是多个条信息，也需要用集合来接收；
5. 将新的集合替换掉原来session中的旧集合；（没有判断新集合是否为空）
6. servlet的工作做好后，最后将页面重定向到主页面 Main.jsp ；
7. 剩下与全查一致。

ALLServlet.java：

//当标识为查询姓名则进来
else if (action.equals("查询姓名")) {
    String stuName = request.getParameter("stuName");
    List<Student> studentList = studentService.getName(stuName);
    HttpSession httpSession = request.getSession();
    //替换掉旧的集合
    httpSession.setAttribute("all", studentList);
    response.sendRedirect("Main.jsp");
}

Main.jsp：

查询：<input type="text" name="stuName">
<input type="submit" name="action" value="查询姓名">

根据ID查询

Servlet/JSP步骤说明：

1. 判断标识，当标识的值为按钮名时，进入到 ALLServlet 中查询ID的部分；
2. 获取到输入栏输入的信息；
3. 调用 studentService 里的查询ID的方法（参数为输入栏信息）；（可查看上文的 getDel）
4. 查询ID返回的只有一个条信息，所以用Student对象来接收；
5. 由于主页面Main使用集合来接收的，为了方便，将对象添加到信息的集合里面；
6. 将新的集合替换掉原来session中的旧集合；（没有判断新集合是否为空）
7. servlet的工作做好后，最后将页面重定向到主页面 Main.jsp ；
8. 剩下与全查一致。

ALLServlet.java：

//当标识为查询ID则进来
else if (action.equals("查询ID")) {
    int stuName = Integer.parseInt(request.getParameter("stuName"));
    Student student = studentService.getId(stuName);
    List<Student> studentList = new ArrayList<>();
    //将Student对象添加到集合当中
    studentList.add(student);
    HttpSession httpSession = request.getSession();
    //替换掉旧的集合
    httpSession.setAttribute("all",studentList);
    response.sendRedirect("Main.jsp");
}

Main.jsp：

查询：<input type="text" name="stuName">
<input type="submit" name="action" value="查询ID">

根据ID删除

Servlet/JSP步骤说明：

1. 当用户勾选需要删除的信息，可以是一条或多条；
2. 点击删除按钮；
3. 判断标识，当标识的值为按钮名时，进入到 ALLServlet 中和删除ID的部分；
4. 由于要删除的可能有多条信息，所以需要用 getParameterValues 方法来接收（该方法获取的是多选框被选中的信息），获取到的是学生ID，返回值为String类型的数组类型；
5. 调用 studentService 里的删除ID的方法（参数为输入栏信息）；（可查看上文的 getDel）
6. 删除ID方法返回的是受影响行数（int类型）；
7. servlet的工作做好后，最后将页面重定向到 AllServlet （相当于刷新页面）；

ALLServlet.java：

//当标识为删除则进来
else if (action.equals("删除")) {
    System.out.println(action);
    //用数组类接受返回值
    String[] del_Id = request.getParameterValues("delId");
    int i = studentService.getDel(del_Id);
    response.sendRedirect("/AllServlet");
}

Main.jsp：

删除按钮：

<input type="submit" name="action" id="delID" value="删除">

信息表头：

<tr>
    <td>
        <input type="checkbox" name="allDel" οnclick="allCheck(this)">
    </td>
    <td>学生编号</td>
    <td>学生姓名</td>
    <td>学生密码</td>
    <td>操作</td>
</tr>

实现全选：

function allCheck(obj){
    var delId = $("[name=delId]");
    for (var i = 0; i < delId.length; i++) {
        delId[i].checked = obj.checked;
    }
}

信息表： checkbox的value的值给的是学生ID

<tr>
    <td>
        <input type="checkbox" name="delId" class="checked" value="<%=stu.getStu_id()%>">
    </td>
    <td><%=stu.getStu_id()%></td>
    <td><%=stu.getStu_username()%></td>
    <td><%=stu.getStu_password()%></td>
    <td>
        <a href="#">修改</a>
    </td>
</tr>

添加学生

Servlet/JSP步骤说明：

1. 点击添加按钮，进入到 ALLServlet ；
2. 判断标识，当标识的值为按钮名时，进入到 ALLServlet 中添加的部分；
3. 将页面重定向到添加页面 Insert.jsp ；
4. 添加页面包含学生的用户名和密码（ID为自增，无需添加），当点击确认添加时，先进行表单验证，判断输入栏是否有空；（表单验证部分与教师的一致）
5. 若输入栏均不为空，则提交到 ALLServlet ；
6. 判断标识，当标识的值为按钮名时，进入到 ALLServlet 中确认添加的部分；
7. 获取用户输入学生的用户名和密码；
8. 实例化一个Student的有参对象（有参构造），参数为输入值；
9. 调用 studentService 里的插入方法（参数Student对象）；（可查看上文的 Insert）
10. 利用 int 类型的值来获取方法的返回值；
11. 判断该值是否大于0，为真则证明添加成功，并将页面转发至登录页面 ALLServlet ；为假，则重定向到原来的添加页面。

ALLServlet.java：

//当标识为确认添加则进来
else if (action.equals("确认添加")) {
    System.out.println(action);

    String stuName = request.getParameter("stuName");
    String stuPass = request.getParameter("stuPass");
    Student student = new Student(stuName, stuPass);
    int i = studentService.Insert(student);
    if (i > 0) {
        response.sendRedirect("/AllServlet");
    } else {
        response.sendRedirect("Insert.jsp");
    }
}

Main.jsp：

<input type="submit" name="action" value="添加">

Insert.jsp：

<h1>添加学生</h1>
<form method="post" action="AllServlet" id="form">
    用户名：<input name="stuName"><br/>
    密码：<input name="stuPass"><br/><br/>
    <input type="submit" name="action" value="确认添加">
    <input type="reset" value="重置">
</form>

学生信息修改

Servlet/JSP步骤说明：

1. 点击操作框里的修改，则进入修改页面 Update.jsp ，同时需要提交的信息有学生ID，学生用户名和密码；
2. 进到修改页面后，对应的学生的信息显示在输入框中，学生ID不能修改，设置为只读；
3. 用户可修改用户名和密码，可单改可全改；
4. 点击确认修改按钮，进入到 ALLServlet ；
5. 判断标识，当标识的值为按钮名时，进入到 ALLServlet 中添加的部分；
6. 实例化一个Student对象；
7. 将获取到学生的所有信息赋给该对象；
8. 调用 studentService 里的修改方法（参数Student对象）；（可查看上文的 getUpdate）
9. 利用 int 类型的值来获取方法的返回值；
10. 判断该值是否大于0，为真则证明添加成功，并将页面转发至登录页面 ALLServlet ；为假，则重定向到原来的修改页面。

ALLServlet.java：

//当标识为确认修改则进来
else if(action.equals("确认修改")) {
    Student student = new Student();
    student.setStu_id(Integer.parseInt(request.getParameter("stuID")));
    student.setStu_username(request.getParameter("stuName"));
    student.setStu_password(request.getParameter("stuPass"));
    int i = studentService.getUpdate(student);
    if (i > 0) {
        response.sendRedirect("/AllServlet");
    } else {
        response.sendRedirect("Update.jsp");
    }
}

Main.jsp： 获取对应学生的ID、姓名、密码

<td>
    <a href="./Update.jsp?stuID=<%=stu.getStu_id()%>&stuName=<%=stu.getStu_username()%>&stuPass=<%=stu.getStu_password()%>">修改</a>
</td>

Update.jsp：

<form method="post" action="AllServlet" id="form">
    用户ID：<input name="stuID" id="stuID" readonly><br/>
    用户名：<input name="stuName" id="stuName"><br/>
    密码：<input name="stuPass" id="stuPass"><br/><br/>
    <input type="submit" name="action" value="确认修改">
    <input type="reset" value="重置">
</form>

获取学生=信息： 截取url里的字符换。

<script src="js/jquery-3.6.0.js" type="text/javascript"></script>
<script>
    $(document).ready(function () {
        var url = window.location.href;
        if (url.indexOf("?") != -1) {
            var str = url.substr(1);
            strs = str.split("?")[1];
            strs = strs.split("&");
            var stuID = strs[0].split("=")[1];
            var stuName = decodeURI(strs[1].split("=")[1]);
            var stuPass = strs[2].split("=")[1];
            $("#stuID").val(stuID);
            $('#stuName').val(stuName);
            $('#stuPass').val(stuPass);
        }
    })
</script>

写在最后

所有内容都打包上传了，需要的自行下载。

注意节点：

1. 将表示层与数据访问隔离开（低耦合）；
2. Service与DAO的内容一致，Service_Impl与DAO_Impl的内容一致；
3. Servlet映射有有两种方法；
4. 教师注册与登录用到了转发；
5. 表单验证出现在教师注册、教师登录、添加学生；
6. action作为标识，用来判断需要完成的功能；
7. 学生部分，查询有关的功能重定向到主页Main，增删改重定向到 ALLServlet ；
8. 修改时，在修改页面获取的信息，是通过字符串截取实现的。

 

---

6.0.js" type=“text/javascript”>

# 写在最后

所有内容都打包上传了，需要的自行下载。

**注意节点：**

1. 将表示层与数据访问隔离开（低耦合）；
2. Service与DAO的内容一致，Service_Impl与DAO_Impl的内容一致；
3. Servlet映射有有两种方法；
4. 教师注册与登录用到了转发；
5. 表单验证出现在教师注册、教师登录、添加学生；
6. action作为标识，用来判断需要完成的功能；
7. 学生部分，查询有关的功能重定向到主页Main，增删改重定向到 `ALLServlet` ；
8. 修改时，在修改页面获取的信息，是通过字符串截取实现的。



 

------

<div align="center">❤️&nbspEND&nbsp❤️</div>