获取保存到redis中的login_token

文章目录

• SpringBoot+Redis+CacheManager

• 1、引入redis
• 2、RedisTemplate与StringRedisTemplate

• 1、存储方式不一样
• 2、使用的场景

• 3、自定义RedisTemplate序列化
• 4、自定义缓存管理器

• 1、使用一个管理器管理所有缓存类
• 2、配置多个缓存管理器分开管理

• 1、配置多个缓存管理器
• 2、使用多个缓存管理器

SpringBoot+Redis+CacheManager

1、引入redis

<!--引入redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

2、RedisTemplate与StringRedisTemplate

1、存储方式不一样

  两者在存储方式上不一样,StringRedisTemplate使用的是普通字符串方式
  例如

stringRedisTemplate.opsForValue().append(“msg”,“hello”);
redisTemplate.opsForValue().set(“msg”,“hello world”);

两者可以共存，因为stringRT存储的key是"msg" 而RT存储的key为序列化转义的"\xac\xed\x00\x05t\x00\x03msg"

2、使用的场景

顾名思义，一个是序列化转义一个是直接存储
所以当我们需要存储的数据非常的简单就是我们需要使用的数据，无需改动时，我们就直接使用sRT
如果当我们的数据比较复杂时，如一个对象，一个map对象，一个数组等情况时，我们就应该使用RT

3、自定义RedisTemplate序列化

如下使用的是Jackson2JsonRedisSerializer默认使用的是jdk序列化

@Configuration
public class MyRedis {

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

4、自定义缓存管理器

1、使用一个管理器管理所有缓存类

自定义缓存管理器后注解的方式会默认传入redis缓存中

*  1、测试缓存
 *      原理：CacheManager===Cache缓存组件来实际给缓存中存取数据
 *      1、引入redis的starter，容器中保存的是RedisCacheManager
 *      2、RedisCacheManager帮我们创建RedisCache来作为缓存组件；RedisCache通过操作redis缓存数据
 *      3、默认保存数据 k-v都是Object，利用序列化保存；如何保存为json?
 *              1、引入redis的starter，cacheManager变为 RedisCacheManager;
 *              2、默认创建的RedisCacheManager操作redis的时候使用的是 RedisTemplate<Object, Object>
 *              3、RedisTemplate<Object,Object>是默认使用jdk的序列化机制

//自定义缓存管理器
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {

        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .computePrefixWith(new CacheKeyPrefix() {
                    @Override
                    public String compute(String cacheName) {
                        return cacheName + ":";
                    }
                }) //将::改写为1个
                .entryTtl(Duration.ofHours(24))   // 设置缓存过期时间
                .disableCachingNullValues()     // 禁用缓存空值，不缓存null校验
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(
                        new GenericJackson2JsonRedisSerializer()
                ));     // 设置CacheManager的值序列化方式为json序列化，可使用加入@Class属性

        // 使用RedisCacheConfiguration创建RedisCacheManager
        RedisCacheManager cm = RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(cacheConfiguration )
                .build();
        return cm;
    }

2、配置多个缓存管理器分开管理

场景如上，我们可以使用一个缓存管理器就能够处理所有的数据
但是我们有时候偏偏有特殊需求，存储的json格式中不带有@class类名所在位置
这时候我们就可以使用多个缓存管理器

1、配置多个缓存管理器

//通用的缓存管理器
    @Bean
    @Primary//如果我们使用时不指定默认缓存管理器，将会默认使用这个缓存管理器
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {

        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .computePrefixWith(new CacheKeyPrefix() {
                    @Override
                    public String compute(String cacheName) {
                        return cacheName + ":";
                    }
                }) //将::改写为1个
                .entryTtl(Duration.ofHours(24))   // 设置缓存过期时间
                .disableCachingNullValues()     // 禁用缓存空值，不缓存null校验
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(
                        new GenericJackson2JsonRedisSerializer()
                ));     // 设置CacheManager的值序列化方式为json序列化，可使用加入@Class属性

        // 使用RedisCacheConfiguration创建RedisCacheManager
        RedisCacheManager cm = RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(cacheConfiguration )
                .build();
        return cm;
    }

    //处理某个类(Employee)的缓存管理器
    @Bean
    public RedisCacheManager empCacheManager(RedisConnectionFactory connectionFactory) {

        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .computePrefixWith(new CacheKeyPrefix() {
                    @Override
                    public String compute(String cacheName) {
                        return cacheName + ":";
                    }
                }) //将::改写为1个
                .entryTtl(Duration.ofHours(24))   // 设置缓存过期时间
                .disableCachingNullValues()     // 禁用缓存空值，不缓存null校验
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(
                        new Jackson2JsonRedisSerializer<Employee>(Employee.class)
                ));     // 设置CacheManager的值序列化方式为json序列化，可使用加入@Class属性

        // 使用RedisCacheConfiguration创建RedisCacheManager
        RedisCacheManager cm = RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(cacheConfiguration )
                .build();
        return cm;
    }
    //处理某个类(Department)的缓存管理器
    @Bean
    public RedisCacheManager depCacheManager(RedisConnectionFactory connectionFactory) {

        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .computePrefixWith(new CacheKeyPrefix() {
                    @Override
                    public String compute(String cacheName) {
                        return cacheName + ":";
                    }
                }) //将::改写为1个
                .entryTtl(Duration.ofHours(24))   // 设置缓存过期时间
                .disableCachingNullValues()     // 禁用缓存空值，不缓存null校验
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(
                        new Jackson2JsonRedisSerializer<Department>(Department.class)
                ));     // 设置CacheManager的值序列化方式为json序列化，可使用加入@Class属性

        // 使用RedisCacheConfiguration创建RedisCacheManager
        RedisCacheManager cm = RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(cacheConfiguration )
                .build();
        return cm;
    }

2、使用多个缓存管理器

//我们可以在类头上的@CacheConfig公共配置中定义
    @Service
    @CacheConfig(cacheManager = "empCacheManager")
    public class EmployeeService {

    //也可以在局部中定义
    @Cacheable(cacheNames = {"dep"},cacheManager = "depCacheManager")