一键解决redis序列化问题

灰太狼 2023-03-02 07:43 66阅读 0赞

# 一、spring boot 集成Redis方法 #

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

# 二、Redis自定义序列化 #

这里不加缓存的话注释代码用不上

package com.guoleyuan.config.redisconfig;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.JsonTypeInfo;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
    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.connection.RedisConnectionFactory;
    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.StringRedisSerializer;
    
    import javax.annotation.Resource;
    import java.lang.reflect.Method;
    import java.time.Duration;
    
    @Configuration
    //@EnableCaching
    public class RedisConfig /*extends CachingConfigurerSupport*/ { 
       /* @Resource private LettuceConnectionFactory lettuceConnectionFactory; Duration exps = Duration.ofSeconds(30); /** * 是默认生成主键的方式(key值)结合缓存注解使用 */
    
       /* @Bean public KeyGenerator keyGenerator() { return new KeyGenerator() { @Override public Object generate(Object target, Method method, Object... params) { StringBuffer sb = new StringBuffer(); sb.append(target.getClass().getName()); sb.append(method.getName()); for (Object obj : params) { sb.append(obj.toString()); } return sb.toString(); } }; } */
    
        /** * 缓存管理器，结合缓存注解时使用 */
    /* public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) { // 配置 RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig(); // 设置缓存的默认过期时间 config.entryTtl(exps); // 不缓存空值 config.disableCachingNullValues(); RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(config).build(); return cacheManager; } */
    
        /** * RedisTemplate配置 */
        @Bean
        public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) { 
            // 配置redisTemplate
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
            redisTemplate.setConnectionFactory(lettuceConnectionFactory);
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                    ObjectMapper.DefaultTyping.NON_FINAL,
                    JsonTypeInfo.As.WRAPPER_ARRAY);
            jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
            // 设置值（value）的序列化采用Jackson2JsonRedisSerializer 。
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
            // 设置键（key）的序列化采用StringRedisSerializer。
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    }

# 三、redis使用的工具类 #

@Component
    public class RedisUtils { 
        @Resource
        private RedisTemplate<String, Object> redisTemplate;
    
        public RedisUtils(RedisTemplate redisTemplate) { 
            this.redisTemplate = redisTemplate;
        }
    
        public void set(String key, Object value) { 
            ValueOperations valueOperations = redisTemplate.opsForValue();
            valueOperations.set(key, value);
    
            //BoundValueOperations的理解对保存的值做一些细微的操作
    // BoundValueOperations boundValueOperations = redisTemplate.boundValueOps(key);
        }
    
        public Object get(String key) { 
            return redisTemplate.opsForValue().get(key);
        }
    
        public void setList(String key, List<?> value) { 
            //Operation 操作。
            ListOperations listOperations = redisTemplate.opsForList();
            listOperations.rightPushAll(key, value);//存值按顺序，从right端存，left会缺失值下标为0的"1"
        }
    
        public Object getList(String key) { 
            return redisTemplate.opsForList().range(key,0,-1);
            //return redisTemplate.opsForList().leftPop(key);//取值不用出栈方式
        }
    
        public void setSet(String key, Set<?> value) { 
            SetOperations setOperations = redisTemplate.opsForSet();
            setOperations.add(key, value);
        }
    
        public Object getSet(String key) { 
            return redisTemplate.opsForSet().members(key);
        }
    
    
        public void setHash(String key, Map<String, ?> value) { 
            HashOperations hashOperations = redisTemplate.opsForHash();
            hashOperations.putAll(key, value);
        }
    
        public Object getHash(String key) { 
            return redisTemplate.opsForHash().entries(key);
        }
    
    
        public void delete(String key) { 
            redisTemplate.delete(key);
        }
    
        public void clearAll() { 
            Set<String> keys = redisTemplate.keys("*");
            redisTemplate.delete(keys);
        }

# 四、几种序列化对比 #

针对StringRedisSerializer，Jackson2JsonRedisSerializer和JdkSerializationRedisSerializer进行测试。

下面是，把3种Serializer保存到Redis中的结果：

1,所有的KeySerializer和HashKeySerializer都使用StringRedisSerializer，用其它Serializer的没有什么意义，就像最上面的例子一样。  
2,上面序列化后的值，是保存到redis中的值，从Redis中读取回Java中后，值的内容都是一样的。  
默认序列化(默认采用的是JDK序列化)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MTQyNTYx_size_16_color_FFFFFF_t_70]  
从上面的结果不难看出，

1，用StringRedisSerializer进行序列化的值，在Java和Redis中保存的内容是一样的

2，用Jackson2JsonRedisSerializer进行序列化的值，在Redis中保存的内容，比Java中多了一对双引号。

3，用JdkSerializationRedisSerializer进行序列化的值，对于Key-Value的Value来说，是在Redis中是不可读的。对于Hash的Value来说，比Java的内容多了一些字符。  
（如果Key的Serializer也用和Value相同的Serializer的话，在Redis中保存的内容和上面Value的差异是一样的，所以我们保存时，只用StringRedisSerializer进行序列化）

# 五、出现问题 #

出现“**存储Integer类型数据，自动序列化（加双引号），存储String类型，序列化失败（没有双引号）**”的原因是：

我在设置自定义序列化的时候，为Bean起了个名称叫：“StringRedisTemplate”,这个名称和StringRedisTemplate重名了，spring注入的时候，注入的是StringRedisTemplate，不是我更改过序列化方式后的RedisTemplate对象，就会使用默认序列化。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MTQyNTYx_size_16_color_FFFFFF_t_70]: /images/20230208/9e2fe81f89b24cc08c3544c54f2cb2dc.png