javaweb-超市管理系统（修改密码+用户管理）

谁践踏了优雅 2022-09-14 09:58 256阅读 0赞

## 一.密码修改实现 ##

目标页面：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAYWJ5c3N3YXRjaGVyXzE_size_18_color_FFFFFF_t_70_g_se_x_16]从底层向上写，先编写Dao层，再编写Service层，最后编写Servlet层实现与前端jsp页面的通信。

### 1.1修改密码的Dao层 ###

编写sql语句：update smbms\_user set userPassword = ? where id = ?  
？处的参数为password和id，调用BaseDao中的execute查询方法。

public int updatePwd(Connection connection, int id, String password) throws SQLException {
        
            PreparedStatement preparedStatement=null;
            int excute=0;
            System.out.println("Dao"+password);
            if(connection!=null){
        
                String sql="update smbms_user set userPassword = ? where id = ?";
                Object[] params={
        password,id};
                excute=BaseDao.execute(connection,sql,preparedStatement,params);
                BaseDao.closeResource(connection,preparedStatement,null);
            }
            return excute;
        }

### 1.2修改密码的Service层 ###

service层主要目的是调用dao层，如果查找到就返回true，否则false。

//修改密码功能service层
        @Override
        public boolean update(int id, String password) throws SQLException {
        
            System.out.println("update"+password);
            Connection connection=null;
            Boolean flag=false;
            try {
        
                connection = BaseDao.getConnection();
                if (userDao.updatePwd(connection, id, password) > 0) {
        
                    flag = true;
                }
            }
            catch (Exception e){
        
                e.printStackTrace();
            }
            finally {
        
                BaseDao.closeResource(connection,null,null);
            }
            return flag;
        }

### 1.3修改密码Servlet层实现 ###

首先利用req.getparameter从前端的输入中获取用户填写的新密码。如果：

!StringUtils.isNullOrEmpty(newpassword)

不成立，则说明用户前端输入的新密码有问题，则返回对应的消息。

req.setAttribute("message","新密码设置有问题");

输入的newpassword没问题，调用service中的update方法进行更新。

public void updatePwd(HttpServletRequest req, HttpServletResponse resp){
        
            Object o=req.getSession().getAttribute(Constant.USER_SESSION);
            String newpassword= req.getParameter("newpassword");
            //没有获取到newpassword
            resp.setCharacterEncoding("utf-8");
            resp.setContentType("text/html;charset=utf-8");
    
            boolean flag=false;
            System.out.println("HttpServlet1"+newpassword);
            if(o!=null&& !StringUtils.isNullOrEmpty(newpassword)){
        
    
                UserService userService=new UserServiceImpl();
                try {
        
                    flag=userService.update(((User)o).getId(),newpassword);
                } catch (SQLException throwables) {
        
                    throwables.printStackTrace();
                }
    
                if(flag==true){
        
                    req.setAttribute("message","密码修改成功");
                    req.getSession().removeAttribute(Constant.USER_SESSION);
                }
                else{
        
                    req.setAttribute("message","密码修改失败");
                }
            }
            else{
        
                req.setAttribute("message","新密码设置有问题");
            }
    
            //无论结果，进行转发
            try {
        
                req.getRequestDispatcher("pwdmodify.jsp").forward(req,resp);
            } catch (ServletException e) {
        
                e.printStackTrace();
            } catch (IOException e) {
        
                e.printStackTrace();
            }
            //super.doPost(req, resp);
        }

关于新密码的长度，已经第二次输入与第一次输入是否一致，使用前端的js进行判断，与后端无关。

### 1.4验证旧密码（Ajax实现） ###

除此之外，应当验证旧密码的输入是否正确。本项目中，希望达到实时判断的效果，即每次失去焦点时，都会立即判断当前输入的旧密码是否正确，使用Ajax实现需求。

Ajax再js中编写，以json的形式，get方法，获取data。

oldpassword.on("blur", function () {
        
            $.ajax({
        
                type: "GET",
                url: path + "/jsp/user.do",
                data: {
        method: "pwdmodify", oldpassword: oldpassword.val()}, //ajax传递的参数
                dataType: "json",
                success: function (data) {
        
                    if (data.result == "true") {
        //旧密码正确
                        validateTip(oldpassword.next(), {
        "color": "green"}, imgYes, true);
                    } else if (data.result == "false") {
        //旧密码输入不正确
                        validateTip(oldpassword.next(), {
        "color": "red"}, imgNo + " 原密码输入不正确", false);
                    } else if (data.result == "sessionerror") {
        //当前用户session过期，请重新登录
                        validateTip(oldpassword.next(), {
        "color": "red"}, imgNo + " 当前用户session过期，请重新登录", false);
                    } else if (data.result == "error") {
        //旧密码输入为空
                        validateTip(oldpassword.next(), {
        "color": "red"}, imgNo + " 请输入旧密码", false);
                    }
                },
                error: function (data) {
        
                    //请求出错
                    validateTip(oldpassword.next(), {
        "color": "red"}, imgNo + " 请求错误", false);
                }
            });

先通过session获取已经登录的用户，使用一个Hashmap储存结果（因为是键值对，后面Ajax使用json形式，也是键值对，方便进行转换），并通过req.getparameter获取用户中的oldpassword，当object为空时，说明session失效了。正常情况下：  
读取session用户中存储的密码，与前端输入的密码进行比较，并向hashmap结果集中存储对应的结果。

使用：

JSONArray.toJSONString(resultMap)

将hashmap转化为json格式（需要导入fastalibaba依赖包）。  
最后通过流的形式写入。

public void pwdModify(HttpServletRequest req, HttpServletResponse resp){
        
            Object o=req.getSession().getAttribute(Constant.USER_SESSION);
            String oldpassword = req.getParameter("oldpassword");
            //Map结果集
            Map<String,String> resultMap=new HashMap<String,String>();
    
            if(o==null){
        //session失效了
                System.out.println("o==null");
                resultMap.put("result","sessionerror");
            }
            else if(StringUtils.isNullOrEmpty(oldpassword)){
        //输入的密码为空
                System.out.println("word=null");
                resultMap.put("result","error");
            }
            else{
        
              
                String userPassword=((User)o).getUserPassword();//读取session中存储的用户密码
                if(oldpassword.equals(userPassword)){
        
                    System.out.println("y");
                    resultMap.put("result","true");
                }
                else{
        
                    System.out.println("g");
                    resultMap.put("result","false");
                }
            }
            resp.setContentType("application/json");
            PrintWriter writer= null;
            try {
        
                writer = resp.getWriter();
                //将resultmap转化为json格式,给ajax使用
                //使用ajax验证旧密码，可以达到每次输入完成都会进行检验（js失去焦点事件），而不是点击保存之后才及进行检验
                writer.write(JSONArray.toJSONString(resultMap));
                writer.flush();
                writer.close();
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }

## 二.用户管理功能 ##

目标页面：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAYWJ5c3N3YXRjaGVyXzE_size_20_color_FFFFFF_t_70_g_se_x_16] 可以通过输入用户名进行模糊查询，以及角色下拉框选择，实现共同删选记录，同时记录过多时，可以进行翻页。

### 2.1用户管理Dao层 ###

因为需要分页，所以要获取用户总数。  
使用string buffer存储sql，方便进行拼接，因为需要根据输入的用户名和选择的角色类别进行联合查询。  
如果输入了username，就将and u.username like ?拼接到sql语句中，注意and前应当有空格。最后将拼接完成的sql语句作为参数，调用BaseDao中的execute查询方法，并使用rs（结果集）的next方法，获得符合条件的条数，并返回。

@Override
        public int getUserCount(Connection connection, String username, int userRole) throws SQLException {
        
            PreparedStatement pstm=null;
            ResultSet rs=null;
            int count=0;//不使用Integer,包装类可能为空，空指针异常
    
            if(connection!=null){
        
                StringBuffer sql=new StringBuffer();
                //连结两表进行查询
                //select count(1) as count from smbms_user u,smbms_role r where u.userRole=r.id
                ArrayList<Object> list= new ArrayList<Object>();
                sql.append("select count(1) as count from smbms_user u,smbms_role r where u.userRole=r.id");
    
                if(!StringUtils.isNullOrEmpty(username)){
        //如果输入的username不为空，就继续拼接一部分参数。
                    sql.append(" and u.username like ?");//?为param中的参数
                    list.add("%"+username+"%");//用户名模糊查询
                }
                if(userRole>0){
        
                    sql.append(" and u.userRole = ?");
                    list.add(userRole);
                }
                Object[] params=list.toArray();
    
                System.out.println("UserDao->getUserCount->sql:"+sql.toString());//输出完整的sql语句。
                rs = BaseDao.execute(connection,sql.toString(),pstm,rs,params);
                if(rs.next()){
        
                    count=rs.getInt("count");//从结果集中获取最终的数量.
                }
            }
            BaseDao.closeResource(null,pstm,rs);
            return count;
        }

获取用户列表：  
与上面类似，依次访问得到的rs（结果集），每次申请一个user对象，获得各种属性，并添加到list中，并返回list。

@Override
        public List<User> getUserList(Connection connection, String username, int userRole, int currentPageNo, int pageSize) throws SQLException {
        
            PreparedStatement pstm=null;
            ResultSet rs=null;
            List<User> userList=new ArrayList<>();
    
            System.out.println("UserDaoImpl:getUserList");
            if(connection!=null){
        
    
                System.out.println("connection!=null");//
                StringBuffer sql=new StringBuffer();
                List<Object> list=new ArrayList<>();//存放参数
                sql.append("select * from smbms_user u,smbms_role r where u.userRole=r.id");//sql语句
                if(!StringUtils.isNullOrEmpty(username)){
        
                    sql.append(" and u.username like ?");
                    list.add("%"+username+"%");
                }
                if(userRole>0){
        
                    sql.append(" and u.userRole = ?");
                    list.add(userRole);
                }
                //在数据库中，，分页使用 limit startindex pageSize;例如pageSize=5
                //第1页 对应数据库 01234
                //第2页 对应数据库 56789
    
                sql.append(" order by u.creationDate DESC limit ?,?");//两个参数
                currentPageNo=(currentPageNo-1)*pageSize;
                list.add(currentPageNo);
                list.add(pageSize);
    
                Object[] params=list.toArray();
                System.out.println("UserDao->getUserList->sql: "+sql.toString());
    
                rs=BaseDao.execute(connection,sql.toString(),pstm,rs,params);//在此处抛出异常，到UserServiceImpl的catch中
                System.out.println("调用BaseDao.execute结束");
                while(rs.next()){
        
                    User _user=new User();
                    _user.setId(rs.getInt("id"));
                    _user.setUserCode(rs.getString("userCode"));
                    _user.setUserName(rs.getString("userName"));
                    _user.setGender(rs.getInt("gender"));
                    _user.setBirthday(rs.getDate("birthday"));
                    _user.setPhone(rs.getString("phone"));
                    _user.setUserRole(rs.getInt("userRole"));
                    //_user.setUserRoleName();
                    userList.add(_user);
                }
                BaseDao.closeResource(null,pstm,rs);
            }
            return userList;
        }

### 2.2用户管理service层 ###

直接调用写好的Dao层即可，connection在service中进行关闭。

//查询记录数
        @Override
        public int getUserCount(String username, int userRole){
        
            Connection connection=null;
            int count=0;
            try{
        
                connection=BaseDao.getConnection();
                count=userDao.getUserCount(connection,username,userRole);
            }catch (SQLException e){
        
                e.printStackTrace();
            }finally {
        
                BaseDao.closeResource(connection,null,null);//connection在service层才关闭.
            }
            return count;
        }

@Override
        public List<User> getUserList(String queryUserName, int queryUserRole, int currentPageNo, int pageSize) {
        
            Connection connection=null;
            List<User> list=new ArrayList<>();
            try{
        
                connection=BaseDao.getConnection();
                list=userDao.getUserList(connection,queryUserName,queryUserRole,currentPageNo,pageSize);
            }catch (SQLException e){
        
                e.printStackTrace();
            }
            finally {
        
                BaseDao.closeResource(connection,null,null);
            }
            return list;
        }

### 2.3用户管理servlet层 ###

当前页，总页数，每页的页数，编写了pagesupport工具类进行控制。

public void query(HttpServletRequest req, HttpServletResponse resp){
        
            //从userlist.jsp中获取数据
            String queryUserName=req.getParameter("queryname");
            String temp=req.getParameter("queryUserRole");
            String pageIndex=req.getParameter("pageIndex");
            int queryUserRole = 0;//role默认是0
    
            //用户列表
            UserServiceImpl userService=new UserServiceImpl();
            List<User> userList=null;
    
            int Pagesize=5;//每5条一页
            int currentPageNo=1;//第一次一定是第一页
            if(queryUserName==null){
        
                queryUserName="";
            }
            if(temp!=null&&!temp.equals("")){
        
                queryUserRole=Integer.parseInt(temp);//给查询赋值0，1，2，3
    
            }
            if(pageIndex!=null){
        
                currentPageNo=Integer.parseInt(pageIndex);
            }
            //获取用户的总数，分页（上一页，下一页）
            int totalCount=userService.getUserCount(queryUserName,queryUserRole);
            //使用pagesupport工具类
            PageSupport pageSupport=new PageSupport();
            pageSupport.setCurrentPageNo(currentPageNo);
            pageSupport.setPageSize(Pagesize);
            pageSupport.setTotalCount(totalCount);
            int totalPageCount = ((int)(totalCount/Pagesize))+1;
            pageSupport.setTotalPageCount(totalPageCount);
            if(currentPageNo<1){
        
                currentPageNo=1;
            }else if(currentPageNo>totalCount){
        
                currentPageNo=totalCount;
            }
            //获取用户列表
            userList=userService.getUserList(queryUserName,queryUserRole,currentPageNo,Pagesize);
            req.setAttribute("userList",userList);
            //将userlist传到前端
            //
            RoleServiceImpl roleService= new RoleServiceImpl();
    
            List<Role> roleList= null;
            try {
        
                roleList = roleService.getRoleList();
                System.out.println(roleList.toArray()[0]);
                System.out.println("UserServlet:调用service层中的getRoleList成功");
            } catch (SQLException throwables) {
        
                throwables.printStackTrace();
            }
    
            req.setAttribute("roleList",roleList);
            req.setAttribute("totalCount",totalCount);
            req.setAttribute("currentPageNo",currentPageNo);
            req.setAttribute("totalPageCount",totalPageCount);
    
            try {
        
                req.getRequestDispatcher("userlist.jsp").forward(req,resp);
            } catch (ServletException e) {
        
                e.printStackTrace();
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }

### 2.4Servlet层的管理 ###

在前端中设置了method属性，req.getParameter获取后即可进行判断，将各个功能的Servlet进行封装，并使用if条件判断是哪种方法，并执行。

@Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
            String method=req.getParameter("method");
            if(method!=null&&method.equals("savepwd")){
        
                this.updatePwd(req, resp);
            }
            else if(method!=null&&method.equals("pwdmodify")){
        
                this.pwdModify(req, resp);
            }
            else if(method!=null&&method.equals("query")){
        
                this.query(req, resp);
            }
        }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAYWJ5c3N3YXRjaGVyXzE_size_18_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/a4ff1ac11eb5440c98d151261bb23d73.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAYWJ5c3N3YXRjaGVyXzE_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/9dd44ee6b3ef4c8e998a9b8d73021744.png