JavaWeb第十七天

最新推荐文章于 2021-02-22 00:25:55 发布

Prayer96

最新推荐文章于 2021-02-22 00:25:55 发布

阅读量229

点赞数

分类专栏： JavaＷeb 文章标签： jdbc java 列表 jsp servlet

本文链接：https://blog.csdn.net/Prayer96/article/details/113923524

版权

JavaＷeb 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

用户信息列表展示案例

开发过程

需求
用户信息的增删改查
设计
    技术选型
        Servlet+JSP+MySQL+JDBCTemplate+Druid+BeanUtils+服务器
        控制器+展示界面+数据库+数据库操作的封装+数据库连接池+数据封装+Tomcat
    数据库设计
        create database day17; -- 创建数据库
        use day17; -- 使用数据库
        create table user(
            id int primary key auto_increment, -- id 主键 自增长
            name varchar(20) not null, -- 姓名
            gender varchar(5), -- 性别
            age int, -- 年龄
            address varchar(32), -- 籍贯
            qq varchar(20), -- qq
            email varchar(50) -- 邮箱
        ); -- 创建表

        use day17; -- 使用数据库
        create table administrator(
            username varchar(32) not null, -- 用户名
            password varchar(32) not null, -- 密码
        ); -- 创建表
开发
    环境搭建 架构师完成
        创建数据库环境
        创建项目，导入需要的jar包
            创建一个模块，右键添加web框架，不要web.xml
            配置项目到tomcat服务器，修改虚拟目录
            创建目录WEB-INF/lib，存放jar包
    编码
        列表查询
            列表查询分析
                用户通过浏览器看到index.html中的超链接"查询所有用户信息"，点击后跳转到UserListServlet
                UserListServlet
                    因为index.html中没有要接受的参数，所以不需要设置request的编码
                    1、调用service层的findAll方法，返回List集合List<User>
                        UserService service = new UserServiceImpl();
                        将接口引用指向实现类对象，将来只需要改动实现类，不需要改动接口，提升了程序的可扩展性和可维护性，这是一种面向接口的编程方式。
                    2、将List集合存入request域中
                    3、转发到list.jsp页面中展示
                service层
                    UserService接口
                        public List<User> findAll();
                    UserServiceImpl实现类
                        public List<User> findAll() {调用dao.findAll() 将数据返回给UserListServlet};
                dao层
                    UserDao接口
                        public List<User> findAll();
                    UserDaoImpl实现类
                        public List<User> findAll() {使用JDBC操作数据库};
                list.jsp
                    使用jstl+el jstl的foreach标签 获取request域中的List集合，生成表格table，展示数据库中的所有用户信息
            列表查询实现
                在src中创建
                    domain包 实现类
                        User类 JavaBean 是User表的实体类 添加成员变量 get set toString
                    web包
                    service包
                    dao包
                    util包 工具包
                创建index.html对应的index.jsp，将超链接"查询所有用户信息"的href改为指向UserListServlet
                web包
                    创建UserListServlet
                        1、调用service层的findAll方法，返回List<User>对象users
                        2、将users存入request域中
                        3、转发到list.jsp页面 不需要加虚拟目录
                service包
                    创建UserService接口
                        1、声明findAll方法 List<User> findAll();
                    创建impl包
                        创建UserServiceImpl实现类
                            1、实现findAll方法
                                调用dao层的findAll方法
                dao包
                    创建UserDao接口
                        1、声明findAll方法 List<User> findAll();
                    创建impl包
                        创建UserDaoImpl实现类
                            1、实现findAll方法
                                使用JDBC操作数据库
                                    将工具类文件JDBCUtils.java复制到util包下
                                        其中包括获取数据库连接池和连接对象的方法
                                    将Druid配置文件druid.properties复制到src下
                                    1、创建JDBCTemplate对象template，传入JDBCUtils.getDataSource()返回的数据库连接对象作为参数
                                    2、定义sql语句
                                    3、使用template的query方法执行sql语句，参数是sql语句和new的RowMapper对象，RowMapper对象传入User.class，并在<>中传入User，以便向下兼容
                                       query方法返回一个List集合
                list.jsp
                    将list.html的内容复制到list.jsp
                    加上page指令
                    删除写死的表格数据，使用jstl和el动态添加数据
                        引入jstl库 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
                        使用jstl的foreach语句获取request域中的users --> items="${users}"，遍历list
                        <c:forEach items="${users}" var="user" varStatus="s">
                            <tr>
                                <td>${s.count}</td>
                                <td>${user.name}</td>
                                <td>${user.gender}</td>
                                <td>${user.age}</td>
                                <td>${user.address}</td>
                                <td>${user.qq}</td>
                                <td>${user.email}</td>
                                <td><a class="btn btn-default btn-sm" href="update.html">修改</a>&nbsp;<a class="btn btn-default btn-sm" href="">删除</a></td>
                            </tr>
                        </c:forEach>
        登录
            login.jsp
                将login.html复制一份，改为login.jsp，加上page指令
                1、调整页面，加入验证码功能
                    复制CheckCodeServlet到web包的servlet包中
                    修改login.jsp页面中的验证码的img标签的src属性，指向CheckCodeServlet
                    实现验证码的点击切换功能，即refreshCode方法
                2、登录
                    输入用户名、密码和验证码，点击登录，将参数提交到服务器
                    将login.jsp中的登录表单的action指向LoginServlet
                        新建表administrator 添加字段username和password
                        在domain包中创建对应的实体类Administrator 添加成员变量 get set toString
                    创建LoginServlet
                        因为要接受参数，所有先设置request的编码
                        获取用户提交的数据
                            获取填写的验证码
                            获取生成的验证码
                            判断验证码是否正确
                            获取用户提交的参数的map集合
                        将获取到的数据封装为对象
                            使用BeanUtils类的populate方法，传入Administrator对象和参数的map集合
                        调用service层的查询
                            创建UserService对象，调用其的login方法
                            在UserService接口中定义login方法，传入封装好的Administrator对象，返回信息完整的Administrator对象
                            在UserServiceImpl实现类中实现login方法，调用dao层的findAdminByUsernameAndPassword方法
                            在UserDao接口中定义login方法
                            在UserDaoImpl实现类中实现findAdminByUsernameAndPassword方法，使用JDBC操作数据库
                        判断是否登录成功，成功则重定向到index.jsp 失败则存储失败信息，转发到login.jsp
        添加
            分析
                点击list.jsp页面上的添加联系人按钮，跳转到添加联系人的页面addUser.jsp，填写数据，点击提交按钮，将数据提交到服务器的AddUserServlet中
                addUser.jsp
                    将add.html复制一份为addUser.jsp，添加page指令
                    将addUser.jsp中的表单的action指向AddUserServlet
                    创建AddUserServlet
                    修改表单中每个输入框的name，使其与user表中的字段相同
                AddUserServlet
                    设置request的编码
                    获取用户提交的参数
                    封装对象
                    调用service层的添加功能
                    跳转到UsrrListServlet，再次发送查询请求，UserListServlet查询后会转发到list.jsp
                service
                    在UserService接口中定义addUser方法，传入一个User对象
                    在UserServiceImpl实现类中实现addUser方法，传入一个User对象，调用dao层的addUser方法
                dao
                    在UserDao接口中定义addUser方法，传入一个User对象
                    在UserDaoImpl实现类中实现addUser方法，传入一个User对象，使用JDBC操作数据库
        删除
            分析
                点击list.jsp中每个用户的删除按钮，弹出确认删除提示框，确认删除则访问DeleteUserServlet
                每条记录的删除按钮应该绑定该条记录的id
                list.jsp
                    删除提示框
                        将删除按钮的href指向deleteUser方法
                        在JavaScript中定义deleteUser方法，传入用户id
                            弹出确认删除的提示框
                            确认删除则让浏览器跳转至DeleteUserServlet
                            if (confirm("您确定要删除该用户吗？")) {
                                 //让浏览器访问的路径
                                 location.href = "${pageContext.request.contextPath}/deleteUserServlet?id=" + id;
                             }
                    创建DeleteUserServlet
                DeleteUserServlet
                    设置request的编码
                    获取点击的那个按钮对应的记录的id
                    调用service的deleteUser方法
                service
                    在UserService接口中定义deleteUser方法，传入String类型的id
                    在UserServiceImpl实现类中实现deleteUser方法，调用dao层的deleteUser方法，将传入的String类型的id转为int类型
                dao
                    在UserDao接口中定义deleteUser方法，传入int类型的id
                    在UserDaoImpl实现类中实现deleteUser方法，使用JDBC操作数据库
        修改
            分析
                点击每个用户的修改按钮，这里要绑定用户id，先访问FindUserServlet，根据用户的id查询出用户的信息，转发到update.jsp，通过el表达式将用户信息显示在页面上（回显信息）
                修改信息，点击提交，将数据提交到UpdateUserServlet，最后跳转到list.jsp(代码中是跳转到UserListServlet，因为要进行一次查询)
                list.jsp
                    将修改按钮的href指向FindUserServlet 绑定用户id
                        href="${pageContext.request.contextPath}/findUserServlet?id=${user.id}"
                    创建FindUserServlet
                update.jsp
                    复制一份update.html为update.jsp，添加page指令
                    使用el表达式将request域中的User对象的信息回显在update.jsp页面上
                        性别单选框和籍贯下拉框的回显
                            使用jstl标签的if语句 先使用taglib导入jstl标签库
                            判断request域中的User对象的性别和籍贯分别是什么，给其加上checked或selected
                            表单中的姓名具有属性readonly="readonly" 不能修改
                    使用隐藏域来提交id
                        隐藏域不影响布局 input type="hidden"
                    将表单的action指向UpdateUserServlet
                    创建UpdateUserServlet
                FindUserServlet
                    获取用户id
                    调用service的findUserById方法查询用户的信息，返回User对象
                    存储User对象到request域中
                    转发到update.jsp
                UpdateUserServlet
                    设置request的编码
                    获取修改的参数
                    封装对象
                    调用service层的updateUser方法
                    重定向到UserListServlet
                service
                    在UserService接口中定义findUserById方法，传递String类型的id
                    在UserServiceImpl实现类中实现findUserById方法，传递String类型的id，调用dao层的findUserById方法，将id转换为int类型，返回User对象
                    在UserService接口中定义updateUser方法，传递User对象
                    在UserServiceImpl实现类中实现updateUser方法，传递User对象，调用dao层的updateUser方法
                dao
                    在UserDao接口中定义findUserById方法，传递int类型的id
                    在UserDaoImpl实现类中实现findUserById方法，传递int类型的id，使用JDBC操作数据库，返回User对象
                    在UserDao接口中定义updateUser方法，传递User对象
                    在UserDaoImpl实现类中实现updateUser方法，传递User对象，使用JDBC操作数据库
                        update user set name = ?, gender = ?, age = ?, address = ?, qq = ?, email = ? where id = ?;
                        这里需要在update.jsp的表单中使用隐藏域来提交id，从而在UpdateUserServlet中可以获取id对用户进行修改
        删除选中
            分析
                list.jsp
                    获取选中记录的id
                        将用户信息表放在一个表单中，表单支持复选框中数据的提交
                        用户信息表中只有选择框属于表单项，所以提交时只会提交选中的选择框，但要提交数据需要给数据行的选择框input加上name="uid"
                    点击删除选中按钮，弹出提示信息，确认后将这些id提交到DeleteSelectedServlet url?uid=1&uid=2...
                        给删除选中按钮加上单击事件
                            先弹出提示信息
                        不给input加value默认提交的是on，加上value后提交value值，这里给其加上value="${user.id}"
                        如果不选择用户就点击删除选中并确认会报500空指针异常
                            在弹出提示框的if语句中的提交表单之前，判断选中用户数是否>0
                    创建DeleteSelectedServlet
                    实现全选/全不选框
                        给全选/全不选框加上id，获取全选/全不选框
                        遍历数据行的选择框，使得它们的选中状态与全选/全不选框一致
                DeleteSelectedServlet
                    获取id数组 getParameterValues
                    调用service层的deleteUsers方法
                    重定向到UserListServlet，再进行一次查询
                service
                    在UserService接口中定义deleteUsers方法，传递id数组
                    在UserServiceImpl实现类中实现deleteUsers方法，传递id数组，遍历id数组，调用dao层的deleteUser方法
        分页查询
            好处
                每次只查询部分记录，减轻了服务器内存的开销
                用户不需要滚动过长的滚动条，体验较好
            分析
                输入
                    每页显示的记录数 int rows
                    当前页码 int currentPage
                        呈现激活状态
                            使用Bootstrap给当前页码加上class="active"
                输出
                    总记录数 int totalCount
                        select count(*) from user;
                    总页数 int totalPage
                        总记录数 % 每页记录数 == 0 ? 总记录数 / 每页记录数 : 总记录数/每页记录数 + 1
                        totalCount % rows == 0 ? totalCount / rows : totalCount / rows + 1
                    每页数据 List list
                        select * from user limit 开始查询的索引beginRow 要查询的记录数rows
                            开始查询的索引beginRow = (currentPage - 1) * rows
                    当前页码 int currentPage
                        呈现激活状态
                            使用Bootstrap给当前页码加上class="active"
                    将上述数据封装为分页对象PageBean输出给客户端，客户端获取该对象使用el+jstl将数据显示在页面上
            实现
                创建PageBean<T>
                    加上泛型，使得用户列表，商品列表等可以通用这个分页对象
                用户点击页码，传递currentPage和rows，访问FindUserByPageServlet
                FindUserByPageServlet
                    设置request的编码
                    获取参数currentPage和rows
                    调用service层的findUserByPage方法，传入currentPage和rows，返回PageBean对象
                    将PageBean对象存入request域中
                    重定向到UserListServlet，再进行一次查询
                service
                    在UserService接口中定义findUserByPage方法，传入currentPage和rows
                    在UserServiceImpl实现类中实现findUserByPage方法，传入currentPage和rows，返回PageBean对象
                        创建空的PageBean对象
                        使用传入的参数给PageBean对象的currentPage属性和rows属性赋值
                        使用currentPage和rows计算开始查询的索引beginRow
                        调用dao层的findTotalCount方法查询总记录数，并给PageBean对象的totalCount属性赋值
                        调用dao层的findUserByPage方法查询当前页码的用户数据，传入beginRow和rows，返回List集合
                        计算总页码
                        返回PageBean对象
                dao
                    在UserDao接口中定义findTotalCount方法
                    在UserDaoImpl实现类中实现findTotalCount方法，使用JDBC操作数据库
                    在UserDao接口中定义findUserByPage方法，传入currentPage和rows
                    在UserDaoImpl实现类中实现findUserByPage方法，使用JDBC操作数据库
                list.jsp
                    将用户信息表的数据行的循环对象${users}改为${pageBean.list}
                    将<span>共30条记录，共6页</span>改为<span>共${requestScope.pageBean.totalCount}条记录，共${requestScope.pageBean.totalPage}页</span>
                    将假的分页列表改为
                         <c:forEach begin="1" end="${requestScope.pageBean.totalPage}}" var="i">
                            <li><a href="${pageContext.request.contextPath}/findUserByPageServlet?currentPage=${i}&rows=5">${i}</a></li>
                         </c:forEach>
                         通过循环遍历总页数，传入循环的当前页数和每页的记录数来创建分页列表
                    将用户编号改为
                        <td>${s.count * user.currentPage}</td>
                    将index.jsp的超链接"查询所有用户信息"指向findUserByPageServlet
                        要在FindUserByPageServlet中获取参数currentPage和rows时判断是否为空，是则赋值为1和5，否则在调用service层时会因为要将空参数转换为int类型而报错
                    给分页列表的当前页加上激活状态
                        使用jstl的if判断
                            <c:if test="${requestScope.pageBean.currentPage == i}">
                                <li class="active"><a href="${pageContext.request.contextPath}/findUserByPageServlet?currentPage=${i}&rows=5">${i}</a></li>
                            </c:if>
                    实现上一页/下一页
                        修改href="${pageContext.request.contextPath}/findUserByPageServlet?currentPage=${requestScope.pageBean.currentPage - 1}&rows=5"
                           href="${pageContext.request.contextPath}/findUserByPageServlet?currentPage=${requestScope.pageBean.currentPage + 1}&rows=5"
                        当当前页为1时，禁用上一页 最后一页同理
                            <c:if test="${requestScope.pageBean.currentPage == 1}">
                                <li class="disabled">
                            </c:if>
                            <c:if test="${requestScope.pageBean.currentPage != 1}">
                                <li>
                            </c:if>
                                    <a href="${pageContext.request.contextPath}/findUserByPageServlet?currentPage=${requestScope.pageBean.currentPage - 1}&rows=5" aria-label="Previous">
                                        <span aria-hidden="true">&laquo;</span>
                                    </a>
                                </li>
                             后台
                                UserServiceImpl的findUserByPage方法中
                                    if (currentPage < 1) {
                                        currentPage = 1;
                                    }
        复杂条件查询，带分页
            select * from user where name like '%李%' and address like '%北京%' limit 起始索引, 查询多少记录;
            输出
                pageBean对象
                    int totalCount
                        select count(*) from user where name like '%李% and address like '%北京%';
                    List list
                        select * from user where name like '' nad address like '' limit 起始索引, 查询多少记录;
            输入
                参数集合
                    name
                    address
                    email
                根据map集合中的值来动态生成sql，因为用户可能只根据姓名查询，也可能根据姓名，籍贯查询，也可能根据姓名，籍贯，邮箱查询
                初始sql
                    select count(*) from user where 1 = 1 恒等式不影响查询结果
                判断map中的属性是否有值
                    name有值，则StringBuilder.append("and name like ?");
                    address有值，则StringBuilder.append("and address like ?");
                    email有值，则StringBuilder.append("and email like ?");
            list.jsp
                给查询表单加上action="${pageContext.request.contextPath}/findUserByPageServlet" method="post"
                将输入的查询条件回显
                    将参数map集合condition到request域中
                    在页面上显示map中的数据
                        如name的input中加上value="${requestScope.condition.name[0]}"
            FindUserByPageServlet
                获取参数map集合condition
                    Map condition = request.getParameterMap()
                将参数map集合condition到request域中
                调用service层的findUserByPage方法时传递新增的参数condition
            service
                UserServiceImpl的findUserByPage方法
                    在调用dao层的findTotalCount方法时传递新增的参数condition
                        定义模板sql select count(*) from user where 1 = 1
                        创建StringBuilder对象用于拼接字符串，传递模板sql
                        创建一个List<Object>集合用于存储condition中有值的参数对应的值，用于之后给拼接的字符串中的?赋值
                        循环condition判断condition中的各个参数是否有值，有值则拼接进sql
                            跳过currentPage和rows
                            有值的参数对应的值存进List集合，值前后要加上%，用于模糊查询
                        执行拼接后的sql,传递List集合，返回总记录数
                    在调用dao层的findUserByPage方法时传递新增的参数condition
                        定义模板sql select count(*) from user where 1 = 1
                        创建StringBuilder对象用于拼接字符串，传递模板sql
                        创建一个List<Object>集合用于存储condition中有值的参数对应的值，用于之后给拼接的字符串中的?赋值
                        循环condition判断condition中的各个参数是否有值，有值则拼接进sql
                            跳过currentPage和rows
                            有值的参数对应的值存进List集合，值前后要加上%，用于模糊查询
                        将limit ?, ?拼接进sql
                        将currentPage和rows存进List集合
                        执行拼接后的sql,传递List集合，返回每页的记录数据
            注意
                点击页码按钮时，也要带着查询条件进行请求，否则会显示所有记录
                    给分页列表的超链接的href后面都加上&name=${condition.name[0]}&address=${condition.address[0]}&email=${condition.email[0]}
测试
部署运维

jsp

login.jsp

<%@page contentType="text/html; charset=UTF-8" language="java" %>
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8"/>
    <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
    <meta name="viewport" content="width=device-width, initial-scale=1"/>
    <title>管理员登录</title>

    <!-- 1. 导入CSS的全局样式 -->
    <link href="css/bootstrap.min.css" rel="stylesheet">
    <!-- 2. jQuery导入，建议使用1.9以上的版本 -->
    <script src="js/jquery-2.1.0.min.js"></script>
    <!-- 3. 导入bootstrap的js文件 -->
    <script src="js/bootstrap.min.js"></script>
    <script type="text/javascript">
        function refreshCode() {
            var codeImg = document.getElementById("vcode");
            codeImg.src = "${pageContext.request.contextPath}/checkCodeServlet?time=" + new Date().getTime();
        }
    </script>
</head>
<body>
<div class="container" style="width: 400px;">
    <h3 style="text-align: center;">管理员登录</h3>
    <form action="${pageContext.request.contextPath}/loginServlet" method="post">
        <div class="form-group">
            <label for="username">用户名：</label>
            <input type="text" name="username" class="form-control" id="username" placeholder="请输入用户名"/>
        </div>

        <div class="form-group">
            <label for="password">密码：</label>
            <input type="password" name="password" class="form-control" id="password" placeholder="请输入密码"/>
        </div>

        <div class="form-inline">
            <label for="vcode">验证码：</label>
            <input type="text" name="verifycode" class="form-control" id="verifycode" placeholder="请输入验证码" style="width: 120px;"/>
            <a href="javascript:refreshCode()"><img src="${pageContext.request.contextPath}/checkCodeServlet" title="看不清点击刷新" id="vcode"/></a>
        </div>
        <hr/>
        <div class="form-group" style="text-align: center;">
            <input class="btn btn btn-primary" type="submit" value="登录">
        </div>
    </form>

    <!-- 出错显示的信息框 -->
    <div class="alert alert-warning alert-dismissible" role="alert">
        <button type="button" class="close" data-dismiss="alert" >
            <span>&times;</span></button>
        <strong>${requestScope.login_err}</strong>
    </div>
</div>
</body>
</html>

index.jsp

<%@page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8"/>
  <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
  <meta name="viewport" content="width=device-width, initial-scale=1"/>
  <title>首页</title>

  <!-- 1. 导入CSS的全局样式 -->
  <link href="css/bootstrap.min.css" rel="stylesheet">
  <!-- 2. jQuery导入，建议使用1.9以上的版本 -->
  <script src="js/jquery-2.1.0.min.js"></script>
  <!-- 3. 导入bootstrap的js文件 -->
  <script src="js/bootstrap.min.js"></script>
  <script type="text/javascript">
  </script>
</head>
<body>
  <div>管理员，${sessionScope.loginAdmin.username}，欢迎您</div>
  <div align="center">
    <a
            href="${pageContext.request.contextPath}/findUserByPageServlet" style="text-decoration:none;font-size:33px">查询所有用户信息
    </a>
  </div>
</body>
</html>

list.jsp

<%@ page import="java.util.List" %>
<%@ page import="domain.User" %>
<%@page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<!-- 网页使用的语言 -->
<!DOCTYPE html>
<!-- 网页使用的语言 -->
<html lang="zh-CN">
<head>
    <!-- 指定字符集 -->
    <meta charset="utf-8">
    <!-- 使用Edge最新的浏览器的渲染方式 -->
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <!-- viewport视口：网页可以根据设置的宽度自动进行适配，在浏览器的内部虚拟一个容器，容器的宽度与设备的宽度相同。
    width: 默认宽度与设备的宽度相同
    initial-scale: 初始的缩放比，为1:1 -->
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
    <title>用户信息管理系统</title>

    <!-- 1. 导入CSS的全局样式 -->
    <link href="css/bootstrap.min.css" rel="stylesheet">
    <!-- 2. jQuery导入，建议使用1.9以上的版本 -->
    <script src="js/jquery-2.1.0.min.js"></script>
    <!-- 3. 导入bootstrap的js文件 -->
    <script src="js/bootstrap.min.js"></script>
    <style type="text/css">
        td, th {
            text-align: center;
        }
    </style>
    <script>
        function deleteUser(id) {
            if (confirm("您确定要删除该用户吗？")) {
                //让浏览器访问的路径
                location.href = "${pageContext.request.contextPath}/deleteUserServlet?id=" + id;
            }
        }
        window.onload = function () {
            document.getElementById("deleteSelected").onclick = function () {
                var flag = false;
                //判断是否选中用户
                var select = document.getElementsByName("uid");
                if (confirm("您确定要删除所选用户吗？")) {
                    for (var i = 0; i < select.length; i++) {
                        if (select[i].checked) {
                            flag = true;
                            break;
                        }
                    }
                    //提交表单
                    if (flag) {
                        document.getElementById("form").submit();
                    } else {
                        alert("没有用户被选中！");
                    }
                }
            };
            document.getElementById("selectAll").onclick = function () {
                var select = document.getElementsByName("uid");
                for (var i = 0; i < select.length; i++) {
                    select[i].checked = this.checked;
                }
            };
        };
    </script>
</head>
<body>
<div class="container">
    <h3 style="text-align: center">用户信息列表</h3>
    <div style="float:left;">
        <form class="form-inline" action="${pageContext.request.contextPath}/findUserByPageServlet" method="post">
            <div class="form-group">
                <label for="exampleInputName2">姓名</label>
                <input type="text" class="form-control" id="exampleInputName2" name="name" value="${requestScope.condition.name[0]}">
            </div>
            <div class="form-group">
                <label for="exampleInputAddress2">籍贯</label>
                <input type="text" class="form-control" id="exampleInputAddress2" name="address" value="${requestScope.condition.address[0]}">
            </div>
            <div class="form-group">
                <label for="exampleInputEmail2">邮箱</label>
                <input type="text" class="form-control" id="exampleInputEmail2" name="email" value="${requestScope.condition.email[0]}">
            </div>
            <button type="submit" class="btn btn-default">查询</button>
        </form>
    </div>
    <div style="float: right; margin: 5px;">
        <a class="btn btn-primary" href="${pageContext.request.contextPath}/addUser.jsp">添加联系人</a>
        <a class="btn btn-primary" href="javascript:void(0);" id="deleteSelected">删除选中</a>
    </div>
    <form action="${pageContext.request.contextPath}/deleteSelectedServlet" method="post" id="form">
        <table border="1" class="table table-bordered table-hover">
            <tr class="success">
                <th><input type="checkbox" id="selectAll"></th>
                <th>编号</th>
                <th>姓名</th>
                <th>性别</th>
                <th>年龄</th>
                <th>籍贯</th>
                <th>QQ</th>
                <th>邮箱</th>
                <th>操作</th>
            </tr>
            <c:forEach items="${requestScope.pageBean.list}" var="user" varStatus="s">
                <tr>
                    <td><input type="checkbox" name="uid" value="${user.id}"></td>
                    <td>${user.id}</td>
                    <td>${user.name}</td>
                    <td>${user.gender}</td>
                    <td>${user.age}</td>
                    <td>${user.address}</td>
                    <td>${user.qq}</td>
                    <td>${user.email}</td>
                    <td>
                        <a class="btn btn-default btn-sm" href="${pageContext.request.contextPath}/findUserServlet?id=${user.id}">修改</a>&nbsp;
                        <a class="btn btn-default btn-sm" href="javascript:deleteUser(${user.id})">删除</a>
                    </td>
                </tr>
            </c:forEach>
        </table>
    </form>
    <div>
        <nav aria-label="Page navigation">
            <ul class="pagination">
                <c:if test="${requestScope.pageBean.currentPage == 1}">
                    <li class="disabled">
                </c:if>
                <c:if test="${requestScope.pageBean.currentPage != 1}">
                    <li>
                </c:if>
                        <a href="${pageContext.request.contextPath}/findUserByPageServlet?currentPage=${requestScope.pageBean.currentPage - 1}&rows=5&name=${condition.name[0]}&address=${condition.address[0]}&email=${condition.email[0]}" aria-label="Previous">
                            <span aria-hidden="true">&laquo;</span>
                        </a>
                    </li>
                    <c:forEach begin="1" end="${requestScope.pageBean.totalPage}" var="i">
                        <c:if test="${requestScope.pageBean.currentPage == i}">
                            <li class="active"><a href="${pageContext.request.contextPath}/findUserByPageServlet?currentPage=${i}&rows=5&name=${condition.name[0]}&address=${condition.address[0]}&email=${condition.email[0]}">${i}</a></li>
                        </c:if>
                        <c:if test="${requestScope.pageBean.currentPage != i}">
                            <li><a href="${pageContext.request.contextPath}/findUserByPageServlet?currentPage=${i}&rows=5&name=${condition.name[0]}&address=${condition.address[0]}&email=${condition.email[0]}">${i}</a></li>
                        </c:if>
                    </c:forEach>
                    <c:if test="${requestScope.pageBean.currentPage == requestScope.pageBean.totalPage}">
                        <li class="disabled">
                    </c:if>
                    <c:if test="${requestScope.pageBean.currentPage != requestScope.pageBean.totalPage}">
                        <li>
                    </c:if>

                            <a href="${pageContext.request.contextPath}/findUserByPageServlet?currentPage=${requestScope.pageBean.currentPage + 1}&rows=5&name=${condition.name[0]}&address=${condition.address[0]}&email=${condition.email[0]}" aria-label="Next">
                                <span aria-hidden="true">&raquo;</span>
                            </a>
                        </li>
            </ul>
        </nav>
        <span>共${requestScope.pageBean.totalCount}条记录，共${requestScope.pageBean.totalPage}页</span>
    </div>
</div>
</body>
</html>

addUser.jsp

<%@page contentType="text/html; charset=UTF-8" language="java" %>
<!-- HTML5文档-->
<!DOCTYPE html>
<!-- 网页使用的语言 -->
<html lang="zh-CN">
<head>
    <!-- 指定字符集 -->
    <meta charset="utf-8">
    <!-- 使用Edge最新的浏览器的渲染方式 -->
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <!-- viewport视口：网页可以根据设置的宽度自动进行适配，在浏览器的内部虚拟一个容器，容器的宽度与设备的宽度相同。
    width: 默认宽度与设备的宽度相同
    initial-scale: 初始的缩放比，为1:1 -->
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
    <title>添加用户</title>

    <!-- 1. 导入CSS的全局样式 -->
    <link href="css/bootstrap.min.css" rel="stylesheet">
    <!-- 2. jQuery导入，建议使用1.9以上的版本 -->
    <script src="js/jquery-2.1.0.min.js"></script>
    <!-- 3. 导入bootstrap的js文件 -->
    <script src="js/bootstrap.min.js"></script>
</head>
<body>
<div class="container">
    <center><h3>添加联系人页面</h3></center>
    <form action="${pageContext.request.contextPath}/addUserServlet" method="post">
        <div class="form-group">
            <label for="name">姓名：</label>
            <input type="text" class="form-control" id="name" name="name" placeholder="请输入姓名">
        </div>

        <div class="form-group">
            <label>性别：</label>
            <input type="radio" name="gender" value="男" checked="checked"/>男
            <input type="radio" name="gender" value="女"/>女
        </div>

        <div class="form-group">
            <label for="age">年龄：</label>
            <input type="text" class="form-control" id="age" name="age" placeholder="请输入年龄">
        </div>

        <div class="form-group">
            <label for="address">籍贯：</label>
            <select name="address" class="form-control" id="address">
                <option value="广东">广东</option>
                <option value="广西">广西</option>
                <option value="湖南">湖南</option>
            </select>
        </div>

        <div class="form-group">
            <label for="qq">QQ：</label>
            <input type="text" class="form-control" name="qq" placeholder="请输入QQ号码" id="qq"/>
        </div>

        <div class="form-group">
            <label for="email">Email：</label>
            <input type="text" class="form-control" name="email" placeholder="请输入邮箱地址" id="email"/>
        </div>

        <div class="form-group" style="text-align: center">
            <input class="btn btn-primary" type="submit" value="提交" />
            <input class="btn btn-default" type="reset" value="重置" />
            <input class="btn btn-default" type="button" value="返回" />
        </div>
    </form>
</div>
</body>
</html>

update.jsp

<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@page contentType="text/html; charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<!-- 网页使用的语言 -->
<html lang="zh-CN">
<head>
    <!-- 指定字符集 -->
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>修改用户</title>

    <link href="css/bootstrap.min.css" rel="stylesheet">
    <script src="js/jquery-2.1.0.min.js"></script>
    <script src="js/bootstrap.min.js"></script>

</head>
<body>
<%
    String[] addresses = {"北京", "上海", "广州", "深圳", "杭州", "天津", "苏州", "福州", "台湾", "香港", "新加坡", "马来西亚", "新疆", "江西", "湖南", "吉林", "辽宁", "黑龙江", "河南", "河北"};
    request.setAttribute("addresses",addresses);
%>
<div class="container" style="width: 400px;">
    <h3 style="text-align: center;">修改联系人</h3>
    <form action="${pageContext.request.contextPath}/updateUserServlet" method="post">
        <%--隐藏域 提交id--%>
        <input type="hidden" id="id" name="id" value="${requestScope.findUser.id}">
        <div class="form-group">
            <label for="name">姓名：</label>
            <input type="text" class="form-control" id="name" name="name"  readonly="readonly" value="${requestScope.findUser.name}"/>
        </div>

        <div class="form-group">
            <label>性别：</label>
            <c:if test="${requestScope.findUser.gender == '男'}">
                <input type="radio" name="gender" value="男"  checked/>男
                <input type="radio" name="gender" value="女"  />女
            </c:if>
            <c:if test="${requestScope.findUser.gender == '女'}">
                <input type="radio" name="gender" value="男"  />男
                <input type="radio" name="gender" value="女"  checked/>女
            </c:if>
        </div>

        <div class="form-group">
            <label for="age">年龄：</label>
            <input type="text" class="form-control" id="age"  name="age" value="${requestScope.findUser.age}"/>
        </div>

        <div class="form-group">
            <label for="address">籍贯：</label>
            <select name="address" class="form-control" id="address" >
                <c:forEach items="${addresses}" var="address">
                    <option value=${address}
                        <c:if test="${address eq requestScope.findUser.address}">
                                selected="selected"</c:if>>${address}
                    </option>
                </c:forEach>
<%--                <c:if test="${requestScope.findUser.address == '广东'}">--%>
<%--                    <option value="广东" selected>广东</option>--%>
<%--                    <option value="广西">广西</option>--%>
<%--                    <option value="湖南">湖南</option>--%>
<%--                </c:if>--%>
<%--                <c:if test="${requestScope.findUser.address == '广西'}">--%>
<%--                    <option value="广东">广东</option>--%>
<%--                    <option value="广西" selected>广西</option>--%>
<%--                    <option value="湖南">湖南</option>--%>
<%--                </c:if>--%>
<%--                <c:if test="${requestScope.findUser.address == '湖南'}">--%>
<%--                    <option value="广东">广东</option>--%>
<%--                    <option value="广西">广西</option>--%>
<%--                    <option value="湖南" selected>湖南</option>--%>
<%--                </c:if>--%>
            </select>
        </div>

        <div class="form-group">
            <label for="qq">QQ：</label>
            <input type="text" class="form-control" name="qq" id="qq" value="${requestScope.findUser.qq}"/>
        </div>

        <div class="form-group">
            <label for="email">Email：</label>
            <input type="text" class="form-control" name="email" id="email" value="${requestScope.findUser.email}"/>
        </div>

        <div class="form-group" style="text-align: center">
            <input class="btn btn-primary" type="submit" value="提交" />
            <input class="btn btn-default" type="reset" value="重置" />
            <input class="btn btn-default" type="button" value="返回"/>
        </div>
    </form>
</div>
</body>
</html>

配置文件

druid.properties

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///day17
username=root
password=root
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000

敏感词汇.txt

笨蛋
傻逼

domain

domain/Administrator

package domain;

public class Administrator {
    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

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

    @Override
    public String toString() {
        return "Administrator{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

domain/PageBean

package domain;

import java.util.List;

/*
分页对象
 */
public class PageBean<T> {
    private int totalCount;//总记录数
    private int totalPage;//总页数
    private int currentPage;//当前页码
    private int rows;//每页记录数
    private List<T> list;//每页数据

    public int getTotalCount() {
        return totalCount;
    }

    public void setTotalCount(int totalCount) {
        this.totalCount = totalCount;
    }

    public int getTotalPage() {
        return totalPage;
    }

    public void setTotalPage(int totalPage) {
        this.totalPage = totalPage;
    }

    public int getCurrentPage() {
        return currentPage;
    }

    public void setCurrentPage(int currentPage) {
        this.currentPage = currentPage;
    }

    public int getRows() {
        return rows;
    }

    public void setRows(int rows) {
        this.rows = rows;
    }

    public List<T> getList() {
        return list;
    }

    public void setList(List<T> list) {
        this.list = list;
    }

    @Override
    public String toString() {
        return "PageBean{" +
                "totalCount=" + totalCount +
                ", totalPage=" + totalPage +
                ", currentPage=" + currentPage +
                ", rows=" + rows +
                ", list=" + list +
                '}';
    }
}

domain/User

package domain;

public class User {
    private int id;
    private String name;
    private String gender;
    private int age;
    private String address;
    private String qq;
    private String email;

    public int getId() {
        return id;
    }

    public void setId(int 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 int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getQq() {
        return qq;
    }

    public void setQq(String qq) {
        this.qq = qq;
    }

    public String getEmail() {
        return email;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", qq='" + qq + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

util

util/JDBCUtils

package util;

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.SQLException;
import java.util.Properties;

/**
 * JDBC工具类 使用Durid连接池
 */
public class JDBCUtils {

    private static DataSource ds ;

    static {

        try {
            //1.加载配置文件
            Properties pro = new Properties();
            //使用ClassLoader加载配置文件，获取字节输入流
            InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            pro.load(is);

            //2.初始化连接池对象
            ds = DruidDataSourceFactory.createDataSource(pro);

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

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


    /**
     * 获取连接Connection对象
     */
    public static Connection getConnection() throws SQLException {
        return  ds.getConnection();
    }
}

web/filter

web/filter/LoginFilter

package web.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.io.IOException;

@WebFilter("/*")//访问day17中资源时进行拦截
public class LoginFilter implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        //强制转换
        HttpServletRequest request = (HttpServletRequest) req;
        //HttpServletResponse response = (HttpServletResponse) resp;
        //判断是否是需要登录验证的资源
        //获取资源的请求路径
        String uri = request.getRequestURI();
        if (uri.contains("/login.jsp") || uri.contains("/loginServlet") || uri.contains("/css/") || uri.contains("/js/") || uri.contains("/fonts/") || uri.contains("/checkCodeServlet")) {
            //放行
            chain.doFilter(req, resp);
        } else {
            HttpSession session = request.getSession();
            Object loginAdmin = session.getAttribute("loginAdmin");
            if (loginAdmin != null) {
                chain.doFilter(req, resp);
            } else {
                request.setAttribute("login_err", "您尚未登录，请先登录！");
                request.getRequestDispatcher("/login.jsp").forward(request, resp);
            }
        }

    }

    public void init(FilterConfig config) throws ServletException {

    }

}

web/filter/SensitiveWordFilter

package web.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@WebFilter("/*")
public class SensitiveWordFilter implements Filter {
    private List<String> list = new ArrayList<String>();//敏感词汇集合

    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        //创建代理对象，增强getParameter方法
        ServletRequest proxy_req = (ServletRequest) Proxy.newProxyInstance(req.getClass().getClassLoader(), req.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //判断是否为getParameter方法
                if (method.getName().equals("getParameter")) {
                    //增强返回值
                    //获取返回值
                    String value = (String) method.invoke(req, args);
                    if (value != null) {
                        //对返回值，即要获取的参数进行敏感词汇过滤
                        for (String s : list) {
                            if (value.contains(s)) {
                                //如果要获取的参数包含敏感词汇
                                value = value.replaceAll(s, "***");
                            }
                        }
                    }
                    return value;
                }
                //判断是否为getParameterMap方法
                if (method.getName().equals("getParameterMap")) {
                    Map<String, String[]> map = (Map<String, String[]>) method.invoke(req, args);
                    for (String key : map.keySet()) {
                        String[] values = map.get(key);
                        for (String value : values) {
                            if (value != null) {
                                for (String s : list) {
                                    if (value.contains(s)) {
                                        value = value.replaceAll(s, "***");
                                    }
                                }
                            }
                        }
                    }
                    return map;
                }
                //判断是否为getParameterValues方法
                if (method.getName().equals("getParameterValues")) {
                    String value = (String) method.invoke(req, args);
                    if (value != null) {
                        for (String s : list) {
                            if (value.contains(s)) {
                                value.replaceAll(s, "***");
                            }
                        }
                    }
                    return value;
                }
                return method.invoke(req, args);
            }
        });
        //放行
        chain.doFilter(proxy_req, resp);
    }

    public void init(FilterConfig config) throws ServletException {
        System.out.println("init");
        try {
            //加载配置文件 先获取文件的真实路径
            ServletContext servletContext = config.getServletContext();
            String filename = new String(("敏感词汇.txt").getBytes("utf-8"),"utf-8");
            String realPath = servletContext.getRealPath("/WEB-INF/classes/" + filename);//src下的资源
            //读取文件
            //本地创建的字符流是GBK，配置文件的编码需要改为GBK，否则会乱码
            BufferedReader br = new BufferedReader(new FileReader(realPath));
            //读取文件
            String line = null;
            while ((line = br.readLine()) != null) {
                //将文件中的每一行数据加到list中
                list.add(line);
            }
            System.out.println(list);
            br.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

web/servlet

LoginServlet

package web.servlet;

import domain.Administrator;
import org.apache.commons.beanutils.BeanUtils;
import service.UserService;
import service.impl.UserServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
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.lang.reflect.InvocationTargetException;
import java.util.Map;

@WebServlet("/loginServlet")
public class LoginServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1、设置编码
        request.setCharacterEncoding("utf-8");
        //2、获取数据
        String verifycode = request.getParameter("verifycode");
        HttpSession session = request.getSession();
        String checkcode_server = (String) session.getAttribute("CHECKCODE_SERVER");
        //删除已生成的验证码，确保验证码的一次性使用
        session.removeAttribute("CHECKCODE_SERVER");
        //3、判断验证码是否正确
        if (checkcode_server != null && checkcode_server.equalsIgnoreCase(verifycode)) {
            //获取用户提交参数的map集合
            Map<String, String[]> map = request.getParameterMap();
            //4、封装对象
            Administrator admin = new Administrator();
            try {
                BeanUtils.populate(admin, map);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
            //5、调用service层的查询
            UserService service = new UserServiceImpl();
            Administrator loginAdmin = service.login(admin);
            //6、判断是否登录成功 成功重定向到index.jsp 失败存储失败信息，转发到login.jsp
            if (loginAdmin != null) {
                //登录成功
                //将登录成功的管理员存入session
                session.setAttribute("loginAdmin", loginAdmin);
                //重定向到index.jsp
                response.sendRedirect(request.getContextPath() + "/index.jsp");
            } else {
                //登录失败
                //存储错误信息
                request.setAttribute("login_err", "用户名或密码错误！");
                //转发到login.jsp页面
                request.getRequestDispatcher("/login.jsp").forward(request, response);
            }
        } else {
            //验证码为空或验证码输入错误
            //存储错误信息
            request.setAttribute("login_err", "验证码错误！");
            //转发到login.jsp
            request.getRequestDispatcher("/login.jsp").forward(request, response);
        }


    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

CheckCodeServlet

package web.servlet;

import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Random;

/**
 * 验证码
 */
@WebServlet("/checkCodeServlet")
public class CheckCodeServlet extends HttpServlet {
	public void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
		
		//服务器通知浏览器不要缓存
		response.setHeader("pragma","no-cache");
		response.setHeader("cache-control","no-cache");
		response.setHeader("expires","0");
		
		//在内存中创建一个长80，宽30的图片，默认黑色背景
		//参数一：长
		//参数二：宽
		//参数三：颜色
		int width = 80;
		int height = 30;
		BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
		
		//获取画笔
		Graphics g = image.getGraphics();
		//设置画笔颜色为灰色
		g.setColor(Color.GRAY);
		//填充图片
		g.fillRect(0,0, width,height);
		
		//产生4个随机验证码，12Ey
		String checkCode = getCheckCode();
		//将验证码放入HttpSession中
		request.getSession().setAttribute("CHECKCODE_SERVER",checkCode);
		
		//设置画笔颜色为黄色
		g.setColor(Color.YELLOW);
		//设置字体的小大
		g.setFont(new Font("黑体",Font.BOLD,24));
		//向图片上写入验证码
		g.drawString(checkCode,15,25);
		
		//将内存中的图片输出到浏览器
		//参数一：图片对象
		//参数二：图片的格式，如PNG,JPG,GIF
		//参数三：图片输出到哪里去
		ImageIO.write(image,"PNG",response.getOutputStream());
	}
	/**
	 * 产生4位随机字符串 
	 */
	private String getCheckCode() {
		String base = "0123456789ABCDEFGabcdefg";
		int size = base.length();
		Random r = new Random();
		StringBuffer sb = new StringBuffer();
		for(int i=1;i<=4;i++){
			//产生0到size-1的随机值
			int index = r.nextInt(size);
			//在base字符串中获取下标为index的字符
			char c = base.charAt(index);
			//将c放入到StringBuffer中去
			sb.append(c);
		}
		return sb.toString();
	}
	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		this.doGet(request,response);
	}
}

UserListServlet

package web.servlet;

import domain.User;
import service.UserService;
import service.impl.UserServiceImpl;

import java.io.IOException;
import java.util.List;

@javax.servlet.annotation.WebServlet("/userListServlet")
public class UserListServlet extends javax.servlet.http.HttpServlet {
    protected void doPost(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, IOException {
        //1、调用service层的findAll方法
        UserService service = new UserServiceImpl();
        List<User> users = service.findAll();
        //2、将List集合users存入request域中
        request.setAttribute("users", users);
        //3、转发到list.jsp页面 不需要加虚拟目录
        request.getRequestDispatcher("/list.jsp").forward(request, response);
    }

    protected void doGet(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, IOException {
        this.doPost(request, response);
    }
}

FindUserServlet

package web.servlet;

import domain.User;
import service.UserService;
import service.impl.UserServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/findUserServlet")
public class FindUserServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //设置request编码
        request.setCharacterEncoding("utf-8");
        //获取修改按钮对应的用户id
        String id = request.getParameter("id");
        //调用service层的findUserById方法，返回User对象
        UserService service = new UserServiceImpl();
        User findUser = service.findUserById(id);
        //将返回的User对象存到request域中
        request.setAttribute("findUser", findUser);
        //转发到update.jsp进行信息的回显
        request.getRequestDispatcher("/update.jsp").forward(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

FindUserByPageServlet

package web.servlet;

import domain.PageBean;
import domain.User;
import service.UserService;
import service.impl.UserServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

@WebServlet("/findUserByPageServlet")
public class FindUserByPageServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("findbypage");
        //设置request的编码
        request.setCharacterEncoding("utf-8");
        //获取参数currentPage和rows
        String currentPage = request.getParameter("currentPage");
        String rows = request.getParameter("rows");
        if (currentPage == null || "".equals(currentPage))
            currentPage = "1";
        if (rows == null || "".equals(rows))
            rows = "5";
        //获取参数集合
        Map<String, String[]> condition = request.getParameterMap();
        request.setAttribute("condition", condition);
        //调用service层的findUserByPage方法
        UserService service = new UserServiceImpl();
        PageBean<User> pageBean = service.findUserByPage(currentPage, rows, condition);
        //将PageBean对象存入reques域中
        request.setAttribute("pageBean", pageBean);
        //转发到list.jsp 因为要共享数据
        request.getRequestDispatcher("/list.jsp").forward(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

AddUserServlet

package web.servlet;

import domain.User;
import org.apache.commons.beanutils.BeanUtils;
import service.UserService;
import service.impl.UserServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;

@WebServlet("/addUserServlet")
public class AddUserServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1、设置request的编码
        request.setCharacterEncoding("utf-8");
        //2、获取填写的参数
        Map<String, String[]> map = request.getParameterMap();
        //3、封装对象
        User user = new User();
        try {
            BeanUtils.populate(user, map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        //4、调用service层的addUser方法
        UserService service = new UserServiceImpl();
        service.addUser(user);
        //重定向到UserListServlet中 因为这里不需要共享数据
        response.sendRedirect(request.getContextPath() + "/list.jsp");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

UpdateUserServlet

package web.servlet;

import domain.User;
import org.apache.commons.beanutils.BeanUtils;
import service.UserService;
import service.impl.UserServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;

@WebServlet("/updateUserServlet")
public class UpdateUserServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //设置request的编码
        request.setCharacterEncoding("utf-8");
        //获取填写的数据
        Map<String, String[]> map = request.getParameterMap();
        //封装对象
        User user = new User();
        try {
            BeanUtils.populate(user, map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        //调用service层的updateUser方法
        UserService service = new UserServiceImpl();
        service.updateUser(user);
        //重定向到UserListServlet，再进行一次查询
        response.sendRedirect(request.getContextPath() + "/list.jsp");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

DeleteUserServlet

package web.servlet;

import service.UserService;
import service.impl.UserServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/deleteUserServlet")
public class DeleteUserServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1、设置request的编码 这里的id不是中文，可以不设置编码
        request.setCharacterEncoding("utf-8");
        //2、获取点击的那个删除按钮对应的记录的id
        String id = request.getParameter("id");
        //3、调用service层的deleteUser方法
        UserService service = new UserServiceImpl();
        service.deleteUser(id);
        //4、重定向到UserListServlet，再进行一次查询
        response.sendRedirect(request.getContextPath() + "/list.jsp");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

DeleteSelectedServlet

package web.servlet;

import service.UserService;
import service.impl.UserServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/deleteSelectedServlet")
public class DeleteSelectedServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //设置request的编码
        request.setCharacterEncoding("utf-8");
        //获取提交的用户id数组
        String[] ids = request.getParameterValues("uid");
        //调用service层的deleteUsers方法
        UserService service = new UserServiceImpl();
        service.deleteUsers(ids);
        //重定向到UserListServlet
        response.sendRedirect(request.getContextPath() + "/list.jsp");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

TestServlet

package web.servlet;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

@WebServlet("/test")
public class TestServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //getParameter
//        String name = request.getParameter("name");
//        String msg = request.getParameter("msg");
//        System.out.println(name + ":" + msg);
        //getParameterMap
        Map<String, String[]> map = request.getParameterMap();
        String[] names = map.get("name");
        String[] msgs = map.get("msg");
        String name = names[0];
        String msg = msgs[0];
        System.out.println(name + ":" + msg);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

service

UserService

package service;

import domain.Administrator;
import domain.PageBean;
import domain.User;

import java.util.List;
import java.util.Map;

//用户管理的业务接口
public interface UserService {
    //查询所有用户信息
    List<User> findAll();
    Administrator login(Administrator admin);
    void addUser(User user);
    void deleteUser(String id);
    User findUserById(String id);
    void updateUser(User user);
    void deleteUsers(String[] ids);
    PageBean<User> findUserByPage(String _currentPage, String _rows, Map<String, String[]> condition);
}

impl/UserServiceImpl

package service.impl;

import dao.UserDao;
import dao.impl.UserDaoImpl;
import domain.Administrator;
import domain.PageBean;
import domain.User;
import service.UserService;

import java.util.List;
import java.util.Map;

public class UserServiceImpl implements UserService {
    private UserDao dao = new UserDaoImpl();
    //查询所有用户信息
    @Override
    public List<User> findAll() {
        //调用dao层的findAll方法
        return dao.findAll();
    }

    @Override
    public Administrator login(Administrator admin) {
        //调用dao层的login方法
        return dao.findAdminByUsernameAndPassword(admin.getUsername(), admin.getPassword());
    }

    @Override
    public void addUser(User user) {
        dao.addUser(user);
    }

    @Override
    public void deleteUser(String id) {
        dao.deleteUser(Integer.parseInt(id));
    }

    @Override
    public User findUserById(String id) {
        return dao.findUserById(Integer.parseInt(id));
    }

    @Override
    public void updateUser(User user) {
        dao.updateUser(user);
    }

    @Override
    public void deleteUsers(String[] ids) {
        if (ids != null && ids.length > 0) {
            for (String id : ids) {
                dao.deleteUser(Integer.parseInt(id));
            }
        }
    }

    @Override
    public PageBean<User> findUserByPage(String _currentPage, String _rows, Map<String, String[]> condition) {
        System.out.println("service");
        //将参数转换为int类型
        int currentPage = Integer.parseInt(_currentPage);
        int rows = Integer.parseInt(_rows);
        if (currentPage < 1) {
            currentPage = 1;
        }
        //创建空的PageBean对象 补全泛型以适配低版本
        PageBean<User> pageBean = new PageBean<User>();
        //设置PageBean对象的currentPage和rows
        pageBean.setRows(rows);
        //调用dao层的findTotalCount方法，查询总记录数
        int totalCount = dao.findTotalCount(condition);
        //计算总页数
        int totalPage = totalCount % rows == 0 ? totalCount / rows : totalCount / rows + 1;
        pageBean.setTotalPage(totalPage);
        if (currentPage > totalPage) {
            currentPage = totalPage;
        }
        pageBean.setCurrentPage(currentPage);
        //计算开始查询的索引
        int beginRow = (currentPage - 1) * rows;
        pageBean.setTotalCount(totalCount);
        //调用dao层的findUserByPage方法，查询当前页码的数据
        List<User> list = dao.findUserByPage(beginRow, rows, condition);
        pageBean.setList(list);
        return pageBean;
    }
}

dao

UserDao

package dao;

import domain.Administrator;
import domain.User;

import java.util.List;
import java.util.Map;

//用户操作的Dao
public interface UserDao {
    //查询所有用户信息
    List<User> findAll();
    Administrator findAdminByUsernameAndPassword(String username, String password);
    void addUser(User user);
    void deleteUser(int id);
    User findUserById(int id);
    void updateUser(User user);
    int findTotalCount(Map<String, String[]> condition);
    List<User> findUserByPage(int beginRow, int rows, Map<String, String[]> condition);
}

impl/UserDaoImpl

package dao.impl;

import dao.UserDao;
import domain.Administrator;
import domain.User;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import util.JDBCUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class UserDaoImpl implements UserDao {
    //1、创建JDBCTemplate对象
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
    //查询所有用户信息
    @Override
    public List<User> findAll() {
        //使用JDBC操作数据库
        //2、定义sql
        String sql = "select * from user";
        //执行sql query方法返回的就是List集合 传入sql语句，并new一个RowMapper
        List<User> users = template.query(sql, new BeanPropertyRowMapper<User>(User.class));
        return users;
    }

    @Override
    public Administrator findAdminByUsernameAndPassword(String username, String password) {
        //使用JDBC操作数据库
        try {
            //定义sql
            String sql = "select * from administrator where username = ? and password = ?";
            //执行sql
            Administrator admin = template.queryForObject(sql, new BeanPropertyRowMapper<Administrator>(Administrator.class), username, password);
            return admin;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public void addUser(User user) {
        //使用JDBC操作数据库
        //定义sql
        String sql = "insert into user values(null, ?, ?, ?, ?, ?, ?)";
        //执行sql
        template.update(sql, user.getName(), user.getGender(), user.getAge(), user.getAddress(), user.getQq(), user.getEmail());
    }

    @Override
    public void deleteUser(int id) {
        //使用JDBC操作数据库
        //定义sql
        String sql = "delete from user where id = ?";
        //执行sql
        template.update(sql, id);
    }

    @Override
    public User findUserById(int id) {
        //使用JDBC操作数据库
        //定义sql
        String sql = "select * from user where id = ?";
        //执行sql
        User user = template.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), id);
        return user;
    }

    @Override
    public void updateUser(User user) {
        //使用JDBC操作数据库
        //定义sql
        String sql = "update user set name = ?, gender = ?, age = ?, address = ?, qq = ?, email = ? where id = ?";
        //执行sql
        template.update(sql, user.getName(), user.getGender(), user.getAge(), user.getAddress(), user.getQq(), user.getEmail(), user.getId());
    }

    @Override
    public int findTotalCount(Map<String, String[]> condition) {
        //使用JDBC操作数据库
        //定义模板sql
        String sql = "select count(*) from user where 1 = 1";
        //根据map中参数是否有值，拼接sql
        //定义有值的参数集合 用于传递sql语句中的?代表的参数
        List<Object> parameters = new ArrayList<Object>();
        //定义StringBuilder对象进行字符串拼接
        StringBuilder sb = new StringBuilder(sql);
        for (String key : condition.keySet()) {
            //排除currentPage和rows
            if ("currentPage".equals(key) || "rows".equals(key)) {
                continue;
            }
            String value = condition.get(key)[0];
            if (value != null && !("".equals(value))) {
                sb.append(" and " + key + " like ? ");
                parameters.add("%" + value + "%");
            }
        }
        System.out.println(sb.toString());
        System.out.println(parameters);
        //执行sql 该方法可以接收可变参数，即数组
        return template.queryForObject(sb.toString(), Integer.class, parameters.toArray());
    }

    @Override
    public List<User> findUserByPage(int beginRow, int rows, Map<String, String[]> condition) {
        //使用JDBC操作数据库
        //定义模板sql
        String sql = "select * from user where 1 = 1";
        //定义List集合存储condition中有值的参数对应的值
        List<Object> parameters = new ArrayList<Object>();
        //定义StringBuilder用于拼接字符串
        StringBuilder sb = new StringBuilder(sql);
        for (String key : condition.keySet()) {
            if ("currentPage".equals(key) || "rows".equals(key)) {
                continue;
            }
            String value = condition.get(key)[0];
            if (value != null && !("".equals(value))) {
                sb.append(" and " + key + " like ? ");
                parameters.add("%" + value + "%");
            }
        }
        //执行sql
        sb.append(" limit ?, ?");
        parameters.add(beginRow);
        parameters.add(rows);
        System.out.println(sb.toString());
        System.out.println(parameters);
        return template.query(sb.toString(), new BeanPropertyRowMapper<User>(User.class), parameters.toArray());
    }
}

Prayer96

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JavaWeb第十七天

用户信息列表展示案例需求　　用户信息的增删改查设计　　技术选型　　　　Servlet+JSP+MySQL+JDBCTemplate+Druid+BeanUtils+服务器　　　　控制器+展示界面+数据库+数据库操作的封装+数据库连接池+数据封装+Tomcat　　数据库设计　　　　create database day17; – 创建数据库　　　　use day17; – 使用数据库　　　　create table user(　　　　　　id int primary key auto_i
复制链接

扫一扫