SMBMS项目学习

发表于 更新于 分类于 本文字数： 22k

SMBMS项目学习

基本架构

在数据库中创建对应的表

一、 搭建项目环境（准备工作）

1. 搭建一个maven web项目

2. 配置Tomcat

3. 测试项目是否能正常运行

4. 导入项目jar包

jsp,Servlet,mysql驱动，jstl，standard…

5. 创建项目包结构

6. 编写实体类pojo

7. 编写基础公共类

1. 数据库配置文件db.properties

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

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
//操作数据库的公共类
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(String sql,Connection connection,Object[] params,ResultSet resultSet ,PreparedStatement preparedStatement) throws SQLException {
      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(String sql,Connection connection,Object[] params,PreparedStatement preparedStatement ) throws SQLException {
      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回收
            } catch (SQLException throwables) {
               throwables.printStackTrace();
               flag=false;
            }
      }
      if (preparedStatement!=null){
            try {
               preparedStatement.close();
               //gc回收
            } catch (SQLException throwables) {
               throwables.printStackTrace();
               flag=false;
            }
      }
      if (connection!=null){
            try {
               connection.close();
               //gc回收
            } catch (SQLException throwables) {
               throwables.printStackTrace();
               flag=false;
            }
      }
      return flag;
   }
}
  1. 编写字符编码过滤器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class CharacterEncodingFilter implements Filter {
   @Override
   public void init(FilterConfig filterConfig) throws ServletException {
      
   }

   @Override
   public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
      servletRequest.setCharacterEncoding("utf-8");
      servletResponse.setCharacterEncoding("utf-8");
      filterChain.doFilter(servletRequest,servletResponse);
   }

   @Override
   public void destroy() {

   }
}

8. 导入静态资源

二、登录页功能实现

1、登录功能实现

  1. 编写前端页面
  2. 设置欢迎页面
1
2
3
4
 <!--设置欢迎页面-->
<welcome-file-list>
  <welcome-file>login.jsp</welcome-file>
</welcome-file-list>
  1. 编写Dao层得到用户登录接口
    1
    2
    3
    4
    public interface UserDao {
     //得到登录的用户
     public User getLoginUser(Connection connection, String userCode) throws SQLException;
    }
  2. 编写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
    public class UserDaoImpl implements UserDao{
       @Override
       public User getLoginUser(Connection connection, String userCode) throws SQLException {
          ResultSet resultSet =null;
          PreparedStatement preparedStatement = null;
          User user = null;
          if (connection!=null){
                String sql="select * from smbms_user where userCode=?";
                Object[] params = {userCode};
                resultSet = BaseDao.execute(sql,connection,params,resultSet,preparedStatement);
                if (resultSet.next()){
                   user = new User();
                   user.setId(resultSet.getInt("id"));
                   user.setUserCode(resultSet.getString("userCode"));
                   user.setUserName(resultSet.getString("userName"));
                   user.setUserPassword(resultSet.getString("userPassword"));
                   user.setGender(resultSet.getInt("gender"));
                   user.setBirthday(resultSet.getDate("birthday"));
                   user.setPhone(resultSet.getString("phone"));
                   user.setAddress(resultSet.getString("address"));
                   user.setUserRole(resultSet.getInt("userRole"));
                   user.setCreatedBy(resultSet.getInt("createdBy"));
                   user.setCreationDate(resultSet.getTimestamp("creationDate"));
                   user.setModifyBy(resultSet.getInt("modifyBy"));
                   user.setModifyDate(resultSet.getTimestamp("modifyDate"));

                }
                BaseDao.closeResource(null,preparedStatement,resultSet);
          }
          return user;
       }
    }
  3. 业务层接口

    在service下建立user包，建立UserService接口

    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
       public interface UserService {
        //用户登录
        public User login(String userCode, String password);
       }
       ```   
    6. 业务层接口实现类
       ``` java
       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 throwables) {
                throwables.printStackTrace();
            }finally {
                BaseDao.closeResource(connection,null,null);
            }
            return user;
        }
       }
  4. 编写Servlet类

    在Servlet包中创建user包，在user包中建立LoginServlet类

    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);  //这里已经把登录的人给查出来了
         System.out.println(userCode);
         System.out.println(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);
     }
    }
  5. 在web.xml中注册
    1
    2
    3
    4
    5
    6
    7
    8
    <servlet>
     <servlet-name>LoginServlet</servlet-name>
     <servlet-class>com.kuang.servlet.user.LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
       <servlet-name>LoginServlet</servlet-name>
       <url-pattern>/login.do</url-pattern>
    </servlet-mapping>

2、注销功能实现

  1. 在Servlet包的user包中建立LogoutServlett类
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 doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
     doGet(req, resp);
 }
}
  1. 在web.xml中注册
1
2
3
4
5
6
7
8
<servlet>
   <servlet-name>LogoutServlet</servlet-name>
   <servlet-class>com.kuang.servlet.user.LogoutServlet</servlet-class>
 </servlet>
 <servlet-mapping>
     <servlet-name>LogoutServlet</servlet-name>
     <url-pattern>/jsp/logout.do</url-pattern>
 </servlet-mapping>
  1. 设置自动注销
1
2
3
4
<!-- 设置30分后session自动失效 -->
<session-config>
   <session-timeout>30</session-timeout>
</session-config>

3、 登录拦截功能实现

  1. 在filter中建立SysFilter类
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    public class SysFilter implements Filter {
     public void init(FilterConfig filterConfig) throws ServletException {
     }

     public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
         HttpServletRequest request = (HttpServletRequest) req;
         HttpServletResponse response = (HttpServletResponse) resp;

         //过滤器，从Session中获取用户，
         User user = (User) request.getSession().getAttribute(Constants.USER_SESSION);

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

     public void destroy() {

     }
    }
  2. 在web.xml中注册
    1
    2
    3
    4
    5
    6
    7
    8
    9
    <!--用户登录过滤器-->
     <filter>
         <filter-name>SysFilter</filter-name>
         <filter-class>com.kuang.filter.SysFilter</filter-class>
     </filter>
     <filter-mapping>
         <filter-name>SysFilter</filter-name>
         <url-pattern>/jsp/*</url-pattern>
     </filter-mapping>

二、密码修改的实现

  1. 导入前端素材
  2. 编写dao层用户修改密码的接口UserDao

    UserDao接口写如下代码

    1
    2
    //修改当前用户密码
    public int updatePwd(Connection connection, int id, String password) throws SQLException;
  3. 编写UserDao 接口实现类UserDaoImpl
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    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, sql, params, pstm);
            BaseDao.closeResource(null,pstm,null);
        }

        return execute;
    }

  4. 编写业务层接口

    在service的user包中的UserService接口中添加如下代码

    1
    2
    3
    //根据用户ID修改密码
    public boolean updatePwd(int id, String pwd);

  5. 编写业务层接口实现类

    在service的user包中的UserServiceImpl类中添加以下代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    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;
     }
  6. 编写Servlet类

    在Servlet包中的user包中建立UserServlet类

    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
    public class UserServlet extends HttpServlet {
     @Override
     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
         String method = req.getParameter("method");
         if (method.equals("savepwd")&&method!=null){
             this.updatePwd(req,resp);
         }else if (method.equals("pwdmodify")){
             this.pwdModify(req, resp);
         }
     }

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

     //修改密码
     public void updatePwd(HttpServletRequest req, HttpServletResponse resp){
         //从Session里面拿ID;
         Object o = req.getSession().getAttribute(Constants.USER_SESSION);

         String newpassword = req.getParameter("newpassword");

         System.out.println("UserServlet:"+newpassword);

         boolean flag = false;

         System.out.println(o!=null);
         System.out.println(StringUtils.isNullOrEmpty(newpassword));

         if (o!=null && newpassword!=null){
             UserService userService = new UserServiceImpl();
             flag = userService.updatePwd(((User) o).getId(), newpassword);
             if (flag){
                 req.setAttribute("message","修改密码成功，请退出，使用新密码登录");
                 //密码修改成功，移除当前Session
                 req.getSession().removeAttribute(Constants.USER_SESSION);
             }else {
                 req.setAttribute("message","密码修改失败");
                 //密码修改成功，移除当前Session
             }
         }else {
             req.setAttribute("message","新密码有问题");
         }

         try {
             req.getRequestDispatcher("pwdmodify.jsp").forward(req,resp);
         } catch (ServletException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     //验证旧密码,session中有用户的密码
     public void pwdModify(HttpServletRequest req, HttpServletResponse resp){
         //从Session里面拿ID;

         Object o = req.getSession().getAttribute(Constants.USER_SESSION);
         String oldpassword = req.getParameter("oldpassword");
         System.out.println(oldpassword);
         //万能的Map : 结果集
         Map<String, String> resultMap = new HashMap<String,String>();

         if (o==null){ //Session失效了，session过期了
             resultMap.put("result","sessionerror");
         }else if (StringUtils.isNullOrEmpty(oldpassword)){ //输入的密码为空
             resultMap.put("result","error");
         }else {
             String userPassword = ((User) o).getUserPassword(); //Session中用户的密码
             if (oldpassword.equals(userPassword)){
                 resultMap.put("result","true");
             }else {
                 resultMap.put("result","false");
             }
         }


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

     }
    }

在web.xml中注册

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

三、用户管理实现

1. 导入分页的工具类

PageSupport
userlist.jsp

2. 获取用户数量

select count(1) as count from smbms_user u,smbms_role r where u.userRole=r.id; 联表查询用户数量

  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
    31
    32
    33
    34
    35
    36
    37
    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<Object>();//存放我们的参数

             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
             }

             //怎么把List转换为数组
             Object[] params = list.toArray();

             System.out.println("UserDaoImpl->getUserCount:"+sql.toString()); //输出最后完整的SQL语句


             rs = BaseDao.execute(connection, pstm, rs, sql.toString(), params);

             if (rs.next()){
                 count = rs.getInt("count"); //从结果集中获取最终的数量
             }
             BaseDao.closeResource(null,pstm,rs);
         }
         return count;
     }
  3. UserService
    1
    2
    //查询用户总数
    public int getUserCount(Connection connection,String username ,int userRole)throws SQLException;
  4. UserServiceImpl
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    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;
         }

2.获取用户列表

  1. UserDao
    1
    2
    //通过条件查询-userList
    public List<User> getUserList(Connection connection, String userName, int userRole, int currentPageNo, int pageSize)throws Exception;
  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
    public List<User> getUserList(Connection connection, String userName,int userRole,int currentPageNo, int pageSize)
            throws Exception {
        PreparedStatement pstm = null;
        ResultSet rs = null;
        List<User> userList = new ArrayList<User>();
        if(connection != null){
            StringBuffer sql = new StringBuffer();
            sql.append("select u.*,r.roleName as userRoleName from smbms_user u,smbms_role r where u.userRole = r.id");
            List<Object> list = new ArrayList<Object>();
            if(!StringUtils.isNullOrEmpty(userName)){
                sql.append(" and u.userName like ?");
                list.add("%"+userName+"%");
            }
            if(userRole > 0){
                sql.append(" and u.userRole = ?");
                list.add(userRole);
            }
            sql.append(" order by creationDate DESC limit ?,?");
            currentPageNo = (currentPageNo-1)*pageSize;
            list.add(currentPageNo);
            list.add(pageSize);

            Object[] params = list.toArray();
            System.out.println("sql ----> " + sql.toString());
            rs = BaseDao.execute(connection, pstm, rs, sql.toString(), params);
            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(rs.getString("userRoleName"));
                userList.add(_user);
            }
            BaseDao.closeResource(null, pstm, rs);
        }
        return userList;
    }
  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
    15
    16
    17
    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 (Exception e) {
            e.printStackTrace();
        }finally{
            BaseDao.closeResource(connection, null, null);
        }
        return userList;
    }

3.获取角色操作

  1. UserDao
    1
    2
    //获取角色列表
    public List<Role> getRoleList(Connection connection)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
    public class RoleDaoImpl implements RoleDao {
     //获取角色列表
     public List<Role> getRoleList(Connection connection) throws SQLException {

         PreparedStatement pstm = null;
         ResultSet resultSet = null;
         ArrayList<Role> roleList = new ArrayList<Role>();

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

             while (resultSet.next()){
                 Role _role = new Role();
                 _role.setId(resultSet.getInt("id"));
                 _role.setRoleCode(resultSet.getString("roleCode"));
                 _role.setRoleName(resultSet.getString("roleName"));
                 roleList.add(_role);
             }
             BaseDao.closeResource(null,pstm,resultSet);
         }
         return roleList;
     }
    }
  3. UserService
    1
    2
     //获取角色列表
    public List<Role> getRoleList();
  4. UserServiceImpl
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    public class RoleServiceImpl implements RoleService {

     //引入Dao
     private RoleDao roleDao;
     public RoleServiceImpl() {
         roleDao = new RoleDaoImpl();
     }

     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;
     }
    }

4.编写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
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
//添加一个if判断
@Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getParameter("method");
        if (method.equals("savepwd")&&method!=null){
            this.updatePwd(req,resp);
        }else if (method.equals("pwdmodify")&&method!=null){
            this.pwdModify(req, resp);
        }else if (method.equals("query")&&method!=null){
            this.query(req, resp);

        }
    }

    //query方法
    public void query(HttpServletRequest req, HttpServletResponse resp){

        //查询用户列表

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

        //获取用户列表
        UserServiceImpl userService = new UserServiceImpl();
        List<User> userList = null;

        //第一次走这个请求，一定是第一页，页面大小固定的；
        int pageSize = 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 = new PageSupport();
        pageSupport.setCurrentPageNo(currentPageNo);
        pageSupport.setPageSize(pageSize);
        pageSupport.setTotalCount(totalCount);

        int totalPageCount = ((int)(totalCount/pageSize))+1;

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

        //获取用户列表展示
        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();
        }
    }
-------------本文结束感谢您的阅读-------------