RedisTemplate 的两种序列化方式

1. 自定义 RedisTemplate 进行序列化
2. 使用 StringRedisTemplate 进行序列化

RedisTemplate 可以接收任意的 Object 作为值写入 Redis，只不过写入前会把 Object 序列化为字节形式，默认采用 JDK 序列化。但是这种方式有两个缺点：

可读性差。对键值对进行了序列化，中文字符串序列化后的内容表示为 16 进制表示的数据，可读性差。
内存空间占用大。存储了额外的对象的类型信息，占用了内存空间。

因此，我们需要使用其他的方式进行序列化。

1. 自定义 RedisTemplate 进行序列化

可以自定义 RedisTemplate 的序列化方式，代码如下：

@Configuration
public class RedisConfig {
  @Bean
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
      // 创建 RedisTemplate 对象
      RedisTemplate<String, Object> template = new RedisTemplate<>();
      // 设置连接工厂
      template.setConnectionFactory(connectionFactory);
      // 创建 JSON 序列化工具
      GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
      // 设置 key 的序列化
      template.setKeySerializer(RedisSerializer.string());
      template.setHashKeySerializer(RedisSerializer.string());
      // 设置 value 的序列化
      template.setValueSerializer(jsonRedisSerializer);
      template.setHashValueSerializer(jsonRedisSerializer);
      // 返回
      return template;
  }
}

使用 @Configuration 注解将 RedisConfig 类定义为配置类，使用 @Bean 注解将 redisTemplate 方法注册为 Bean 对象。

在上面配置类的方法中，创建了一个 JSON 序列化工具叫作 GenericJackson2JsonRedisSerializer()，这个类需要一个 Jackson 依赖，因此还需要在 pom 文件中引入依赖：

<!--Jackson 依赖-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

定义一个实体类 User.java

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    private String name;
    private Integer age;

}

注入自定义的 RedisTemplate：

@Autowired
private RedisTemplate<String, Object> redisTemplate;

编写测试：

 @Test
void testSaveUser() {
    // 写入数据
    redisTemplate.opsForValue().set("user:100", new User("华仔仔", 24));
    // 获取数据
    User user = (User) redisTemplate.opsForValue().get("user:100");
    System.out.println("user=" + user);
}

输出结果：

使用 Another Redis Desktop Manager 软件查看刚才存入的键为 user:100 对应的值的情况：

这是一个 JSON 形式的数据，@class 存放的值为序列化的对象的类的信息，这个信息是用于在反序列化的时候可以知道对象的类型，但是也带来了额外的内存开销。

2. 使用 StringRedisTemplate 进行序列化

为了节省内存空间，通常并不会使用 JSON 序列化器来处理 value，而是统一使用 String 序列化器，要求只能存储 String 类型的 key 和 value，当需要存储 Java 对象时，手动完成对象的序列化和反序列化。

Spring 默认提供了一个 StringRedisTemplate 类，它的 key 和 value 的序列化方式默认就是 String 方式。省去了自定义 RedisTemplate 的过程。

1、首先，注入 StringRedisTemplate 类

@Autowired
private StringRedisTemplate stringRedisTemplate;

2、编写测试
对于存储 String 类型的数据，SpringRedisTempalte 默认帮我们实现了存储前的序列化以及取出前的反序列化。

@Test
void testString() {
	 // 写入一条 String 数据
	 stringRedisTemplate.opsForValue().set("name", "华仔仔");
	 // 获取 String 数据
	 Object name = stringRedisTemplate.opsForValue().get("name");
	 System.out.println("name = " + name);
}

对于存取 Object 数据，存取前都需要借助类 ObjectMapper 手动地进行序列化和反序列化。

@Test
void testSaveUser() throws JsonProcessingException {
	 // 创建
	 ObjectMapper mapper = new ObjectMapper();
	 // 创建对象
	 User user = new User("华仔仔", 24);
	 // 手动序列化
	 String json = mapper.writeValueAsString(user);
	 // 写入数据
	 stringRedisTemplate.opsForValue().set("user:200", json);
	 // 获取数据
	 String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
	 // 手动反序列化
	 User user1 = mapper.readValue(jsonUser, User.class);
	 System.out.println("user1=" + user1);
}