Spring Boot | Spring Boot “自定义“ Redis缓存 “序列化机制“

Spring Boot "自定义" Redis缓存 "序列化机制" ：
- 一、基于 "注解" 的 "Redis缓存管理" 的 "默认序列化机制" 和 "自定义序列化机制"
- - 1.1 基于 "注解" 的 "Redis缓存管理" 的 "默认序列化机制"
  - 1.2 自定义基于"注解" "Redis缓存管理" 的 "序列化机制" ( 自定义一个 "RedisCacheManager对象" , 在该对象中进行 "序列化" 的 "自定义" )
- 二、Redis API ( RedisTemplate类 ) 的 "默认序列化机制" 和 "自定义序列化机制"
- - 2.1 Redis API ( RedisTemplate类 ) 的 "默认序列化机制"
  - 2.2 自定义 Redis API ( RedisTemplate类 ) 的 "序列化机制" ( 自定义一个"RedisTemplate"对象，在该对象中进行 "序列化" 的 "自定义" )

作者简介 ：一只大皮卡丘，计算机专业学生，正在努力学习、努力敲代码中! 让我们一起继续努力学习！

该文章参考学习教材为：
《Spring Boot企业级开发教程》 黑马程序员 / 编著
文章以课本知识点 + 代码为主线，结合自己看书学习过程中的理解和感悟，最终成就了该文章

文章用于本人学习使用 ，同时希望能帮助大家。
欢迎大家点赞👍 收藏⭐ 关注💖哦！！！

（侵权可联系我，进行删除，如果雷同，纯属巧合）

Spring Boot “自定义” Redis缓存 “序列化机制” ：

一、基于 “注解” 的 “Redis缓存管理” 的 “默认序列化机制” 和 “自定义序列化机制”

1.1 基于 “注解” 的 “Redis缓存管理” 的 “默认序列化机制”

在基于 “注解” 的 “Redis缓存管理” 中我们已经实现了在 Spring Boot 中使用 Redis 来进行 数据的 “缓存管理”，此时 缓存管理 的使用的 序列化机制为： JDK 序列化机制 ，如下图所示 ：

( Redis API的默认序列化机制 为 : JDK序列化机制 )。

可通过 JSON格式的 "序列化机制" 来 解决这个问题。

1.2 自定义基于"注解" “Redis缓存管理” 的 “序列化机制” ( 自定义一个 “RedisCacheManager对象” , 在该对象中进行 “序列化” 的 “自定义” )

打开 Spring Boot 整合 Redis 组件提供的缓存自动配置类 ：RedisCacheConfiguration (org.springframework.boot.autoconfigure.cache 包下的)，查看该类的 源码信息，其 核心代码 如下：

package org.springframework.boot.autoconfigure.cache;

@Configuration
class RedisCacheConfiguration {

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory, ResourceLoader resourceLoader) {
      RedisCacheManagerBuilder builder =            RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(this.determineConfiguration(resourceLoader.getClassLoader()));
        List<String> cacheNames = cacheProperties.getCacheNames();
         if (!cacheNames.isEmpty()) {
            builder.initialCacheNames(new LinkedHashSet(cacheNames));
        }
          return (RedisCacheManager)cacheManagerCustomizers.customize(builder.build());
    }
        .....

      private org.springframework.data.redis.cache.RedisCacheConfiguration createConfiguration(ClassLoader classLoader) {
        CacheProperties.Redis redisProperties = cacheProperties.getRedis();
        org.springframework.data.redis.cache.RedisCacheConfiguration config = org.springframework.data.redis.cache.RedisCacheConfiguration.defaultCacheConfig();
        config = config.serializeValuesWith(SerializationPair.fromSerializer(new JdkSerializationRedisSerializer(classLoader))); 
        .....
        return config;
    }
}

从上述核心源码中可以看出，同 RedisTemplate 核心源码 类似，RedisCacheConfiguration 内部同样通过 RedisConnectionFactory ( Redis连接工厂 ) 定义了一个 RedisCacheManager ( 缓存管理器 ) ; 同时定制 RedisCacheManager 时，使用了默认的 JdkSerializationRedisSerializer ( JDK序列化机制 ) 。

如果想要使用 自定义序列化方式的 RedisCacheManager进行数据缓存操作，可以参考上述核心代码创建一个名为 cacheManager的
Bean组件，并在该组件中 设置对应 的 序列化方式 即可。

通过 自定义 RedisCacheManager对象 来 “自定义序列化机制” ( 自定义 基于 “注解” 的 “Redis缓存管理” 的 “序列化机制” ) :

RedisConfig.java ： ( 添加该 配置类，即可实现 JSON序列化机制 )

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@Configuration //标记该类为"配置类"
public class RedisConfig { 

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        //分别创建String 和 JSON格式的 "序列化对象" , 对缓存数据key和value进行转换
        /**
         * "String格式序列化机制" ---用在存储的"缓存数据"的key
         */
        RedisSerializer<String> strSerializer = new StringRedisSerializer();

        //解决查询缓存转换异常的问题
        ObjectMapper objectMapper  = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        /*
          使用"JSON格式序列化机制" 对缓存数据key和value进行转换 ---用在存储的"缓存数据"的value
         */
        Jackson2JsonRedisSerializer jsonSerializer = new Jackson2JsonRedisSerializer(objectMapper,Object.class);

        /*
         定制"缓存数据序列化方式"及"时效"
         */
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofDays(1)) //"缓存数据"的"持续时效"
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(strSerializer))//设置key的"序列化机制"
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jsonSerializer))//设置value的"序列化机制"
                .disableCachingNullValues();

        //创建RedisCacheManager对象
        RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(config).build();
        return redisCacheManager;
    }
}

上述代码中，在 RedisConfig 配置类中使用 @Bean 注解注入了一个默认名称为方法名的cacheManager 组件。
在定义的 Bean 组件中，通过 RedisCacheConfiguration 对缓存数据的 key和 value 分别进行了序列化方式的定制，其中缓存数据的 key定制为 StringRedisSerializer(即String 格式)，而 value 定制为了 Jackson2JsonRedisSerializer(即 JSON 格式 )，同时还使用entryTtl ( Duration.ofDays(1) ) 方法将 缓存数据有效期 设置为 1天。最后创建 RedisCacheManager对象。

基于 “注解” 的 “Redis缓存管理” ，在 左边的项目代码的基础上，添加 RedisConfig.java 配置类 ，启动该项目 ，访问ulr，可以看到 Redis数据库 中的数据为 JSON格式 ( 如下图所示 )，便于查看和管理，表明其实 序列化方式为： JSON序列化方式 。

在这里插入图片描述

二、Redis API ( RedisTemplate类 ) 的 “默认序列化机制” 和 “自定义序列化机制”

2.1 Redis API ( RedisTemplate类 ) 的 “默认序列化机制”

在基于 “API” ( RedisTemplate类 ) 的 “Redis缓存管理” 中我们已经实现了在 Spring Boot 中使用 Redis 来进行 数据的
“缓存管理”，此时 缓存管理的使用的 序列化机制 为： JDK 序列化机制 。

( Redis API 的 默认序列化机制 为 : JDK序列化机制 )。

JDK 序列化机制 的缺点 :

① 实体类中要 实现 "Serializable接口" ，以此对数据进行"序列化"。

② 不便于使用可视化管理工具进行查看和管理 ( 即此时在 Redis数据库可视化界面中看到都是一些 Hex 格式的数据 ( 或者 二进制格式 / 其他格式 )，都 不是一些明细可视化的数据 )，如下图所示 ：

可通过 JSON格式的 "序列化机制" 来 解决这个问题。

2.2 自定义 Redis API ( RedisTemplate类 ) 的 “序列化机制” ( 自定义一个"RedisTemplate"对象，在该对象中进行 “序列化” 的 “自定义” )

在 项目中引入 Redis 依赖 后，Spring Boot 提供的 RedisAutoConfiguration 自动配置会生效 ( Redis自动配置类生效)。

打开RedisAutoConfiguration 类，查看内部源码 中关于 RedisTemplate 的 定义方式，核心代码如下所示 :
public class RedisAutoConfiguration {

  @Bean
  @ConditionalOnMissingBean( name = {"redisTemplate"} )
  public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
  .....
}
从上述 RedisAutoConfiguration 核心源码中可以看出，在 Redis 自动配置类 中，通过 RedisConnectionFactory ( Redis连接工厂对象 ) 初始化 了一个 RedisTemplate 对象 ( Redis模板对象 )。

RedisTemplate 类上方添加了 @ConditionalOnMissingBean 注解( 顾名思义，当某个 Bean 不存在时生效 )，用来表明如果开发者自定义了一个名为 redisTemplate 的 Bean，则 RedisTemplate 会 使用自定义 的 Bean。
如果 想要使用自定义序列化方式的 RedisTemplate对象 进行数据缓存操作，可以参考上述核心创建一个名为 redisTemplate 对象 的 Bean 组件，并在该组件中 设置 对应的序列化方式 ( JSON序列化方式 ) 即可。

配置类代码例子如 :

RedisConfig.java ：
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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;

  @Configuration //标记该类为"配置类"，定义一个配置类
  public class RedisConfig { //关于RedisTemplate对象的配置类
        @Bean
  public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) { //参数为: Redis连接工厂对象
      //创建RedisTemplate对象
      RedisTemplate<Object, Object> redisTemplate = new RedisTemplate();
      //设置Redis连接工厂对象
      redisTemplate.setConnectionFactory(redisConnectionFactory );
            //设置解决缓存异常问题
      ObjectMapper objectMapper  = new ObjectMapper();
      objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
      objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

      /*
        使用"JSON格式序列化机制" 对缓存数据key和value进行转换
       */
      Jackson2JsonRedisSerializer jsonRedisSerializer = new Jackson2JsonRedisSerializer(objectMapper,Object.class);
      //设置RedisTemplate对象的"序列化机制" 为 "JSON序列化机制"
      redisTemplate.setDefaultSerializer(jsonRedisSerializer);

      return redisTemplate;
    }
  }
在上面的代码中，使用 自定义的 Jackson2JsonRedisSerializer数据序列化方式自定义一个 RedisTemplate，在定制序列化方式中，定义一个ObjectMapper 用于进行数据转换设置。

基于 “API” ( RedisTemplate类 ) 的 “Redis缓存管理” ，在 左边的项目代码的基础上，添加 RedisConfig.java 配置类 ，启动该项目 ，访问ulr，可以看到 Redis数据库中的数据为 JSON格式 ( 如下图所示 )，便于查看和管理，表明其实 序列化方式为： JSON序列化方式 。