行初雾

SMBMS

  • 2022-03-01
  • 作者 行初雾
  • ~23.52K 字

SMBMS

参考博客：Javaweb-超市订单管理系统SMBMS_Mario的博客-CSDN博客_超市订单系统

image-20220214141136108

数据库

image-20220214141238994

项目如何搭建？

考虑使用不使用Maven？依赖，jar

项目搭建准备工作

  1. 搭建一个Maven web项目

  2. 配置Tomcat

  3. 测试项目是否能够跑起来

  4. 导入项目中会遇到的jar包

    jsp，Servlet，mysql驱动，jstl，stand…

  5. 创建项目包结构

    image-20220214141941416

  6. 编写实体类

    ORM映射：表-类映射

  7. 编写基础公共类

    1. 数据库配置文件

      1
      2
      3
      4
      driver=com.mysql.jdbc.Driver
      url=jdbc:mysql://localhost:3306?useUnicode=true&characterEncoding=utf-8
      username=root
      password=cjy521213

    2. 编写数据库的公共类

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95
      96
      97
      98
      99
      100
      101
      102
      103
      104
      105
      106
      107
      108
      package com.xcw.dao;

      import com.mysql.jdbc.Driver;

      import java.io.IOException;
      import java.io.InputStream;
      import java.sql.*;
      import java.util.Properties;

      //操作数据库的公共类
      public class BaseDao {
          private static String driver;
          private static String url;
          private static String username;
          private static String password;

          //静态代码块，类加载的时候就初始化了
          static {
              Properties properties = new Properties();
              //通过类加载器读取对应的资源
              InputStream is = BaseDao.class.getClassLoader().getResourceAsStream("db.properties");

              try {
                  properties.load(is);
              } catch (IOException e) {
                  e.printStackTrace();
              }
              driver = properties.getProperty("driver");
              url = properties.getProperty("url");
              username = properties.getProperty("username");
              password = properties.getProperty("password");
          }

          //获取数据库的链接
          public static Connection getConnection(){
              Connection connection = null;
              try {
                  Class.forName(driver);
                  connection = DriverManager.getConnection(url, username, password);
              } catch (Exception e) {
                  e.printStackTrace();
              }
              return connection;
          }

          //编写查询公共方法
          public static ResultSet execute(Connection connection,String sql,Object[] params,ResultSet resultSet,PreparedStatement preparedStatement) throws SQLException {
              //预编译的sql，在后面直接执行就行了
              preparedStatement = connection.prepareStatement(sql);

              for (int i = 0; i < params.length; i++) {
                  preparedStatement.setObject(i+1,params[i]);
              }

              resultSet = preparedStatement.executeQuery();
              return resultSet;
          }
          //编写增删改公共方法
          public static int execute(Connection connection,String sql,Object[] params,PreparedStatement preparedStatement) throws SQLException {
              //预编译的sql，在后面直接执行就行了
              preparedStatement = connection.prepareStatement(sql);

              for (int i = 0; i < params.length; i++) {
                  preparedStatement.setObject(i+1,params[i]);
              }

              int updateRows = preparedStatement.executeUpdate();
              return updateRows;
          }

          //释放资源
          public static boolean closeResource(Connection connection,PreparedStatement preparedStatement,ResultSet resultSet){
              boolean flag = true;
              if(resultSet!=null){
                  try {
                      resultSet.close();
                      //GC回收
                      resultSet = null;
                  } catch (SQLException e) {
                      e.printStackTrace();
                      flag = false;
                  }
              }
              if(preparedStatement!=null){
                  try {
                      preparedStatement.close();
                      //GC回收
                      preparedStatement = null;
                  } catch (SQLException e) {
                      e.printStackTrace();
                      flag = false;
                  }
              }
              if(connection!=null){
                  try {
                      connection.close();
                      //GC回收
                      connection = null;
                  } catch (SQLException e) {
                      e.printStackTrace();
                      flag = false;
                  }
              }
              return flag;
          }

      }

    3. 编写字符编码过滤器

  8. 导入静态资源

登陆功能实现

image-20220214174455050

  1. 编写前端页面

  2. 设置首页

    1
    2
    3
    4
    <!--设置欢迎界面-->
    <welcome-file-list>
        <welcome-file>login.jsp</welcome-file>
    </welcome-file-list>

  3. 编写dao层用户登录的接口

    1
    2
    //得到要登陆的用户
    public User getLoginUser(Connection connection,String userCode) throws SQLException;

  4. 编写dao接口的实现类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    package com.xcw.dao.user;

    import com.xcw.dao.BaseDao;
    import com.xcw.pojo.User;

    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;

    public class UserDaoImpl implements UserDao{
        //得到要登录的用户
        @Override
        public User getLoginUser(Connection connection, String userCode) throws SQLException {
            PreparedStatement pstm = null;
            ResultSet rs = null;
            User user = null;

            if(connection!=null){
                String sql = "select * from smbms_user where userCode=?";
                Object[] params = {userCode};

                rs = BaseDao.execute(connection,pstm,sql,params,rs);
                if(rs.next()){
                    user = new User();
                    user.setId(rs.getInt("id"));
                    user.setUserCode(rs.getString("userCode"));
                    user.setUserName(rs.getString("userName"));
                    user.setUserPassword(rs.getString("userPassword"));
                    user.setGender(rs.getInt("gender"));
                    user.setBirthdy(rs.getDate("birthdy"));
                    user.setPhone(rs.getString("phone"));
                    user.setAddress(rs.getString("address"));
                    user.setUserRole(rs.getInt("userRole"));
                    user.setCreatedBy(rs.getInt("createdBy"));
                    user.setCreatedDate(rs.getDate("creationDate"));
                    user.setModifyBy(rs.getInt("modifyBy"));
                    user.setModifyDate(rs.getDate("modifyDate"));
                }
                BaseDao.closeResource(null,pstm,rs);
            }
            return user;
        }
    }

  5. 业务层接口

    1
    2
    //用户登录
    public User login(String userCode,String password);

  6. 业务层实现类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    public class UserServiceImpl implements UserService{

        //业务层都会调用dao层，所以我们要引入Dao层
        private UserDao userDao;
        public UserServiceImpl(){
            userDao = new UserDaoImpl();
        }

        @Override
        public User login(String userCode, String password) {
            Connection connection = null;
            User user = null;


            try {
                connection = BaseDao.getConnection();
                //通过业务层调用对应的具体的数据库操作
                user = userDao.getLoginUser(connection,userCode);
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                BaseDao.closeResource(connection,null,null);
            }
            return user;


        }
        @Test
        public void test1(){
            UserServiceImpl userService = new UserServiceImpl();
            User admin = userService.login("admin", "1234567");
            System.out.println(admin.getUserPassword());
        }
    }

  7. 编写servlet

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    public class LoginServlet extends HttpServlet {
        //Servlet：控制层，调用业务层代码
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            System.out.println("LoginServlet--start....");

            //获取用户名和密码
            String userCode = req.getParameter("userCode");
            String userPassword = req.getParameter("userPassword");

            //和数据库中的密码进行对比，调用业务层
            UserService userService = new UserServiceImpl();
            User user = userService.login(userCode,userPassword);

            if(user!=null){//查有此人，可以登录
                //将用户的信息放到Session中
                req.getSession().setAttribute(Constants.USER_SESSION,user);
                //跳转到主页
                resp.sendRedirect("jsp/frame.jsp");
            } else{ //查无此人，无法登录
                //转发会登录页面，顺带提示他，用户名或者密码错误
                req.setAttribute("error","用户名或者密码不正确");
                req.getRequestDispatcher("login.jsp").forward(req,resp);
            }

        }

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

  8. 注册servlet

    1
    2
    3
    4
    5
    6
    7
    8
    9
    <!--Servlet-->
    <servlet>
        <servlet-name>LoginServlet</servlet-name>
        <servlet-class>com.xcw.servlet.user.LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>LoginServlet</servlet-name>
        <url-pattern>/login.do</url-pattern>
    </servlet-mapping>

  9. 测试访问，确保以上功能成功！

登录功能优化

注销功能：

思路：移除Session，返回登录页面

1
2
3
4
5
6
7
8
9
10
11
12
13
public class LogoutServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //移除用户的Constants.USER_SESSION
        req.getSession().removeAttribute(Constants.USER_SESSION);
        resp.sendRedirect("/login.jsp");//返回登录界面
    }

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

注册xml

1
2
3
4
5
6
7
8
<servlet>
    <servlet-name>LogoutServlet</servlet-name>
    <servlet-class>com.xcw.servlet.user.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>LogoutServlet</servlet-name>
    <url-pattern>/user/logout</url-pattern>
</servlet-mapping>

登录拦截优化

编写一个过滤器，并注册

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class JspFilter 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中获取用户
        User user = (User) request.getSession().getAttribute(Constants.USER_SESSION);

        if(user == null){ //已经被移除或者注销了，或者未登录
            response.sendRedirect("/smbms/error.jsp");
        } else{
            filterChain.doFilter(request,response);
        }
    }

    @Override
    public void destroy() {

    }
}

1
2
3
4
5
6
7
8
9
<!--用户登录过滤器-->
<filter>
    <filter-name>JspFilter</filter-name>
    <filter-class>com.xcw.filter.JspFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>JspFilter</filter-name>
    <url-pattern>/jsp/*</url-pattern>
</filter-mapping>

密码修改

  1. 导入前端素材

    1
    <li><a href="${pageContext.request.contextPath }/jsp/pwdmodify.jsp">密码修改</a></li>

  2. 写项目，建议用底层向上写

    image-20220221150004176

  3. UserDao接口

    1
    2
    //修改当前用户密码
    public int updatePwd(Connection connection,int id,String password) throws SQLException;

  4. UserDao接口实现类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    //修改当前用户密码
    @Override
    public int updatePwd(Connection connection, int id, String password) throws SQLException {
        PreparedStatement pstm = null;
        int execute = 0;
        if(connection != null){
            String sql = "update smbms_user set userPassword = ? where id = ?";
            Object[] params = {password,id};

            execute = BaseDao.execute(connection, pstm, sql, params);
            BaseDao.closeResource(null,pstm,null);
        }
        return execute;
    }

  5. UserService层

    1
    2
    //修改密码
    public boolean updatePwd(int id,String pwd);

  6. UserService实现类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    @Override
    public boolean updatePwd(int id, String pwd) {
        Connection connection = null;
        boolean flag = false;

        try {
            connection = BaseDao.getConnection();
            if(userDao.updatePwd(connection,id,pwd)>0){
                flag = true;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            BaseDao.closeResource(connection,null,null);
        }
        return flag;
    }

  7. Servlet实现复用，需要提取出方法

    1
    2
    3
    4
    5
    6
    7
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getParameter("method");
        if(method.equals("savepwd")){
            this.updatePwd(req,resp);
        }
    }

  8. Servlet注册

    1
    2
    3
    4
    5
    6
    7
    8
    <servlet>
        <servlet-name>UserServelt</servlet-name>
        <servlet-class>com.xcw.servlet.user.UserServelt</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>UserServelt</servlet-name>
        <url-pattern>/jsp/user.do</url-pattern>
    </servlet-mapping>

  9. 测试

验证旧密码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//验证旧密码，Session中有用户的密码
public void pwdModify(HttpServletRequest req, HttpServletResponse resp){
    //从Session中拿ID
    Object o = req.getSession().getAttribute(Constants.USER_SESSION);
    String oldpassword = req.getParameter("oldpassword");

    //万能的Map ：结果集
    Map<String,String> reslutMap = new HashMap<>();

    if(o == null){
        reslutMap.put("result","sessionerror");
    } else if(StringUtils.isNullOrEmpty(oldpassword)){
        reslutMap.put("result","error");
    } else {
        String userPassword = ((User) o).getUserPassword();
        if(userPassword.equals(oldpassword)){
            reslutMap.put("result","true");
        } else {
            reslutMap.put("result","false");
        }
    }

    try {
        resp.setContentType("application/json");
        PrintWriter writer = resp.getWriter();
        //JSONArray 阿里巴巴的JSON工具类
        /*
            resultMap = {"result","sessionerror"}
            Json格式 = {key: value}
         */
        writer.write(JSONArray.toJSONString(reslutMap));
        writer.flush();
        writer.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

用户管理实现

思路：

image-20220221145504703

  1. 导入分页的工具类

  2. 用户列表页面导入

    userlist.jsp

获取用户数量

  1. UserDao

    1
    2
    //根据用户名或者角色查询用户总数
    public int getUserCount(Connection connection,String username,int userRole) throws SQLException;

  2. UserDaoImpl

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    //根据用户名或者角色查询用户总数
    @Override
    public int getUserCount(Connection connection, String username, int userRole) throws SQLException {
        PreparedStatement pstm = null;
        ResultSet rs = null;
        int count = 0;
        if(connection != null){
            StringBuffer sql = new StringBuffer();
            sql.append("select count(1) as count from smbms_user u,smbms_role r where u.userRole = r.id");
            ArrayList<Object> list = new ArrayList<>();

            if(!StringUtils.isNullOrEmpty(username)){
                sql.append(" and u.userName like ?");
                list.add("%"+username+"%"); // index:0
            }
            if(userRole>0){
                sql.append(" and u.userRole = ?");
                list.add(userRole); // index:1
            }
            Object[] params = list.toArray();

            System.out.println("UserDaoImpl->getUserCount:"+sql.toString());
            rs = BaseDao.execute(connection, pstm,sql.toString(),params,rs);
            if(rs.next()){
                count = rs.getInt("count");
            }
            BaseDao.closeResource(null,pstm,rs);
        }
        return count;
    }

  3. UserService

    1
    2
    //查询记录数
    public int getUserCount(String username, int userRole);

  4. UserServiceImpl

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    @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);
        }
        return count;
    }

获取用户列表

  1. UserDao

    1
    2
    //通过条件查询-userList
    public List<User> getUserList(Connection connection,String username,int userRole,int currentPageNo,int pageSize) throws SQLException;

  2. UserDaoImpl

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    //通过条件查询-userList
    @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<>();
        if(connection != null){
            StringBuffer sql = new StringBuffer();
            sql.append("select count(1) as count from smbms_user u,smbms_role r where u.userRole = r.id");
            ArrayList<Object> list = new ArrayList<>();

            if(!StringUtils.isNullOrEmpty(username)){
                sql.append(" and u.userName like ?");
                list.add("%"+username+"%"); // index:0
            }
            if(userRole>0){
                sql.append(" and u.userRole = ?");
                list.add(userRole); // index:1
            }
            sql.append(" order by creationDate DESC limit ?,?");
            currentPageNo = (currentPageNo-1)*pageSize;
            list.add(currentPageNo);
            list.add(pageSize);

            Object[] params = list.toArray();

            System.out.println("UserDaoImpl->getUserList:"+sql.toString());
            rs = BaseDao.execute(connection, pstm,sql.toString(),params,rs);
            if(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(rs.getString("userRoleName"));
                userList.add(_user);
            }
            BaseDao.closeResource(null,pstm,rs);
        }
        return userList;
    }

  3. UserService

    1
    2
    //根据条件查询用户列表
    public List<User> getUserList(String queryUserName,int queryUserRole,int currentPageNo,int pageSize);

  4. UserServiceImpl

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    @Override
    public List<User> getUserList(String queryUserName, int queryUserRole, int currentPageNo, int pageSize) {
        Connection connection = null;
        List<User> userList = null;
        System.out.println("queryUserName ---- > " + queryUserName);
        System.out.println("queryUserRole ---- > " + queryUserRole);
        System.out.println("currentPageNo ---- > " + currentPageNo);
        System.out.println("pageSize ---- > " + pageSize);
        try {
            connection = BaseDao.getConnection();
            userList = userDao.getUserList(connection,queryUserName,queryUserRole,currentPageNo,pageSize);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            BaseDao.closeResource(connection,null,null);
        }
        return userList;
    }

获取角色操作

为了我们职责统一，可以把角色的操作单独放在一个包中，和POJO类对应

  1. RoleDao

    1
    2
    //获取角色列表
    public List<Role> getRoleList(Connection connection) throws SQLException;

  2. RoleDaoImpl

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    //获取角色列表
    @Override
    public List<Role> getRoleList(Connection connection) throws SQLException {
        PreparedStatement pstm = null;
        ResultSet rs = null;
        ArrayList<Role> roleList = new ArrayList<>();

        if(connection != null){
            String sql = "select * from smbms_role";
            Object[] params = {};
            rs = BaseDao.execute(connection,pstm,sql,params,rs);

            if(rs.next()){
                Role _role = new Role();
                _role.setId(rs.getInt("id"));
                _role.setRoleCode(rs.getString("roleCode"));
                _role.setRoleName(rs.getString("roleName"));
                roleList.add(_role);
            }
            BaseDao.closeResource(null,pstm,rs);
        }
        return roleList;
    }

  3. RoleService

    1
    2
    //获取角色列表
    public List<Role> getRoleList();

  4. RoleServiceImpl

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    @Override
    public List<Role> getRoleList() {
        Connection connection = null;
        List<Role> roleList = null;
        try {
            connection = BaseDao.getConnection();
            roleList = roleDao.getRoleList(connection);

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            BaseDao.closeResource(connection,null,null);
        }
        return roleList;
    }

用户显示的Servlet

  1. 获取用户前端的数据（查询）
  2. 判断请求释放需要执行，看参数的值判断
  3. 为了实现分页，需要计算出当前页面和总页面，页面大小…
  4. 用户列表展示
  5. 返回前端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
//重点、难点，用户管理
public void query(HttpServletRequest req, HttpServletResponse resp){

    //查询用户列表

    //从前端获取数据
    String queryUserName = req.getParameter("queryname");
    String queryUserRoleTemp = req.getParameter("queryUserRole");
    String pageIndex = req.getParameter("pageIndex");
    int queryUserRole = 0;

    //获取用户列表
    UserServiceImpl userService = new UserServiceImpl();

    //第一次走这个请求，一定是第一页，页面大小固定
    int pageSize = 5;//可放配置文件中，方便后期修改
    int currentPageNo = 1;

    if(queryUserName == null){
        queryUserName = "";
    }
    if(queryUserRoleTemp!=null && !queryUserRoleTemp.equals("")){
        queryUserRole = Integer.parseInt(queryUserRoleTemp); //给查询赋值 0，1，2，3
    }
    if(pageIndex!=null){
        currentPageNo = Integer.parseInt(pageIndex);
    }

    //获取用户总数（分页，上一页，下一页的情况）
    int totalCount = userService.getUserCount(queryUserName, queryUserRole);
    //总页数支持
    PageSupport pageSupport = new PageSupport();
    pageSupport.setCurrentPageNo(currentPageNo);
    pageSupport.setPageSize(pageSize);
    pageSupport.setTotalCount(totalCount);

    int totalPageCount = pageSupport.getTotalPageCount();

    //控制首页和尾页
    //如果页面要小于1，就显示第一页的东西
    if(currentPageNo<1){
        currentPageNo = 1;
    } else if(currentPageNo > totalPageCount) { //当前页面大于最后一页
        currentPageNo = totalPageCount;
    }

    //获取用户列表展示
    List<User> userList = userService.getUserList(queryUserName, queryUserRole, currentPageNo, pageSize);
    req.setAttribute("userList",userList);

    RoleServiceImpl roleService = new RoleServiceImpl();
    List<Role> roleList = roleService.getRoleList();
    req.setAttribute("roleList",roleList);

    req.setAttribute("totalCount",totalCount);
    req.setAttribute("currentPageNo",currentPageNo);
    req.setAttribute("totalPageCount",totalPageCount);
    req.setAttribute("queryUserName",queryUserName);
    req.setAttribute("queryUserRole",queryUserRole);

    //返回前端
    try {
        req.getRequestDispatcher("userlist.jsp").forward(req,resp);
    } catch (ServletException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
本作品采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可
最后编辑：2022-03-01