当前位置:

首页 > 编程开发 > 如何使用Spring Boot集成Redis实现高并发数据缓存

如何使用Spring Boot集成Redis实现高并发数据缓存

Redis Assistant
Redis Assistant

Redis Assistant 是一款为Redis设计的高效可视化管理与监控工具,提供多种操作模式,高效处理服务器数据。日常使用里的持续防护和信息管理会更突出,适合把安全控制放进长期使用流程中的场景。

立即下载
¥19
Windows/macOS/Linux 2026-08-22
正版软件 Windows macOS软件 Linux 数据库管理工具

什么是缓存缓存是⼀个高速数据交换的存储器,使用它可以快速的访问和操作数据。举个通俗的例子。小明经营着一家饭店,在刚开张的时候由于名气不足,客源少,生意并不是很忙,平时没事的时候就闲着,有客人来了再进厨房安排做菜。随着饭店的日益发展,此时的饭店已经不同往日,有着大量的稳定客源,并且在某些节假日的时候甚至爆满。按照以前的做法,那肯定是行不通了,在用餐高峰期的时候因为备餐慢导致了客户的长时间等待,使得饭店的屡遭投诉。为解决这一问题,小明想到了一个办法,可以在空闲的时候,提前将热门的菜做完后放入保温柜,等用餐高峰

本文目录

    什么是缓存

    缓存是⼀个高速数据交换的存储器,使用它可以快速的访问和操作数据。

    举个通俗的例子。

    小明经营着一家饭店,在刚开张的时候由于名气不足,客源少,生意并不是很忙,平时没事的时候就闲着,有客人来了再进厨房安排做菜。随着饭店的日益发展,此时的饭店已经不同往日,有着大量的稳定客源,并且在某些节假日的时候甚至爆满。按照以前的做法,那肯定是行不通了,在用餐高峰期的时候因为备餐慢导致了客户的长时间等待,使得饭店的屡遭投诉。
    为解决这一问题,小明想到了一个办法,可以在空闲的时候,提前将热门的菜做完后放入保温柜,等用餐高峰期时再拿出来加热后就可以直接上菜,就规避了短时间内大量客源而导致的备餐慢的问题,通过这一方法,即使在高峰期,也能很好的应对。

    这就是缓存的本质,将热点资源(高频读、低频写)提前放入离用户最近、访问速度更快的地方,以提高访问速度。

    为什么要用缓存

    使用缓存后,效率会大大的提升,减少了不必要的资源消耗,提升了用户体验。

    redis的特点:

    • redis支持数据的持久化,可以将内存中的数据保存在磁盘中,重启的时候可以再次加在进行使用。

    • redis不仅仅支持简单的key-value类型的数据,同时还提供list,set,zset,hash等数据结构的储存

    • redis支持数据的备份,即master-slave模式的数据备份

    redis的优势:

    • 性能极高——redis能读得的速度是110000次/s,写的速度是81000次/s。

    • 丰富的数据类型——redis支持二进制案例的Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。

    • 原子——redis的所有操作都是原子性的,意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务,即原子性,通过multi和exec指令包起来。

    • 丰富的特性redis还支持publish/subscribe,通知,key过期等等特性

    Redis为什么这么快

    (1)完全基于内存,数据存在内存中,绝大部分请求是纯粹的内存操作,非常快速,跟传统的磁盘文件数据存储相比,避免了通过磁盘IO读取到内存这部分的开销。

    (2)数据结构简单,对数据操作也简单。Redis中的数据结构是专门进行设计的,每种数据结构都有一种或多种数据结构来支持。Redis正是依赖这些灵活的数据结构,来提升读取和写入的性能。

    (3)采用单线程,省去了很多上下文切换的时间以及CPU消耗,不存在竞争条件,不用去考虑各种锁的问题,不存在加锁释放锁操作,也不会出现死锁而导致的性能消耗。

    (4)使用基于IO多路复用机制的线程模型,可以处理并发的链接。

    实现一个用户信息的缓存

    数据库表结构:

    CREATE TABLE `blade_user` (
      `id` bigint(20) NOT NULL COMMENT '主键',
      `tenant_id` varchar(12) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT '000000' COMMENT '租户ID',
      `code` varchar(12) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '用户编号',
      `user_type` int(11) DEFAULT NULL COMMENT '用户平台',
      `account` varchar(45) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '账号',
      `password` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '密码',
      `name` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '昵称',
      `real_name` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '真名',
      `avatar` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '头像',
      `email` varchar(45) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '邮箱',
      `phone` varchar(45) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '手机',
      `birthday` datetime DEFAULT NULL COMMENT '生日',
      `sex` int(11) DEFAULT NULL COMMENT '性别',
      `role_id` varchar(1000) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '角色id',
      `dept_id` varchar(1000) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '部门id',
      `post_id` varchar(1000) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '岗位id',
      `create_user` bigint(20) DEFAULT NULL COMMENT '创建人',
      `create_dept` bigint(20) DEFAULT NULL COMMENT '创建部门',
      `create_time` datetime DEFAULT NULL COMMENT '创建时间',
      `update_user` bigint(20) DEFAULT NULL COMMENT '修改人',
      `update_time` datetime DEFAULT NULL COMMENT '修改时间',
      `status` int(11) DEFAULT NULL COMMENT '状态',
      `is_deleted` int(11) DEFAULT '0' COMMENT '是否已删除',
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=DYNAMIC COMMENT='用户表';

    方式一:利用RedisTemplate实现 导入依赖

    完整pom.xml文件:

    
    
        4.0.0
        
            org.springframework.boot
            spring-boot-starter-parent
            2.7.8
             
        
        com.redis.demo
        springboot-redis
        0.0.1-SNAPSHOT
        springboot-redis
        Demo project for Spring Boot
        
            1.8
        
        
    
            
                org.springframework.boot
                spring-boot-starter-web
            
    
    
            
                org.projectlombok
                lombok
                true
            
            
                org.springframework.boot
                spring-boot-starter-test
                test
            
    
            
            
                com.baomidou
                mybatis-plus-boot-starter
                3.4.2
            
            
                org.springframework.boot
                spring-boot-starter-data-redis
            
    
            
            
                mysql
                mysql-connector-java
                8.0.15
            
    
           
            
                cn.hutool
                hutool-all
                5.8.5
            
            
                com.alibaba
                fastjson
                1.2.41
            
    
            
                org.springframework.boot
                spring-boot-starter-cache
            
    
        
    
        
            
                
                    org.springframework.boot
                    spring-boot-maven-plugin
                    
                        
                            
                                org.projectlombok
                                lombok
                            
                        
                    
                
            
        
    
    
    添加配置

    application.yml文件:

    server:
      port: 8081
    
    spring:
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://3.129.36.183:3306/test?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: root
      #redis
      redis:
        host: 3.129.36.183
        #Redis服务器连接端口
        port: 6379
        #Redis服务器连接密码
        password: 123456
    
    mybatis-plus:
      configuration:
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #开启sql日志
        # 将带有下划线的表字段映射为驼峰格式的实体类属性
        map-underscore-to-camel-case: true
      #配置类型别名所对应的包
      type-aliases-package: com.redis.demo.entity
      #配置SQL输出语句com.winsun.dataclean.mapper
      mapper-locations: com/redis/demo/dao/*.xml
    添加redis工具类及配置类

    RedisUtils:

    package com.redis.demo.utils;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    /**
     * Redis工具类
     *
     * @author
     */
    @Component
    public class RedisUtils {
    
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        // =============================common============================
    
        /**
         * 指定缓存失效时间
         *
         * @param key  键
         * @param time 时间(秒)
         * @return
         */
        public boolean expire(String key, long time) {
            try {
                if (time > 0) {
                    redisTemplate.expire(key, time, TimeUnit.SECONDS);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据key 获取过期时间
         *
         * @param key 键 不能为null
         * @return 时间(秒) 返回0代表为永久有效
         */
        public long getExpire(String key) {
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
        /**
         * 判断key是否存在
         *
         * @param key 键
         * @return true 存在 false不存在
         */
        public boolean hasKey(String key) {
            try {
                return redisTemplate.hasKey(key);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 删除缓存
         *
         * @param key 可以传一个值 或多个
         */
        @SuppressWarnings("unchecked")
        public void del(String... key) {
            if (key != null && key.length > 0) {
                if (key.length == 1) {
                    redisTemplate.delete(key[0]);
                } else {
                    redisTemplate.delete(CollectionUtils.arrayToList(key));
                }
            }
        }
    
        // ============================String=============================
    
        /**
         * 普通缓存获取
         *
         * @param key 键
         * @return 值
         */
        public Object get(String key) {
            return key == null ? null : redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 普通缓存放入
         *
         * @param key   键
         * @param value 值
         * @return true成功 false失败
         */
        public boolean set(String key, Object value) {
            try {
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 普通缓存放入并设置时间
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
         * @return true成功 false 失败
         */
        public boolean set(String key, Object value, long time) {
            try {
                if (time > 0) {
                    redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                } else {
                    set(key, value);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 递增
         *
         * @param key   键
         * @param delta 要增加几(大于0)
         * @return
         */
        public long incr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递增因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, delta);
        }
    
        /**
         * 递减
         *
         * @param key   键
         * @param delta 要减少几(小于0)
         * @return
         */
        public long decr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递减因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, -delta);
        }
    
        // ================================Map=================================
    
        /**
         * HashGet
         *
         * @param key  键 不能为null
         * @param item 项 不能为null
         * @return 值
         */
        public Object hget(String key, String item) {
            return redisTemplate.opsForHash().get(key, item);
        }
    
        /**
         * 获取hashKey对应的所有键值
         *
         * @param key 键
         * @return 对应的多个键值
         */
        public Map hmget(String key) {
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * HashSet
         *
         * @param key 键
         * @param map 对应多个键值
         * @return true 成功 false 失败
         */
        public boolean hmset(String key, Map map) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * HashSet 并设置时间
         *
         * @param key  键
         * @param map  对应多个键值
         * @param time 时间(秒)
         * @return true成功 false失败
         */
        public boolean hmset(String key, Map map, long time) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                if (time > 0) {
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object value) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object value, long time) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                if (time > 0) {
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 删除hash表中的值
         *
         * @param key  键 不能为null
         * @param item 项 可以使多个 不能为null
         */
        public void hdel(String key, Object... item) {
            redisTemplate.opsForHash().delete(key, item);
        }
    
        /**
         * 判断hash表中是否有该项的值
         *
         * @param key  键 不能为null
         * @param item 项 不能为null
         * @return true 存在 false不存在
         */
        public boolean hHasKey(String key, String item) {
            return redisTemplate.opsForHash().hasKey(key, item);
        }
    
        /**
         * hash递增 如果不存在,就会创建一个 并把新增后的值返回
         *
         * @param key  键
         * @param item 项
         * @param by   要增加几(大于0)
         * @return
         */
        public double hincr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, by);
        }
    
        /**
         * hash递减
         *
         * @param key  键
         * @param item 项
         * @param by   要减少记(小于0)
         * @return
         */
        public double hdecr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, -by);
        }
    
        // ============================set=============================
    
        /**
         * 根据key获取Set中的所有值
         *
         * @param key 键
         * @return
         */
        public Set sGet(String key) {
            try {
                return redisTemplate.opsForSet().members(key);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 根据value从一个set中查询,是否存在
         *
         * @param key   键
         * @param value 值
         * @return true 存在 false不存在
         */
        public boolean sHasKey(String key, Object value) {
            try {
                return redisTemplate.opsForSet().isMember(key, value);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将数据放入set缓存
         *
         * @param key    键
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSet(String key, Object... values) {
            try {
                return redisTemplate.opsForSet().add(key, values);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 将set数据放入缓存
         *
         * @param key    键
         * @param time   时间(秒)
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSetAndTime(String key, long time, Object... values) {
            try {
                Long count = redisTemplate.opsForSet().add(key, values);
                if (time > 0)
                    expire(key, time);
                return count;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 获取set缓存的长度
         *
         * @param key 键
         * @return
         */
        public long sGetSetSize(String key) {
            try {
                return redisTemplate.opsForSet().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 移除值为value的
         *
         * @param key    键
         * @param values 值 可以是多个
         * @return 移除的个数
         */
        public long setRemove(String key, Object... values) {
            try {
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        // ===============================list=================================
    
        /**
         * 获取list缓存的内容
         *
         * @param key   键
         * @param start 开始
         * @param end   结束 0 到 -1代表所有值
         * @return
         */
        public List lGet(String key, long start, long end) {
            try {
                return redisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 获取list缓存的长度
         *
         * @param key 键
         * @return
         */
        public long lGetListSize(String key) {
            try {
                return redisTemplate.opsForList().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 通过索引 获取list中的值
         *
         * @param key   键
         * @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
         * @return
         */
        public Object lGetIndex(String key, long index) {
            try {
                return redisTemplate.opsForList().index(key, index);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @return
         */
        public boolean lSet(String key, Object value) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒)
         * @return
         */
        public boolean lSet(String key, Object value, long time) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                if (time > 0)
                    expire(key, time);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @return
         */
        public boolean lSet(String key, List value) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒)
         * @return
         */
        public boolean lSet(String key, List value, long time) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                if (time > 0)
                    expire(key, time);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据索引修改list中的某条数据
         *
         * @param key   键
         * @param index 索引
         * @param value 值
         * @return
         */
        public boolean lUpdateIndex(String key, long index, Object value) {
            try {
                redisTemplate.opsForList().set(key, index, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 移除N个值为value
         *
         * @param key   键
         * @param count 移除多少个
         * @param value 值
         * @return 移除的个数
         */
        public long lRemove(String key, long count, Object value) {
            try {
                Long remove = redisTemplate.opsForList().remove(key, count, value);
                return remove;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    }

    RedisConfig:

    package com.redis.demo.config;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.redis.demo.utils.MapUtil;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.interceptor.KeyGenerator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializer;
    
    import javax.annotation.PostConstruct;
    import java.util.Map;
    
    /**
     * @Author: laz
     * @CreateTime: 2023-02-20  11:55
     * @Version: 1.0
     *
     * 序列化
     */
    @Configuration
    public class RedisConfig {
    
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        @PostConstruct
        public void init() {
            initRedisTemplate();
        }
    
        private void initRedisTemplate() {
            RedisSerializer stringSerializer = redisTemplate.getStringSerializer();
            redisTemplate.setKeySerializer(stringSerializer);
            redisTemplate.setHashKeySerializer(stringSerializer);
            redisTemplate.setValueSerializer(stringSerializer);
            redisTemplate.setHashValueSerializer(stringSerializer);
        }
    }

    开发mapper接口

    package com.redis.demo.dao;
    
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.redis.demo.entity.BladeUser;
    
    /**
     * 

     * 用户表 Mapper 接口  * 

     *  * @author laz  * @since 2023-03-09  */ public interface BladeUserMapper extends BaseMapper { }
    service层

    IBladeUserService:

    package com.redis.demo.service;
    import com.baomidou.mybatisplus.extension.service.IService;
    import com.redis.demo.entity.BladeUser;
    import com.redis.demo.result.DealResult;
    
    /**
     * 

     * 用户表 服务类  * 

     *  * @author laz  * @since 2023-03-09  */ public interface IBladeUserService extends IService {     DealResult getById(Long id); }

    BladeUserServiceImpl:

    package com.redis.demo.service.impl;
    
    import cn.hutool.core.bean.BeanUtil;
    import cn.hutool.json.JSONUtil;
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    import com.redis.demo.constant.RedisConstants;
    import com.redis.demo.dao.BladeUserMapper;
    import com.redis.demo.entity.BladeUser;
    import com.redis.demo.result.DealResult;
    import com.redis.demo.service.IBladeUserService;
    import com.redis.demo.status.CacheNameStatus;
    import com.redis.demo.utils.RedisUtils;
    import org.springframework.beans.BeanUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.stereotype.Service;
    import org.springframework.util.ObjectUtils;
    
    /**
     * 

     * 用户表 服务实现类  * 

     *  * @author laz  * @since 2023-03-09  */ @Service public class BladeUserServiceImpl extends ServiceImpl implements IBladeUserService {     @Autowired     private  RedisUtils redisUtils;     @Override     public DealResult getById(Long id) {         String userKey = RedisConstants.CACHE_USER_KEY+id;         Object user = redisUtils.get(userKey);         if (!ObjectUtils.isEmpty(user)){             return DealResult.data(JSONUtil.toBean(JSONUtil.toJsonStr(user),BladeUser.class));         }         BladeUser bladeUser = baseMapper.selectById(id);         redisUtils.set(userKey, JSON.toJSONString(bladeUser));         return DealResult.data(bladeUser);     } }
    controller层
    package com.redis.demo.controller;
    import com.redis.demo.result.DealResult;
    import com.redis.demo.service.IBladeUserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * 

     * 用户表 前端控制器  * 

     *  * @author laz  * @since 2023-03-09  */ @RestController @RequestMapping("/bladeUser") public class BladeUserController {     @Autowired     private IBladeUserService bladeUserService;     @RequestMapping("getById/{id}")     public DealResult getById(@PathVariable("id")Long id){         return bladeUserService.getById(id);     } }
    测试

    启动项目,使用postman访问该接口,连续请求两次,观察响应时长:

    第一次:

    如何使用Spring Boot集成Redis实现高并发数据缓存

    第二次:

    如何使用Spring Boot集成Redis实现高并发数据缓存

    可以看到,第一次3.34s,第二次43ms,效率明显提高!

    方式二:采用SpringBoot注解开启缓存

    以方式一为准

    在启动类添加@EnableCaching注解

    如何使用Spring Boot集成Redis实现高并发数据缓存

    修改service层实现类代码
    package com.redis.demo.service.impl;
    
    import cn.hutool.core.bean.BeanUtil;
    import cn.hutool.json.JSONUtil;
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    import com.redis.demo.constant.RedisConstants;
    import com.redis.demo.dao.BladeUserMapper;
    import com.redis.demo.entity.BladeUser;
    import com.redis.demo.result.DealResult;
    import com.redis.demo.service.IBladeUserService;
    import com.redis.demo.status.CacheNameStatus;
    import com.redis.demo.utils.RedisUtils;
    import lombok.AllArgsConstructor;
    import org.springframework.beans.BeanUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.stereotype.Service;
    import org.springframework.util.ObjectUtils;
    
    /**
     * 

     * 用户表 服务实现类  * 

     *  * @author laz  * @since 2023-03-09  */ @Service public class BladeUserServiceImpl extends ServiceImpl implements IBladeUserService {     @Autowired     private  RedisUtils redisUtils; //    @Override //    public DealResult getById(Long id) { // //        String userKey = RedisConstants.CACHE_USER_KEY+id; //        Object user = redisUtils.get(userKey); //        if (!ObjectUtils.isEmpty(user)){ // //            return DealResult.data(JSONUtil.toBean(JSONUtil.toJsonStr(user),BladeUser.class)); //        } // //        BladeUser bladeUser = baseMapper.selectById(id); //        redisUtils.set(userKey, JSON.toJSONString(bladeUser)); //        return DealResult.data(bladeUser); //    }     @Cacheable(cacheNames = CacheNameStatus.BLADE_USER,keyGenerator = CacheNameStatus.KEY_GENERATOR)     @Override     public DealResult getById(Long id) {         BladeUser bladeUser = baseMapper.selectById(id);         return DealResult.data(bladeUser);     } }
    修改RedisConfig配置类

    在配置类中添加自定义KeyGenerator

      /**
         * 自定义KeyGenerator
         * @return
         */
        @Bean
        public KeyGenerator simpleKeyGenerator() {
            return (o, method, objects) -> {
                StringBuilder stringBuilder = new StringBuilder();
                stringBuilder.append(o.getClass().getSimpleName());
                stringBuilder.append(".");
                stringBuilder.append(method.getName());
                stringBuilder.append("[");
                for (Object obj : objects) {
                    if(obj.toString().indexOf("Vo@")!= -1)
                    {
                        Map map = MapUtil.getAttrFromModel(obj);
                        stringBuilder.append("[");
                        for(String item:map.keySet())
                        {
                            stringBuilder.append(",");
                            stringBuilder.append(map.get(item));
                        }
    
                        stringBuilder.append(",");
                        stringBuilder.deleteCharAt(stringBuilder.length() - 1);
    
                        stringBuilder.append("]");
    
                    }
                    else {
                        stringBuilder.append(obj);
                        stringBuilder.append(",");
                    }
    
                }
    
                stringBuilder.append("]");
                return stringBuilder.toString();
            };
        }

    注:关于 @Cacheable注解的参数,不懂的可以点击查看。

    重启项目,再次访问以上接口,观察响应时间:

    第一次:

    如何使用Spring Boot集成Redis实现高并发数据缓存

    第二次:

    如何使用Spring Boot集成Redis实现高并发数据缓存

    可以看到,第一次2.52s,第二次44ms,效率明显提高!

    通过Redis可视化工具观察缓存数据:

    如何使用Spring Boot集成Redis实现高并发数据缓存

    如何使用Spring Boot集成Redis实现高并发数据缓存

    通过观察缓存数据大小可知:方式一449字节,方式二976字节,如果从内存占用大小的角度考虑,博主认为使用RedisTemplate方式做缓存更合适,因为这种方式所占内存相对较少。

    本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
    作者最新文章
    编程开发
    相关文章 更多
    php72w redis,docker php7安装php-redis
    php72w redis,docker php7安装php-redis

    在Docker环境下为PHP安装Redis扩展:手动编译需下载源码、安装phpize、配置编译并安装,生成redis.so并在php.d目录新建redis.ini加载,重启PHP-FPM;也可直接yum安装php72w-pecl-redis,免手动编译。

    php 如何配置 redis,php 如何设置redis
    php 如何配置 redis,php 如何设置redis

    配置PHP的Redis扩展:先安装Redis服务,从GitHub下载phpredis源码,用phpize编译安装,修改php.ini添加extension=redis.so,重启php-fpm或Apache,通过phpinfo验证并连接Redis。

    c++如何将结构体序列化为Redis兼容的RESP协议格式【深度】
    c++如何将结构体序列化为Redis兼容的RESP协议格式【深度】

    C++结构体无法直接序列化为RESP协议,需手动将字段映射为*N数组嵌套$lenbulkstring形式。整数需转换为字符串并加:前缀,空字符串用$0\r\n,null用$-1\r\n。长度计算需精确到字节数,特别注意二进制安全,同时确保字段顺序与结构体定义一致。

    如何在Golang架构中部署Redict作为高能数据临时存储中转站
    如何在Golang架构中部署Redict作为高能数据临时存储中转站

    Redis作为跨服务临时状态枢纽,需按消息队列、缓存和原子状态三重角色设计。选型用List实现任务分发及延迟重试,Stream用于事件广播与位点回溯。go-redis/v8需配置MinIdleConns、MaxRetries及超时。数据写入应JSON序列化并带type标签、设合理TTL、将关键字段提至顶层。消费通过原子GET+DEL或processedkey

    TP8.0 高并发下库存超卖?Redis 原子递减结合数据库乐观锁控制
    TP8.0 高并发下库存超卖?Redis 原子递减结合数据库乐观锁控制

    在高并发秒杀场景下,利用Redis的减库存原子操作预扣减库存拦截超卖请求,再通过数据库乐观锁(版本号与库存校验)确保最终一致性,异常时回滚Redis库存并借助Lua脚本保证原子性,从而有效防止库存超卖。

    如何在 Go 中利用 go-redis 执行 Lua 脚本优化逻辑
    如何在 Go 中利用 go-redis 执行 Lua 脚本优化逻辑

    在Go中使用go-redis执行Lua脚本可借助原子性解决竞态问题,通过redis.Script封装脚本并自动处理SHA1缓存与重试。需注意KEYS必须为非空切片且所有键在Cluster模式下落在同一slot,ARGV以字符串传入并由tonumber转换。返回值需先检查错误再调用Val(),避免panic。

    TP6.0 基于 Redis SetNX 实现的简单互斥锁机制【并发】
    TP6.0 基于 Redis SetNX 实现的简单互斥锁机制【并发】

    先看一个典型场景:电商秒杀、库存扣减、定时任务重复调度——这些并发冲突在 TP6 应用里屡见不鲜。用 Redis 的 SETNX 做互斥锁,确实是轻量又直接的方案,但“能用”和“稳妥”之间,隔着三层硬功夫:原子加锁、身份校验、合理超时。这三条,差一条就翻车。 很多人第一次上手,直接写 SETNX 加

    TP6.0 如何处理高并发抢购?Redis 原子锁与队列削峰详解【秒杀】
    TP6.0 如何处理高并发抢购?Redis 原子锁与队列削峰详解【秒杀】

    高并发抢购中,Redis的DECR原子操作可安全扣库存;配合think-queue异步削峰,接口仅扣库存和推消息;分布式锁需用SETNXEX加唯一标识,释放时用Lua脚本校验;成功资格后须以数据库事务双写为准,失败时补回Redis库存。

    Golang 实现基于 Redis 的延时任务队列
    Golang 实现基于 Redis 的延时任务队列

    基于Redis的ZSET实现延时队列需解决并发重复消费、失败重试混乱、精度不足及内存爆炸等问题。通过Lua脚本保证取删原子性,使用毫秒级时间戳,对临时错误采用指数退避重试,永久错误记入独立哈希表,并限制最大延迟、定期清理过期任务、使用紧凑序列化格式。

    RedisInsight怎么修改Key的过期时间 Redis操作方法【步骤】
    RedisInsight怎么修改Key的过期时间 Redis操作方法【步骤】

    操作 Redis 的时候,改个 Key 的过期时间其实是个高频场景。特别是做运维排查或者临时调试那会儿,谁也不想反复切命令行窗口、背那些命令参数。好在 RedisInsight 这个图形工具把这事儿做得很顺手——三种方式任选,总有一种合你胃口。 在动手前,先确认一下 Key 当前的 TTL 状态是个

    查看更多
    精品专题 更多
    装机必备
    装机必备

    正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

    Windows
    Windows

    正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

    PDF教程
    PDF教程

    正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

    Mac软件 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    Aperty macOS版
    Aperty macOS版
    macOS

    Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

    WINDOWS 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    PixTV 网页版
    PixTV 网页版
    Windows

    PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。

    即将离开本站
    您即将前往第三方网站,请确认是否继续?
    为什么要购买正版软件?
    01 官方授权

    授权来源透明,订单与许可信息可随时查询。

    02 即时交付

    付款成功后自动发放激活信息,支持订单追踪。

    03 中文协助

    安装、激活、迁移与续费问题都有专人响应。

    04 长期可用

    提供升级提醒与授权管理,换机时也能轻松迁移。

    网站备案号:苏ICP备2026018738号-1 联系邮箱:bd@zhengruan.com 网站地图

    Copyright ©2018-2026