当前位置： 首页 > article >正文

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

article 2025/1/8 20:30:50

超市管理系统

源码已上传至资源

1.系统概要

1.1系统介绍

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

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

1.2功能介绍

  1. 用户登录：系统为不同角色的用户提供通过用户名和密码登录的功能
  2. 订单管理
  • 根据商品名称查询订单（包括供应商、是否付款条件查询）：用户可以根据商品名称、供应商ID和支付状态等条件对订单进行查询
  • 添加订单：系统支持创建订单，包括订单编码、商品名称、描述、单位、数量、总额等信息。
  • 删除订单：系统提供订单信息删除的功能，便于对订单信息进行维护
  • 修改订单：系统提供订单信息修改的功能，便于对订单信息进行维护
  • 查看订单：系统提供订单详细信息的查看，便于对订单信息进行维护
  1. 供应商管理
  • 根据供应商编码、供应商名称查询供应商：支持按名称和编码对供应商信息进行模糊查询，快速定位供应商数据。
  • 添加供应商：系统提供供应商信息删除的功能，便于对供应商信息进行维护
  • 删除供应商：系统提供供应商信息删除的功能，便于对供应商信息进行维护
  • 修改供应商：系统提供供应商信息删除的功能，便于对供应商信息进行维护
  • 查看供应商：系统提供供应商信息删除的功能，便于对供应商信息进行维护
  1. 用户管理
  • 根据用户名查询用户（包括用户角色条件查询）
  • 添加用户：系统提供用户信息删除的功能，便于对用户信息进行维护
  • 删除用户：系统提供用户信息删除的功能，便于对用户信息进行维护
  • 修改用户：系统提供用户信息删除的功能，便于对用户信息进行维护
  • 查看用户：系统提供用户信息删除的功能，便于对用户信息进行维护
  1. 修改密码
  2. 引入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

  1. 使用命令连接redis
redis-cli.exe -h 127.0.0.1 -p 6379
  1. 输入密码登录
AUTH 123456
  1. 存入key-value到redis
set myKey 123
  1. 获取key-value
get myKey

5.2在IDEA中使用redis步骤

  1. 在IDEA中连接redis

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

  1. 在pom.xml中添加redis的依赖

  1. 编写工具类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);  // 检查获取到的值是否与写入的值一致
    }

}
  1. 成功运行

  1. 刷新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实现快速查询供应商
  1. 在 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);
    }
  1. 更新 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;
    }
}

6.系统测试及效果

  • 登录界面

  • 系统首页

  • 订单管理页面

  • 用户管理页面

  • 供应商管理页面

  • 密码修改

7.总结与展望


http://www.kler.cn/a/472009.html

相关文章：

  • MongoTemplate 性能优化指南
  • Git撤销指定commit并更新远端仓库
  • 域名注册网国际域名与国内域名的区别
  • Sam Altman发布博客，回顾OpenAI九年历程，直言目标已瞄准ASI超级人工智能
  • Nginx——入门介绍、安装与核心配置文件结构（一/五）
  • 【练习】PAT 乙 1022 D进制的A+B
  • VSCode 使用鼠标滚轮控制字体
  • 【商城的功能开发】
  • Space Nation白皮书(区块链游戏)
  • 【iOS Swift Moya 最新请求网络框架封装通用】
  • centOS7
  • gitlab启动时gitaly报错网页访问503的解决方法
  • Go怎么实现面向对象编程
  • 测试用例的基本要素与设计方法详解
  • 《鸿蒙微内核与人工智能算法协同，开启智能系统新时代》
  • 机器学习是？
  • vue2 使用vue-color调色盘
  • echarts图折线图的一些修改，改变分割线颜色或者虚实，改变数据轴背景颜色渐变，改变折线图的圆点，折线图的平滑还是折直线
  • 【笔记】海康摄像头 SpringBoot 对接视频流播放
  • 欧几里得距离在权重矩阵中的物理意义
  • EXCEL: (二) 常用图表
  • 小程序组件 —— 29 组件案例 - 字体图标的使用
  • 【剑指Offer刷题系列】0～n-1中缺失的数字
  • （六）优化 ChatGPT 交互：任务式 Prompt 的力量
  • OSPF - LSA对照表
  • JavaScript语言的网络编程