Spring优雅整合Redis缓存

“小明，多系统的session共享，怎么处理？”“Redis缓存啊！” “小明，我想实现一个简单的消息队列？”“Redis缓存啊！”

“小明，分布式锁这玩意有什么方案？”“Redis缓存啊！” “小明，公司系统响应如蜗牛，咋整？”“Redis缓存啊！”

本着研究的精神，我们来分析下小明的第四个问题。

准备：

Idea2019.03/Gradle6.0.1/Maven3.6.3/JDK11.0.4/Lombok0.28/SpringBoot2.2.4RELEASE/mybatisPlus3.3.0/Soul2.1.2/

Dubbo2.7.5/Druid1.2.21/Zookeeper3.5.5/Mysql8.0.11/Vue2.5/Redis3.2

难度： 新手--战士--老兵--大师

目标：

  1. Spring优雅整合Redis做数据库缓存

步骤：

为了遇见各种问题，同时保持时效性，我尽量使用最新的软件版本。源码地址：https://github.com/xiexiaobiao/vehicle-shop-admin

1 先说结论

Redis缓存不是金弹，若系统DB毫无压力，系统性能瓶颈不在DB上，不建议强加缓存层！

  1. 增加业务复杂度：同一缓存必须被全部相关方法所覆盖，如订单缓存，只要涉及到订单数据更新的方法都要进行缓存逻辑处理。

　　　　同时，KV存储时，因各方法返回的类型不同，这样就需要多个缓存池，但各方法后台的数据又存在关联，往往导致一个方法需

　　　　要处理关联的多个缓存，从而形成网状处理逻辑。

　　  2. 存在并发问题：缓存没有锁机制，B线程进行DB更新，同时A线程请求数据，缓存中存在即返回，但B线程还未更新到缓存，导

　　　　致缓存与DB不一致；或者A线程B线程都进行DB更新，但写入缓存的顺序发生颠倒，也会导致缓存与DB不一致，请看官君想想如何解决；

　　  3.内存消耗：小数据量可直接全部进内存，但海量数据不可能全部直接进入Redis，机器吃不消！可考虑只缓存DB数据索引，然后配合

　　　　“布隆过滤器”拦截无效请求，有效请求再去DB查询；

　　  4. 缓存位置：缓存注解的方法，执行时序上应尽量靠近DB，远离前端，如放dao层，请看官君思考下为啥。

适用场景：1.确认DB为系统性能瓶颈，2.数据内容稳定，低频更新，高频查询，如历史订单数据；3.热点数据，如新上市商品；

2 步骤

2.1 原理

这里我说的是注解模式，有四个注解，SpringCache缓存原理即注解+拦截器 org.springframework.cache.interceptor.CacheInterceptor 对方法进行拦截处理：

@Cacheable：可标记在类或方法上。标记在类上则缓存该类所有方法的返回值。请求方法时，先在缓存进行key匹配，存在则直接取缓存数据并返回。主要参数表：

@CacheEvict：从缓存中移除相应数据。主要参数表：

@CachePut：方法支持缓存功能。与@Cacheable不同的是使用@CachePut标注的方法在执行前不会去检查缓存中是否存在之前执行过的结果，

而是每次都会执行该方法，并将执行结果以键值对的形式存入指定的缓存中。主要参数表：

@Caching: 多个Cache注解组合使用,比如新增用户时，同时要删除其他缓存，并更新用户信息缓存，即以上三个注解的集合。

2.2 编码

项目有五个微服务，我仅改造了customer服务模块：

引入依赖，build.gradle文件：

Redis配置项，resources/config/application-dev.yml文件：

文件： com.biao.shop.customer.conf.RedisConf

@Configuration
@EnableCaching
public class RedisConf {

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory){
        return RedisCacheManager.create(redisConnectionFactory);
    }

    @Bean
    public CacheManager cacheManager() {
        // configure and return an implementation of Spring‘s CacheManager SPI
         SimpleCacheManager cacheManager = new SimpleCacheManager();
         cacheManager.setCaches(Arrays.asList(new ConcurrentMapCache("default")));
         return cacheManager;
    }

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        // 设置key的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 设置value的序列化器,使用Jackson 2，将对象序列化为JSON
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer =
                new Jackson2JsonRedisSerializer(Object.class);
        // json转对象类，不设置,默认的会将json转成hashmap
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);
        return redisTemplate;
    }
}
以上代码解析：1.声明缓存管理器CacheManager，会创建一个切面（aspect）并触发Spring缓存注解的切点，根据类或者方法所使用的注解以及缓存的状态，

这个切面会从缓存中获取数据，将数据添加到缓存之中或者从缓存中移除某个值 2. RedisTemplate即为Redis连接器，实际上即为jedis客户端。

文件： com.biao.shop.customer.impl.ShopClientServiceImpl

@org.springframework.stereotype.Service
@Slf4j
public class ShopClientServiceImpl extends ServiceImpl<ShopClientDao, ShopClientEntity> implements ShopClientService {

    private final Logger logger = LoggerFactory.getLogger(ShopClientServiceImpl.class);

    private ShopClientDao shopClientDao;

    @Autowired
    public ShopClientServiceImpl(ShopClientDao shopClientDao){
        this.shopClientDao = shopClientDao;
    }

    @Override
    public String getMaxClientUuId() {
        return shopClientDao.selectList(new LambdaQueryWrapper<ShopClientEntity>()
                .isNotNull(ShopClientEntity::getClientUuid).orderByDesc(ShopClientEntity::getClientUuid))
                .stream().limit(1).collect(Collectors.toList())
                .get(0).getClientUuid();
    }

    @Override
    @Caching(put = @CachePut(cacheNames = {"shopClient"},key = "#root.args[0].clientUuid"),
            evict = @CacheEvict(cacheNames = {"shopClientPage","shopClientPlateList","shopClientList"},allEntries = true))
    public int createClient(ShopClientEntity clientEntity) {
        clientEntity.setGenerateDate(LocalDateTime.now());
        return shopClientDao.insert(clientEntity);
    }

    /** */
    @Override
    @CacheEvict(cacheNames = {"shopClient","shopClientPage","shopClientPlateList","shopClientList"},allEntries = true)
    public int deleteBatchById(Collection<Integer> ids) {
        logger.info("deleteBatchById 删除Redis缓存");
        return shopClientDao.deleteBatchIds(ids);
    }

    @Override
    @CacheEvict(cacheNames = {"shopClient","shopClientPage","shopClientPlateList","shopClientList"},allEntries = true)
    public int deleteById(int id) {
        logger.info("deleteById 删除Redis缓存");
        return shopClientDao.deleteById(id);
    }

    @Override
    @Caching(evict = {@CacheEvict(cacheNames = "shopClient",key = "#root.args[0]"),
            @CacheEvict(cacheNames = {"shopClientPage","shopClientPlateList","shopClientList"},allEntries = true)})
    public int deleteByUUid(String uuid) {
        logger.info("deleteByUUid 删除Redis缓存");
        QueryWrapper<ShopClientEntity> qw = new QueryWrapper<>();
        qw.eq(true,"uuid",uuid);
        return shopClientDao.delete(qw);
    }

    @Override
    @Caching(put = @CachePut(cacheNames = "shopClient",key = "#root.args[0].clientUuid"),
            evict = @CacheEvict(cacheNames = {"shopClientPage","shopClientPlateList","shopClientList"},allEntries = true))
    public int updateClient(ShopClientEntity clientEntity) {
        logger.info("updateClient 更新Redis缓存");
        clientEntity.setModifyDate(LocalDateTime.now());
        return shopClientDao.updateById(clientEntity);
    }

    @Override
    @CacheEvict(cacheNames = {"shopClient","shopClientPage","shopClientPlateList","shopClientList"},allEntries = true)
    public int addPoint(String uuid,int pointToAdd) {
        ShopClientEntity clientEntity =  this.queryByUuId(uuid);
        log.debug(clientEntity.toString());
        clientEntity.setPoint(Objects.isNull(clientEntity.getPoint()) ? 0 : clientEntity.getPoint() + pointToAdd);
        return shopClientDao.updateById(clientEntity);
    }

    @Override
    @Cacheable(cacheNames = "shopClient",key = "#root.args[0]")
    public ShopClientEntity queryByUuId(String uuid) {
        logger.info("queryByUuId 未使用Redis缓存");
        QueryWrapper<ShopClientEntity> qw = new QueryWrapper<>();
        qw.eq(true,"client_uuid",uuid);
        return shopClientDao.selectOne(qw);
    }

    @Override
    @Cacheable(cacheNames = "shopClientById",key = "#root.args[0]")
    public ShopClientEntity queryById(int id) {
        logger.info("queryById 未使用Redis缓存");
        return shopClientDao.selectById(id);
    }

    @Override
    @Cacheable(cacheNames = "shopClientPage")
    public PageInfo<ShopClientEntity> listClient(Integer current, Integer size, String clientUuid, String name,
                                                 String vehiclePlate, String phone) {
        logger.info("listClient 未使用Redis缓存");
        QueryWrapper<ShopClientEntity> qw = new QueryWrapper<>();
        Map<String,Object> map = new HashMap<>(4);
        map.put("client_uuid",clientUuid);
        map.put("vehicle_plate",vehiclePlate);
        map.put("phone",phone);
        // "name" 模糊匹配
        boolean valid = Objects.isNull(name);
        qw.allEq(true,map,false).like(!valid,"client_name",name);
        PageHelper.startPage(current,size);
        List<ShopClientEntity> clientEntities = shopClientDao.selectList(qw);
        return  PageInfo.of(clientEntities);
    }

    // java Stream
    @Override
    @Cacheable(cacheNames = "shopClientPlateList")
    public List<String> listPlate() {
        logger.info("listPlate 未使用Redis缓存");
        List<ShopClientEntity> clientEntities =
                shopClientDao.selectList(new LambdaQueryWrapper<ShopClientEntity>().isNotNull(ShopClientEntity::getVehiclePlate));
        return clientEntities.stream().map(ShopClientEntity::getVehiclePlate).collect(Collectors.toList());
    }

    @Override
    @Cacheable(cacheNames = "shopClientList",key = "#root.args[0].toString()")
    public List<ShopClientEntity> listByClientDto(ClientQueryDTO clientQueryDTO) {
        logger.info("listByClientDto 未使用Redis缓存");
        QueryWrapper<ShopClientEntity> qw = new QueryWrapper<>();
        boolean phoneFlag = Objects.isNull(clientQueryDTO.getPhone());
        boolean clientNameFlag = Objects.isNull(clientQueryDTO.getClientName());
        boolean vehicleSeriesFlag = Objects.isNull(clientQueryDTO.getVehicleSeries());
        boolean vehiclePlateFlag = Objects.isNull(clientQueryDTO.getVehiclePlate());
        //如有null的条件直接不参与查询
        qw.eq(!phoneFlag,"phone",clientQueryDTO.getPhone())
                .like(!clientNameFlag,"client_name",clientQueryDTO.getClientName())
                .like(!vehicleSeriesFlag,"vehicle_plate",clientQueryDTO.getVehiclePlate())
                .like(!vehiclePlateFlag,"vehicle_series",clientQueryDTO.getVehicleSeries());
        return shopClientDao.selectList(qw);
    }
}
以上代码解析：

1. 因方法返回类型不同，故建立了5个缓存  2. 使用SpEL表达式#root.args[0]取得方法第一个参数，使用#result取得返回对象，

用于构造key  3. 对于@Cacheable不能使用#result返回对象做key值，如queryById(int id)方法，会导致NPE，，因为此注解将在方法执行前先

进入缓存匹配，而#result则是在方法执行后计算  4. @Caching注解可一次集合多个注解，如deleteByUUid(String uuid)方法，删除一个用户记录，

需同时进行更新shopClient，并清空其他几个缓存。

2.3 测试

运行起来整个项目，启动顺序：souladmin -> soulbootstrap -> zookeeper -> authority -> customer -> stock -> order -> business -> vue前端 ,

进入后端管理页： 按页浏览客户信息，分别点击页签：

可以看到缓存shopClientPage缓存了4项数据，key值即为方法的参数组合，再去点击页签，则系统后台无DB请求记录输出，说明直接使用了缓存：

编辑客户信息，我随意打开了两个：

可以看到缓存shopClientById增加了两个对象，再去点击编辑，则系统后台无DB查询记录输出，说明直接使用了缓存：

按条件查询客户：

可以看到缓存shopClientPage增加一项，因为key值不一样，故独立为一项缓存数据，多次点查询，则系统后台无DB查询SQL输出，说明直接使用了缓存：

新增客户：

可以看到shopClientPage缓存将会被清空，同时增加一个shopClient缓存的对象，即同时进行了多个缓存池操作：


问题解答：

前面说到的两个问题：

1.多线程问题，可配合DB事务机制，进行缓存延时双删，每次DB更新前，先删除缓存中对象，更新后，再去删除一次缓存中对象，

2.缓存方法位置问题，按照前端到后端的“倒金字塔模型”，越靠近前端，缓存数据对象被其他业务逻辑更新的可能性越大，靠近DB，能尽量保证每次DB的更新都能被缓存逻辑感知。

全文完！


我的其他文章：

1 SOFARPC模式下的Consul注册中心

2 八种控制线程顺序的方法

3 移动应用APP购物车(店铺系列二)

4 H5开发移动应用APP(店铺系列一)

5 阿里云平台OSS对象存储

只写原创，敬请关注

原文地址：https://www.cnblogs.com/xxbiao/p/12593525.html

时间： 2024-08-02 15:53:47

Spring优雅整合Redis缓存的相关文章

spring boot 使用 redis 缓存

spring boot redis 使用 1 Redis:Redis 是完全开源免费的,遵守BSD协议,是一个高性能的key-value数据库.Redis 与其他 key - value 缓存产品有以下三个特点:Redis支持数据的持久化,可以将内存中的数据保存在磁盘中,重启的时候可以再次加载进行使用.Redis不仅仅支持简单的key-value类型的数据,同时还提供list,set,zset,hash等数据结构的存储.Redis支持数据的备份,即master-slave模式的数据备份. spr

Spring Boot自定义Redis缓存配置,保存value格式JSON字符串

Spring Boot自定义Redis缓存,保存格式JSON字符串 部分内容转自 https://blog.csdn.net/caojidasabi/article/details/83059642 package springboot01cache.config; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; im

Spring Boot 整合Redis 实现缓存

本文提纲 一.缓存的应用场景 二.更新缓存的策略 三.运行 springboot-mybatis-redis 工程案例 四.springboot-mybatis-redis 工程代码配置详解 运行环境: Mac OS 10.12.x JDK 8 + Redis 3.2.8 Spring Boot 1.5.1.RELEASE 一.缓存的应用场景 什么是缓存? 在互联网场景下,尤其 2C 端大流量场景下,需要将一些经常展现和不会频繁变更的数据,存放在存取速率更快的地方.缓存就是一个存储器,在技术选型

Spring AOP整合redis 实现缓存统一管理

项目使用redis作为缓存数据,但面临着问题,比如,项目A,项目B都用到redis,而且用的redis都是一套集群,这样会带来一些问题.问题:比如项目A的开发人员,要缓存一些热门数据,想到了redis,于是乎把数据放入到了redis,自定义一个缓存key:hot_data_key,数据格式是项目A自己的数据格式,项目B也遇到了同样的问题,也要缓存热门数据,也是hot_data_key,数据格式是项目B是自己的数据格式,由于用的都是同一套redis集群,这样key就是同一个key,有的数据格式适合

spring boot 使用redis缓存

感谢大神分享! https://www.cnblogs.com/gdpuzxs/p/7222309.html (1)pom.xml引入jar包,如下: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> (2)修改项目启动类,增加注解@

SpringBoot整合redis缓存（一）

准备工作 1.Linux系统 2.安装redis(也可以安装docker,然后再docker中装redis,本文章就直接用Linux安装redis做演示) redis下载地址:http://download.redis.io/releases/redis-4.0.14.tar.gz 修改redis,开启远程访问 找到redis中的redis.conf文件并编辑(在安装路径中找到) vim ./redis.conf 1.找到bind 127.0.0.1并注释掉 默认127.0.0.1只能本地访问,

spring boot 整合 redis

自己开发环境需要安装 redis 服务,百度一下很多,下面主要说明Springboot 集成 redis 讲解 我的版本 java8 + redis3.0 + springboot 1.5.9. Spring redis 集成了 jedis redis 中存储的是 bytes 1 spring boot已经支持集成 redis,在 mvn 中只需添加依赖即可.pom 配置片段如下 <parent> <groupId>org.springframework.boot</grou

SpringBoot 整合 Redis缓存

在我们的日常项目开发过程中缓存是无处不在的,因为它可以极大的提高系统的访问速度,关于缓存的框架也种类繁多,今天主要介绍的是使用现在非常流行的NoSQL数据库(Redis)来实现我们的缓存需求. SpringBoot整合Redis是非常方便快捷的,我用的是Mybatis,这里就不说Springboot整合Mybatis了网上有很多,同样非常简单. 下面进入正题: 原文地址:https://www.cnblogs.com/yueguanguanyun/p/9756058.html

Spring Boot整合Redis

一.Spring Boot对Redis的支持 Spring对Redis的支持是使用Spring Data Redis来实现的,一般使用Jedis或者lettuce(默认),Java客户端在 org.springframework.boot.autoconfigure.data.redis(Spring Boot 2.x) 中redis的自动配置 AutoConfigureDataRedis RedisAutoConfiguration提供了RedisTemplate与StringRedisTem