阶段二模块三解题思路

最新推荐文章于 2021-05-30 22:17:52 发布

是你得不到的人

最新推荐文章于 2021-05-30 22:17:52 发布

阅读量532

点赞数 1

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/weixin_43835305/article/details/108847507

版权

JavaSE 专栏收录该内容

37 篇文章 1 订阅

订阅专栏

模块编程题

使用前端、数据库、JavaWeb 等技术并采用 MVC 设计模式,基于三层架构实现学生信息管理系统
其中学生信息有：
- 学号、姓名、性别、出生日期
要求：
- a. 完成用户登陆功能（判断用户输入的用户名密码和数据库存储的用户名密码是否相同）
  - 当登陆成功跳转到首页显示登陆成功（页面、数据库表自行设计实现）
- b.完成用户添加功能（首先跳转到添加页面，将页面表单中填写的内容保存到数据库中）
- c.使用过滤器对添加用户的请求进行拦截，判断是否是未登录状态
  - 未登录：跳转到登陆页面
  - 已登陆：放行到目标资源，完成添加操作
- 提示：用户登陆时，将用户信息存到session中，过滤器中判断session中有没有用户信息

解题思路

代码资源：代码
第二阶段模块三作业效果演示

前端页面

使用vue框架挂载页面，使用jQuery的ajax异步请求

1.需要设计三个页面，登录页、首页、添加信息页。

2.登录页设计文本框，密码框以及登录按钮，还可以加一个注册按钮；提交信息采用ajax异步请求，登录按钮绑定点击事件提交post请求，将请求数据发送给后端，然后根据后端的响应信息判断用户名密码是否正确，正确跳转到首页，不正确给予提示；注册按钮绑定点击事件，点击后跳转到注册页

3.首页设计了一个添加按钮，表格(用来展示用户列表)以及删除按钮；添加按钮绑定点击事件，点击跳转添加用户页；表格用来展示用户列表，其中采用了vue框架的v-for指令遍历用户列表；删除按钮绑定点击事件，点击向后端提交post请求删除指定数据，再根据后端响应信息给予相应的提示

4.添加信息页设计文本框，密码框，单选框，添加按钮(注册按钮)，注册页和添加信息页其实是一样的；文本框用来输入用户名以及出生日期，密码框输入密码，单选框用来选择性别默认选中男；添加按钮绑定点击事件，点击则向后端发送post请求，根据后端响应信息给予提示，添加按钮只有在四个输入框都有值时才能点击

前端代码展示

index.html（登录页）

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>学生管理系统</title>
    <script src="resource/jquery-3.5.1.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <style>
        body {
            padding: 0;
            margin: 0;
        }
        #top {
            width:100%;
            height: 500px;
            background-color: lightseagreen;
        }
        #content {
            height: 500px;
            width: 700px;
            border: dimgray 1px solid;
            background-color: white;
            float: left;
            margin-left: 30%;
            margin-top: 200px;
        }
        #bottom {
            width: 100%;
            height: 50%;
            background-color: white;
        }
        input {
            height: 30px;
            width: 300px;
            margin-left: 30px;
        }
        #name {
            margin-left: 140px;
            margin-top: 100px;
        }
        #password {
            margin-left: 156px;
            margin-top: 60px;
        }
        #but {
            margin-left: 110px;
            margin-top: 60px;
        }
        #login {
            width: 200px;
            height: 40px;
            background-color: darkseagreen;
        }

        #reg {
            margin-left: 20px;
            width: 200px;
            height: 40px;
            background-color: dodgerblue;
        }
        p {
            color: red;
            margin-left: 150px;
        }
    </style>
</head>
<body>
    <div id="content">

            <div id="name">
                用户名 <input type="text" name="name" placeholder="请输入用户名"
                           v-model="name" @focus="show1" @blur="show3"/>
            </div>
            <p v-show="flag1">请输入用户名</p>
            <div id="password">
                密码   <input type="password" name="password" placeholder="请输入密码"
                            v-model="password" @focus="show2" @blur="show4"/>
            </div>
            <p v-show="flag2">请输入密码</p>
            <P v-show="flag3">{{msg}}</P>
            <div id="but" >
                <input id="login" type="submit" value="登录" @click="login"/>
                <button id="reg" @click="add">注册</button>
            </div>
    </div>
    <div id="top"></div>
</body>

<script>
    // 创建Vue对象
    new Vue({
        el: "#content", // 挂载
        data:{
            flag1:false,   // 控制用户名提示消息框
            flag2:false,   // 控制密码提示消息框
            flag3:false,   // 控制登录信息提示消息框
            loginFlag:false,  // 记录是否已经点过登录按钮
            msg:"",         // 登录提示的消息
            name:"",       // 用户名
            password: ""   // 密码
        },
        methods:{
            // 点击登录按钮
            login:function () {
                if("" == this.name){  // 用户名为空，提示框显示
                    this.flag1 = true;
                }
                if("" == this.password){  // 密码框为空，提示框显示
                    this.flag2 = true
                }
                this.loginFlag=true;  // 点击过登录按钮
                if("" != this.name && "" != this.password){ // 用户名密码都不为空
                    var t = this;
                    // 向后端发送post请求
                    $.post("/student_item/login",{  // 请求参数
                            name:this.name,
                            password:this.password
                        },
                        function(data){ // 响应回调函数
                            var jsonData = JSON.parse(data); // json解析
                            var code = jsonData["code"];   // 消息类型

                            if (code==0){  // 登录失败，相应提示
                                t.name="";
                                t.password="";
                                t.flag3=true;
                                t.msg=jsonData["msg"];
                            }else{ // 登录成功，跳转列表页
                                window.location.href = "/student_item/item.html"
                            }
                        });
                }
            },
            // 用户款获得焦点
            show1:function () {
                this.flag1=false;
                this.flag3=false
            },
            // 密码框获得焦点
            show2:function () {
                this.flag2 = false;
                this.flag3 = false
            },
            // 用户框失去焦点
            show3:function () {
                if("" == this.name && this.loginFlag){
                    this.flag1=true
                }
            },
            // 密码框失去焦点
            show4:function () {
                if("" == this.password && this.loginFlag){
                    this.flag2=true
                }
            },
            // 点击注册按钮，跳转注册页面
            add:function () {
                window.location.href = "/student_item/register.html"
            }
        }
    })
</script>
</html>

item.html（首页，列表展示页）

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>学生信息</title>
    <script src="resource/jquery-3.5.1.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
</head>
<body>
    <div id="content">
        <div style="margin-left: 20%; margin-top: 40px">
            <button style="height: 30px; width: 80px" @click="add">添加</button>
        </div>

        <table style="margin-top: 20px" border="1px" width="60%" align="center" cellspacing="0px">
            <tr>
                <th>学号</th>
                <th>姓名</th>
                <th>性别</th>
                <th>出生日期</th>
                <th>操作</th>
            </tr>
            <tr v-for="(student, index) in students" align="center" style="font-weight: bold; font-size: 18px">
                <td>{{student.id}}</td>
                <td>{{student.name}}</td>
                <td>{{student.sex == 0 ? "男" : "女"}}</td>
                <td>{{student.birthday}}</td>
                <td><button @click="deleteStudent(student.id)">删除</button></td>
            </tr>
        </table>
    </div>
</body>

<script>
    // 创建vue对象
    new Vue({
        el:"#content",  // 挂载
        data:{
            students:[]  // 学生信息列表
        },
        methods:{
            // 点击添加按钮，跳转添加用户页面
            add:function () {
                window.location.href = "/student_item/add.html"
            },
            // 点击删除按钮，删除对应用户
            deleteStudent:function (id) {
                // post请求
                $.post("/student_item/deleteStudent",{ //请求参数
                    "id" : id
                },function (data) {  // 响应回调函数
                    var jsonData = JSON.parse(data);  // json 解析
                    var code = jsonData.code;    // 消息类型
                    if(code == 3){   // 未登录状态，跳转回登录页
                        alert(jsonData.msg);
                        window.location.href = "/student_item/index.html"
                    }else{ // 登录状态，删除后重新加载本页面
                        alert(jsonData.msg);
                        window.location.reload();
                    }
                })
            }
        },
        // 挂载后执行，发送请求
        mounted(){ // 页面加载就请求用户列表数据
            var t = this;
            // get请求，获取用户列表
            $.get("/student_item/listStudent",{},
                function (data) {
                    var jsonData = JSON.parse(data); // json解析
                    var students = jsonData.data;    // 返回的数据
                    t.students = students;   // 赋值，其通过v-model和页面进行了双向通讯
            })
        }
    })
</script>
</html>

add.html（添加信息页)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>添加学生信息</title>
    <!--    导入jquery和vue包-->
    <script src="resource/jquery-3.5.1.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <!--    配置界面样式-->
    <style>
        body {
            padding: 0;
            margin: 0;
        }
        #top {
            width:100%;
            height: 500px;
            background-color: lightseagreen;
        }
        #content {
            height: 500px;
            width: 700px;
            border: dimgray 1px solid;
            background-color: white;
            float: left;
            margin-left: 30%;
            margin-top: 200px;
        }
        .tx {
            height: 30px;
            width: 300px;
            margin-left: 30px;
        }
        #name {
            margin-left: 140px;
            margin-top: 60px;
        }
        #password {
            margin-left: 156px;
            margin-top: 40px;
        }
        #birthday {
            margin-left: 125px;
            margin-top: 40px;
        }
        #sex {
            margin-left: 156px;
            margin-top: 40px;
        }
        #but {
            margin-left: 260px;
            margin-top: 40px;
        }
        #login {
            width: 200px;
            height: 40px;
            background-color: darkseagreen;
        }

        #reg {
            margin-left: 20px;
            width: 200px;
            height: 40px;
            background-color: dodgerblue;
        }
        p {
            color: red;
            margin-left: 150px;
        }
    </style>
</head>
<body>
<div id="content">

    <div id="name">
        用户名 <input class="tx" type="text" name="name" placeholder="请输入用户名"
                   v-model="name" @blur="isEmpty"/>
    </div>

    <div id="password">
        密码   <input class="tx" type="password" name="password" placeholder="请输入密码"
                    v-model="password"  @blur="isEmpty"/>
    </div>

    <div id="sex">
        &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
        <input type="radio" name="sex" checked="checked" v-model="sex" value=0 />男
        &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
        <input type="radio" name="sex" v-model="sex" value=1 />女
    </div>

    <div id="birthday">
        出生日期 <input class="tx" type="text" name="birthday" placeholder="请输入出生日期" v-model="birthday" @blur="isEmpty"/>
    </div>

    <div id="but" >
        <input :disabled="flag" id="login" type="submit" value="添加" @click="add"/>
    </div>

</div>
<div id="top"></div>
</body>
<script>
    // vue框架
    new Vue({
        el:"#content",  // 挂载
        data:{ // 使用 v-model 和页面双向通讯
            flag:true, // 添加按钮是否可点击
            name:"",   // 用户名
            password:"",  // 密码
            sex:0,     // 性别 0男 1女
            birthday:""  // 出生日期
        },
        methods:{
            isEmpty:function () {
                // 用来配置添加按钮的disabled属性，防止信息未输入全就添加
                if(this.name != "" && this.password != "" && this.birthday != ""){
                    this.flag = false;
                }else{
                    this.flag = true
                }
            },
            // 点击添加按钮
            add:function () {
                var t = this; // 复制vue对象，在ajax中的this不再是vue的this
                // post 请求服务器添加用户
                $.post("/student_item/addStudent",{// 请求参数
                    name: this.name,
                    password: this.password,
                    sex: this.sex,
                    birthday: this.birthday
                },function (data) { // 响应回调函数
                    var jsonData = JSON.parse(data);  // 解析json
                    var code = jsonData.code;        // 消息类型
                    if(code==0){                      // 判断是否添加成功
                        alert(jsonData.msg)         // 弹框
                    }else if(code == 1){ // 添加成功，跳转列表页
                        window.location.href = "/student_item/item.html"
                    }else{ // 未登录状态，跳转回登录页
                        alert(jsonData.msg);
                        window.location.href = "/student_item/index.html"
                    }
                })
            }
        }
    })
</script>
</html>

后端

采用Servlet作为服务，mysql数据库作为存储数据，Druid德鲁伊连接池用于连接数据库，DBUtils用于和数据库交互，用json格式处理响应信息，tomcat代理服务器，采用MVC和三层架构理念，设计项目目录

1.创建数据库和数据表

2.先处理数据库的交互，完成DruidUtils德鲁伊连接池的编写，配置其配置文件，测试是否连接成功

3.编写DB.java，提供增删改操作，采用DBUtils的自动创建方式和数据库交互，将QueryRunner放在静态代码块中创建，这样就不需要每个操作都要创建一次QueryRunner

4.编写实体类，要实现序列化接口，提供构造方法，Getter和Setter

5.编写具体逻辑处理类，登录Login.java，继承HttpServlet抽象类，重写doGet和doPost方法，在doGet方法中，使用ParseParamUtils工具类提供的方法处理请求数据，通过DB.java提供的方法，验证用户名和密码，验证成功，将用户名和密码存入session中，用RestResultUtils中提供的响应模板响应前端页面

其他逻辑处理类的逻辑也差不多

6.编写拦截器AddFilter.java，实现Filter接口，重写方法，在doFilter方法中处理逻辑，从session中取出登录时存入的用户名，如果取得则放行，如果未取得表示未登录，则响应前端未登录的信息，让前端跳转到登录页；

注意点是，写完响应要return，不然会继续向下执行，则会执行放行代码，起不到拦截的效果

7.编写web配置文件web.xml，添加登录，注册，删除，添加等操作的请求路由，配置拦截器拦截删除和添加请求

后端代码展示

DruidUtils.java

package com.panxiaojia.utils;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

public class DruidUtils {

    // 1.定义成员变量
    private static DataSource dataSource;

    // 2.静态代码块
    static {
        try{
            // 3.创建属性集对象
            Properties p = new Properties();

            //4.加载配置文件 Druid 连接池不能够主动加载配置文件 ,需要指定文件
            InputStream resourceAsStream = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");

            //5. 使用Properties对象的 load方法 从字节流中读取配置信息
            p.load(resourceAsStream);

            //6. 通过工厂类获取连接池对象
            dataSource = DruidDataSourceFactory.createDataSource(p);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 获取连接池对象
    public static DataSource getDataSource(){
        return dataSource;
    }

    // 获取连接的方法
    public static Connection getConnection(){
        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

    //释放资源
    public static void close(Connection con, Statement statement){

        if(con != null && statement != null){
            try {
                statement.close();
                //归还连接
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static void close(Connection con, Statement statement, ResultSet resultSet){

        if(con != null && statement != null && resultSet != null){
            try {
                resultSet.close();
                statement.close();
                //归还连接
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

ParseParamUtils

package com.panxiaojia.utils;
import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

public class ParseParamUtils {

    // 请求参数二次封装
    public static Map<String, Object> parseParamMapObject(HttpServletRequest request) {
        Map<String, String> map = parseParamMap(request);
        Map<String, Object> map2 = new HashMap(map);
        return map2;
    }
    // 请求参数一次封装
    public static Map<String, String> parseParamMap(HttpServletRequest request) {
        // 申明一个集合
        Map<String, String> map = new HashMap();
        // 参数处理
        if (null != request) { // 请求不为空
            // 取得请求参数的所有参数名
            Enumeration enumeration = request.getParameterNames();

            while(true) {
                String paraName;  // 参数名
                String paraValue;  // 参数值
                // 请求参数无下一个 则返回集合
                if (!enumeration.hasMoreElements()) {
                    return map;
                }
                // 获取参数名
                paraName = (String)enumeration.nextElement();
                // 获取参数值
                paraValue = request.getParameter(paraName);
                if (null != paraValue) { // 参数值不为空
                    paraValue = paraValue.trim();  // 去空格
                }
                // 参数如果不为空，但为字符串null 或 undefind，设为对象null
                // sql中不能带null 和 undefined
                if ("null".equals(paraValue) || "undefined".equals(paraValue)) {
                    paraValue = null;
                }
                // 参数值为空字符串的处理
                if (paraValue == "") {
                    paraValue = null;
                }
                // 将参数名和参数值放入集合
                map.put(paraName, paraValue);
            }
        } else {
            return map;
        }
    }
}

package com.panxiaojia.utils;
import com.google.gson.Gson;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;

public class RestResultUtils {

    public static void restResult(HttpServletResponse resp, int code, Object data, String msg) throws IOException {
        // 设置response 的返回编码，防止乱码
        resp.setContentType("text/html;charset=utf-8");
        // response 响应体输出流
        PrintWriter out = resp.getWriter();
        Map<String, Object> result = new HashMap<>();
        Gson gson = new Gson();  // json对象， 需要GSon.jar包
        // 消息封装进集合
        result.put("code", code);
        result.put("data", data);
        result.put("msg", msg);
        // 将集合json格式化，以便传输
        String item = gson.toJson(result);
        // 响应消息
        out.print(item);
    }
}

DB.java

package com.panxiaojia.dao;

import com.panxiaojia.domain.Student;
import com.panxiaojia.utils.DruidUtils;
import javafx.beans.binding.ObjectExpression;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.sql.SQLException;
import java.util.List;
import java.util.Map;

public class DB {
    // 声明一个QueryRunner变量
    private static QueryRunner qr;
    // 静态代码块。初始化qr,抽取到静态代码块，是为了提高效率，不需要每次访问都创建一个qr
    static{
        // 自动创建方式
        qr = new QueryRunner(DruidUtils.getDataSource());
    }
    // 根据id查询信息
    public static Student findById(Map<String, Object> param){

        String sql = "select * from student where id=?";
        Student student = null;

        try {
            student = qr.query(sql, new BeanHandler<Student>(Student.class), param.get("id"));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return student;
    }
    // 查询所有用户信息，用户信息列表
    public static List<Student> findAll(){
        String sql = "select * from student";
        List<Student> students = null;

        try {
            // 查询
            students = qr.query(sql, new BeanListHandler<Student>(Student.class));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return students;
    }
    // 根据用户名查询用户
    public static Student findByName(Map<String, Object> param){
        String sql = "select * from student where name=?";
        Student student = null;

        try {
            // 查询
            student = qr.query(sql, new BeanHandler<Student>(Student.class), param.get("name"));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return student;
    }
    // 添加用户信息
    public static int add(Map<String, Object> param){
        String sql = "insert into student(name, password, sex, birthday) values(?,?,?,?)";
        int update = 0;
        try {
            // 封装参数
            Object[] params = {param.get("name"), param.get("password"),
                               param.get("sex"), param.get("birthday")};
            // 更新，返回添加成功的条数
            update = qr.update(sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return update;
    }
    // 更新用户信息
    public static int update(Map<String, Object> param){
        String sql = "update student set name=?, password=?, sex=?, birthday=? where id=?";
        int update = 0;
        try {
            // 封装参数
            Object[] params = {param.get("name"), param.get("password"),
                    param.get("sex"), param.get("birthday")};
            // 更新
            update = qr.update(sql, params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return update;
    }
    // 根据id删除用户
    public static int deleteById(Map<String, Object> param){
        String sql = "delete from student where id=?";
        int delete = 0;
        try {
            // 更新
            delete = qr.update(sql, param.get("id"));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return delete;
    }
}

Student.java

package com.panxiaojia.domain;
import java.io.Serializable;
public class Student  implements Serializable {
    private int id; // 学号
    private String name;  // 姓名
    private String password; // 密码
    private int sex;      // 性别 0男  1女
    private String birthday;  // 出生日期
    private int disabled;  // 禁用 0否 1是
    private int deleted;   // 删除 0否 1是

    public Student() {
    }

    public Student(int id, String name, String password, int sex, String birthday, int disabled, int deleted) {
        this.id = id;
        this.name = name;
        this.password = password;
        this.sex = sex;
        this.birthday = birthday;
        this.disabled = disabled;
        this.deleted = deleted;
    }

    public String getName() {
        return name;
    }

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

    public int getSex() {
        return sex;
    }

    public int getId() {
        return id;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }

    public int getDisabled() {
        return disabled;
    }

    public void setDisabled(int disabled) {
        this.disabled = disabled;
    }

    public int getDeleted() {
        return deleted;
    }

    public void setDeleted(int deleted) {
        this.deleted = deleted;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday='" + birthday + '\'' +
                '}';
    }
}

AddStudent.java

package com.panxiaojia.service;

import com.panxiaojia.dao.DB;
import com.panxiaojia.domain.Student;
import com.panxiaojia.utils.ParseParamUtils;
import com.panxiaojia.utils.RestResultUtils;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

public class AddStudent extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 对请求参数进行一定的封装处理
        Map<String, Object> paramMap = ParseParamUtils.parseParamMapObject(req);
        // 查询是否用户已存在
        Student student = DB.findByName(paramMap);
        if(student != null){
            // 返回信息的包装
            RestResultUtils.restResult(resp, 0, "", "当前用户已存在");
            return;
        }
        // 添加用户信息到数据库
        int num = DB.add(paramMap);
        if(num==0){
            // 返回信息的包装
            RestResultUtils.restResult(resp, 0, "", "添加学生失败");
        }else{
            // 返回信息的包装
            RestResultUtils.restResult(resp, 1, "", "添加学生成功");
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 调用doGet方法
        doGet(req, resp);
    }
}

DeleteStudent.java

package com.panxiaojia.service;

import com.panxiaojia.dao.DB;
import com.panxiaojia.utils.ParseParamUtils;
import com.panxiaojia.utils.RestResultUtils;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

public class DeleteStudent extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 对请求参数进行一定封装处理
        Map<String, Object> param = ParseParamUtils.parseParamMapObject(req);
        // 根据用户id删除用户
        int num = DB.deleteById(param);
        if(num==0){
            // 返回信息的包装
            RestResultUtils.restResult(resp, 0, "", "删除失败");
        }else{
            // 返回信息的包装
            RestResultUtils.restResult(resp, 1, "", "删除成功");
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 调用doGet方法
        doGet(req, resp);
    }
}

ListStudent.java

package com.panxiaojia.service;

import com.google.gson.Gson;
import com.panxiaojia.domain.Student;
import com.panxiaojia.dao.DB;
import com.panxiaojia.utils.RestResultUtils;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ListStudent extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 用户列表信息
        List<Student> students = DB.findAll();

        if(null == students){
            // 返回信息的包装
            RestResultUtils.restResult(resp, 1, new ArrayList<>(), "查询无结果");
        }else{
            // 返回信息的包装
            RestResultUtils.restResult(resp, 1, students, "success");
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

package com.panxiaojia.service;

import com.panxiaojia.domain.Student;
import com.panxiaojia.dao.DB;
import com.panxiaojia.utils.ParseParamUtils;
import com.panxiaojia.utils.RestResultUtils;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.Map;

public class Login extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 请求参数的封装处理
        Map<String, Object> param = ParseParamUtils.parseParamMapObject(req);
        // 查询用户是否存在
        Student student = DB.findByName(param);
        if(student == null){ // 不存在，则提示用户名密码不正确
            // 返回信息的包装
            RestResultUtils.restResult(resp, 0, "", "用户名/密码不正确");
        }else{// 存在，判断密码是否匹配
            // 取得密码
            String password = student.getPassword();
            if(password.equals(param.get("password"))){ // 密码匹配
                // 往session中添加信息
                HttpSession session = req.getSession();
                session.setAttribute("name", student.getName());
                session.setAttribute("password", student.getPassword());
                // 返回信息的包装
                RestResultUtils.restResult(resp, 1, "", "登录成功");
            }else{
                // 返回信息的包装
                RestResultUtils.restResult(resp, 0, "", "用户名/密码不正确");
            }
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 调用doGet方法
        doGet(req, resp);
    }
}

package com.panxiaojia.service;

import com.panxiaojia.dao.DB;
import com.panxiaojia.domain.Student;
import com.panxiaojia.utils.ParseParamUtils;
import com.panxiaojia.utils.RestResultUtils;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

public class Register extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 请求参数的封装处理
        Map<String, Object> paramMap = ParseParamUtils.parseParamMapObject(req);
        // 查询用户名是否已存在
        Student student = DB.findByName(paramMap);
        if(student != null){ // 存在，则提示用户名已存在
            // 返回信息的包装
            RestResultUtils.restResult(resp, 0, "", "当前用户已存在");
            return;
        }
        // 添加学生信息
        int num = DB.add(paramMap);
        if(num==0){ // 注册成功0条即注册失败
            // 返回信息的包装
            RestResultUtils.restResult(resp, 0, "", "注册失败");

        }else{
            // 返回信息的包装
            RestResultUtils.restResult(resp, 1, "", "注册成功");
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 调用doGet方法
        doGet(req, resp);
    }
}

AddFilter.java

package com.panxiaojia.fliter;

import com.google.gson.Gson;
import com.panxiaojia.utils.RestResultUtils;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

public class AddFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // 向下转型
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        // 取得session空间， 判断是否有内容
        HttpSession session = request.getSession();
        Object name = session.getAttribute("name");
        // 拦截 验证
        if(null == name){ // session 空间无登录信息，提示用户登录
            RestResultUtils.restResult(response, 3, "", "未登录，请重新登录!");
            return;
        }
        // 符合要求 放行
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {

    }
}

web配置文件

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
<!--    配置可访问的路由-->
    <!-- 配置添加用户的路由   -->
    <servlet>
        <servlet-name>AddStudent</servlet-name>
        <servlet-class>com.panxiaojia.service.AddStudent</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>AddStudent</servlet-name>
        <url-pattern>/addStudent</url-pattern>
    </servlet-mapping>
    <!-- 配置登录的路由   -->
    <servlet>
        <servlet-name>Login</servlet-name>
        <servlet-class>com.panxiaojia.service.Login</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>Login</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>
    <!-- 配置注册的路由   -->
    <servlet>
        <servlet-name>Register</servlet-name>
        <servlet-class>com.panxiaojia.service.Register</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>Register</servlet-name>
        <url-pattern>/register</url-pattern>
    </servlet-mapping>
    <!-- 配置用户列表的路由   -->
    <servlet>
        <servlet-name>ListStudent</servlet-name>
        <servlet-class>com.panxiaojia.service.ListStudent</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>ListStudent</servlet-name>
        <url-pattern>/listStudent</url-pattern>
    </servlet-mapping>
    <!-- 配置删除用户的路由   -->
    <servlet>
        <servlet-name>DeleteStudent</servlet-name>
        <servlet-class>com.panxiaojia.service.DeleteStudent</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>DeleteStudent</servlet-name>
        <url-pattern>/deleteStudent</url-pattern>
    </servlet-mapping>
    <!-- 配置拦截器的路由  -->
    <filter>
        <filter-name>AddFilter</filter-name>
        <filter-class>com.panxiaojia.fliter.AddFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>AddFilter</filter-name>
        <!--该拦截器的拦截路径 -->
        <url-pattern>/deleteStudent</url-pattern> <!--拦截用户删除-->
        <url-pattern>/addStudent</url-pattern>    <!--拦截用户添加-->
    </filter-mapping>
</web-app>

n>

ListStudent
com.panxiaojia.service.ListStudent

ListStudent
/listStudent

DeleteStudent
com.panxiaojia.service.DeleteStudent

DeleteStudent
/deleteStudent

AddFilter
com.panxiaojia.fliter.AddFilter

AddFilter

/deleteStudent
/addStudent