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

最新推荐文章于 2024-08-02 16:12:15 发布
最新推荐文章于 2024-08-02 16:12:15 发布
阅读量832 收藏 1
点赞数
分类专栏： redis 文章标签： redis java 缓存 spring boot
原文链接：https://blog.csdn.net/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.csdn.net/u014212540/article/details/118611381

~日句水+3木@
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot 使用spring cache缓存 和 使用fastjson配置redis系列化
09-13
在本篇文档中，我们将探讨如何使用Spring Cache来缓存数据，并结合Fastjson配置Redis序列化，确保数据正确存储和读取。 首先，我们需要在`pom.xml`中添加必要的依赖。Spring Boot的`spring-boot-starter-cache`模块...
JedisSerialization:实现利用Jedis向Redis中写入和得到Java对象的几种序列化工具：JDK、XML、JSON、Protostuff
05-15
本文主要探讨四种常见的序列化工具——JDK自带的序列化、XML序列化、JSON序列化以及Protostuff，以及如何结合Jedis库来实现这些操作。 1. JDK序列化 JDK提供了一种内置的序列化机制，通过实现`Serializable`接口使...
SpringBoot2整合redis 三种序列化方式（Jdk,Jackson,FastJson）
u014212540的博客
07-09 3108
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
FastJson2JsonRedisSerializer JSONReader
weixin_28752415的博客
07-03 49
FastJson2JsonRedisSerializer JSONReader 科普 在Java开发中，我们经常会遇到需要将对象序列化为JSON字符串或者将JSON字符串反序列化为对象的情况。而FastJson2JsonRedisSerializer JSONReader是一个用于将对象序列化和反序列化的工具类，它结合了F...
Springboot+redis序列化方式到底怎么选+redis配置类+redis工具类
鸢尾_的博客
09-06 814
Springboot+redis序列化方式到底怎么选+redis配置类+redis工具类
Springboot2.0整合Redis时的序列化与反序列化
响当当的名字
02-29 1395
首先说一下环境： springboot：2.1.7 redis：5.0.5 在默认的情况下，两者整合后便可将数据缓存到redis，但是缓存进去的对象类型数据是经过jdk默认序列化过后的，在可视化工具中是HEX格式，看起来非常不方便，所以需要进行格式化 首先创建FastJsonRedisSerializer类实现RedisSerializer接口 public class FastJsonRe...
SpringBoot2整合Redis从入门到进阶
冷兮Coding
05-03 1765
首先需要安装Redis，如何安装可以看我的这篇文章 接下来说明如何使用，以及一些Redis的相关知识。 一、缓存 哪些数据适合放入缓存？ 即时性、数据一致性要求不高 访问量大且更新频率不高的数据（读多，写少） 本地缓存：和微服务同一个进程。缺点：分布式时本地缓存不能共享 分布式缓存：缓存中间件 二、使用 1. pom.xml文件中导入依赖 <dependency> <groupId>org.springframework.boot</groupId>
springboot集成redis序列化问题汇总
weixin_43401380的博客
04-04 4969
    spring中使用redis目前接触的到的有两种方式,一种是使用封装的RedisTemplate工具类;另一种是使用Spring Cache,cache实现方式选择RedisCache.两种方案中都需要对序列化方式进行设置,否则会出现二进制格式的数据(不论是Redis desktop manager工具还是redis自带客户端黑窗口打开),如果需要查看数据则会影响观感,关于序列化方式设置底层都是对RedisSerializer接口进行设置,现分别说明为何出现此
SpringBoot3 redis序列化配置
yyh2868952213的博客
04-28 442
【代码】SpringBoot3 redis序列化配置。
springboot整合redis Json序列化配置与缓存注解使用
m0_59588838的博客
06-08 2424
大三已经结束了，虽然现在面临就业，我还是放下焦虑慢慢补充自己的知识面，实习工作也在不停地面试不停地投简历，不求offer直接飞过来，在这一步一步的找工作的过程中我自己也在不断地进步。这波我们处理的是redis作为缓存时默认jdk序列化数据的问题，虽然在前端后者后端读取时是利用反序列化机制将数据反转成之前的格式，但是进入redis数据库中查看时却发现是X86X23X76等统一类型的数据格式，这对于维护是一个大障碍。之前有写过配置Json序列化的配置Bean文章，这一次主要也想统一的把缓存记录一下！...
【Spring Boot实战与进阶】Redis配置Fastjson进行序列化和反序列化
程序员云帆哥的博客
10-19 1986
FastJson是阿里开源的一个高性能的JSON框架，FastJson数据处理速度快，无论序列化（把JavaBean对象转化成Json格式的字符串）和反序列化（把JSON格式的字符串转化为Java Bean对象），都是当之无愧的fast；功能强大（支持普通JDK类，包括javaBean, Collection, Date 或者enum）；零依赖（没有依赖其他的任何类库）。
SpringBoot 整合 Redis
m0_57801749的博客
05-23 371
5. 定制化 LettuceConnectionFactory。3. 定制化redisTemplate。4. 定制化缓存管理。
SpringBoot通过redisTemplate调用lua脚本并打印调试信息到redis log(方法步骤详解)
08-25
RedisTemplate的序列化方式默认是基于Java JDK的序列化，但这种序列化方式会出现乱码的问题。因此，需要将序列化方式设置为JSON序列化，以便正确地传递参数给lua脚本。 六、总结 本文详细介绍了如何在Spring Boot...
layering-cache:为监控而生的分布式多级缓存框架
05-06
layering-cache简介layering-cache是一个支持分布式...会开启一个异步线程刷新缓存）缓存Key支持SpEL表达式Redis支持Kryo、FastJson、Jackson、Jdk和Protostuff序列化，默认使用Protostuff序列化，并支持自定义的序列
Dubbo 32道面试题及答案.docx
06-14
4. **序列化框架**：默认序列化方式是Hessian，还有Duddo、FastJson和Java自带的序列化方式。选择合适的序列化方式对于性能和数据传输效率至关重要。 5. **服务容错机制**：Dubbo提供了多种容错策略，如Failover...
Linux安装 Redis
最新发布
Blooming death的博客
08-02 231
下载方式为两种：官网、网盘官网：我这里下载了：7.0.5网盘：链接：https://pan.baidu.com/s/1A_-ZL3x3Xa5YNlcDqyuV_A?pwd=g8jh提取码：g8jh解压：将文件上传至。
项目中引入RedisTemplate和Redisson时RedisTemplate无法使用zset问题（栈溢出stackOverflow）深入源码分析解决
HumorChen的博客
08-02 628
项目中引入RedisTemplate和Redisson时RedisTemplate无法使用zset问题（栈溢出stackOverflow）深入源码分析解决
redisson分布式锁
我这个代码你能看懂吗？
08-02 535
Redisson 是一个基于 Redis 的 Java 驻内存数据网格（In-Memory Data Grid）客户端，它提供了许多分布式数据结构和服务，包括分布式锁。Redisson 的分布式锁实现基于 Redis 的。Redisson 的分布式锁是可重入的，这意味着同一个线程可以多次获取同一个锁，而不会发生死锁。通过以上步骤，可以使用 Redisson 实现分布式锁，从而在分布式系统中确保资源的互斥访问。使用 Redisson 客户端获取分布式锁，并进行加锁和解锁操作。
【源码阅读】Redisson lock源码
m0_64944491的博客
07-30 685
Redisson 加锁非常简单，还支持 redis 单实例、redis 哨兵、redis cluster、redis master-slave 等各种部署架构 底层原理 废话不多说，直接看源码，下面的代码先不看，先看 tryAcquire 是如何获取锁的 查看 tryAcquire 方法，点进去看发现调用了 tryAcquireAsync0 方法，这里 RFuture 继承自 java.util.concurrent.Future，表示这是一个异步的任务，get 方法会同步获取结果 查看 tr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值