springboot2.0 序列化方式详解, @Cacheable乱码，以及GenericToStringSerializer VS Jackson2JsonRedisSerializer

╰+哭是因爲堅強的太久メ 2023-06-08 06:29 7阅读 0赞

最近研究(GenericToStringSerializer VS Jackson2JsonRedisSerializer)的对比，网上查了查资料，这里记录一下，有一些修改。

# 前言 #

**sprintboot 1.x.x的版本时默认使用的jedis客户端, 现在是sprintboot  2.x.x版本默认使用的lettuce客户端，两种客户端的区别如下:**  
        Jedis和Lettuce都是Redis Client,Jedis 是直连模式，在多个线程间共享一个 Jedis 实例时是线程不安全的，如果想要在多线程环境下使用 Jedis，需要使用连接池，每个线程都去拿自己的 Jedis 实例，当连接数量增多时，物理连接成本就较高了。

Lettuce的连接是基于Netty的，连接实例可以在多个线程间共享，所以，一个多线程的应用可以使用同一个连接实例，而不用担心并发线程的数量当然这个也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。通过异步的方式可以让我们更好的利用系统资源，而不用浪费线程等待网络或磁盘I/O。 Lettuce 是基于 netty 的，netty 是一个多线程、事件驱动的 I/O 框架，所以 Lettuce 可以帮助我们充分利用异步的优势。

## 一、redisTemplate和stringRedisTemplate对比 ##

RedisTemplate看这个类的名字后缀是Template，如果了解过Spring如何连接关系型数据库的，大概不会难猜出这个类是做什么的 ，它跟JdbcTemplate一样封装了对Redis的一些常用的操作，当然StringRedisTemplate跟RedisTemplate功能类似那么肯定就会有人问，为什么会需要两个Template呢，一个不就够了吗？其实他们两者之间的区别主要在于他们使用的序列化类。

RedisTemplate使用的是 JdkSerializationRedisSerializer 序列化对象
    StringRedisTemplate使用的是 StringRedisSerializer 序列化String

### 1、StringRedisTemplate ###

*  主要用来存储字符串，StringRedisSerializer的泛型指定的是String。当存入对象时，会报错 ：can not cast into String。
 *  可见性强，更易维护。如果过都是字符串存储可考虑用StringRedisTemplate。

![format_png][]

### 2、RedisTemplate ###

*  可以用来存储对象，但是要实现Serializable接口。
 *  以二进制数组方式存储，内容没有可读性。

![format_png 1][]

## 二、redisTemplate序列化方式比较 ##

那有没有办法，可以序列化对象，可读性又强呢？

*  1、手动转化成json串再存储。取出数据需要反序列化。
 *  2、使用其他序列化方式。

spring-data-redis提供如下几种选择：

*  GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化
 *  Jackson2JsonRedisSerializer: 跟JacksonJsonRedisSerializer实际上是一样的
 *  JacksonJsonRedisSerializer: 序列化object对象为json字符串
 *  JdkSerializationRedisSerializer: 序列化java对象
 *  StringRedisSerializer: 简单的字符串序列化

### 1、性能测试对比 ###

@Test
        public void testSerial(){
            UserPO userPO = new UserPO(1111L,"小明_testRedis1",25);
            List<Object> list = new ArrayList<>();
            for(int i=0;i<200;i++){
                list.add(userPO);
            }
            JdkSerializationRedisSerializer j = new JdkSerializationRedisSerializer();
            GenericJackson2JsonRedisSerializer g = new GenericJackson2JsonRedisSerializer();
            Jackson2JsonRedisSerializer j2 = new Jackson2JsonRedisSerializer(List.class);
    
    
            Long j_s_start = System.currentTimeMillis();
            byte[] bytesJ = j.serialize(list);
            System.out.println("JdkSerializationRedisSerializer序列化时间："+(System.currentTimeMillis()-j_s_start) + "ms,序列化后的长度：" + bytesJ.length);
            Long j_d_start = System.currentTimeMillis();
            j.deserialize(bytesJ);
            System.out.println("JdkSerializationRedisSerializer反序列化时间："+(System.currentTimeMillis()-j_d_start));
    
    
            Long g_s_start = System.currentTimeMillis();
            byte[] bytesG = g.serialize(list);
            System.out.println("GenericJackson2JsonRedisSerializer序列化时间："+(System.currentTimeMillis()-g_s_start) + "ms,序列化后的长度：" + bytesG.length);
            Long g_d_start = System.currentTimeMillis();
            g.deserialize(bytesG);
            System.out.println("GenericJackson2JsonRedisSerializer反序列化时间："+(System.currentTimeMillis()-g_d_start));
    
            Long j2_s_start = System.currentTimeMillis();
            byte[] bytesJ2 = j2.serialize(list);
            System.out.println("Jackson2JsonRedisSerializer序列化时间："+(System.currentTimeMillis()-j2_s_start) + "ms,序列化后的长度：" + bytesJ2.length);
            Long j2_d_start = System.currentTimeMillis();
            j2.deserialize(bytesJ2);
            System.out.println("Jackson2JsonRedisSerializer反序列化时间："+(System.currentTimeMillis()-j2_d_start));
        }

结果：

JdkSerializationRedisSerializer序列化时间：8ms,序列化后的长度：1325  
JdkSerializationRedisSerializer反序列化时间：4  
GenericJackson2JsonRedisSerializer序列化时间：52ms,序列化后的长度：17425  
GenericJackson2JsonRedisSerializer反序列化时间：60  
Jackson2JsonRedisSerializer序列化时间：4ms,序列化后的长度：9801  
Jackson2JsonRedisSerializer反序列化时间：4

### 2、性能总结 ###

*  **JdkSerializationRedisSerializer序列化后长度最小，Jackson2JsonRedisSerializer效率最高**。
 *  **如果综合考虑效率和可读性，牺牲部分空间，推荐key使用StringRedisSerializer，保持的key简明易读；value可以使用Jackson2JsonRedisSerializer**
 *  如果空间比较敏感，效率要求不高，推荐key使用StringRedisSerializer，保持的key简明易读；value可以使用JdkSerializationRedisSerializer

### 3、方案一、考虑效率和可读性，牺牲部分空间 ###

package com.example.demo.config.redisConfig;
    
    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;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    @Configuration
    public class RedisConfig {
        @Bean(name = "redisTemplate")
        public RedisTemplate<String, Object> getRedisTemplate(RedisConnectionFactory factory) {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
            redisTemplate.setConnectionFactory(factory);
            redisTemplate.setKeySerializer(new StringRedisSerializer()); // key的序列化类型
    
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    
            jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value的序列化类型
            return redisTemplate;
        }
    }

**注： new Jackson2JsonRedisSerializer(Object.class)需要指明类型，例如：new Jackson2JsonRedisSerializer(User.class)，否则会报错**：

java.lang.ClassCastException: java.util.LinkedHashMap cannot be cast to com.example.demo.bean.User。

或者开启默认类型：

ObjectMapper objectMapper = new ObjectMapper();
     objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
     objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
     jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

这种方式存储时会自动带上类的全路径，占用部分空间：

![format_png 2][]

**另外，使用GenericJackson2JsonRedisSerializer序列化后的数据形式：**

![70][]

### 4、方案二、空间敏感，忽略可读性和效率影响 ###

@Configuration
    public class RedisConfig {
        @Bean(name = "redisTemplate")
        public RedisTemplate<String, Object> getRedisTemplate(RedisConnectionFactory factory) {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
            redisTemplate.setConnectionFactory(factory);
            redisTemplate.setKeySerializer(new StringRedisSerializer()); // key的序列化类型
            redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer()); // value的序列化类型
            return redisTemplate;
        }
    }

注：该方式，对象需要实现接口：Serializable

### 5、使用示例 ###

@RunWith(SpringRunner.class)
    @SpringBootTest
    @WebAppConfiguration
    public class RedisTest {
        @Resource
        private RedisTemplate redisTemplate;
    
        @Test
        public void testRedis1(){
            User user = new User();
            user.setAge(11);
            user.setName("我是小王1");
            redisTemplate.opsForValue().set("user37",user);
            System.out.println(redisTemplate.getValueSerializer());
            System.out.println(redisTemplate.getKeySerializer());
            User result = (User) redisTemplate.opsForValue().get("user37");
            System.out.println(result);
        }
    }

# 6 设置规则 #

代码参考：

package com.johnfnash.learn.redis.config;
    
    import java.lang.reflect.Method;
    import java.time.Duration;
    import java.util.HashMap;
    import java.util.Map;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.cache.interceptor.KeyGenerator;
    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.connection.RedisStandaloneConfiguration;
    import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    @Configuration
    @EnableCaching // Enables Spring's annotation-driven cache management capability
    public class RedisConfig extends CachingConfigurerSupport {
        @Value("${spring.redis.host}")
        private String hostName;
    
        @Value("${spring.redis.port}")
        private int port;
    
        @Value("${spring.cache.redis.time-to-live.seconds}")
        private int entryTTL;
    
        @Bean
        public LettuceConnectionFactory redisConnectionFactory() {
            RedisStandaloneConfiguration config = new RedisStandaloneConfiguration(hostName, port);
            return new LettuceConnectionFactory(config);
        }
    
        @Bean
        @Override
        public KeyGenerator keyGenerator() {
            return new KeyGenerator() {
                // 当没有指定缓存的 key时来根据类名、方法名和方法参数来生成key
                @Override
                public Object generate(Object target, Method method, Object... params) {
                    StringBuilder sb = new StringBuilder();
                    sb.append(target.getClass().getName());
                    sb.append('.').append(method.getName());
                    if(params.length > 0) {
                        sb.append('[');
                        for (Object obj : params) {
                            sb.append(obj.toString());
                        }
                        sb.append(']');
                    }
                    System.out.println("keyGenerator=" + sb.toString());
                    return sb.toString();
                }
            };
        }
    
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
            return new RedisCacheManager(
                     RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory),
                     this.getRedisCacheConfigurationWithTtl(entryTTL),  // 默认策略，未配置的 key 会使用这个
                     this.getRedisCacheConfigurationMap()               // 指定 key 策略
                );
        }
    
        private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
            Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<String, RedisCacheConfiguration>();
            redisCacheConfigurationMap.put("user", this.getRedisCacheConfigurationWithTtl(30)); // 单独设置某些cache的超时时间
            return redisCacheConfigurationMap;
        }
    
        private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
            // 设置CacheManager的值序列化方式为JdkSerializationRedisSerializer,
            // 但其实RedisCacheConfiguration默认就是使用StringRedisSerializer序列化key，
            // JdkSerializationRedisSerializer序列化value,所以以下注释代码为默认实现
            // ClassLoader loader = this.getClass().getClassLoader();
            // JdkSerializationRedisSerializer jdkSerializer = new
            // JdkSerializationRedisSerializer(loader);
            // RedisSerializationContext.SerializationPair<Object> pair =
            // RedisSerializationContext.SerializationPair.fromSerializer(jdkSerializer);
            // RedisCacheConfiguration defaultCacheConfig =
            // RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);
            // RedisCacheConfiguration defaultCacheConfig =
            // RedisCacheConfiguration.defaultCacheConfig();
    
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(
                    Object.class);
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(om);
    
            RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
            redisCacheConfiguration = redisCacheConfiguration
                    .serializeValuesWith(
                            RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                    .entryTtl(Duration.ofSeconds(seconds));
    
            return redisCacheConfiguration;
        }
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
            RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
            template.setConnectionFactory(factory);
    
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
                    Object.class);
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(om);
            template.setValueSerializer(jackson2JsonRedisSerializer);
    
            template.setKeySerializer(new StringRedisSerializer());
            template.setHashKeySerializer(new StringRedisSerializer());
            template.afterPropertiesSet();
            return template;
        }
    
    }

从上面看到，有两个地方设置了Jackson2JsonRedisSerializer，一个是在RedisCacheConfiguration getRedisCacheConfigurationWithTtl()函数，一个是在RedisTemplate<String, Object> redisTemplate()函数，为什么呢？

**因为：**

1.  **RedisCacheConfiguration 里设置是为了在spring cache的注解使用的序列化规则设置。**
2.  **redisTemplate里设置是为了直接使用redisTemplate时，使用序列化规则。**

[https://www.cnblogs.com/asker009/p/9813932.html][https_www.cnblogs.com_asker009_p_9813932.html]

[https://blog.csdn.net/u013435893/article/details/81128893][https_blog.csdn.net_u013435893_article_details_81128893]

# 参考： #

[https://www.cnblogs.com/wangzhuxing/p/10198347.html][https_www.cnblogs.com_wangzhuxing_p_10198347.html]

[https://andersonfeng.github.io/2018/09/28/Spring-Boot-RedisTemplate-Reviews/][https_andersonfeng.github.io_2018_09_28_Spring-Boot-RedisTemplate-Reviews]

[https://blog.csdn.net/johnf\_nash/article/details/87526631][https_blog.csdn.net_johnf_nash_article_details_87526631]

[https://blog.csdn.net/zyt807/article/details/82428615][https_blog.csdn.net_zyt807_article_details_82428615]

[http://itmanclub.com/blog/article/604][http_itmanclub.com_blog_article_604]

[format_png]: /images/20230531/5ceb290d2ba74ed3b75131cd31a3c29a.png
[format_png 1]: /images/20230531/f6a404a0ff2b4162832762ac50c85d02.png
[format_png 2]: /images/20230531/5569877b70a74514ad107e0ec788ecd5.png
[70]: /images/20230531/a972641bf791417690eda0a5378a1561.png
[https_www.cnblogs.com_asker009_p_9813932.html]: https://www.cnblogs.com/asker009/p/9813932.html
[https_blog.csdn.net_u013435893_article_details_81128893]: https://blog.csdn.net/u013435893/article/details/81128893
[https_www.cnblogs.com_wangzhuxing_p_10198347.html]: https://www.cnblogs.com/wangzhuxing/p/10198347.html
[https_andersonfeng.github.io_2018_09_28_Spring-Boot-RedisTemplate-Reviews]: https://andersonfeng.github.io/2018/09/28/Spring-Boot-RedisTemplate-Reviews/
[https_blog.csdn.net_johnf_nash_article_details_87526631]: https://blog.csdn.net/johnf_nash/article/details/87526631
[https_blog.csdn.net_zyt807_article_details_82428615]: https://blog.csdn.net/zyt807/article/details/82428615
[http_itmanclub.com_blog_article_604]: http://itmanclub.com/blog/article/604