Redis中的序列化器及对序列化的理解

在JAVA项目中使用Redis

引入jar包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.6.4</version>
</dependency>

配置RedisTemplate序列化器

@Configuration
public class RedisTemplateConfig {
    @Bean
    public RedisTemplate<String, Object> MyRedisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        redisTemplate.setKeySerializer(RedisSerializer.string());
        // 默认使用JDK序列化器
        // redisTemplate.setValueSerializer(RedisSerializer.java());
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        redisTemplate.setHashValueSerializer(RedisSerializer.json());
        return redisTemplate;
    }
}

测试RedisTemplate的序列化器

@SpringBootTest
public class RedisTest {

    @Resource
    private RedisTemplate redisTemplate;  // 默认的redisTemplate使用JDK序列化器
    @Resource
    private RedisTemplate MyRedisTemplate;  // 使用自己的序列化器
    @Resource
    private StringRedisTemplate stringRedisTemplate; // 报错：cannot be cast to class java.lang.String

    @Test
    void testValue() {
        ValueOperations valueOperations = MyRedisTemplate.opsForValue();
        // 定义
        User user = new User();
        user.setId(1L);
        user.setUsername("hwx");
        // 存
        valueOperations.set("User:hwx", user);
        // 取
        User user2 = (User) valueOperations.get("User:hwx");
        System.out.println(user2);
    }

    @Test
    void testHash() {
        HashOperations hashOperations = MyRedisTemplate.opsForHash();
        // 定义
        User user = new User();
        user.setId(1L);
        user.setUsername("hwx");
        // 存
        hashOperations.put("User", "hwx", user);
        // 取
        User user2 = (User) hashOperations.get("User","hwx");
        System.out.println(user2);
    }
}

序列化结果

使用GenericJackson2JsonRedisSerializer()序列化器

// 使用GenericJackson2JsonRedisSerializer()
{
  "@class": "com.user.center.model.domain.User",
  "id": 1,
  "username": "hwx",
  "userAccount": null,
  "avatarUrl": null,
  "gender": null,
  "userPassword": null,
  "phone": null,
  "email": null,
  "tags": null,
  "userStatus": null,
  "createTime": null,
  "updateTime": null,
  "isDelete": null,
  "userRole": null,
  "planetCode": null
}

使用 JdkSerializationRedisSerializer() 序列化器

// 使用 JdkSerializationRedisSerializer()
\xAC\xED\x00\x05sr\x00!com.user.center.model.domain.User\x00\x00\x00\x00\x00\x00\x00\x01\x02\x00\x0FJ\x00\x02idL\x00	avatarUrlt\x00\x12Ljava/lang/String;L\x00\x0AcreateTimet\x00\x10Ljava/util/Date;L\x00\x05emailq\x00~\x00\x01L\x00\x06gendert\x00\x13Ljava/lang/Integer;L\x00\x08isDeleteq\x00~\x00\x03L\x00\x05phoneq\x00~\x00\x01L\x00\x0AplanetCodeq\x00~\x00\x01L\x00\x04tagsq\x00~\x00\x01L\x00\x0AupdateTimeq\x00~\x00\x02L\x00\x0BuserAccountq\x00~\x00\x01L\x00\x0CuserPasswordq\x00~\x00\x01L\x00\x08userRoleq\x00~\x00\x03L\x00\x0AuserStatusq\x00~\x00\x03L\x00\x08usernameq\x00~\x00\x01xp\x00\x00\x00\x00\x00\x00\x00\x01pppppppppppppt\x00\x03hwx

Redis中的序列化器

分类

keySerializer： 这个是对key的默认序列化器，默认值是JdkSerializationRedisSerializer。

valueSerializer： 这个是对value的默认序列化器，默认值JdkSerializationRedisSerializer。

hashKeySerializer： 对hash结构数据的hashkey序列化器，默认值是JdkSerializationRedisSerializer。

hashValueSerializer： 对hash结构数据的hashvalue序列化器，默认值是JdkSerializationRedisSerializer。

序列化器的区别

• StringSerializer： 是通过String.getBytes()来实现的，而且在Redis中，所有存储的值都是字符串类型的。所以这种方法保存后，通过Redis-cli控制台，是可以清楚的查看到我们保存了什么key，value是什么。

• JdkSerializationRedisSerializer： 这个序列化方法是Jdk提供的，要求要被序列化的类继承自Serializeable接口，然后通过Jdk对象序列化的方法保存，这个序列化保存的对象，即使是个String类型的，在redis控制台，也是看不出来的，因为它保存了一些对象的类型什么的额外信息。

• Jackson2JsonRedisSerializer： 这个序列化器只保留类属性的键值对信息，不包含额外的信息，因此Json占用的内存最小，但是还原时不如JdkSerializationRedisSerializer高效，JdkSerializationRedisSerializer是最高效的。

什么是序列化

序列化的定义

序列化是将对象实例的状态信息转换为二进制或文本形式以便持久存储到存储介质或通过网络传输的过程

SerialVersionUID的理解

这个SerialVersionUID是用来辅助对象的序列化与反序列化的。
原则上序列化后的数据当中的SerialVersionUID与当前类当中的SerialVersionUID一致，那么该对象才能被反序列化成功。

这个SerialVersionUID的详细的工作机制是：在序列化的时候系统将SerialVersionUID写入到序列化的文件中去，当反序列化的时候系统会先去检测文件中的SerialVersionUID是否跟当前的文件的SerialVersionUID是否一致，如果一致则反序列化成功，否则就说明当前类跟序列化后的类发生了变化，比如是成员变量的数量或者是类型发生了变化，那么在反序列化时就会发生crash，并且会报出错误。

SerialVersionUID的生成

自动生成

序列化之后，类文件增加了字段，反序列化会怎么样？
答案是: 会失败
为什么没有设置SerialVersionUID但是却发生了变化?
答案是: 正是因为没有设置，所以变化了，因为我们增加了一个字段,如果我们不设置SerialVersionUID，系统就会自动生成，自动生成有风险，就是我们的字段类型或者长度改变（新增或者删除的时候），自动生成的SerialVersionUID会发生变化，那么以前序列化出来的对象，反序列化的时候就会失败。
实测： 序列化完成之后，如果原类型字段减少，不指定SerialVersionUID的情况下，也是会报不一致的错误。

手动指定

我们可以手动设置一个 SerialVersionUID = -1
执行序列化，序列化出文件 后，增加一个字段，执行反序列化
执行结果是可以成功的，只是新增的字段是默认值null

使用序列化实现深拷贝

public class SerialTest {
    public static void main(String[] args) {
        User user = new User();
        user.setId(1L);
        user.setUsername("hwx");
        User user2= UserClone.myClone(user);
        System.out.println(user == user2);
    }

    public static class UserClone implements Serializable {
        public static User myClone(User student){
            User anotherUser = null;
            try {
                //在内存中开辟一块缓冲区，将对象序列化成流
                ByteArrayOutputStream bout = new ByteArrayOutputStream();
                ObjectOutputStream out = new ObjectOutputStream(bout);
                out.writeObject(student);

                //找到这一块缓冲区，将字节流反序列化成另一个对象
                ByteArrayInputStream bais = new ByteArrayInputStream(bout.toByteArray());
                ObjectInputStream ois = new ObjectInputStream(bais);
                anotherUser = (User) ois.readObject();
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
            return anotherUser;
        }
    }
}