AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

[原创]SpringBoot 2.x Redis缓存乱码问题/自定义SpringBoot-Cache序列化方式

2022-06-09 203
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
简介： [原创]SpringBoot 2.x Redis缓存乱码问题/自定义SpringBoot-Cache序列化方式
  • 代码

@Cacheable(cacheNames = "article",
            cacheManager = "cacheManager",
            keyGenerator = "keyGenerator",
            condition = "#id!=null && #id!=''",
            unless = "#id==1")
    @Override
    public Article byId(String id) {
        log.info("查找id为{}的文章", id);
        //调用dao层
        return articleDao.byId(id);
    }


  • 结果

image.png

  • 原因
  • 查看数据是在何时被存入缓存中。
  1. 找到缓存自动配置类CacheAutoConfiguration


image.png


image.png



找到Redis的自动配置类


image.png

缓存管理器CacheManager是缓存的抽象，RedisCacheManager是对抽象的实现


image.png

image.png


Redis缓存管理器


image.png

image.png

  • 进入RedisCacheManager类
  • 根据继承关系得知，一般通过的方法都在AbstractXXX类中

image.png


  • 进入AbstractCacheManager类


image.png

Cache类的角色与作用

image.png

debug类的调用关系可达：


image.png


进入serializeCacheValue(cacheValue)方法


image.png


cacheConfig.getValueSerializationPair()返回的是 RedisCacheConfiguration类下的SerializationPair<Object> valueSerializationPair，并且是通过构造方法注入进来的


image.png


  • 那么把这个序列化类改成我们自定的应该就可以了
  • 回到向容器中添加这个Bean的地方，可发现：


image.png


JDK的序列化方式

image.png


  1. 使用fastjson实现自定义的序列化方式-并将JDK的序列化方式改为自定义的序列化方式-需要自定义我们自己的CacheManager

package com.lazy.cache.redis;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
/**
 * @author futao
 * Created on 2019/10/24.
 */
public class FastJsonRedisSerializer4CacheManager<T> implements RedisSerializer<T> {
    private final FastJsonRedisSerializer<T> fastJsonRedisSerializer = new FastJsonRedisSerializer<>();
    @Override
    public byte[] serialize(T t) throws SerializationException {
        return fastJsonRedisSerializer.serialize(t);
    }
    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        return fastJsonRedisSerializer.deserialize(bytes);
    }
}

package com.lazy.cache.redis;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import java.nio.charset.StandardCharsets;
/**
 * 自定义Redis序列化,对于redisTemplate.opsForValue.set()有效，对注解@Cache无效，因为@Cache注解使用的是RedisTemplate<Object.Object>，
 * --可以自定义RedisCacheManager，并将redisTemplate设置成自定义的序列化工具，然后再@Cache()中使用这个自定义的RedisCacheManager
 *
 * @author futao
 * Created on 2019-03-22.
 */
public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
    /**
     * 仅仅用作识别JSON.parseObject(text,class)方法
     */
    private Class<T> clazz = null;
    protected static final SerializerFeature[] SERIALIZER_FEATURES = new SerializerFeature[]{
            SerializerFeature.PrettyFormat
            , SerializerFeature.SkipTransientField
//            , SerializerFeature.WriteEnumUsingName
//            , SerializerFeature.WriteDateUseDateFormat
            , SerializerFeature.WriteNullStringAsEmpty
            , SerializerFeature.WriteNullListAsEmpty
            , SerializerFeature.WriteMapNullValue
            // 【重点】序列化的时候必须需要带上Class类型，否则反序列化的时候无法知道Class类型
            , SerializerFeature.WriteClassName
    };
    /**
     * 序列化
     *
     * @param t 数据
     * @return
     * @throws SerializationException
     */
    @Override
    public byte[] serialize(T t) throws SerializationException {
        return t == null ? null : JSON.toJSONString(t, SERIALIZER_FEATURES).getBytes(StandardCharsets.UTF_8);
    }
    /**
     * 反序列化
     * clazz为null也可以反序列化成功是因为对象在序列化的时候保存了对象的class
     *
     * @param bytes 字节数组
     * @return
     * @throws SerializationException
     */
    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        return bytes == null ? null : JSON.parseObject(new String(bytes, StandardCharsets.UTF_8), clazz);
    }
}

package com.lazy.cache.redis;
import com.alibaba.fastjson.parser.ParserConfig;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration;
import org.springframework.boot.autoconfigure.cache.CacheManagerCustomizers;
import org.springframework.boot.autoconfigure.cache.CacheProperties;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Primary;
import org.springframework.core.annotation.Order;
import org.springframework.core.io.ResourceLoader;
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.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.util.LinkedHashSet;
import java.util.List;
/**
 * @author futao
 * Created on 2019/10/24.
 */
@Configuration
@Order
@AutoConfigureAfter({CacheAutoConfiguration.class})
@Import({CacheAutoConfiguration.class})
public class RedisConfig {
    private final CacheProperties cacheProperties;
    private final CacheManagerCustomizers customizerInvoker;
    private final RedisCacheConfiguration redisCacheConfiguration;
    public RedisConfig(CacheProperties cacheProperties,
                       CacheManagerCustomizers customizerInvoker,
                       ObjectProvider<RedisCacheConfiguration> redisCacheConfiguration) {
        this.cacheProperties = cacheProperties;
        this.customizerInvoker = customizerInvoker;
        this.redisCacheConfiguration = redisCacheConfiguration.getIfAvailable();
    }
    /**
     * 自定义序列化
     * 这里的FastJsonRedisSerializer引用的自己定义的
     * 不自定义的话redisTemplate会乱码
     */
    @Primary
    @Bean
    public <T> RedisTemplate<String, T> redisTemplate(RedisConnectionFactory factory) {
        //redis反序列化 开启fastJson反序列化的autoType
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        RedisTemplate<String, T> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        FastJsonRedisSerializer fastJsonRedisSerializer = new FastJsonRedisSerializer<T>();
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setDefaultSerializer(fastJsonRedisSerializer);
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setValueSerializer(fastJsonRedisSerializer);
        redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
        return redisTemplate;
    }
    @Primary
    @Bean
    public KeyGenerator keyGenerator() {
        return (target, method, params) -> {
            StringBuilder sb = new StringBuilder();
            sb
                    .append(target.getClass().getSimpleName())
                    .append(":")
                    .append(method.getName());
            for (Object param : params) {
                sb
                        .append(":")
                        .append(param);
            }
            return sb.toString();
        };
    }
    @Primary
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory,
                                          ResourceLoader resourceLoader) {
        RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager
                .builder(redisConnectionFactory)
                .cacheDefaults(determineConfiguration(resourceLoader.getClassLoader()));
        List<String> cacheNames = this.cacheProperties.getCacheNames();
        if (!cacheNames.isEmpty()) {
            builder.initialCacheNames(new LinkedHashSet<>(cacheNames));
        }
        return this.customizerInvoker.customize(builder.build());
    }
    /**
     * 读取redisCache配置
     *
     * @param classLoader
     * @return
     */
    private RedisCacheConfiguration determineConfiguration(
            ClassLoader classLoader) {
        if (this.redisCacheConfiguration != null) {
            return this.redisCacheConfiguration;
        }
        CacheProperties.Redis redisProperties = this.cacheProperties.getRedis();
        RedisCacheConfiguration config = RedisCacheConfiguration
                .defaultCacheConfig();
        //指定采用的序列化工具
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new FastJsonRedisSerializer4CacheManager<>()));
        if (redisProperties.getTimeToLive() != null) {
            config = config.entryTtl(redisProperties.getTimeToLive());
        }
        if (redisProperties.getKeyPrefix() != null) {
            config = config.prefixKeysWith(redisProperties.getKeyPrefix());
        }
        if (!redisProperties.isCacheNullValues()) {
            config = config.disableCachingNullValues();
        }
        if (!redisProperties.isUseKeyPrefix()) {
            config = config.disableKeyPrefix();
        }
        return config;
    }
}


  • 再debug，可发现程序已经进入了我们自定义的序列化方法


image.png

再查看缓存


image.png

  • 乱码问题解决


在项目中使用RedisTemplate<String,T>


  • 自定义序列化类

package com.lazy.cache.redis;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import java.nio.charset.StandardCharsets;
/**
 * @author futao
 * Created on 2019-03-22.
 */
public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
    /**
     * 仅仅用作识别JSON.parseObject(text,class)方法
     */
    private Class<T> clazz = null;
    protected static final SerializerFeature[] SERIALIZER_FEATURES = new SerializerFeature[]{
            SerializerFeature.PrettyFormat
            , SerializerFeature.SkipTransientField
//            , SerializerFeature.WriteEnumUsingName
//            , SerializerFeature.WriteDateUseDateFormat
            , SerializerFeature.WriteNullStringAsEmpty
            , SerializerFeature.WriteNullListAsEmpty
            , SerializerFeature.WriteMapNullValue
            // 【重点】序列化的时候必须需要带上Class类型，否则反序列化的时候无法知道Class类型
            , SerializerFeature.WriteClassName
    };
    /**
     * 序列化
     *
     * @param t 数据
     * @return
     * @throws SerializationException
     */
    @Override
    public byte[] serialize(T t) throws SerializationException {
        return t == null ? null : JSON.toJSONString(t, SERIALIZER_FEATURES).getBytes(StandardCharsets.UTF_8);
    }
    /**
     * 反序列化
     * clazz为null也可以反序列化成功是因为对象在序列化的时候保存了对象的class
     *
     * @param bytes 字节数组
     * @return
     * @throws SerializationException
     */
    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        return bytes == null ? null : JSON.parseObject(new String(bytes, StandardCharsets.UTF_8), clazz);
    }
}
  • 定义RedisTemplate<String,T>Bean

/**
     * 自定义序列化
     * 这里的FastJsonRedisSerializer引用的自己定义的
     */
    @Primary
    @Bean
    public <T> RedisTemplate<String, T> redisTemplate(RedisConnectionFactory factory) {
        //redis反序列化 开启fastJson反序列化的autoType
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        RedisTemplate<String, T> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        FastJsonRedisSerializer fastJsonRedisSerializer = new FastJsonRedisSerializer<T>();
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setDefaultSerializer(fastJsonRedisSerializer);
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setValueSerializer(fastJsonRedisSerializer);
        redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
        return redisTemplate;
    }
  • 使用

@Autowired
    private RedisTemplate<String, User> redisTemplate;


文章标签：
云数据库 Tair（兼容 Redis）
Java
容器
NoSQL
fastjson
Redis
缓存
关键词：
springboot云数据库 Tair（兼容 Redis）
云数据库 Tair（兼容 Redis）缓存
redis缓存
云数据库 Tair（兼容 Redis）Springboot
缓存redis
游客2bl3ay4hqudhe
目录
相关文章
蓝易云
|
14天前
|
NoSQL Java 网络安全
SpringBoot启动时连接Redis报错：ERR This instance has cluster support disabled - 如何解决？
通过以上步骤一般可以解决由于配置不匹配造成的连接错误。在调试问题时，一定要确保服务端和客户端的Redis配置保持同步一致。这能够确保SpringBoot应用顺利连接到正确配置的Redis服务，无论是单机模式还是集群模式。
蓝易云
104 5
aliyun9170107523-43660
|
1月前
|
缓存 负载均衡 监控
135_负载均衡：Redis缓存 - 提高缓存命中率的配置与最佳实践
在现代大型语言模型（LLM）部署架构中，缓存系统扮演着至关重要的角色。随着LLM应用规模的不断扩大和用户需求的持续增长，如何构建高效、可靠的缓存架构成为系统性能优化的核心挑战。Redis作为业界领先的内存数据库，因其高性能、丰富的数据结构和灵活的配置选项，已成为LLM部署中首选的缓存解决方案。
aliyun9170107523-43660
246 25
varin
|
2月前
|
存储 缓存 NoSQL
Redis专题-实战篇二-商户查询缓存
本文介绍了缓存的基本概念、应用场景及实现方式，涵盖Redis缓存设计、缓存更新策略、缓存穿透问题及其解决方案。重点讲解了缓存空对象与布隆过滤器的使用，并通过代码示例演示了商铺查询的缓存优化实践。
varin
147 1
Redis专题-实战篇二-商户查询缓存
蒋星熠Jaxonic
|
1月前
|
缓存 运维 监控
Redis 7.0 高性能缓存架构设计与优化
🌟蒋星熠Jaxonic，技术宇宙中的星际旅人。深耕Redis 7.0高性能缓存架构，探索函数化编程、多层缓存、集群优化与分片消息系统，用代码在二进制星河中谱写极客诗篇。
蒋星熠Jaxonic
164 3
游客y6nbucfgpbrn4
|
2月前
|
缓存 NoSQL 关系型数据库
Redis缓存和分布式锁
Redis 是一种高性能的键值存储系统，广泛用于缓存、消息队列和内存数据库。其典型应用包括缓解关系型数据库压力，通过缓存热点数据提高查询效率，支持高并发访问。此外，Redis 还可用于实现分布式锁，解决分布式系统中的资源竞争问题。文章还探讨了缓存的更新策略、缓存穿透与雪崩的解决方案，以及 Redlock 算法等关键技术。
游客y6nbucfgpbrn4
75 0
计算机程序设计Y2013070224
|
27天前
|
JavaScript Java 关系型数据库
基于springboot的项目管理系统
本文探讨项目管理系统在现代企业中的应用与实现，分析其研究背景、意义及现状，阐述基于SSM、Java、MySQL和Vue等技术构建系统的关键方法，展现其在提升管理效率、协同水平与风险管控方面的价值。
计算机程序设计Y2013070224
162 43
计算机程序设计Y2013070224
|
29天前
|
搜索推荐 JavaScript Java
基于springboot的儿童家长教育能力提升学习系统
本系统聚焦儿童家长教育能力提升，针对家庭教育中理念混乱、时间不足、个性化服务缺失等问题，构建科学、系统、个性化的在线学习平台。融合Spring Boot、Vue等先进技术，整合优质教育资源，提供高效便捷的学习路径，助力家长掌握科学育儿方法，促进儿童全面健康发展，推动家庭和谐与社会进步。
计算机程序设计Y2013070224
107 5
计算机程序设计Y2013070224
|
29天前
|
JavaScript Java 关系型数据库
基于springboot的古树名木保护管理系统
本研究针对古树保护面临的严峻挑战，构建基于Java、Vue、MySQL与Spring Boot技术的信息化管理系统，实现古树资源的动态监测、数据管理与科学保护，推动生态、文化与经济可持续发展。
计算机程序设计Y2013070224
79 4
计算机程序设计Y2013070224
|
20天前
|
监控 安全 JavaScript
2025基于springboot的校车预定全流程管理系统
针对传统校车管理效率低、信息不透明等问题，本研究设计并实现了一套校车预定全流程管理系统。系统采用Spring Boot、Java、Vue和MySQL等技术，实现校车信息管理、在线预定、实时监控等功能，提升学校管理效率，保障学生出行安全，推动教育信息化发展。
计算机程序设计Y2013070224
110 0

热门文章

最新文章

  • 1
    vLLM 性能优化实战：批处理、量化与缓存配置方案
  • 2
    MySQL 与 Redis 如何保证双写一致性？
  • 3
    Redis 服务器全方位介绍：从入门到核心原理
  • 4
    Spring Boot 拦截器（Interceptor）详解
  • 5
    【Spring Boot实战】EasyPoi神技：一篇搞定“一对多+图片”导入！
  • 6
    《深入理解Spring》 Spring Boot——约定优于配置的革命者
  • 7
    一文搞懂 Spring Boot 自动配置原理
  • 8
    Spring Boot 过滤器（Filter）详解
  • 9
    《深入理解Spring》：Spring、Spring MVC与Spring Boot的深度解析
  • 10
    基于springboot的项目管理系统
  • 1
    【Java】（10）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
    99
  • 2
    【Java基础】（1）进程与线程的关系、Tread类；讲解基本线程安全、网络编程内容；JSON序列化与反序列化
    104
  • 3
    配置RedisTemplate序列化机制
    152
  • 4
    从JSON到Protobuf，深入序列化方案的选型与原理
    229
  • 5
    RedisTemplate序列化问题排查与优化建议。
    149
  • 6
    深入理解Java序列化接口及其实现机制
    160
  • 7
    在Golang中序列化JSON字符串的教程
    183
  • 8
    说一说关于序列化/反序列化中的细节问题
    76
  • 9
    Java 序列化和反序列化为什么要实现 Serializable 接口
    117
  • 10
    说一说序列化与反序列化中存在的问题
    147

    • 相关课程

    更多
  • 大数据实战项目：反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第三阶段
  • 大数据实战项目：反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第四阶段
  • 大数据实战项目 - 反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第六阶段
  • Redis入门实战演练
  • 云数据库 Redis 版使用教程
  • Redis数据库入门

    • 相关电子书

    更多
  • 基于英特尔 SSD 的虚拟机缓存解决SSD
  • 用户态高速块缓存方案
  • 高性能Web架构之缓存体系
    • 下一篇
    阿里云对象存储OSS收费标准：500G存储118元1年、