超市管理系统（javaweb+mysql+redis）

超市管理系统

源码已上传至资源

1.系统概要

1.1系统介绍

超市管理系统是一个面向超市业务管理的综合性系统，旨在通过信息化手段提高超市的运营效率和管理水平。该系统通过整合供应商管理、订单管理、用户管理等多个模块，为超市提供了一个全面的业务解决方案。系统采用B/S架构，用户可以通过浏览器访问系统，实现对超市业务的在线管理。该系统将极大地提高超市运营效率。

当访问量大大增加时，基于MySQL的超市管理系统响应速度过慢会大大影响用户体验。为了解决这个痛点问题，本系统引入redis缓存，通过将高频查询的数据存储到 Redis 缓存中，可以减少对 MySQL 数据库的直接访问，提升系统的整体性能。

1.2功能介绍

用户登录：系统为不同角色的用户提供通过用户名和密码登录的功能
订单管理

根据商品名称查询订单（包括供应商、是否付款条件查询）：用户可以根据商品名称、供应商ID和支付状态等条件对订单进行查询
添加订单：系统支持创建订单，包括订单编码、商品名称、描述、单位、数量、总额等信息。
删除订单：系统提供订单信息删除的功能，便于对订单信息进行维护
修改订单：系统提供订单信息修改的功能，便于对订单信息进行维护
查看订单：系统提供订单详细信息的查看，便于对订单信息进行维护

供应商管理

根据供应商编码、供应商名称查询供应商：支持按名称和编码对供应商信息进行模糊查询，快速定位供应商数据。
添加供应商：系统提供供应商信息删除的功能，便于对供应商信息进行维护
删除供应商：系统提供供应商信息删除的功能，便于对供应商信息进行维护
修改供应商：系统提供供应商信息删除的功能，便于对供应商信息进行维护
查看供应商：系统提供供应商信息删除的功能，便于对供应商信息进行维护

用户管理

根据用户名查询用户（包括用户角色条件查询）
添加用户：系统提供用户信息删除的功能，便于对用户信息进行维护
删除用户：系统提供用户信息删除的功能，便于对用户信息进行维护
修改用户：系统提供用户信息删除的功能，便于对用户信息进行维护
查看用户：系统提供用户信息删除的功能，便于对用户信息进行维护

修改密码
引入redis缓存减少数据库MySQL的访问压力，提高系统响应速度。

2.redis与mysql

2.1redis

2.1.1什么是redis

Redis 是一个开源的、基于内存的、高性能的 NoSQL 数据库。它以键值对的形式存储数据，支持多种数据结构（如字符串、列表、集合、有序集合、哈希表、位图、地理空间索引等）。Redis 还提供了持久化功能，可以将内存中的数据以快照或日志的形式存储到磁盘。可用于缓存，事件发布或订阅，高速队列等场景。支持网络，提供字符串，哈希，列表，队列，集合结构直接存取，基于内存，可持久化。

2.1.2为什么要使用redis

热点数据的缓存

缓存是Redis最常见的应用场景，redis用于缓存场景，可以有效减少数据库的访问压力，提高系统响应速度。

作为缓存使用时，一般有两种方式保存数据：

读取前，先去读Redis，如果没有数据，读取数据库，将数据拉入Redis。
插入数据时，同时写入Redis。

2.1.3在本项目中使用redis的好处

提高性能，降低数据库负载

- 通过将高频查询的数据存储到 Redis 缓存中，可以减少对 MySQL 数据库的直接访问，提升系统的整体性能。

提升用户体验

- Redis 是基于内存的，读取速度非常快（通常为微秒级）。在用户请求的数据已被缓存的情况下，可以大幅缩短响应时间。

减少数据库热点问题

- 某些高频访问的数据通过 Redis 缓存后，可以避免 MySQL 承担大量重复查询的压力，从而减少数据库的热点问题。

2.2mysql

2.2.1什么是mysql

MySQL 是一个开源的关系型数据库管理系统（RDBMS），基于 SQL（结构化查询语言）进行数据管理。它以表的形式存储数据，并支持复杂的查询操作，是实现数据存储和管理的核心工具之一。MySQL 提供事务支持、完整性约束、多用户并发访问，以及可靠的数据存储和查询能力。因其高效性、稳定性和易用性，广泛应用于各种规模的 Web 应用程序。

2.2.2为什么要使用mysql

高效的数据存储与查询

MySQL 通过关系型模型，以结构化的方式存储和管理数据，支持复杂的 SQL 查询，适合需要严密数据结构和关系的场景。

● 支持复杂操作

提供强大的 SQL 查询能力，支持多表联结、聚合操作等复杂的业务逻辑。

● 数据一致性与完整性

通过事务支持（ACID 特性）和完整性约束（如外键、主键约束）确保数据可靠。

● 多种存储引擎

提供 InnoDB、MyISAM 等多种存储引擎，可根据需求选择性能优化方案。

可靠的持久化能力

MySQL 将数据存储在磁盘中，适合持久化需求，确保数据在应用重启或系统崩溃后不丢失。

2.2.3在本项目中使用mysql的好处

可靠的数据存储与管理

● MySQL 提供了事务支持和持久化能力，可以确保关键业务数据的安全性和一致性。

○ 适合保存用户信息、订单记录等核心业务数据。

高效的数据查询

● MySQL 的关系型模型支持复杂查询，能够满足多维度数据分析与处理需求。

○ 比如在项目中，用户可以通过查询获取历史记录、关联数据等。

支持多用户并发访问

● MySQL 通过事务和锁机制，支持多用户同时访问，保证数据的一致性和稳定性。

○ 在高并发情况下，能够稳定处理读写请求。

3.需求分析

供应商管理需求：超市需要对供应商信息进行有效管理，包括信息的录入、查询和维护
订单处理需求：超市需要处理大量订单，要求系统能够快速创建、查询和修改订单信息
用户与权限管理需求：系统需要对不同角色的用户进行权限控制
提升系统整体性能：引入redis缓存加快系统访问速度

4.数据库设计

4.1redis设计

redis以key-value的方式存储数据，在本项目使用方案如下：

读取前，先去读Redis，如果没有数据，读取数据库，将数据拉入Redis。
插入数据时，同时写入Redis。

redis示例代码如下：

{"id":1,
"userCode":"admin",
"userName":"系统管理员",
"userPassword":"1234567",
"gender":1,
"birthday":"十月 10, 1983",
"phone":"13688889999",
"address":"北京市海淀区成府路207号",
"userRole":1,
"createdBy":1,
"creationDate":"Mar 21, 
2013 4:52:07 PM",
"modifyBy":0}

4.2MySQL设计

4.2.1实体关系分析

用户（smbms_user）和角色（smbms_role）：多对一关系，多个用户smbms_user可以是同一个角色smbms_role，通过smbms_user.roleId关联
用户（smbms_user）和地址（smbms_address）：一对多关系，一个用户smbms_user可以有多个地址smbms_address，通过smbms_address.userId进行关联
用户（smbms_user）和订单（smbms_bill）：一对多关系，一个用户smbms_user可以创建多个订单（smbms_bill），通过smbms_bill.createdBy进行关联
供应商（smbms_provider）和订单（smbms_bill）：一对多关系，一个供应商smbms_provider可以关联多个订单，通过smbms_bill.providerId进行关联

4.2.2er图

4.2.3关系数据模型

smbms_address

smbms_bill

smbms_provider

smbms_role

smbms_user

4.2.4SQL语句分析

存储引擎：InnoDB，支持事务和外键；字符集：utf8，支持多语言字符；排序规则：utf8_unicode_ci，适合unicode字符集的语言无关排序；行存储格式：compact，紧凑存储，减少磁盘空间消耗；自增起始值；创建表之前指定drop语句删除已存在的表

smbms_address

DROP TABLE IF EXISTS smbms_address;
CREATE TABLE smbms_address (
id bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
contact varchar(15) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '联系人姓名',
addressDesc varchar(50) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '收货地址明细',
postCode varchar(15) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '邮编',
tel varchar(20) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '联系人电话',
createdBy bigint(20) NULL DEFAULT NULL COMMENT '创建者',
creationDate datetime NULL DEFAULT NULL COMMENT '创建时间',
modifyBy bigint(20) NULL DEFAULT NULL COMMENT '修改者',
modifyDate datetime NULL DEFAULT NULL COMMENT '修改时间',
userId bigint(20) NULL DEFAULT NULL COMMENT '用户ID',
PRIMARY KEY (id) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8 COLLATE = utf8_unicode_ci ROW_FORMAT = Compact;
smbms_bill

DROP TABLE IF EXISTS smbms_bill;
CREATE TABLE smbms_bill (
id bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
billCode varchar(20) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '账单编码',
productName varchar(20) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '商品名称',
productDesc varchar(50) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '商品描述',
productUnit varchar(10) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '商品单位',
productCount decimal(20, 2) NULL DEFAULT NULL COMMENT '商品数量',
totalPrice decimal(20, 2) NULL DEFAULT NULL COMMENT '商品总额',
isPayment int(10) NULL DEFAULT NULL COMMENT '是否支付（1：未支付 2：已支付）',
createdBy bigint(20) NULL DEFAULT NULL COMMENT '创建者（userId）',
creationDate datetime NULL DEFAULT NULL COMMENT '创建时间',
modifyBy bigint(20) NULL DEFAULT NULL COMMENT '更新者（userId）',
modifyDate datetime NULL DEFAULT NULL COMMENT '更新时间',
providerId int(20) NULL DEFAULT NULL COMMENT '供应商ID',
PRIMARY KEY (id) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 24 CHARACTER SET = utf8 COLLATE = utf8_unicode_ci ROW_FORMAT = Compact;
smbms_provider

DROP TABLE IF EXISTS smbms_provider;
CREATE TABLE smbms_provider (
id bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
proCode varchar(20) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '供应商编码',
proName varchar(20) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '供应商名称',
proDesc varchar(50) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '供应商详细描述',
proContact varchar(20) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '供应商联系人',
proPhone varchar(20) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '联系电话',
proAddress varchar(50) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '地址',
proFax varchar(20) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '传真',
createdBy bigint(20) NULL DEFAULT NULL COMMENT '创建者（userId）',
creationDate datetime NULL DEFAULT NULL COMMENT '创建时间',
modifyDate datetime NULL DEFAULT NULL COMMENT '更新时间',
modifyBy bigint(20) NULL DEFAULT NULL COMMENT '更新者（userId）',
PRIMARY KEY (id) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 19 CHARACTER SET = utf8 COLLATE = utf8_unicode_ci ROW_FORMAT = Compact;
smbms_role

DROP TABLE IF EXISTS smbms_role;
CREATE TABLE smbms_role (
id bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
roleCode varchar(15) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '角色编码',
roleName varchar(15) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '角色名称',
createdBy bigint(20) NULL DEFAULT NULL COMMENT '创建者',
creationDate datetime NULL DEFAULT NULL COMMENT '创建时间',
modifyBy bigint(20) NULL DEFAULT NULL COMMENT '修改者',
modifyDate datetime NULL DEFAULT NULL COMMENT '修改时间',
PRIMARY KEY (id) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 8 CHARACTER SET = utf8 COLLATE = utf8_unicode_ci ROW_FORMAT = Compact;
smbms_user

DROP TABLE IF EXISTS smbms_user;
CREATE TABLE smbms_user (
id bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
userCode varchar(15) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '用户编码',
userName varchar(15) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '用户名称',
userPassword varchar(15) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '用户密码',
gender int(10) NULL DEFAULT NULL COMMENT '性别（1:女、 2:男）',
birthday date NULL DEFAULT NULL COMMENT '出生日期',
phone varchar(15) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '手机',
address varchar(30) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '地址',
userRole int(10) NULL DEFAULT NULL COMMENT '用户角色（取自角色表-角色id）',
createdBy bigint(20) NULL DEFAULT NULL COMMENT '创建者（userId）',
creationDate datetime NULL DEFAULT NULL COMMENT '创建时间',
modifyBy bigint(20) NULL DEFAULT NULL COMMENT '更新者（userId）',
modifyDate datetime NULL DEFAULT NULL COMMENT '更新时间',
idPicPath varchar(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '证件照路径',
workPicPath varchar(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci NULL DEFAULT NULL COMMENT '工作证照片路径',
PRIMARY KEY (id) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 52 CHARACTER SET = utf8 COLLATE = utf8_unicode_ci ROW_FORMAT = Compact;

5.关键步骤及分析

5.1安装并测试redis

使用命令连接redis

redis-cli.exe -h 127.0.0.1 -p 6379
输入密码登录

AUTH 123456
存入key-value到redis

set myKey 123
获取key-value

get myKey

5.2在IDEA中使用redis步骤

在IDEA中连接redis

成功连接redis，并且可以看到里面的数据

在pom.xml中添加redis的依赖

编写工具类RedisUtil并测试

package com.wxy.util;

import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import static org.junit.Assert.assertEquals;

public class RedisUtil {
private static JedisPool jedisPool = null;

 static {
     JedisPoolConfig config = new JedisPoolConfig();
     config.setMaxTotal(20); // 最大连接数
     config.setMaxIdle(10); // 最大空闲连接数
     config.setMinIdle(5); // 最小空闲连接数
     config.setMaxWaitMillis(10000); // 获取连接时的最大等待毫秒数

     jedisPool = new JedisPool(config, "localhost", 6379, 2000, "123456"); // 连接Redis服务器，设置密码
 }

 public static Jedis getJedis() {
     return jedisPool.getResource();
 }

 public static void closeJedis(Jedis jedis) {
     if (jedis != null) {
         jedis.close();
     }
 }

 public static void set(String key, String value) {
     Jedis jedis = null;
     try {
         jedis = getJedis();
         jedis.set(key, value);
     } finally {
         closeJedis(jedis);
     }
 }

 public static String get(String key) {
     Jedis jedis = null;
     try {
         jedis = getJedis();
         return jedis.get(key);
     } finally {
         closeJedis(jedis);
     }
 }

 public static void del(String key) {
     Jedis jedis = null;
     try {
         jedis = getJedis();
         jedis.del(key);
     } finally {
         closeJedis(jedis);
     }
 }


 @Test
 public void testSetAndGet() {
     String key = "testKey";        // Redis 的键
     String value = "testValue";    // 要存入 Redis 的值

     // Set the value in Redis
     RedisUtil.set(key, value);     // 将 key-value 对写入 Redis

     // Get the value from Redis
     String retrievedValue = RedisUtil.get(key);  // 从 Redis 中获取值

     // 打印获取到的值
     System.out.println("Retrieved value from Redis: " + retrievedValue);

     // Assert that the retrieved value matches the set value
     assertEquals(value, retrievedValue);  // 检查获取到的值是否与写入的值一致
 }

}

成功运行

刷新redis中数据

5.2引入redis代码分析

读取前，先去读Redis，如果没有数据，读取数据库，将数据拉入Redis。
插入数据，同时写入Redis。

1. 引入redis实现快速登录

插入数据的同时要写入redis，需要实现 User 对象到 JSON 字符串的转换，我们可以使用一个流行的库，比如 Gson 或 Jackson。这里我将使用 Gson 库来实现 toJson 方法。

在pom.xml中添加以下依赖
<dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> <version>2.8.9</version> </dependency>
在User类中添加toJson方法，使用 Gson 库将 User 对象转换为 JSON 字符串。

// toJson method
public String toJson() {
com.google.gson.Gson gson = new com.google.gson.Gson();
return gson.toJson(this);
}
更新UserDaoImpl.java

在 UserDaoImpl.java 中，使用 toJson 方法将 User 对象转换为 JSON 字符串并存储到 Redis 中。

 if (userJson != null) {
            // 从Redis中读取用户信息
            user = new User(); // 假设有一个方法将JSON字符串转换为User对象
            // user = User.fromJson(userJson); // 需要实现fromJson方法
        } else {
            // 从数据库中读取用户信息
            PreparedStatement pstm = null;
            ResultSet rs = null;
            ···
             // 将用户信息写入Redis
                    RedisUtil.set(redisKey, user.toJson());

运行系统成功把用户名和密码写入redis

{"id":1,
"userCode":"admin",
"userName":"系统管理员",
"userPassword":"1234567",
"gender":1,
"birthday":"十月 10, 1983",
"phone":"13688889999",
"address":"北京市海淀区成府路207号",
"userRole":1,
"createdBy":1,
"creationDate":"Mar 21, 
2013 4:52:07 PM",
"modifyBy":0}

package com.wxy.dao.user;

import com.mysql.cj.util.StringUtils;
import com.wxy.dao.BaseDao;
import com.wxy.pojo.User;
import com.wxy.util.RedisUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class UserDaoImpl implements UserDao {
    @Override
    public User getLoginUser(Connection connection, String userCode)
            throws Exception {
        User user = null;
        String redisKey = "user:" + userCode;
        String userJson = RedisUtil.get(redisKey);

        if (userJson != null) {
            // 从Redis中读取用户信息
            user = new User(); // 假设有一个方法将JSON字符串转换为User对象
            // user = User.fromJson(userJson); // 需要实现fromJson方法
        } else {
            // 从数据库中读取用户信息
            PreparedStatement pstm = null;
            ResultSet rs = 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"));

                    // 将用户信息写入Redis
                    RedisUtil.set(redisKey, user.toJson());
                }
                BaseDao.closeResource(null, pstm, rs);
            }
        }

        return user;
    }

    @Override
    public int updatePwd(Connection connection, int id, String pwd)
            throws Exception {
        int flag = 0;
        PreparedStatement pstm = null;
        if (connection != null) {
            String sql = "update smbms_user set userPassword= ? where id = ?";
            Object[] params = {pwd, id};
            flag = BaseDao.execute(connection, pstm, sql, params);
            BaseDao.closeResource(null, pstm, null);

            // 更新Redis中的用户信息
            String redisKey = "user:" + id;
            RedisUtil.del(redisKey); // 删除旧的用户信息
        }
        return flag;
    }

    @Override
    public int getUserCount(Connection connection, String userName, int userRole)
            throws Exception {
        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");
            List<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
            }
            Object[] params = list.toArray();
            System.out.println("sql ----> " + sql.toString());
            rs = BaseDao.execute(connection, pstm, rs, sql.toString(), params);
            if (rs.next()) {
                count = rs.getInt("count");
            }
            BaseDao.closeResource(null, pstm, rs);
        }
        return count;
    }

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

    @Override
    public int add(Connection connection, User user) throws Exception {
        int updateRows = 0;
        PreparedStatement pstm = null;
        if (null != connection) {
            String sql = "insert into smbms_user (userCode,userName,userPassword," +
                    "userRole,gender,birthday,phone,address,creationDate,createdBy) " +
                    "values(?,?,?,?,?,?,?,?,?,?)";
            Object[] params = {user.getUserCode(), user.getUserName(), user.getUserPassword(),
                    user.getUserRole(), user.getGender(), user.getBirthday(),
                    user.getPhone(), user.getAddress(), user.getCreationDate(), user.getCreatedBy()};
            updateRows = BaseDao.execute(connection, pstm, sql, params);
            BaseDao.closeResource(null, pstm, null);

            // 将新用户信息写入Redis
            String redisKey = "user:" + user.getId();
            RedisUtil.set(redisKey, user.toJson());
        }
        return updateRows;
    }

    @Override
    public int deleteUserById(Connection connection, Integer delId) throws Exception {
        int flag = 0;
        PreparedStatement pstm = null;
        if (null != connection) {
            String sql = "delete from smbms_user where id=?";
            Object[] params = {delId};
            flag = BaseDao.execute(connection, pstm, sql, params);
            BaseDao.closeResource(null, pstm, null);

            // 从Redis中删除用户信息
            String redisKey = "user:" + delId;
            RedisUtil.del(redisKey);
        }
        return flag;
    }

    @Override
    public int modify(Connection connection, User user) throws Exception {
        int flag = 0;
        PreparedStatement pstm = null;
        if (null != connection) {
            String sql = "update smbms_user set userName=?," +
                    "gender=?,birthday=?,phone=?,address=?,userRole=?,modifyBy=?,modifyDate=? where id = ? ";
            Object[] params = {user.getUserName(), user.getGender(), user.getBirthday(),
                    user.getPhone(), user.getAddress(), user.getUserRole(), user.getModifyBy(),
                    user.getModifyDate(), user.getId()};
            flag = BaseDao.execute(connection, pstm, sql, params);
            BaseDao.closeResource(null, pstm, null);

            // 更新Redis中的用户信息
            String redisKey = "user:" + user.getId();
            RedisUtil.del(redisKey); // 删除旧的用户信息
        }
        return flag;
    }

    @Override
    public User getUserById(Connection connection, String id) throws Exception {
        User user = null;
        String redisKey = "user:" + id;
        String userJson = RedisUtil.get(redisKey);

        if (userJson != null) {
            // 从Redis中读取用户信息
            user = new User(); // 假设有一个方法将JSON字符串转换为User对象
            // user = User.fromJson(userJson); // 需要实现fromJson方法
        } else {
            // 从数据库中读取用户信息
            PreparedStatement pstm = null;
            ResultSet rs = null;

            if (null != connection) {
                String sql = "select u.*,r.roleName as userRoleName from smbms_user u,smbms_role r where u.id=? and u.userRole = r.id";
                Object[] params = {id};
                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"));
                    user.setUserRoleName(rs.getString("userRoleName"));

                    // 将用户信息写入Redis
                    RedisUtil.set(redisKey, user.toJson());
                }
                BaseDao.closeResource(null, pstm, rs);
            }
        }

        return user;
    }
}

2. 引入redis实现快速查询供应商

在 Provider 类中添加 toJson 和 fromJson 方法：使用 Gson 库进行 JSON 序列化和反序列化。

// toJson method
public String toJson() {
Gson gson = new Gson();
return gson.toJson(this);
}
```
 // fromJson method
 public static Provider fromJson(String json) {
     Gson gson = new Gson();
     return gson.fromJson(json, Provider.class);
 }
```

更新 ProviderDaoImpl.java 以使用 Redis：

// 从Redis中读取Provider对象
provider = Provider.fromJson(providerJson);
} else {
// 从数据库中读取Provider对象
···
// 将用户信息写入Redis
RedisUtil.set(redisKey, user.toJson());

package com.wxy.dao.provider;

import com.mysql.cj.util.StringUtils;
import com.wxy.dao.BaseDao;
import com.wxy.pojo.Provider;
import com.wxy.util.RedisUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;

public class ProviderDaoImpl implements ProviderDao {

 @Override
 public List<Provider> getProviderList(Connection connection, String proName, String proCode) throws Exception {
     PreparedStatement pstm = null;
     ResultSet rs = null;
     List<Provider> providerList = new ArrayList<Provider>();
     if (connection != null) {
         StringBuffer sql = new StringBuffer();
         sql.append("select * from smbms_provider where 1=1 ");
         List<Object> list = new ArrayList<Object>();
         if (!StringUtils.isNullOrEmpty(proName)) {
             sql.append(" and proName like ?");
             list.add("%" + proName + "%");
         }
         if (!StringUtils.isNullOrEmpty(proCode)) {
             sql.append(" and proCode like ?");
             list.add("%" + proCode + "%");
         }
         Object[] params = list.toArray();
         System.out.println("sql--->" + sql.toString());
         rs = BaseDao.execute(connection, pstm, rs, sql.toString(), params);
         while (rs.next()) {
             Provider _provider = new Provider();
             _provider.setId(rs.getInt("id"));
             _provider.setProCode(rs.getString("proCode"));
             _provider.setProName(rs.getString("proName"));
             _provider.setProDesc(rs.getString("proDesc"));
             _provider.setProContact(rs.getString("proContact"));
             _provider.setProPhone(rs.getString("proPhone"));
             _provider.setProAddress(rs.getString("proAddress"));
             _provider.setProFax(rs.getString("proFax"));
             _provider.setCreationDate(rs.getTimestamp("creationDate"));
             providerList.add(_provider);

             // 将每个Provider对象写入Redis
             String redisKey = "provider:" + _provider.getId();
             RedisUtil.set(redisKey, _provider.toJson());
         }
         BaseDao.closeResource(null, pstm, rs);
     }
     return providerList;
 }

 @Override
 public int add(Connection connection, Provider provider) throws Exception {
     PreparedStatement pstm = null;
     int flag = 0;
     if (null != connection) {
         String sql = "insert into smbms_provider (proCode,proName,proDesc," +
                 "proContact,proPhone,proAddress,proFax,createdBy,creationDate) " +
                 "values(?,?,?,?,?,?,?,?,?)";
         Object[] params = {provider.getProCode(), provider.getProName(), provider.getProDesc(),
                 provider.getProContact(), provider.getProPhone(), provider.getProAddress(),
                 provider.getProFax(), provider.getCreatedBy(), provider.getCreationDate()};
         flag = BaseDao.execute(connection, pstm, sql, params);
         BaseDao.closeResource(null, pstm, null);

         // 将新Provider对象写入Redis
         String redisKey = "provider:" + provider.getId();
         RedisUtil.set(redisKey, provider.toJson());
     }
     return flag;
 }

 @Override
 public int deleteProviderById(Connection connection, String delId) throws Exception {
     PreparedStatement pstm = null;
     int flag = 0;
     if (null != connection) {
         String sql = "delete from smbms_provider where id=?";
         Object[] params = {delId};
         flag = BaseDao.execute(connection, pstm, sql, params);
         BaseDao.closeResource(null, pstm, null);

         // 从Redis中删除Provider对象
         String redisKey = "provider:" + delId;
         RedisUtil.del(redisKey);
     }
     return flag;
 }

 @Override
 public int modify(Connection connection, Provider provider) throws Exception {
     int flag = 0;
     PreparedStatement pstm = null;
     if (null != connection) {
         String sql = "update smbms_provider set proName=?,proDesc=?,proContact=?," +
                 "proPhone=?,proAddress=?,proFax=?,modifyBy=?,modifyDate=? where id = ? ";
         Object[] params = {provider.getProName(), provider.getProDesc(), provider.getProContact(), provider.getProPhone(), provider.getProAddress(),
                 provider.getProFax(), provider.getModifyBy(), provider.getModifyDate(), provider.getId()};
         flag = BaseDao.execute(connection, pstm, sql, params);
         BaseDao.closeResource(null, pstm, null);

         // 更新Redis中的Provider对象
         String redisKey = "provider:" + provider.getId();
         RedisUtil.del(redisKey); // 删除旧的Provider对象
     }
     return flag;
 }

 @Override
 public Provider getProviderById(Connection connection, String id) throws Exception {
     Provider provider = null;
     String redisKey = "provider:" + id;
     String providerJson = RedisUtil.get(redisKey);

     if (providerJson != null) {
         // 从Redis中读取Provider对象
         provider = Provider.fromJson(providerJson);
     } else {
         // 从数据库中读取Provider对象
         PreparedStatement pstm = null;
         ResultSet rs = null;
         if (null != connection) {
             String sql = "select * from smbms_provider where id=?";
             Object[] params = {id};
             rs = BaseDao.execute(connection, pstm, rs, sql, params);
             if (rs.next()) {
                 provider = new Provider();
                 provider.setId(rs.getInt("id"));
                 provider.setProCode(rs.getString("proCode"));
                 provider.setProName(rs.getString("proName"));
                 provider.setProDesc(rs.getString("proDesc"));
                 provider.setProContact(rs.getString("proContact"));
                 provider.setProPhone(rs.getString("proPhone"));
                 provider.setProAddress(rs.getString("proAddress"));
                 provider.setProFax(rs.getString("proFax"));
                 provider.setCreatedBy(rs.getInt("createdBy"));
                 provider.setCreationDate(rs.getTimestamp("creationDate"));
                 provider.setModifyBy(rs.getInt("modifyBy"));
                 provider.setModifyDate(rs.getTimestamp("modifyDate"));

                 // 将Provider对象写入Redis
                 RedisUtil.set(redisKey, provider.toJson());
             }
             BaseDao.closeResource(null, pstm, rs);
         }
     }

     return provider;
 }

}