Redis缓存的使用和基于SpringBoot1.x和SpringBoot2.x的RedisCacheManager配置使用详解

最新推荐文章于 2024-02-19 23:58:01 发布
最新推荐文章于 2024-02-19 23:58:01 发布
阅读量3.1k 收藏 2
点赞数 2
分类专栏： 后端开发（偏java向）经验交流 文章标签： redis 缓存 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xy294636185/article/details/122449000
版权

     * Redis是一个开源的，内存中的数据机构存储系统，它可以作为数据库，缓存和消息中间件。
     * 使用：安装redis，引入redis的starter，配置redis
     * 原理：CacheManager == Cache 缓存组件来实际给缓存中存取数据，替换默认的SimpleCacheConfiguration
     *      1.引入redis的starter，容器中保存的是RedisCacheManager
     *      2.RedisCacheManager 底层帮我们创建RedisCache来作为缓存组件：RedisCache通过操作redis缓存数据的
     *      3.默认保存数据 k-v 都是Object，利用序列化保存的（需转换json）
     *      附 SimpleCacheConfiguration和RedisCacheConfiguration 底层配置对比：
     *          @Configuration(proxyBeanMethods = false)
     *          @ConditionalOnMissingBean({CacheManager.class})  //SimpleCacheConfiguration起作用是容器中没有CacheManager
     *          @Conditional({CacheCondition.class})
     *          class SimpleCacheConfiguration {}
     *
     *          @Configuration(proxyBeanMethods = false)
     *          @ConditionalOnClass({RedisConnectionFactory.class})
     *          @AutoConfigureAfter({RedisAutoConfiguration.class})
     *          @ConditionalOnBean({RedisConnectionFactory.class})
     *          @ConditionalOnMissingBean({CacheManager.class})  //redis也需要判断容器中没有CacheManager才生效
     *          @Conditional({CacheCondition.class})
     *          class RedisCacheConfiguration {}
     * 原因：
     *      1.引入redis的starter，cacheManager变为RedisCacheManager，剩下的CacheManager就不起作用了
     *      2.默认创建的RedisCacheManager操作redis的时候使用的是RedisTemplate<Object,Object>
     *      3.RedisTemplate<Obejct,Object>是默认使用【jdk的序列化机制】
     *      4.自定义CacheManager在MyRedisConfig中

     * 使用：
     *         常用类型：String list（列表） Set（集合） Hash（散列） ZSet（有序集合）
     *          stringRedisTemplate.opsForValue();
     *          stringRedisTemplate.opsForList();
     *          stringRedisTemplate.opsForSet();
     *          stringRedisTemplate.opsForHash();
     *          stringRedisTemplate.opsForZSet();

导入坐标（版本根据springboot走）：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>

配置文件：

spring.redis.host=localhost
spring.cache.redis.use-key-prefix=true  #使用CacheName作为key的前缀

基于Springboot1.x配置RedisCacheManager

import com.bootbootboot.springboot01cache.bean.Department;
import com.bootbootboot.springboot01cache.bean.Employee;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

/**
 * springboot 1.X 版本RedisCacheManager配置
 */
@Configuration
public class MyRedisConfig {

    @Bean
    //@ConditionalOnMissingBean
    public RedisTemplate<Object, Employee> empRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Employee> template = new RedisTemplate<Object, Employee>();
        template.setConnectionFactory(redisConnectionFactory);
        //获取jackson序列化器
        Jackson2JsonRedisSerializer<Employee> ser = new Jackson2JsonRedisSerializer<Employee>(Employee.class);
        //设置序列化器
        template.setDefaultSerializer(ser);
        return template;
    }

    @Bean
    public RedisTemplate<Object, Department> deptRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Department> template = new RedisTemplate<Object, Department>();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Department> ser = new Jackson2JsonRedisSerializer<Department>(Department.class);
        template.setDefaultSerializer(ser);
        return template;
    }

    /**
     * 这里可以扩展使用自定义的RedisTemplate<Object,Object>自定义缓存
     */
    //CacheManagerCustomizers可以来定制缓存的一些规则
    @Primary  //将某个管理器设为默认
    @Bean
    public RedisCacheManager employeeCacheManager(RedisTemplate<Object, Employee> empRedisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(empRedisTemplate);
        //使用CacheName作为key的前缀，可在application配置文件中开启
        //cacheManager.setUserPrefix(true);
        return cacheManager;
    }

    @Bean
    public RedisCacheManager deptCacheManager(RedisTemplate<Object, Department> deptRedisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(deptRedisTemplate);
        //cacheManager.setUserPrefix(true);
        return cacheManager;
    }

}

基于Springboot2.x配置RedisCacheManager

import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

import java.time.Duration;
import java.util.Objects;

/**
 * springboot 2.X 版本的RedisManager配置
 * 注意：
 *      在配置文件中使用CacheName作为key的前缀：spring.cache.redis.use-key-prefix=true
 *      在spring-boot2.x之前：RedisCacheManager cacheManager = new RedisCacheManager(RedisTemplate redisTemplate);
 *      在spring-boot2.0之后：RedisCacheManager cacheManager = new RedisCacheManager(RedisCacheWriter redisCacheWriter,RedisCacheConfiguration redisCacheConfiguration);
 */
@Configuration
public class MyRedisCacheConfig {

    //spring-boot2.x之前
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofDays(1))
                .disableCachingNullValues()
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
        return RedisCacheManager.builder(factory).cacheDefaults(cacheConfiguration).build();
    }

    //spring-boot2.0之后
    @Bean  //给容器注册一个Bean，返回缓存管理器,这里redisTemplate容器中有，所以会自动注入
    public CacheManager MyRedisCacheConfig(RedisTemplate redisTemplate) {
        //1.创建RedisCacheWriter
        /**
         * 非锁方式：nonLockingRedisCacheWriter(RedisConnectionFactory connectionFactory);
         * 有锁方式：lockingRedisCacheWriter(RedisConnectionFactory connectionFactory);
         */
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(Objects.requireNonNull(redisTemplate.getConnectionFactory()));
        //2.创建Jackson对象并传入需要序列化的对象
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        //3.传入 Jackson对象 并获取 RedisSerializationContext对象
        RedisSerializationContext<Object, Object> serializationContext = RedisSerializationContext.fromSerializer(serializer);
        //4.配置RedisCacheConfiguration
        /**
         * RedisCacheConfiguration.defaultCacheConfig()
         * 设置 value 的序列化 serializeValuesWit(SerializationPari<?> valueSerializationPari)
         * 设置 key 的序列化 serializeKeysWith(SerializationPari valueSerializationPari)
         */
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(serializationContext.getValueSerializationPair());
        //5.创建RedisCacheManager(RedisCacheWriter redisCacheWriter, RedisCacheConfiguration redisCacheConfiguration)对象并返回
        return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
    }

    //spring-boot2.0之后简化版
    @Bean(name = "MyRedisCacheManager")
    public CacheManager MyRedisCacheManagerSimple(RedisTemplate redisTemplate) {
        return new RedisCacheManager(
                RedisCacheWriter
                        .nonLockingRedisCacheWriter(Objects
                                .requireNonNull(redisTemplate
                                        .getConnectionFactory())),
                RedisCacheConfiguration
                        .defaultCacheConfig()
                        .serializeValuesWith(
                                RedisSerializationContext
                                        .fromSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class))
                                        .getValueSerializationPair()
                        )
        );
    }
}

使用：

@Service
public class EmployeeServiceForRedisService {

    @Autowired
    private DepartmentMapper departmentMapper;

    @Autowired
    RedisTemplate redisTemplate;  //key-value都是对象

    @Autowired
    RedisTemplate<Object, Employee> empRedisTemplate;  //使用特定对象的redistemplate

    @Qualifier("deptCacheManager")  //使用注解方式指定使用某个缓存管理器
    @Autowired                      //sprintboot 1.x 中配置的CacheManager
    RedisCacheManager deptCacheManager;

    @Qualifier("MyRedisCacheManager")  //springboot 2.x 中配置的CacheManager
    @Autowired
    CacheManager MyRedisCacheConfigSimple;

    /**
     * Redis是一个开源的，内存中的数据机构存储系统，它可以作为数据库，缓存和消息中间件。
     * 使用：安装redis，引入redis的starter，配置redis
     * 原理：CacheManager == Cache 缓存组件来实际给缓存中存取数据，替换默认的SimpleCacheConfiguration
     *      1.引入redis的starter，容器中保存的是RedisCacheManager
     *      2.RedisCacheManager 底层帮我们创建RedisCache来作为缓存组件：RedisCache通过操作redis缓存数据的
     *      3.默认保存数据 k-v 都是Object，利用序列化保存的（需转换json）
     *      附：
     *          @Configuration(proxyBeanMethods = false)
     *          @ConditionalOnMissingBean({CacheManager.class})  //SimpleCacheConfiguration起作用是容器中没有CacheManager
     *          @Conditional({CacheCondition.class})
     *          class SimpleCacheConfiguration {}
     *
     *          @Configuration(proxyBeanMethods = false)
     *          @ConditionalOnClass({RedisConnectionFactory.class})
     *          @AutoConfigureAfter({RedisAutoConfiguration.class})
     *          @ConditionalOnBean({RedisConnectionFactory.class})
     *          @ConditionalOnMissingBean({CacheManager.class})  //redis也需要判断容器中没有CacheManager才生效
     *          @Conditional({CacheCondition.class})
     *          class RedisCacheConfiguration {}
     * 原因：
     *      1.引入redis的starter，cacheManager变为RedisCacheManager，剩下的CacheManager就不起作用了
     *      2.默认创建的RedisCacheManager操作redis的时候使用的是RedisTemplate<Object,Object>
     *      3.RedisTemplate<Obejct,Object>是默认使用【jdk的序列化机制】
     *      4.自定义CacheManager在MyRedisConfig中
     * 常用类型：String list（列表） Set（集合） Hash（散列） ZSet（有序集合）
     *  stringRedisTemplate.opsForValue();
     *  stringRedisTemplate.opsForList();
     *  stringRedisTemplate.opsForSet();
     *  stringRedisTemplate.opsForHash();
     *  stringRedisTemplate.opsForZSet();
     */

    public void saveStringType() {
        //保存数据
        stringRedisTemplate.opsForValue().append("msg", "hello");
        stringRedisTemplate.opsForList().leftPush("myList", "2");
        //读取数据
        String msg = stringRedisTemplate.opsForValue().get("msg");
    }

    public void saveBeanType() {
        Employee empById = employeeMapper.getEmpById(1);
        //默认如果保存对象(对象需实现Serializable接口)，使用jdk序列化机制，序列化后的数据保存到redis中
        redisTemplate.opsForValue().set("emp-01", empById);
        /**
         * 将数据以json方式保存
         *  1.自己将对象转为json
         *  2.redisTemplate实现自己的序列化机制
         */
        empRedisTemplate.opsForValue().set("emp-01", empById);
    }

    /**
     * 使用配置缓存
     * 注意：
     *      如果使用的JPA，不要使用findById(id).get() 来返回对象；会反序列化失败。
     */
    @Cacheable(cacheNames = "dept",key = "#id", cacheManager = "deptCacheManager")  //springboot 1.X
//    @Cacheable(cacheNames = "dept",key = "#id", cacheManager = "MyRedisCacheConfig")  //springboot 2.X
    public Department getDeptById(Integer id) {
        Department department = departmentMapper.getDeptById(id);
        return department;
    }

    /**
     * 使用缓存管理器得到缓存:
     *     @Qualifier("deptCacheManager")  //指定使用某个缓存管理器
     *     @Autowired
     *     RedisCacheManager deptCacheManager;
     */
    public Department getDeptById2(Integer id) {
        Department department = departmentMapper.getDeptById(id);
        //获取某个缓存
        Cache dept = deptCacheManager.getCache("dept");
        dept.put("dept:1", department);
        return department;
    }
}

xy294636185
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot2.x整合redis知识点讲解
08-25
在本篇文章中小编给大家分享的是一篇关于springboot2.x整合redis知识点内容，有兴趣的朋友们可以学习下。
【SpringBoot】Redis配置CacheManager实现缓存
wistchen
11-28 7074
1.唠嗑 最近学了网上的springboot1.X的springboot整合redis实现缓存，自己在练习的时候才发现springboot2.x已经不支持教程里面的配置cacheManager了，网上找了很久，都失败了。最后在b站有一个视频看见了，实验成功了。 最终的成果是springboot整合Jpa、redis，配置redisconfig，实现缓存。 2.概念 3.springboot2.x配置cacheManager 找了很久，可以用的，希望能帮助到大家。 @C.
Redis 缓存(Cache)
最新发布
ikun66666的博客
02-19 1463
Redis 缓存(Cache)
SpringBoot2.x整合Redis
02-24
最近在学习SpringBoot2.x整合Redis，在这里和大家分享一下，希望对大家有帮助。Redis是开源免费高性能的key-value数据库。有以下的优势（源于Redis官网）：1.性能极高–Redis能读的速度是110000次/s,写的速度是81000次/s。2.丰富的数据类型–Redis支持二进制案例的Strings,Lists,Hashes,Sets及OrderedSets数据类型操作。3.原子–Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。4.丰富的特性–Redis还支
RedisCacheManager + CacheManager +@Cacheable 实现注解化缓存管理
yiqiu1959的博客
08-04 2844
@Cacheable + RedisCacheManager
Redis缓存之自定义CacheManager
weixin_30519071的博客
04-29 1632
测试缓存：原理：CacheManager===Cache 缓存组件来实际给缓存中存储数据1，引入redis的starter，容器中保存的是RedisCacheManager2，RedisCacheManager 帮我们创建RedisCache 来作为缓存组件；RedisCache通过操作redis来缓存数据3，默认保存数据 K -V 都是通过序列化来保存的； 关于能存储redis。第二次...
Spring Boot 中的 RedisCacheManager 是什么，原理，如何使用
徐师兄的博客
06-29 3378
在现代应用程序中，缓存是提高应用程序性能的重要组成部分。Spring Boot 提供了一个强大的缓存框架，它支持多种缓存提供程序，包括 Redis、Ehcache、Caffeine 等。在本文中，我们将重点介绍 Spring Boot 中的 RedisCacheManager，并探讨它的原理和如何使用它来提高应用程序的性能。
SpringBoot与RedisCacheManager整合
zzhongcy的专栏
05-26 2317
从3.1开始Spring定义了和接口来统一不同的缓存技术；并支持使用 注解简化开发. <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> <!-- redis --> <dependency> <groupId
Cache源码解析（RedisCache配置过程)
weixin_44577106的博客
12-21 3722
①cache配置过程 1、找到CacheAutoConfiguration类 内部有个配置类加载选择器，决定了哪个配置类会被加载！ 2、找到CacheConfigurations类 RedisCacheConfiguration为redis的缓存配置类。 3、找到RedisCacheConfiguration类 RedisCacheConfiguration向spring中放入了RedisCacheManager的bean，用于管理Re...
SpringCache的简单入门（RedisCacheManager）（@Cacheable、@CachePut、@CacheEvict）
weixin_45281071的博客
10-21 1838
SpringCache的简单入门（RedisCacheManager），@Cacheable、@CachePut、@CacheEvict注解的使用。
redisCacheManager
weixin_34067102的博客
09-27 1449
2019独角兽企业重金招聘Python工程师标准>>> ...
Springboot2.X集成redis集群(Lettuce)连接的方法
08-27
主要介绍了Springboot2.X集成redis集群(Lettuce)连接的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springboot2.X+mybatis+redis
03-23
springboot2.X+mybatis+redis 简单项目搭建以及使用，可以在实践中了解这三者的关系
RedisTemplate操作Redis
love_eat_peach的博客
05-17 382
根据方法对其返回结果进行缓存，下次请求时，如果缓存存在，则直接读取缓存数据返回；如果缓存不存在，则执行方法，并把返回的结果存入缓存中。（特别注意，当注入的是StringRedisTemplete时只能操作字符串，所以对象数据都要通过json工具类转为json数据进行保存）使用该注解标志的方法，每次都会执行，并将结果存入指定的缓存中。如果指定为 true，则方法调用后将立即清空所有的缓存。缓存名，必填，它指定了你的缓存存放在哪块命名空间。缓存名，必填，它指定了你的缓存存放在哪块命名空间。
springboot缓存之CacheManager详解
qq_35876365的博客
01-06 5141
整合spring-cache的关键就在于配置一个缓存管理器CacheManager，让我们慢慢走近redis看看他的缓存管理器的实现吧~
springboot2.x 的 RedisCacheManager
s297485987的专栏
11-22 4913
redis介绍 Redis是目前业界使用最广泛的内存数据存储。相比memcached，Redis支持更丰富的数据结构，例如hashes, lists, sets等，同时支持数据持久化。除此之外，Redis还提供一些类数据库的特性，比如事务，HA，主从库。可以说Redis兼具了缓存系统和数据库的一些特性，因此有着丰富的应用场景。本文介绍Redis在Spring Boot中两个典型的应用场景。 如何使...
springboot使用redis，改变序列化方式时，RedisCacheConfiguration类总是不能导入
黄坤的博客
02-14 2848
springboot使用redis，改变序列化方式时，RedisCacheConfiguration类总是不能导入，在找了好久之后，终于发现是我的springboot版本不对，我原来的版本是1.5.6，现在改为2.1.3就能用了。 package com.example.springboot_cache_redis_demo.config; import com.fasterxml.jackso...
1.2_springboot2.x中redis缓存&原理介绍
含江君
10-13 540
1、整合redis作为缓存 说明这里springboot版本2.19 Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构 1、安装redis,使用docker安装 docker search redis docker pull redis 下载redis，这里已经下载过了就不演示了 使用docker images 查看...
springboot集成redis，使用@Cacheable注解
qq_30198981的博客
11-21 1047
springboot 2.0 集成redis 使用@Cacheable 注解所需要的配置，注意：在使用中所有的序列化机制保持一致 package com.best.config; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAcce...
redis3.x和redis 6.x版本区别
07-28
Redis 3.x 和 Redis 6.x 是 Redis 数据库的不同版本，它们之间有一些重要的区别。以下是其中一些主要区别： 1. 多线程支持：Redis 3.x 是单线程的，在处理请求时只能使用一个 CPU 核心。而 Redis 6.x 引入了多线程支持，可以利用多个 CPU 核心进行并行处理，从而提高了性能。 2. 内存分配器：Redis 3.x 使用了 jemalloc 作为默认的内存分配器，而 Redis 6.x 则改为使用了更现代化的 TCMalloc。 3. RDB 文件格式：Redis 3.x 使用 RDB 文件格式来进行持久化，而 Redis 6.x 引入了新的 RDB 文件格式，该格式支持更多的数据类型和功能。 4. 模块化：Redis 6.x 引入了模块化的架构，允许开发者通过编写插件来扩展 Redis 的功能。这使得开发者可以更方便地定制和增强 Redis 的行为。 5. ACL（访问控制列表）：Redis 6.x 引入了更强大的 ACL 功能，允许管理员对 Redis 进行更细粒度的权限控制和用户管理。 6. 复制和集群：Redis 6.x 对复制和集群的支持进行了改进，提供了更高的可靠性和容错性。 这些是 Redis 3.x 和 Redis 6.x 之间的一些重要区别，但还有其他一些细微的变化和改进。根据您的具体需求和使用场景，选择适合的版本是很重要的。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值