smbms超市管理系统

smbms超市管理系统

项目介绍

首先该项目基于maven创建，idea进行开发,使用mysql数据库进行数据存储.

项目地址： 链接：https://pan.baidu.com/s/1oDMSolH5N4XcbhK5KjtsUQ
提取码：2431

注意解压文件后请先查看一下.md文件

实现功能

• 用户管理页面

• 用户登录

• 用户删除

• 用户添加

• 供应商页面

• 系统退出

功能并不全，可以根据需要自己进行完善

项目架构

1. 首先项目采用三层架构，便于代码复用

   • dao层

     数据持久层，主要操作数据库，进行后台信息的增删改查

   • service层

     业务层，具体业务实现，直接操作dao层

   • control层

     控制层，处理前端请求，操作业务层，完成视图跳转

2. 项目封装了数据库的基本操作，创建了一些工具类（分页操作等）

3. 使用过滤器进行页面拦截和字符乱码处理

项目配置

1. 导入相关依赖包，项目所需要的jar包

   <dependencies>
       <dependency>
           <groupId>javax.servlet</groupId>
           <artifactId>servlet-api</artifactId>
           <version>2.5</version>
       </dependency>
       <dependency>
           <groupId>javax.servlet.jsp</groupId>
           <artifactId>jsp-api</artifactId>
           <version>2.1</version>
       </dependency>
    	<!--数据库驱动-->   
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>5.1.40</version>
       </dependency>
       <dependency>
           <groupId>javax.servlet.jsp.jstl</groupId>
           <artifactId>jstl-api</artifactId>
           <version>1.2</version>
       </dependency>
       <!-- taglibs 标签库依赖-->
       <dependency>
           <groupId>taglibs</groupId>
           <artifactId>standard</artifactId>
           <version>1.1.2</version>
       </dependency>
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.12</version>
       </dependency>
       <dependency>
           <groupId>com.alibaba</groupId>
           <artifactId>fastjson</artifactId>
           <version>1.2.58</version>
       </dependency>
   </dependencies>
   

2. web.xml的配置

   <!DOCTYPE web-app PUBLIC
           "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
           "http://java.sun.com/dtd/web-app_2_3.dtd" >
   <web-app>
       //过滤器的映射
       <filter>
           <filter-name>characterEncoding</filter-name>
           <filter-class>com.sheng.filter.characterEncoding</filter-class>
       </filter>
       <filter-mapping>
           <filter-name>characterEncoding</filter-name>
           <url-pattern>/*</url-pattern>
       </filter-mapping>
       <filter>
           <filter-name>loginFilter</filter-name>
           <filter-class>com.sheng.filter.loginFilter</filter-class>
       </filter>
       <filter-mapping>
           <filter-name>loginFilter</filter-name>
           <url-pattern>/jsp/*</url-pattern>
       </filter-mapping>
       
       //欢迎页的设置
       <welcome-file-list>
           <welcome-file>login.jsp</welcome-file>
       </welcome-file-list>
       <servlet>
           <servlet-name>loginServlet</servlet-name>
           <servlet-class>com.sheng.servlet.loginServlet</servlet-class>
       </servlet>
       <servlet-mapping>
           <servlet-name>loginServlet</servlet-name>
           <url-pattern>/user/login.zcl</url-pattern>
       </servlet-mapping>
       <servlet>
           <servlet-name>logoutServlet</servlet-name>
           <servlet-class>com.sheng.servlet.logoutServlet</servlet-class>
       </servlet>
       <servlet-mapping>
           <servlet-name>logoutServlet</servlet-name>
           <url-pattern>/logout.do</url-pattern>
       </servlet-mapping>
       <servlet>
           <servlet-name>userServlet</servlet-name>
           <servlet-class>com.sheng.servlet.userServlet.userServlet</servlet-class>
       </servlet>
       <servlet-mapping>
           <servlet-name>userServlet</servlet-name>
           <url-pattern>/user/pwdModify</url-pattern>
       </servlet-mapping>
       <servlet-mapping>
           <servlet-name>userServlet</servlet-name>
           <url-pattern>/user/query</url-pattern>
       </servlet-mapping>
       <servlet-mapping>
           <servlet-name>userServlet</servlet-name>
           <url-pattern>/user/add</url-pattern>
       </servlet-mapping>
       <servlet-mapping>
           <servlet-name>userServlet</servlet-name>
           <url-pattern>/user/getRoleList</url-pattern>
       </servlet-mapping>
       <servlet-mapping>
           <servlet-name>userServlet</servlet-name>
           <url-pattern>/user/ucexist</url-pattern>
       </servlet-mapping>
       <servlet-mapping>
           <servlet-name>userServlet</servlet-name>
           <url-pattern>/user/delUser</url-pattern>
       </servlet-mapping>
       <servlet>
           <servlet-name>test</servlet-name>
           <servlet-class>com.sheng.servlet.test</servlet-class>
       </servlet>
       <servlet-mapping>
           <servlet-name>test</servlet-name>
           <url-pattern>/test</url-pattern>
       </servlet-mapping>
       <servlet>
           <servlet-name>provideServlet</servlet-name>
           <servlet-class>com.sheng.servlet.provideServlet.provideServlet</servlet-class>
       </servlet>
       <servlet-mapping>
           <servlet-name>provideServlet</servlet-name>
           <url-pattern>/provide/query</url-pattern>
       </servlet-mapping>
   </web-app>
   

   注意此处web.xml版本较低，可以使用新的版本，还有可能在xml文件里添加中文注释会报错

3. 数据库配置文件的编写

   driver=com.mysql.jdbc.Driver
   url=jdbc:mysql://localhost:3306/数据库名?useUnicode=true&characterEncoding=utf-8&useSSL=true
   username=root
   password=password
   

   此处账号密码填写自己设置的，driver在高版本mysql中需要有cj,url链接有的需要加上时区&serverTimezone=GMT%2B8，进一步问题解决请自己搜索

功能实现

数据库实现

• 建表语句在压缩包里，你需要首先创建一个数据库然后执行sql语句即可

• jdbc连接数据库方法封装

  public class basedao {
      public static void main(String[] args) {
          System.out.println(basedao.getConnection());
      }
      private static String driver;
      private static String url;
      private static String username;
      private static String password;
      static {
          //静态代码块，类加载时调用,通过类加载器加载资源默认在字节码文件下，此处在target下的classes。
          InputStream db = basedao.class.getClassLoader().getResourceAsStream("db.properties");
          Properties properties = new Properties();
          try {
              properties.load(db);
              driver=properties.getProperty("driver");
              url=properties.getProperty("url");
              username=properties.getProperty("username");
              password=properties.getProperty("password");
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
      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 excute(Connection connection,PreparedStatement preparedStatement,Object[] pa,String sql){
          //可变形参传参数
          ResultSet resultSet = null;
          try {
              preparedStatement=connection.prepareStatement(sql);
              for (int i = 0; i <pa.length ; i++) {
                  preparedStatement.setObject(i+1,pa[i]);
              }
  //            System.out.println(preparedStatement);
              resultSet = preparedStatement.executeQuery();
          } catch (SQLException throwables) {
              throwables.printStackTrace();
          }
          return resultSet;
      }
      public static int excute(Connection connection,String sql,PreparedStatement preparedStatement, Object[] pa){
          int in = 0;
          try {
              preparedStatement = connection.prepareStatement(sql);
              for (int i = 0; i <pa.length ; i++) {
                  preparedStatement.setObject(i+1,pa[i]);
              }
              in = preparedStatement.executeUpdate();
              System.out.println(in);
          } catch (SQLException throwables) {
              throwables.printStackTrace();
          }
          return in;
      }
      public static boolean release(ResultSet resultSet,PreparedStatement preparedStatement,Connection connection){
          boolean flag=true;
          if (resultSet!=null)
          {
              try {
                  resultSet.close();
                  resultSet=null;
              } catch (SQLException throwables) {
                  throwables.printStackTrace();
                  flag=false;
              }
          }
  
              if (preparedStatement!=null)
              {
                  try {
                      preparedStatement.close();
                      preparedStatement=null;
                  } catch (SQLException throwables) {
                      throwables.printStackTrace();
                      flag=false;
                  }
              }
  
              if (connection!=null)
              {
                  try {
                      connection.close();
                      connection=null;
                  } catch (SQLException throwables) {
                      throwables.printStackTrace();
                      flag=false;
                  }
              }
          return flag;
      }
  }
  
  

  通过类名可以直接使用方法，可以进行数据库的连接和sql查询以及update

实体类pojo

user类

public class user {
    private Integer id; //id
    private String userCode; //用户编码
    private String userName; //用户名称
    private String userPassword; //用户密码
    private Integer gender;  //性别
    private Date birthday;  //出生日期
    private String phone;   //电话
    private String address; //地址
    private Integer userRole;    //用户角色
    private Integer createdBy;   //创建者
    private Date creationDate; //创建时间
    private Integer modifyBy;     //更新者
    private Date modifyDate;   //更新时间

    private Integer age;//年龄
    private String userRoleName;    //用户角色名称


    public String getUserRoleName() {
        return userRoleName;
    }
    public void setUserRoleName(String userRoleName) {
        this.userRoleName = userRoleName;
    }
    public Integer getAge() {
        Date date = new Date();
        Integer age = date.getYear()-birthday.getYear();
        return age;
    }

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

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUserCode() {
        return userCode;
    }
    public void setUserCode(String userCode) {
        this.userCode = userCode;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserPassword() {
        return userPassword;
    }
    public void setUserPassword(String userPassword) {
        this.userPassword = userPassword;
    }
    public Integer getGender() {
        return gender;
    }
    public void setGender(Integer gender) {
        this.gender = gender;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public Integer getUserRole() {
        return userRole;
    }
    public void setUserRole(Integer userRole) {
        this.userRole = userRole;
    }
    public Integer getCreatedBy() {
        return createdBy;
    }
    public void setCreatedBy(Integer createdBy) {
        this.createdBy = createdBy;
    }
    public Date getCreationDate() {
        return creationDate;
    }
    public void setCreationDate(Date creationDate) {
        this.creationDate = creationDate;
    }
    public Integer getModifyBy() {
        return modifyBy;
    }
    public void setModifyBy(Integer modifyBy) {
        this.modifyBy = modifyBy;
    }
    public Date getModifyDate() {
        return modifyDate;
    }
    public void setModifyDate(Date modifyDate) {
        this.modifyDate = modifyDate;
    }
}

role类

public class role {
    private Integer id;   //id
    private String roleCode; //角色编码
    private String roleName; //角色名称
    private Integer createdBy; //创建者
    private Date creationDate; //创建时间
    private Integer modifyBy; //更新者
    private Date modifyDate;//更新时间

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getRoleCode() {
        return roleCode;
    }
    public void setRoleCode(String roleCode) {
        this.roleCode = roleCode;
    }
    public String getRoleName() {
        return roleName;
    }
    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }
    public Integer getCreatedBy() {
        return createdBy;
    }
    public void setCreatedBy(Integer createdBy) {
        this.createdBy = createdBy;
    }
    public Date getCreationDate() {
        return creationDate;
    }
    public void setCreationDate(Date creationDate) {
        this.creationDate = creationDate;
    }
    public Integer getModifyBy() {
        return modifyBy;
    }
    public void setModifyBy(Integer modifyBy) {
        this.modifyBy = modifyBy;
    }
    public Date getModifyDate() {
        return modifyDate;
    }
    public void setModifyDate(Date modifyDate) {
        this.modifyDate = modifyDate;
    }

}

bill类

public class bill {
        private Integer id;   //id
        private String billCode; //账单编码
        private String productName; //商品名称
        private String productDesc; //商品描述
        private String productUnit; //商品单位
        private BigDecimal productCount; //商品数量
        private BigDecimal totalPrice; //总金额
        private Integer isPayment; //是否支付
        private Integer providerId; //供应商ID
        private Integer createdBy; //创建者
        private Date creationDate; //创建时间
        private Integer modifyBy; //更新者
        private Date modifyDate;//更新时间

        private String providerName;//供应商名称


        public String getProviderName() {
            return providerName;
        }
        public void setProviderName(String providerName) {
            this.providerName = providerName;
        }
        public Integer getId() {
            return id;
        }
        public void setId(Integer id) {
            this.id = id;
        }
        public String getBillCode() {
            return billCode;
        }
        public void setBillCode(String billCode) {
            this.billCode = billCode;
        }
        public String getProductName() {
            return productName;
        }
        public void setProductName(String productName) {
            this.productName = productName;
        }
        public String getProductDesc() {
            return productDesc;
        }
        public void setProductDesc(String productDesc) {
            this.productDesc = productDesc;
        }
        public String getProductUnit() {
            return productUnit;
        }
        public void setProductUnit(String productUnit) {
            this.productUnit = productUnit;
        }
        public BigDecimal getProductCount() {
            return productCount;
        }
        public void setProductCount(BigDecimal productCount) {
            this.productCount = productCount;
        }
        public BigDecimal getTotalPrice() {
            return totalPrice;
        }
        public void setTotalPrice(BigDecimal totalPrice) {
            this.totalPrice = totalPrice;
        }
        public Integer getIsPayment() {
            return isPayment;
        }
        public void setIsPayment(Integer isPayment) {
            this.isPayment = isPayment;
        }

        public Integer getProviderId() {
            return providerId;
        }
        public void setProviderId(Integer providerId) {
            this.providerId = providerId;
        }
        public Integer getCreatedBy() {
            return createdBy;
        }
        public void setCreatedBy(Integer createdBy) {
            this.createdBy = createdBy;
        }
        public Date getCreationDate() {
            return creationDate;
        }
        public void setCreationDate(Date creationDate) {
            this.creationDate = creationDate;
        }
        public Integer getModifyBy() {
            return modifyBy;
        }
        public void setModifyBy(Integer modifyBy) {
            this.modifyBy = modifyBy;
        }
        public Date getModifyDate() {
            return modifyDate;
        }
        public void setModifyDate(Date modifyDate) {
            this.modifyDate = modifyDate;
        }

}

provider类

public class provider {
    private Integer id;   //id
    private String proCode; //供应商编码
    private String proName; //供应商名称
    private String proDesc; //供应商描述
    private String proContact; //供应商联系人
    private String proPhone; //供应商电话
    private String proAddress; //供应商地址
    private String proFax; //供应商传真
    private Integer createdBy; //创建者
    private Date creationDate; //创建时间
    private Integer modifyBy; //更新者
    private Date modifyDate;//更新时间

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getProCode() {
        return proCode;
    }
    public void setProCode(String proCode) {
        this.proCode = proCode;
    }
    public String getProName() {
        return proName;
    }
    public void setProName(String proName) {
        this.proName = proName;
    }
    public String getProDesc() {
        return proDesc;
    }
    public void setProDesc(String proDesc) {
        this.proDesc = proDesc;
    }
    public String getProContact() {
        return proContact;
    }
    public void setProContact(String proContact) {
        this.proContact = proContact;
    }
    public String getProPhone() {
        return proPhone;
    }
    public void setProPhone(String proPhone) {
        this.proPhone = proPhone;
    }
    public String getProAddress() {
        return proAddress;
    }
    public void setProAddress(String proAddress) {
        this.proAddress = proAddress;
    }
    public String getProFax() {
        return proFax;
    }
    public void setProFax(String proFax) {
        this.proFax = proFax;
    }
    public Integer getCreatedBy() {
        return createdBy;
    }
    public void setCreatedBy(Integer createdBy) {
        this.createdBy = createdBy;
    }
    public Date getCreationDate() {
        return creationDate;
    }
    public void setCreationDate(Date creationDate) {
        this.creationDate = creationDate;
    }
    public Integer getModifyBy() {
        return modifyBy;
    }
    public void setModifyBy(Integer modifyBy) {
        this.modifyBy = modifyBy;
    }
    public Date getModifyDate() {
        return modifyDate;
    }
    public void setModifyDate(Date modifyDate) {
        this.modifyDate = modifyDate;
    }
}

过滤器设置

public class characterEncoding implements Filter {

    public void init(FilterConfig filterConfig) throws ServletException {

    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("进入过滤层");
        HttpServletRequest request1=(HttpServletRequest) request;
        HttpServletResponse response1=(HttpServletResponse) response;
        String requestURI = request1.getRequestURI();
        if (requestURI.contains(".css")||requestURI.contains(".js")||requestURI.contains(".png")){
            chain.doFilter(request,response);
            return;
        }
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        chain.doFilter(request,response);
    }

    public void destroy() {

    }
}

//登录信息拦截
public class loginFilter implements Filter {

    public void init(FilterConfig filterConfig) throws ServletException {

    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //向下转型来获取session值
//        System.out.println("进入过滤层");
        HttpServletRequest request1 = (HttpServletRequest) request;
        HttpServletResponse response1 = (HttpServletResponse) response;
        Object attribute = request1.getSession().getAttribute(userCons.userSession);
        if (attribute==null){
            //过滤拦截，避免直接访问需要登陆的页面
            response1.sendRedirect("/login.jsp");
        }
        else
        {
//            System.out.println("进入方法");
            chain.doFilter(request1,response1);
        }
    }

    public void destroy() {

    }
}

字符集过滤，解决乱码问题，登录信息拦截，正常情况下登陆成功后会给客户端一个cookie¹值或者session²,避免用户直接输入url访问网站其他页面

用户dao层

面向接口编程，通过在dao接口里声明相应的方法，在实现类里完整方法

public interface usedaoInter {
    public user getLoginUser(Connection connection, String userCode);
    public int userPwdModify(int userId,String newPwd);
    //获取用户总数
    public int getUserCount(String word,int userRole);
    //实现分页
    public List<user> getUserList(String word, int userRole,int pageNo,int pageSize);
    //判断userCode是否存在
    public boolean testUser(String userCode);
    //添加用户
    public int userAdd(Connection connection,user user);
    //删除用户
    public int delUser(int userId);
}

dao层具体实现类

public class userdaoimpl implements usedaoInter {

    PreparedStatement preparedStatement = null;

    public user getLoginUser(Connection connection, String userCode) {

        String sql = "select * from smbms.smbms_user where userCode = ?";
        Object a[] = {userCode};
        ResultSet rs = basedao.excute(connection, preparedStatement, a, sql);
        user user = null;
        try {
            if (rs.next()) {
                user = new user();
                user.setAddress(rs.getString("address"));
                user.setBirthday(rs.getDate("birthday"));
                user.setCreatedBy(rs.getInt("createdBy"));
                user.setCreationDate(rs.getDate("creationDate"));
                user.setGender(rs.getInt("gender"));
                user.setModifyBy(rs.getInt("modifyBy"));
                user.setModifyDate(rs.getDate("modifyDate"));
                user.setId(rs.getInt("id"));
                user.setPhone(rs.getString("phone"));
                user.setUserCode(rs.getString("userCode"));
                user.setUserName(rs.getString("userName"));
                user.setUserPassword(rs.getString("userPassword"));
                user.setUserRole(rs.getInt("userRole"));
//                System.out.println(rs.getString("userPassword"));
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        basedao.release(rs, preparedStatement, connection);
        return user;
    }

    public int userPwdModify(int userId, String newPwd) {
        System.out.println(newPwd);
        String sql = "update smbms_user set userPassword=? where id=?";
        PreparedStatement preparedStatement = null;
        Object pa[] = {newPwd, userId};
        Connection connection = basedao.getConnection();
        int excute = basedao.excute(connection, sql, preparedStatement, pa);
        //System.out.println(excute);
        basedao.release(null, preparedStatement, connection);
        return excute;
    }

    public int getUserCount(String word, int userRole) {
        //获得数据库连接对象
        Connection connection = basedao.getConnection();
        PreparedStatement preparedStatement = null;
        ArrayList<Object> list = new ArrayList<Object>();
        //Stringbuffer和String类型相互转换，可以通过构造函数，还可以就是用append方法。
        StringBuffer sql = new StringBuffer();
        sql.append("select count(1) as count from smbms_user u,smbms_role r where u.`userRole`=r.id");
        //判断前端传来的用户名实现特定搜索
        if (!StringUtils.isNullOrEmpty(word)) {
            sql.append(" and u.userName like ?");
            list.add("%" + word + "%");
        }
        //同样也是前端传来的用户职位参数
        if (userRole > 0) {
            sql.append(" and u.userRole = ?");
            list.add(userRole);
        }
        Object[] objects = list.toArray();
        System.out.println("参数数组:" + objects);
        System.out.println("sql最终样式：" + sql.toString());
        ResultSet resultSet = basedao.excute(connection, preparedStatement, objects, sql.toString());
        //获取用户个数
        int count = 0;
        try {
            if (resultSet.next()) {
                count = resultSet.getInt("count");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        basedao.release(resultSet, preparedStatement, connection);
        return count;
    }

    public List<user> getUserList(String word, int userRole, int pageNo, int pageSize) {
        //存储用户列表 
        ArrayList<user> users = new ArrayList<user>();
        //获得数据库连接对象
        Connection connection = basedao.getConnection();
        PreparedStatement preparedStatement = null;
        ArrayList<Object> list = new ArrayList<Object>();
        //Stringbuffer和String类型相互转换，可以通过构造函数，还可以就是用append方法。
        StringBuffer sql = new StringBuffer();
        sql.append("select * from smbms_user u , smbms_role r where u.`userRole`=r.id");
        //判断前端传来的用户名实现特定搜索
        if (!StringUtils.isNullOrEmpty(word)) {
            sql.append(" and u.userName like ?");
            list.add("%" + word + "%");
        }
        //同样也是前端传来的用户职位参数
        if (userRole > 0) {
            sql.append(" and u.userRole = ?");
            list.add(userRole);
        }
        //实现分页
        sql.append(" order by u.`creationDate` asc limit ?,?");
        //当前页起始位置的计算方式 (page-1)*pageSize
        list.add((pageNo - 1) * pageSize);
        list.add(pageSize);
        Object[] objects = list.toArray();
        System.out.println(Arrays.toString(objects));
        System.out.println("最终sql:" + sql);
        ResultSet excute = basedao.excute(connection, preparedStatement, objects, sql.toString());
        try {
            while (excute!=null&&excute.next()) {
                user user = new user();
                user.setId(excute.getInt(1));
                user.setUserCode(excute.getString("userCode"));
                user.setUserName(excute.getString("userName"));
                user.setGender(excute.getInt("gender"));
                user.setUserPassword(excute.getString("userPassword"));
                user.setPhone(excute.getString("phone"));
                user.setUserRoleName(excute.getString("roleName"));
                user.setBirthday(excute.getDate("birthday"));
                user.setAge(user.getAge());
//                System.out.println(user.getAge());
                users.add(user);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        basedao.release(excute, preparedStatement, connection);
        //返回用户列表对象
//        System.out.println(users.size());
        return users;
    }

    public boolean testUser(String userCode) {
        Connection connection = basedao.getConnection();
        String sql = "select userCode from smbms_user";
        PreparedStatement preparedStatement = null;
        Object[] objects = {};
        ResultSet excute = basedao.excute(connection, preparedStatement, objects, sql);
        try {
            while (excute.next()) {
                if (excute.getString("userCode").equals(userCode))
                {
                    return false;
                }
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return true;
    }

    public int userAdd(Connection connection, user user) {
        PreparedStatement preparedStatement=null;
        String sql="insert into smbms_user (`userCode`,`userName`,`userPassword`,`userRole`,gender,phone,address,birthday,`creationDate`,`createdBy`) value (?,?,?,?,?,?,?,?,?,?)";
        ArrayList arrayList = new ArrayList();
        arrayList.add(user.getUserCode());
        arrayList.add(user.getUserName());
        arrayList.add(user.getUserPassword());
        arrayList.add(user.getUserRole());
        arrayList.add(user.getGender());
        arrayList.add(user.getPhone());
        arrayList.add(user.getAddress());
        arrayList.add(user.getBirthday());
        arrayList.add(user.getCreationDate());
        arrayList.add(user.getCreatedBy());
        Object[] objects = arrayList.toArray();
        System.out.println("sql: "+sql);
        int excute = basedao.excute(connection, sql, preparedStatement, objects);
        basedao.release(null,preparedStatement,null);
        return excute;
    }

    public int delUser(int userId) {
        Connection connection = basedao.getConnection();
        PreparedStatement preparedStatement=null;
        Object[] objects={userId};
        String sql="delete from smbms_user where id = ?";
        System.out.println("sql: "+sql);
        int excute = basedao.excute(connection, sql, preparedStatement, objects);
        basedao.release(null,preparedStatement,connection);
        return excute;
    }


    void test1(ArrayList arrayList) {
        arrayList = new ArrayList(22);
        arrayList.add(569);
        System.out.println(arrayList.hashCode());
        System.out.println(arrayList);
    }

    @Test
    public void test() {
        String a="ss";
        String b="ss";
        System.out.println(a==b);
//        ArrayList arrayList = new ArrayList();
//        arrayList.add("ss");
//        test1(arrayList);
//        System.out.println(arrayList.hashCode());
//        System.out.println(arrayList);
//        user sss = getLoginUser(basedao.getConnection(), "admin");
//        System.out.println(sss);
//        System.out.println(sss.getId());
//        String s = new String("ss");
//        s="ss";
//        String s1 = new String("ss");
//        s1="ss";
//        System.out.println(s.hashCode());
//        System.out.println(s1.hashCode());
    }
}

role层

role接口类

public interface roleDaonIter {
    public List<role> getRoleList();
}

role实现类

public class roleDaoImpl implements roleDaonIter {
    public List<role> getRoleList() {
        ArrayList<role> roles = new ArrayList<role>();
        ArrayList list = new ArrayList();
        Connection connection = basedao.getConnection();
        PreparedStatement preparedStatement = null;
        System.out.println(preparedStatement);
        String sql = "select * from smbms_role";
        Object[] objects = list.toArray();
        ResultSet excute = basedao.excute(connection, preparedStatement, objects, sql);
        try {
            while (excute.next()) {
                role role = new role();
                role.setId(excute.getInt("id"));
                role.setRoleCode(excute.getString("roleCode"));
                role.setRoleName(excute.getString("roleName"));
                roles.add(role);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        System.out.println(roles.size());
//        System.out.println(preparedStatement);
        basedao.release(excute,preparedStatement,connection);
        return roles;
    }
    @Test
   public void test(){
        getRoleList();
    }
}

供应商provider层

供应商接口类

public interface provideinter {
    public List<provider> getProvideList(String code,String name);
}

供应商实现类

public class provideImpl implements provideinter {
    public List<provider> getProvideList(String code, String name) {
        Connection connection = basedao.getConnection();
        PreparedStatement preparedStatement=null;
        StringBuilder stringBuilder = new StringBuilder();
        String sql="select * from smbms_provider";
        ArrayList arrayList = new ArrayList();
        ArrayList<provider> providers = new ArrayList<provider>();
        stringBuilder.append(sql);
        if (!StringUtils.isNullOrEmpty(code)){
            stringBuilder.append(" where proCode=?");
            arrayList.add(code);
        }
        if (!StringUtils.isNullOrEmpty(name)){
            stringBuilder.append(" and proName=?");
            arrayList.add(name);
        }
        Object[] objects = arrayList.toArray();
//        System.out.println(objects);
//        System.out.println(stringBuilder);
        ResultSet resultSet = basedao.excute(connection, preparedStatement, objects, stringBuilder.toString());
        try {
            while (resultSet.next()){
                System.out.println("进入");
                provider provider = new provider();
                provider.setId(resultSet.getInt("id"));
                provider.setProCode(resultSet.getString("proCode"));
                provider.setProName(resultSet.getString("proName"));
                provider.setProPhone(resultSet.getString("proPhone"));
                provider.setProDesc(resultSet.getString("proDesc"));
                provider.setProContact(resultSet.getString("proContact"));
                provider.setProFax(resultSet.getString("proFax"));
                provider.setCreationDate(resultSet.getDate("creationDate"));
                providers.add(provider);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
//        System.out.println(providers);
//        System.out.println(providers.size());
        return providers;
    }
}

用户业务层

接口

public interface userServer {
    public user login(String useCode,String password);
    public boolean userPwdModify(int userId,String newPwd);
    public int getUserCount(String word,int userRole);
    public List<user> getUserList(String word, int userRole, int pageNo, int pageSize);
    public boolean testUser(String userCode);
    public boolean userAdd( user user);
    public boolean delUser(int userId);
}

实现类

public class userServerImpl implements userServer {
    private userdaoimpl usedaoimpl;

    public userServerImpl() {
        usedaoimpl=new userdaoimpl();
    }

    public user login(String useCode, String password) {


        Connection connection = basedao.getConnection();
        user user = usedaoimpl.getLoginUser(connection, useCode);
        basedao.release(null,null,connection);
//        System.out.println(user.getUserPassword());
            if(user.getUserPassword().equals(password))
            {
                return user;
            }
            else
            {
                System.out.println("1");

                return null;

            }
    }

    public boolean userPwdModify(int userId, String newPwd) {
//        System.out.println(newPwd);
        boolean flag=false;
        if (usedaoimpl.userPwdModify(userId,newPwd)>0)
        {
            flag=true;
        }
        return flag;
    }

    public int getUserCount(String word, int userRole) {
        int userCount = usedaoimpl.getUserCount(word, userRole);
        return userCount;
    }

    public List<user> getUserList(String word, int userRole, int pageNo, int pageSize) {
        List<user> users = usedaoimpl.getUserList(word, userRole, pageNo, pageSize);
        return users;
    }

    public boolean testUser(String userCode) {
        boolean b = usedaoimpl.testUser(userCode);
        return b;
    }

    public boolean userAdd(user user) {
        Connection connection = basedao.getConnection();
        try {
            //开启事务
            connection.setAutoCommit(false);
            if (usedaoimpl.userAdd(connection,user)>0){
                //插入成功
                connection.commit();
                return true;
            }
        } catch (SQLException throwables) {
            try {
                connection.rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            throwables.printStackTrace();
        }finally {

            basedao.release(null,null,connection);
        }
        return false;
    }

    public boolean delUser(int userId) {
        if (usedaoimpl.delUser(userId)>0){
            return true;
        }
        return false;
    }

    //调试
    @Test
    public void test(){
        userServerImpl useServer = new userServerImpl();
        //user user = useServer.login("admin", "4545");
//        System.out.println(user.getUserPassword());
        int count = useServer.getUserCount(null, 2);
        System.out.println(count);
    }
}

在业务层实现类中设置一个dao类型的实例对象属性，方便调用dao层方法

role业务层

接口

public interface roleServer {
    public List<role> getRoleList();
}

实现类

public class roleServerImpl implements roleServer {
    //dao层实现类对象
    private roleDaoImpl roleDao;
//方便操作dao层
    public roleServerImpl() {
        roleDao=new roleDaoImpl();
    }

    public List<role> getRoleList() {
        //返回给控制层
        List<role> roleList = roleDao.getRoleList();
        return roleList;
    }
}

provider业务层

接口

public interface provideServer {
    public List<provider> getProvideList(String code, String name);
}

实现类

public class provideServerImpl implements provideServer {
    private provideImpl provide;
    public provideServerImpl() {
        provide=new provideImpl();
    }

    public List<provider> getProvideList(String code, String name) {
        List<provider> provideList = provide.getProvideList(code, name);
        return provideList;
    }
}

控制层用户servlet

public class userServlet extends HttpServlet {

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

    @Override
    protected void doPost(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("testpwd")) {
            this.testPwd(req, resp);
        } else if (method != null && method.equals("query")) {
            this.userQuery(req, resp);
        } else if (method != null && method.equals("add")) {
            this.userAdd(req, resp);
        } else if (method != null && method.equals("getrolelist")) {
            this.getRoleList(req, resp);
        } else if (method != null && method.equals("ucexist")) {
            this.testUser(req, resp);
        } else if (method != null && method.equals("deluser")) {
            this.delUser(req, resp);
        }
    }

    //修改密码
    public void updatePwd(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        if (req.getSession() == null) {
//            System.out.println("进入");
            req.getRequestDispatcher("../login.jsp").forward(req, resp);
        }
        user user = (user) req.getSession().getAttribute(userSession);
        Integer id = user.getId();
        String newPassword = req.getParameter("newpassword");
        System.out.println(newPassword);
        userServerImpl userServer = new userServerImpl();
        boolean b = userServer.userPwdModify(id, newPassword);
        if (b) {
            //修改密码成功，移除session
            req.getSession().removeAttribute(userSession);
            req.setAttribute("message", "密码修改成功请重新登录");
            req.getRequestDispatcher("/jsp/pwdmodify.jsp").forward(req, resp);
        } else {
            //修改密码失败，提示错误
            req.setAttribute("message", "修改密码失败");
            req.getRequestDispatcher("/jsp/pwdmodify.jsp").forward(req, resp);
        }
    }

    //验证密码
    public void testPwd(HttpServletRequest req, HttpServletResponse resp) {
        resp.setContentType("application/json");
        Object o = req.getSession().getAttribute(userSession);
        //通过map来实现对前端数据的返回，map可以转成json对象
        Map<String, String> map = new HashMap<String, String>();
        if (o == null) {
            //session 丢失
            map.put("result", "sessionerror");
        }
        String oldpassword = req.getParameter("oldpassword");
        if (oldpassword == null || oldpassword == "") {
            map.put("result", "error");
        } else {
            user user = (com.sheng.pojo.user) o;
            String userPassword = user.getUserPassword();
            if (oldpassword.equals(userPassword)) {
                //旧密码输入正确
                map.put("result", "true");
            } else {
                map.put("result", "false");
            }
        }
        try {
            PrintWriter writer = resp.getWriter();
            //可以自己拼接json类型的字符串
//            writer.write("{\"result\":\"true\"}");
            writer.print(JSONArray.toJSONString(map));
            writer.flush();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //用户管理
    public void userQuery(HttpServletRequest req, HttpServletResponse resp) {
        //判断是否注销了session
        Object attribute = req.getSession().getAttribute(userCons.userSession);
        if (attribute == null) {
//            System.out.println("进入");
            try {
                req.getRequestDispatcher("../login.jsp").forward(req, resp);
            } catch (ServletException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //这里通过点击search搜索来提交表单，然后提供相应的参数信息，当然第一次加载页面需要具有默认值
        //获取参数
        String queryname = req.getParameter("queryname");
        String queryUserRole = req.getParameter("queryUserRole");
        String pageIndex = req.getParameter("pageIndex");
//        System.out.println(queryname+"\t"+queryUserRole+"\t"+pageIndex);
        //设置分页属性
        int queryRole;
        int pageNo = 1;
        pageSupport pageSupport = new pageSupport();
        pageSupport.setPageSize(5);
        //判断参数合理性
        if (queryUserRole == null) {
            queryRole = 0;
        } else {
            queryRole = Integer.parseInt(queryUserRole);
        }
        if (pageIndex != null && !pageIndex.equals("")) {
            pageNo = Integer.parseInt(pageIndex);
        }
        //获得用户总数,并设置分页属性
        userServerImpl userServer = new userServerImpl();
        int userCount = userServer.getUserCount(queryname, queryRole);
//        System.out.println(userCount);
        pageSupport.setTotalRecords(userCount);
        if (pageNo < 1) {
            pageNo = 1;
        } else if (pageNo > pageSupport.getTotalPages()) {
            pageNo = pageSupport.getTotalPages();
        }
        pageSupport.setPageNo(pageNo);
        //获得用户列表
        List<user> userList = userServer.getUserList(queryname, queryRole, pageSupport.getPageNo(), pageSupport.getPageSize());
//        System.out.println(userList.size());
        if (userList == null) {
            System.out.println("userList==null");
        }
        //获得角色列表
        roleServerImpl roleServer = new roleServerImpl();
        List<role> roleList = roleServer.getRoleList();
        if (roleList == null) {
            System.out.println("roleList==null");
        }
        //传值
        req.setAttribute("userList", userList);
        req.setAttribute("roleList", roleList);
        req.setAttribute("totalPageCount", pageSupport.getTotalPages());
        req.setAttribute("totalCount", pageSupport.getTotalRecords());
        req.setAttribute("currentPageNo", pageSupport.getPageNo());
        req.setAttribute("totalPageCount", pageSupport.getTotalPages());
        try {
//            System.out.println("进入·");
            System.out.println();
            req.getRequestDispatcher("/jsp/userlist.jsp").forward(req, resp);
        } catch (ServletException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //添加用户
    public void userAdd(HttpServletRequest req, HttpServletResponse resp) {
        //获取参数
        String userCode = req.getParameter("userCode");
        String userName = req.getParameter("userName");
        String userPassword = req.getParameter("userPassword");
        String birthday = req.getParameter("birthday");
        String phone = req.getParameter("phone");
        String userRole = req.getParameter("userRole");
        String gender = req.getParameter("gender");
        String address = req.getParameter("address");
        System.out.println(gender);
        user user = new user();
        user.setAddress(address);
        try {
            user.setBirthday(new SimpleDateFormat("yy-MM-dd").parse(birthday));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        user.setCreatedBy(Integer.parseInt(userRole));
        user.setCreationDate(new Date());
        user.setGender(Integer.parseInt(gender));
        user.setPhone(phone);
        user.setUserCode(userCode);
        user.setUserName(userName);
        user.setUserPassword(userPassword);
        user.setUserRole(Integer.parseInt(userRole));
        userServerImpl userServer = new userServerImpl();
        //操作业务层
        boolean add = userServer.userAdd(user);
        if (add) {
            //成功跳转用户页面
            System.out.println("添加成功");
            req.getRequestDispatcher("/user/query?method=query");
        } else {
            try {
                req.getRequestDispatcher("/jsp/useradd.jsp").forward(req, resp);
            } catch (ServletException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //获得角色列表
    public void getRoleList(HttpServletRequest req, HttpServletResponse resp) {
        System.out.println("进入角色列表查询方法");
        roleServerImpl roleServer = new roleServerImpl();
        List<role> roleList = roleServer.getRoleList();
        if (roleList == null) {
            System.out.println("roleList==null");
        }
        resp.setContentType("application/json");
        try {
            PrintWriter writer = resp.getWriter();
            writer.write(JSONArray.toJSONString(roleList));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //判断用户是否存在
    public void testUser(HttpServletRequest req, HttpServletResponse resp) {
        HashMap<String, String> map = new HashMap<String, String>();
        String userCode = req.getParameter("userCode");
        if (!StringUtils.isNullOrEmpty(userCode)) {
            userServerImpl userServer = new userServerImpl();
            boolean b = userServer.testUser(userCode);
            if (!b) {
//                System.out.println("进入存在");
                map.put("userCode", "exist");
            } else {
//                System.out.println("进入不存在");
                map.put("userCode", "notexist");
            }
            try {
                resp.getWriter().write(JSONArray.toJSONString(map));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //删除用户
    public void delUser(HttpServletRequest req, HttpServletResponse resp) {
        String userid = req.getParameter("uid");
        System.out.println(userid);
        HashMap<String, String> map = new HashMap<String, String>();
        int userId = Integer.parseInt(userid);
        System.out.println(userId);
        userServerImpl userServer = new userServerImpl();
        boolean b = userServer.delUser(userId);
        if (b) {
            System.out.println("删除成功");
            map.put("delResult", "true");
        } else map.put("delResult", "false");
        try {
            resp.setContentType("application/json");
            PrintWriter writer = resp.getWriter();
            writer.print(JSONArray.toJSONString(map));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

控制层供应商servlet

public class provideServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getParameter("method");
        if (method!=null&&method.equals("query")){
            this.provideList(req,resp);
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
    public void provideList(HttpServletRequest req, HttpServletResponse resp){
        //判断是否注销了session
        Object attribute = req.getSession().getAttribute(userCons.userSession);
        if (attribute == null) {
//            System.out.println("进入");
            try {
                req.getRequestDispatcher("../login.jsp").forward(req, resp);
            } catch (ServletException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //这里通过点击search搜索来提交表单，然后提供相应的参数信息，当然第一次加载页面需要具有默认值
        //获取参数
        //操作业务层获取视图层所需要的数据，provideList
        String queryProCode = req.getParameter("queryProCode");
        String queryProName = req.getParameter("queryProName");
        System.out.println(queryProCode+"\t"+queryProName);
        provideServerImpl provideServer = new provideServerImpl();
        List<provider> provideList = provideServer.getProvideList(queryProCode,queryProName);
        req.setAttribute("providerList",provideList);
        try {
            req.getRequestDispatcher("/jsp/providerlist.jsp").forward(req,resp);
        } catch (ServletException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

url发起请求流程，首先通过url获得相应的servlet,这里是根据web.xml来进行匹配，然后通过servlet找到相应的class对象，在servlet类对象里创建具体业务，然后操纵dao层，返回一些需要的信息给前端，把相关信息通过setAttribute存到请求中通过请求转发或者重定向实现视图跳转。

关于servlet映射一个servlet可以有多个mapping映射，即一个servlet可以有多个url去匹配，用户servlet就是这样，在servlet里通过隐藏的form表单属性method去执行对应的方法进而调用相应的业务

工具类

分页实现

public class pageSupport {


    //结果集
    private List list;

    //查询记录数
    private int totalRecords;

    //第几页
    private int pageNo;

    //每页多少条记录
    private int pageSize;

    //总页数
    public int getTotalPages(){
        return (totalRecords + pageSize -1)/pageSize;
    }

    //首页
    public int getTopPage(){
        return 1;
    }

    //上一页
    public int getPreviousPage(){
        if(pageNo<=1){
            return 1;
        }
        return pageNo-1;
    }
    //下一页
    public int getNextPage(){
        if(pageNo>=getBottomPage()){
            return getBottomPage();
        }
        return pageNo+1;
    }

    //尾页
    public int getBottomPage(){
        return getTotalPages();
    }

    public List getList() {
        return list;
    }
    public void setList(List list) {
        this.list = list;
    }
    public int getTotalRecords() {
        return totalRecords;
    }
    public void setTotalRecords(int totalRecords) {
        this.totalRecords = totalRecords;
    }
    public int getPageNo() {
        return pageNo;
    }
    public void setPageNo(int pageNo) {
        this.pageNo = pageNo;
    }
    public int getPageSize() {
        return pageSize;
    }
    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }
}

关于分页操作的使用，用户列表查询中使用，前端传来页码相关参数，创建分野实例对象，设置总数据数量，设置页面大小，总页数的计算公式为(totalRecords + pageSize -1)/pageSize;然后判断前端参数是否在合理范围，如果大于最大页数则设置页码为最大页数，反之设置为第一页。在dao层操作数据库时，分页通过limit x,y来实现，x为起始数据索引，y为查询数量。，每一页的其实索引为（页码-1）*pageSize

注意事项

关于src目录下配置文件xml或者properties文件不能加载到打包后项目里的问题解决

 <build>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <excludes>
          <exclude>**/*.properties</exclude>
          <exclude>**/*.xml</exclude>
        </excludes>
        <filtering>false</filtering>
      </resource>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
  </build>

在视图层中显示数据是通过el表达式获得，首次需要在获得jsp内置对象，然后存取相关属性在里面，配合foreach来进行显示/8

写下最后

完整代码在压缩包里，这里关于代码的赘述到此为止！

欢迎各位大佬纠错指正，另外如果代码不能正常运行，可以私信我，我会尽最大努力去帮忙解决。😄

> 关于分页操作的使用，用户列表查询中使用，前端传来页码相关参数，创建分野实例对象，设置总数据数量，设置页面大小，总页数的计算公式为(totalRecords + pageSize -1)/pageSize;然后判断前端参数是否在合理范围，如果大于最大页数则设置页码为最大页数，反之设置为第一页。在dao层操作数据库时，分页通过limit x,y来实现，x为起始数据索引，y为查询数量。，每一页的其实索引为（页码-1）*pageSize

##### 注意事项

==关于src目录下配置文件xml或者properties文件不能加载到打包后项目里的问题解决==

```java
 <build>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <excludes>
          <exclude>**/*.properties</exclude>
          <exclude>**/*.xml</exclude>
        </excludes>
        <filtering>false</filtering>
      </resource>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
  </build>

在视图层中显示数据是通过el表达式获得，首次需要在获得jsp内置对象，然后存取相关属性在里面，配合foreach来进行显示

写下最后

完整代码在压缩包里，这里关于代码的赘述到此为止！

欢迎各位大佬纠错指正，另外如果代码不能正常运行，可以私信我，我会尽最大努力去帮忙解决。😄

---

1. 浏览器给客户端的，可以长期保存在客户端，每次发起请求需要携带 ↩︎

2. 浏览器访问请求时产生，同一个浏览器访问相同页面session相同，当浏览器关闭或者服务器关闭session失效 ↩︎