# smbms

**Repository Path**: magic304/smbms

## Basic Information

- **Project Name**: smbms
- **Description**: 超市订单管理系统
- **Primary Language**: Java
- **License**: GPL-3.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2022-08-08
- **Last Updated**: 2025-05-27

## Categories & Tags

**Categories**: Uncategorized

**Tags**: 超市订单管理系统

## README

# SMBMS

![image-20220720201327527](https://s2.loli.net/2022/07/20/XWqpNDZx9oGrzQt.png)



## 数据库

![](https://s2.loli.net/2022/07/20/YCXn9afOGzucP8r.png)

## 项目搭建准备工作

1. 搭建一个Maven Web项目

2. 配置Tomcat

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

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

   jsp，servlet，mysql驱动，jstl，stand....

5. 创建项目包结构

   ![image-20220720231032934](https://s2.loli.net/2022/07/20/YOVMyqAk3HeumBg.png)

6. 编写实体类

   ORM映射：表-类 映射

7. 编写基础公共类

   1. 数据库配置文件 

      ```properties
      driver=com.mysql.cj.jdbc.Driver
      url=jdbc:mysql://localhost:3306?useUnicode=true&characterEncoding=utf-8
      username=root
      password=123456
      ```

   2. 编写数据库的公共类

      ```java
      package com.swust.dao;
      
      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) {
                  throw new RuntimeException(e);
              }
      
              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(drive);
                  connection = DriverManager.getConnection(url, username, password);
              } catch (Exception e) {
                  throw new RuntimeException(e);
              }
              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++) {
                  //setObject,占位符从1开始，但我们的数组是从0开始的
                  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 {
              preparedStatement = connection.prepareStatement(sql);
      
              for (int i = 0; i < params.length; i++) {
                  //setObject,占位符从1开始，但我们的数组是从0开始的
                  preparedStatement.setObject(i + 1, params[i]);
              }
              return preparedStatement.executeUpdate();
          }
      
          //释放资源
          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. 编写字符编码过滤器

      ```xml
      <?xml version="1.0" encoding="UTF-8"?>
      <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
               http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
               version="4.0"
               metadata-complete="true">
          
      <!--  字符编码过滤器  -->
          <filter>
              <filter-name>CharacterEncodingFilter</filter-name>
              <filter-class>com.swust.filter.CharacterEncodingFilter</filter-class>
          </filter>
          <filter-mapping>
              <filter-name>CharacterEncodingFilter</filter-name>
              <url-pattern>/*</url-pattern>
          </filter-mapping>
      </web-app>
      ```

8. 导入静态资源

   ![image-20220721172421527](https://s2.loli.net/2022/07/21/a1zdGeOgMTPmuxq.png)

## 登录功能实现

![image-20220721173105612](https://s2.loli.net/2022/07/21/T1lJdv9OhKbH67W.png)

1. 编写前端页面

2. 设置首页

   ```xml
   <!--  设置欢迎页面  -->
       <welcome-file-list>
           <welcome-file>login.jsp</welcome-file>
       </welcome-file-list>
   ```

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

   ```java
   public interface UserDao {
       //得到要登录的用户
       public User getLoginUser(Connection connection, String userCode) throws SQLException;
   }
   ```

4. 编写dao接口的实现类

   ```java
   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, rs, sql, params);
   
               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.setBirthday(rs.getDate("birthday"));
                   user.setPhone(rs.getString("phone"));
                   user.setAddress(rs.getString("address"));
                   user.setUserRole(rs.getInt("userRole"));
                   user.setCreatedBy(rs.getInt("createdBy"));
                   user.setCreationDate(rs.getTimestamp("creationDate"));
                   user.setModifyBy(rs.getInt("modifyBy"));
                   user.setModifyDate(rs.getTimestamp("modifyDate"));
               }
               BaseDao.closeResource(null,pstm,rs);
   
           }
           return user;
       }
   }
   ```

5. 业务层接口

   ```java
   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 e) {
               e.printStackTrace();
           } finally {
               BaseDao.closeResource(connection, null, null);
           }
           return user;
       }
   }
   ```

7. 编写servlet

   ```java
   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");
   
           //和数据库中的密码进行对比，调用业务层；
           UserServiceImpl userService = new UserServiceImpl();
           User user = userService.login(userCode, userPassword);//这里已经把登录的人查出来了
           if (user != null && userCode.equals(user.getUserCode()) && userPassword.equals(user.getUserPassword())) {//查有此人，可以登录
               //将用户的信息放在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

   ```xml
   <servlet>
       <servlet-name>LoginServlet</servlet-name>
       <servlet-class>com.swust.servlet.user.LoginServlet</servlet-class>
   </servlet>
   <servlet-mapping>
       <servlet-name>LoginServlet</servlet-name>
       <url-pattern>/login.do</url-pattern>
   </servlet-mapping>
   ```

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

   ![动画](https://s2.loli.net/2022/07/28/2ZpfbkKqoWj7JO6.gif)
## 登录功能优化

> 注销功能

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

1. 编写Servlet

   ```java
   public class LogoutServlet extends HttpServlet {
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           //移除用户的Session
           req.getSession().removeAttribute(Constants.USER_SESSION);
           resp.sendRedirect(req.getContextPath()+"/login.jsp");//返回登录页面
       }
   
       @Override
       protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           doGet(req, resp);
       }
   }
   ```

2. 注册Servlet

   ```xml
   <servlet>
       <servlet-name>LogoutServlet</servlet-name>
       <servlet-class>com.swust.servlet.user.LogoutServlet</servlet-class>
   </servlet>
   <servlet-mapping>
       <servlet-name>LogoutServlet</servlet-name>
       <url-pattern>/jsp/logout.do</url-pattern>
   </servlet-mapping>
   ```

3. **登录拦截优化**

   编写一个过滤器并注册

   ```java
   public class SysFilter 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(servletRequest, servletResponse);
           }
       }
   
       @Override
       public void destroy() {
   
       }
   }
   ```

   ```xml
   <!--用户登录过滤器-->
       <filter>
           <filter-name>SysFilter</filter-name>
           <filter-class>com.swust.filter.SysFilter</filter-class>
       </filter>
       <filter-mapping>
           <filter-name>SysFilter</filter-name>
           <url-pattern>/jsp/*</url-pattern>
       </filter-mapping>
   ```

4. 测试登录注销权限都要保证ok

   ![动画](https://s2.loli.net/2022/07/28/pdRgK8lHJujNfTc.gif)

## 密码修改

1. 导入前端素材

2. 写项目建议从底层向上写

   ![image-20220728220649822](https://s2.loli.net/2022/07/28/DScwJQ2UqvyGnTV.png)

3. UserDao 接口

   ```java
   //修改当前用户密码
       public int updatePwd(Connection connection,int id,int password) throws SQLException;
   }
   ```

4. UserDao 接口实现类

   ```java
   @Override
   public int updatePwd(Connection connection, int id, int 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);
   ```

5. UserService层

   ```java
   public boolean updatePwd(int id, int password);
   ```

6. UserService层实现类

   ```java
   public boolean updatePwd(int id, int password) {
       Connection connection = null;
       boolean flag = false;
       //修改密码
       try {
           connection = BaseDao.getConnection();
           if (userDao.updatePwd(connection, id, password) > 0) {
               flag = true;
           }
       } catch (SQLException e) {
           e.printStackTrace();
       }finally {
           BaseDao.closeResource(connection,null,null);
       }
       return flag;
   }
   ```

7. 记得实现复用，需提取出方法

   ```java
   //实现Servlet复用
   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);
           }
       }
   
       @Override
       protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           doGet(req, resp);
       }
   
       public void updatePwd(HttpServletRequest req, HttpServletResponse resp) {
           //从Session里拿Id；
           Object attribute = req.getSession().getAttribute(Constants.USER_SESSION);
           String newpassword = req.getParameter("newpassword");
   
           boolean flag = false;
   
           if (attribute != null && !StringUtils.isNullOrEmpty(newpassword)) {
               UserServiceImpl userService = new UserServiceImpl();
               flag = userService.updatePwd(((User) attribute).getId(), newpassword);
               if (flag) {
                   req.setAttribute("message", "修改密码成功，请退出，使用新密码登录");
                   //密码修改成功，移除当前Session
                   req.getSession().removeAttribute(Constants.USER_SESSION);
               } else {
                   req.setAttribute("message", "密码修改失败");
               }
           } else {
               req.setAttribute("message", "新密码有问题");
           }
           try {
               req.getRequestDispatcher("pwdmodify.jsp").forward(req, resp);
           } catch (ServletException | IOException e) {
               e.printStackTrace();
           }
       }
   }
   ```

8. 注册XML

   ```xml
   <servlet>
       <servlet-name>UserServlet</servlet-name>
       <servlet-class>com.swust.servlet.user.UserServlet</servlet-class>
   </servlet>
   <servlet-mapping>
       <servlet-name>UserServlet</servlet-name>
       <url-pattern>/jsp/user.do</url-pattern>
   </servlet-mapping>
   ```

9. 测试

**优化密码修改，使用Ajax**

1. 阿里巴巴的fastjson

   ```xml
   <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
   <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>fastjson</artifactId>
       <version>2.0.10</version>
   </dependency>
   ```

2. 后台代码实现

   ```java
   //修改密码
   public void updatePwd(HttpServletRequest req, HttpServletResponse resp) {
       //从Session里拿Id；
       Object attribute = req.getSession().getAttribute(Constants.USER_SESSION);
       String newpassword = req.getParameter("newpassword");
   
       boolean flag = false;
   
       if (attribute != null && !StringUtils.isNullOrEmpty(newpassword)) {
           UserServiceImpl userService = new UserServiceImpl();
           flag = userService.updatePwd(((User) attribute).getId(), newpassword);
           if (flag) {
               req.setAttribute("message", "修改密码成功，请退出，使用新密码登录");
               //密码修改成功，移除当前Session
               req.getSession().removeAttribute(Constants.USER_SESSION);
           } else {
               req.setAttribute("message", "密码修改失败");
           }
       } else {
           req.setAttribute("message", "新密码有问题");
       }
       try {
           req.getRequestDispatcher("pwdmodify.jsp").forward(req, resp);
       } catch (ServletException | IOException e) {
           e.printStackTrace();
       }
   }
   
   //验证旧密码,session中有用户的密码
   public void pwdModify(HttpServletRequest req, HttpServletResponse resp){
       //从Session里拿Id；
       Object attribute = req.getSession().getAttribute(Constants.USER_SESSION);
       String oldpassword = req.getParameter("oldpassword");
   
       //万能的map:结果集
       HashMap<String, String> resultMap = new HashMap<>();
       if (attribute==null){//Session失效了，session过期了
           resultMap.put("result","sessionerror");
       } else if (StringUtils.isNullOrEmpty(oldpassword)) {//输入的密码为空
           resultMap.put("result","error");
       }else {
           String userPassword = ((User) attribute).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阿里巴巴的工具类,转换格式
           /*
           resultMap = ["result","sessionerror"]
           Json格式 = {key: value}
            */
           writer.write(JSONArray.toJSONString(resultMap));
           writer.flush();
           writer.close();
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
   ```

3. 测试

## 用户管理实现

思路：

![image-20220805152828757](https://s2.loli.net/2022/08/05/hQ7neALiT6ZBykc.png)

1. 导入分页的工具类
2. 用户列表页面导入

### 1.获取用户数量

1.  UserDao

   ```java
   //查询用户总数
   public int getUserCount(Connection connection,String username, int userRole) throws SQLException;
   ```

2. UserDaoImpl

   ```java
   //根据用户名或角色查询用户总数
   @Override
   public int getUserCount(Connection connection, String username, int userRole) throws SQLException {
       PreparedStatement preparedStatement = 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 like ?");
               list.add(userRole);//index:1
           }
   
           //怎么把list转换为数组
           Object[] params = list.toArray();
   
           System.out.println("UserDapImpl -> getUserCount:" + sql.toString());//输出完整的sql语句
           rs = BaseDao.execute(connection, preparedStatement, rs, sql.toString(), params);
   
           if (rs.next()){
               count = rs.getInt("count");//从结果中获取最终的数量
           }
           BaseDao.closeResource(null,preparedStatement,rs);
       }
       return count;
   }
   ```

3. UserService

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

4. UserServiceImpl

   ```java
   //查询记录数
   @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;
   }
   ```

### 2.获取用户列表

1. userDao

   ```java
   //获取用户列表
   public List<User> getUserList(Connection connection, String username, int userRole, int currentPageNo, int pageSize) throws SQLException;
   ```

2. userDaoImpl

   ```java
   public List<User> getUserList(Connection connection, String username, int userRole, int currentPageNo, int pageSize) throws SQLException {
       PreparedStatement preparedStatement = null;
       ResultSet rs = null;
       ArrayList<User> userList = new ArrayList<>();
   
       if (connection != null) {
           StringBuffer sql = new StringBuffer("select u.*,r.roleName as userRolename 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 + "%");
           }
           if (userRole > 0) {
               sql.append(" and u.userRole = ?");
               list.add(userRole);
           }
   
           //在数据库中，分页使用： limit  startIndex，PageSiz；总数
           /*
               当前页（当前页-1)*页面大小
               0,5     1 0     01234
               5,5     2 5     56789
               10,5    3 10
            */
           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, preparedStatement, 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, preparedStatement, rs);
       }
       return userList;
   }
   ```

3. userService

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

4. userServiceImpl

   ```java
   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);
   
       connection = BaseDao.getConnection();
       try {
           userDao.getUserList(connection,queryUserName,queryUserRole,currentPageNo,pageSize);
       } catch (SQLException e) {
           e.printStackTrace();
       }finally {
           BaseDao.closeResource(connection,null,null);
       }
       return userList;
   }
   ```

### 3.获取角色操作

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

1. RoleDao

   ```java
   public interface RoleDao {
       //获取用户角色列表
       public List<Role> getRoleList(Connection connection) throws SQLException;
   }
   ```

2. RoleDaoImpl

   ```java
   public class RoleDaoImpl implements RoleDao {
       //获取用户角色列表
       @Override
       public List<Role> getRoleList(Connection connection) throws SQLException {
           PreparedStatement preparedStatement = null;
           ResultSet resultSet = null;
   
           ArrayList<Role> roleList = new ArrayList<>();
   
           if (connection!=null){
               String sql = "select * from smbms_role";
               Object[] params = {};
               resultSet = BaseDao.execute(connection, preparedStatement, 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,preparedStatement,resultSet);
           }
           return roleList;
       }
   }
   ```

3. RoleService

   ```java
   public interface RoleService {
       //获取用户角色列表
       public List<Role> getRoleList();
   }
   ```

4. RoleServiceImpl

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

5.