SpringBoot2整合redis三种序列化方式（Jdk,Jackson,FastJson）

最新推荐文章于 2025-04-09 22:31:34 发布
最新推荐文章于 2025-04-09 22:31:34 发布
阅读量882 收藏 1
点赞数
分类专栏： redis 文章标签： redis java 缓存 spring boot
原文链接：https://blog.youkuaiyun.com/u014212540/article/details/118611381
版权

第一种方式： JdkSerializationRedisSerializer

package com.ruoyi.framework.config;

import com.alibaba.fastjson.JSON;
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.apache.commons.codec.digest.DigestUtils;
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.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;
import java.time.Duration;

/**
 * redis配置
 *
 * @author ruoyi
 */
@Configuration
@EnableCaching
public class RedisConfig2 extends CachingConfigurerSupport {
    @Bean
    @SuppressWarnings(value = {"unchecked", "rawtypes"})
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer();
        template.setValueSerializer(jdkSerializer);
        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        // 缓存30分钟
        Duration duration = Duration.ofSeconds(30);
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().entryTtl(duration);
        return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory))
                .cacheDefaults(redisCacheConfiguration).build();
    }

    @Override
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... objects) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                sb.append("&");
                for (Object obj : objects) {
                    sb.append(obj.getClass().getName());
                    sb.append("&");
                    sb.append(JSON.toJSONString(obj));
                    sb.append("&");
                }
                return DigestUtils.sha256Hex(sb.toString());
            }
        };
    }
}

第二种方式：Jackson2JsonRedisSerializer

package com.ruoyi.framework.config;

import com.alibaba.fastjson.JSON;
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.PolymorphicTypeValidator;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.apache.commons.codec.digest.DigestUtils;
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.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;
import java.time.Duration;

/**
 * redis配置
 *
 * @author ruoyi
 */
@Configuration
@EnableCaching
public class RedisConfig3 extends CachingConfigurerSupport {
    @Bean
    @SuppressWarnings(value = {"unchecked", "rawtypes"})
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
         // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        template.setValueSerializer(jackson2JsonRedisSerializer);
        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        // 缓存30分钟
        Duration duration = Duration.ofSeconds(30);
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().entryTtl(duration);
        return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory))
                .cacheDefaults(redisCacheConfiguration).build();
    }

    @Override
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... objects) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                sb.append("&");
                for (Object obj : objects) {
                    sb.append(obj.getClass().getName());
                    sb.append("&");
                    sb.append(JSON.toJSONString(obj));
                    sb.append("&");
                }
                return DigestUtils.sha256Hex(sb.toString());
            }
        };
    }
}

第三种方式：FastJson2JsonRedisSerializer

package com.ruoyi.framework.config;

import com.alibaba.fastjson.JSON;
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.apache.commons.codec.digest.DigestUtils;
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.cache.interceptor.SimpleKeyGenerator;
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.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;
import java.time.Duration;

/**
 * redis配置
 *
 * @author ruoyi
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    @SuppressWarnings(value = {"unchecked", "rawtypes"})
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        serializer.setObjectMapper(mapper);

        template.setValueSerializer(serializer);
        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        // 缓存30分钟
        Duration duration = Duration.ofSeconds(30);
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().entryTtl(duration);
        return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory))
                .cacheDefaults(redisCacheConfiguration).build();
    }

    @Override
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... objects) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                sb.append("&");
                for (Object obj : objects) {
                    sb.append(obj.getClass().getName());
                    sb.append("&");
                    sb.append(JSON.toJSONString(obj));
                    sb.append("&");
                }
                return DigestUtils.sha256Hex(sb.toString());
            }
        };
    }
}

转载自https://blog.youkuaiyun.com/u014212540/article/details/118611381

SpringBoot + jackson + redis 序列化、反序列化 配置正确姿势
u014212540的博客
02-04 5870
SpringBoot + jackson + redis 序列化、反序列化 配置正确姿势
03. SpringBoot 整合 Redis
kezhou的博客
05-22 981
Jedis：底层采用直连的方式，如果多个线程操作，不安全。更像 BIO 模式！Lettuce：采用 netty，实例可以在多个线程中共享，不存在不安全的情况！可以减少线程数，性能高，更像 NIO 模式！SpringBoot 所有的配置类，都有一个自动配置类，RedisAutoConfiguration；默认的 RedisTemplate 没有过多的设置，redis 保存的对象都是需要序列化的！SpringBoot 操作数据：Spring Data jpa jdbc redis。
SpringBoot2整合redis 三种序列化方式（Jdk,Jackson,FastJson）
u014212540的博客
07-09 3339
SpringBoot2整合redis 三种序列化方式（Jdk,Jackson,FastJson） import com.alibaba.fastjson.JSON; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.JsonTypeInfo; import com.fasterxml.jackson.annotat
SpringBoot Redis序列化 FastJson2Json自定义序列化
最新发布
生产队的驴
04-09 312
【代码】SpringBoot Redis序列化 FastJson2Json自定义序列化。
SpringBoot整合Redis实现几种自定义数据序列化存储方式
懒羊羊的博客
12-24 2782
SpringBoot整合Redis自定义序列化方式
springboot-redis使用fastjson2
u013947963的博客
07-27 1881
springboot-redis+fastjson2
springboot+Redis+jackson
Rabir-YellowDavid的博客
08-19 348
1、修改application.properties中redis主机+端口号 spring.redis.host=192.168.91.100 spring.redis.port=6379 2、在springboob启动类上面加上注解，开启缓存注解 @EnableCaching 3、springboot默认的序列化方式是jdk，添加配置使用jackson方式序列化 import org.springframework.boot.autoconfigure.cache.CacheProperties; i
springboot 使用spring cache缓存 和 使用fastjson配置redis系列化
09-13
在本篇文档中，我们将探讨如何使用Spring Cache来缓存数据，并结合Fastjson配置Redis序列化，确保数据正确存储和读取。 首先，我们需要在`pom.xml`中添加必要的依赖。Spring Boot的`spring-boot-starter-cache`模块...
Springboot2.0整合Redis时的序列化与反序列化
还叫康师傅吧
09-14 2417
首先说一下环境： springboot：2.1.7 redis：5.0.5 在默认的情况下，两者整合后便可将数据缓存到redis，但是缓存进去的对象类型数据是经过jdk默认序列化过后的，在可视化工具中是HEX格式，看起来非常不方便，所以需要进行格式化 首先创建FastJsonRedisSerializer类实现RedisSerializer接口 public class FastJsonRe...
记录一次SpringBoot 2.x Redis 序列化Integer类型不起作用
qq_31445987的博客
08-31 1940
在一次往Redis缓存中插入一个 Map&amp;lt;Integer, ActivityCacheModel&amp;gt;， public void setDisplayActivityMap(Map&amp;lt;Integer, ActivityCacheModel&amp;gt; displayActivityMap) { redisMapTemplate.opsForValue().set(DI...
【SpringBoot整合Redis篇】 ---- RedisTemplate自定义序列化
TheWhc
11-07 877
对RedisTemplate和StringRedisTemplate进行了分析,最后自定义Redis序列化工具类
【Spring Boot 3 + fastjson2】更改RedisTemplate的序列化策略
还没入门Java的博客
10-09 4627
pom依赖</</</</</</</</</</</</</</</</</</</</</</</</
fastjson2 作为redis 序列化 反序列化
weixin_36040584的博客
08-25 291
我整理的一些关于【JSON】的项目学习资料（附讲解～～）和大家一起分享、学习一下：https://d.51cto.com/Hpqqk2使用 Fastjson2 进行 Redis 序列化与反序列化 在现代应用程序开发中，数据的持久化和传输是一个重要课题。Redis 作为一种高性能的内存数据库，广泛应用于缓存、消息队列和实时...
SpringBoot+Redis缓存新老版本FastJson序列化使用方法（redis配置无效问题）
HumorChen的博客
11-08 1763
FastJson序列化器 实现RedisSerializer /** * @Author:humorchen * @Date 2020/11/8 13:32 */ @Component public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> { public static final Charset DEFAULT_CHARSET = Charset.forName("UT
SpringBoot中配置redis的序列化方式(使用jackson序列化方式)
编程学习者的博客
04-12 6917
1.声明 当前内容用于本人复习和使用redis,主要用于配置redis的值的序列化方式jackson 这里借助spring 2.配置pom文件 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifa...
redisson 使用fastJson2序列化
qq_41369135的博客
05-21 1002
前因：一个项目：有人用redisTemplete存数据（使用了fastjson2），使用redisson取的时候就会报错。要让redisTemplete与redisson序列化一致。二、redsson 配置里添加自定义序列化器（RedissonConfiguration）
Springboot2整合Redis以及jackson序列化
zaincs的博客
11-23 2554
pom.xml &lt;!--redis--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId&gt; &lt;/dependency&gt;
Redis使用Fastjson2序列化方案(解决AutoType问题)
qeqw787的博客
07-20 4923
因为fastjson升级到2后，AutoType默认是关闭的，需要添加类名到拦截器才可以正常转换类型，但是我们使用Fastjson2作为Redis的序列化工具时非常不方便！
SpringBoot Redis使用fastjson进行序列化
大树叶 技术专栏
07-27 2977
在使用spring-data-redis,默认情况下是使用org.springframework.data.redis.serializer.JdkSerializationRedisSerializer这个类来做序列化,Jackson redis序列化是spring中自带的.我们使用jackson方式 @Bean(name="redisTemplate") public RedisTemplate<String, Object> redisTemplate() {
springboot的redis序列化和反序列化
05-26
Spring Boot提供了多种Redis序列化方式，包括JDK序列化、JSON序列化、FastJSON序列化、Jackson序列化、Protobuf序列化等。其中，JDK序列化是默认的序列化方式。 JDK序列化： JDK序列化是Java自带的序列化方式，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值