RedisTemplate序列化方式转换

最新推荐文章于 2024-02-01 08:45:00 发布
最新推荐文章于 2024-02-01 08:45:00 发布
阅读量2k 收藏
点赞数 1
分类专栏： java 文章标签： redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45941687/article/details/121203342
版权

RedisTemplate序列化方式

不足的地方，或者理解有误的地方，评论区欢迎！！❀ 🌙❀

1 Redis 的几种序列方式

Redis存储序列化方式，常用的有以下几种：

  • JdkSerializationRedisSerializer：将数据序列化为对象
  • StringRedisSerializer：简单的字符串序列化
  • GenericToStringSerializer: 可以将任何对象泛化为字符串并序列化
  • JacksonJsonRedisSerializer: 序列化object对象为json字符串
  • Jackson2JsonRedisSerializer：将数据序列化为json ，序列化带泛型的数据时，会以map的结构进行存储，反序列化是不能将map解析成对象。跟JacksonJsonRedisSerializer实际上是一样的
  • GenericJackson2JsonRedisSerializer：将数据序列化为json，但这个时保存了对象包名 方便反序列化

Jackson2JsonRedisSerializer 和 GenericJackson2JsonRedisSerializer 区别

2 StringRedisTemplate和RedisTemplate的区别及使用方法

https://www.cnblogs.com/MyYJ/p/10778874.html

3 注释解析

spring framework中的注解

@EnableCaching：启用注解缓存，若使用该注解，就不需要在XML文件中配置cache manager

@Cacheable ： 开启缓存，使用这个注解的方法在执行后会缓存其返回结果。【写在方法上】
@Cacheable(cacheNames = “studentCache”, key = “#id”)

@CacheEvict：用完缓存后，清除缓存【写在方法上】
@CacheEvict(cacheNames=“cacheValue”,key = “#id”)

@CachePut：每次用完缓存，更新缓存【写在方法上】

@cacheConfig: 【写在类上】

https://www.cnblogs.com/dianzan/p/11209846.html【Spring中注解使用缓存】

4 缓存模式存储

4.1 参考链接

SpringCloud用Spring Cache的方式使用Redis缓存 ※
springboot使用@EnableCaching实现缓存 ※

4.2 其中遇到的问题

1.org.springframework.cache.support.SimpleValueWrapper cannot be cast to java.util.Map
存储对象用map示例时，获取缓存报错，后改用javaObject为示例

2.java.lang.IllegalStateException

java.lang.IllegalStateException: No CacheResolver specified, and no unique bean of type CacheManager found. Mark one as primary or declare a specific CacheManager to use.
	at org.springframework.cache.interceptor.CacheAspectSupport.afterSingletonsInstantiated(CacheAspectSupport.java:223) ~[spring-context-5.2.2.RELEASE.jar:5.2.2.RELEASE]
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:896) ~[spring-beans-5.2.2.RELEASE.jar:5.2.2.RELEASE]
	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:878) ~[spring-context-5.2.2.RELEASE.jar:5.2.2.RELEASE]
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:550) ~[spring-context-5.2.2.RELEASE.jar:5.2.2.RELEASE]
	......

原因：两个配置类重复
解决方法：两个cacheManager在其中一个上面加**@Primary**，指定一个默认的

4.3 完整代码

// 配置文件
// @EnableCaching 开启缓存支持；

@EnableCaching
@Configuration
public class CacheConfig {

    //放入缓存
    @Bean
    @Primary
    public ConcurrentMapCacheManager cacheManagerTwo(){
        ConcurrentMapCacheManager mapCacheManager = new ConcurrentMapCacheManager();
        //cacheManager.setStoreByValue(true); //true表示缓存一份副本，否则缓存引用
        return mapCacheManager;
    }
}

// 控制类
// @Cacheable-------使用这个注解的方法在执行后会缓存其返回结果。
// @CacheEvict--------使用这个注解的方法在其执行前或执行后移除Spring Cache中的某些元素。


@RestController
@AllArgsConstructor
@RequestMapping("/test")
public class TestController {
    @Autowired
    private CacheConfig cacheConfig;

    /**
     * @Cacheable-------使用这个注解的方法在执行后会缓存其返回结果。
     */
    @Cacheable(cacheNames = "cacheValue",key = "#id")
    @GetMapping("/getInfo")
    public Result getInfo(@ApiParam(value="主键id") Integer id){
        JSONObject json = new JSONObject();
        json.put("code",1);
        json.put("msg","缓存内容");
        json.put("date", DateTimeUtil.formatDefault(new Date()));
        System.out.println("json==>"+json);
        return Result.success(json);
    }

    /**
     * 获取缓存信息
     */
    @GetMapping("/getCache")
    public Result getCache(){
        Cache cache = cacheConfig.cacheManagerTwo().getCache("cacheValue");
        System.out.println("Cache.getName===>"+cache.getName()); //Cache.getName===>cacheValue
        System.out.println("Cache===>"+cache.get(1));
        return Result.success(cache);
    }

    /**
     *  修改缓存信息
     *  修改删除 都可以用这个 @CacheEvict
     */
    @CacheEvict(cacheNames="cacheValue",key = "#id")
    @PutMapping("/update")
    public Result update(@RequestParam(value = "id")Integer id){
        JSONObject json = new JSONObject();
        json.put("code",2);
        json.put("msg","删除缓存信息");
        json.put("date", DateTimeUtil.formatDefault(new Date()));
        System.out.println("json==>"+json);
        return Result.success(json);
    }
}

◀  执行的返回值

1. 查询，将结果直接放入缓存  127.0.0.1:9528/test/getInfo?id=1
{
    "code": 0,
    "message": "成功",
    "data": {
        "msg": "缓存内容",
        "date": "2021-11-09 14:12:56",
        "code": 1
    },
    "exception": false,
    "error": null
}


◀  执行的返回值

2. 查询缓存  127.0.0.1:9528/test/getCache
{
    "code": 0,
    "message": "成功",
    "data": {
        "allowNullValues": true,
        "name": "cacheValue",
        "nativeCache": {
            "1": {
                "code": 0,
                "message": "成功",
                "data": {
                    "msg": "缓存内容",
                    "date": "2021-11-09 14:12:56",
                    "code": 1
                },
                "exception": false,
                "error": null
            }
        },
        "storeByValue": false
    },
    "exception": false,
    "error": null
}

◀  执行的返回值

3.1清除缓存  127.0.0.1:9528/test/update?id=1
{
    "code": 0,
    "message": "成功",
    "data": {
        "msg": "删除缓存信息",
        "date": "2021-11-09 14:47:41",
        "code": 2
    },
    "exception": false,
    "error": null
}

3.2 再次查询缓存  127.0.0.1:9528/test/getCache  数据已删除
{
    "code": 0,
    "message": "成功",
    "data": {
        "allowNullValues": true,
        "name": "cacheValue",
        "nativeCache": {},
        "storeByValue": false
    },
    "exception": false,
    "error": null
}

5 redisTemplate不同序列化

5.1 参考链接

https://blog.csdn.net/weixin_45941687/article/details/118933149
【RedisTemplate操作redis时,可视化工具查看，值前总会有一串“\xAC\xED\x00\x05t\x00\x”】

https://www.cnblogs.com/liuyi-clover/p/9406598.html
【JAVA操作ObjectMapper类】

https://www.cnblogs.com/wangzhuxing/p/10198347.html
【springboot系列十一、redisTemplate和stringRedisTemplate对比、redisTemplate几种序列化方式比较】

https://blog.csdn.net/bai_bug/article/details/81222519
【Jackson2JsonRedisSerializer和GenericJackson2JsonRedisSerializer的区别】

5.2 配置方式一 - GenericJackson2JsonRedisSerializer

【我下载了redis可视化工具RDM，方便查看数据，如果你下载了其他的可视化工具，就用你当前工具❀】

pom.xml依赖

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

RedisConfig配置文件

package com.nanodata.mole.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;


@Configuration
public class RedisConfig {
    @Autowired
    private RedisTemplate redisTemplate;

    @Bean
    public RedisTemplate  redisTemplateInit(){
        //设置序列化Key的实例化对象
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置序列化Value的实例化对象
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }

/**
* 这个是前辈写在这的，暂时未理解它的用处，知道的欢迎评论区告诉我，蟹蟹
*/
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {

        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
                .entryTtl(Duration.ofHours(1))
                ; // 设置缓存有效期一小时

        return RedisCacheManager
                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                .cacheDefaults(redisCacheConfiguration).build();
    }

}

在这里插入图片描述

5.2 配置方式二 - GenericJackson2JsonRedisSerializer（hash key 和value）

pom.xml

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

RedisConfig配置文件

package com.nanodata.mole.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
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.*;

import java.time.Duration;

@Configuration
public class RedisConfig {
   @Autowired
    private RedisTemplate redisTemplate;

    /** 该方式也可以 */

    @Bean
    public RedisTemplate  redisTemplateInit(){
        //设置序列化Key的实例化对象
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置序列化Value的实例化对象
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        // 设置hash key 和value序列化模式 ♥
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }
}

在这里插入图片描述

5.3 配置方式三 - Jackson2JsonRedisSerializer

pom.xml

        <!-- redis -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>

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

RedisConfig配置文件

package com.nanodata.mole.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
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.*;

@Configuration
public class RedisConfig {
    @Autowired
    private RedisTemplate redisTemplate;
    
    @Bean
    public RedisTemplate<String, Object> redisTemplateInit(RedisConnectionFactory redisConnectionFactory)  {
//        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);


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

        // 值采用json序列化
        redisTemplate.setValueSerializer(jacksonSeial);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        redisTemplate.setKeySerializer(new StringRedisSerializer());

        // 设置hash key 和value序列化模式
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jacksonSeial);

        // 设置支持事物
        redisTemplate.setEnableTransactionSupport(true);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

在这里插入图片描述

总结对比

使用Jackson2JsonRedisSerializer需要指明序列化的类Class，可以使用Obejct.class

2、使用GenericJacksonRedisSerializer比Jackson2JsonRedisSerializer效率低，占用内存高。

3、GenericJacksonRedisSerializer反序列化带泛型的数组类会报转换异常，解决办法存储以JSON字符串存储。

4、GenericJacksonRedisSerializer和Jackson2JsonRedisSerializer都是以JSON格式去存储数据，都可以作为Redis的序列化方式。

该片段总结来自-->原文链接：https://blog.csdn.net/bai_bug/article/details/81222519

5.4 问题

  1. Error:(35,37) java: 无法访问com.fasterxml.jackson.databind.JavaType
    解决方式：pom.xml添加如下依赖，重启服务

     <dependency>
     <groupId>com.fasterxml.jackson.core</groupId>
     <artifactId>jackson-databind</artifactId>
 </dependency>

  2. RedisTemplate配置的jackson.ObjectMapper里的一个enableDefaultTyping方法过期解决
    解决方式如下

// 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
//      om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        om.activateDefaultTyping(om.getPolymorphicTypeValidator(),ObjectMapper.DefaultTyping.NON_FINAL);

RedisTemplate配置的jackson.ObjectMapper里的一个enableDefaultTyping方法过期解决
【https://www.cnblogs.com/exmyth/p/13794524.html】

QTWWlhh
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RedisTemplate取值类型转换问题
qq_49067108的博客
08-20 1万+
当用到redis缓存数据库数据时，存的时候，可以是String，可以是处理过的对象，还可以是List集合...，但是在取数据时，作为操作者的你需要对接收到的数据类型做转换，否则类型不一致，影响返回和接收。 类型转换方式一：封装方法 封装关于redis的get方法，通过泛型对值类型进行转换。 //存储时，value为一个对象，返回时，value默认为 object类型，需要进行类型转换 @SuppressWarnings("unchecked") public static <T> List&.
封装自定义的redis切库工具类ByteArrayRedisTemplate，读取byte数组反序列化成List＜Object＞
weixin_36894490的博客
03-02 934
封装自定义的RedisTemplate切库工具读取List序列化的byte数组的步骤注入LettuceConnectionFactory连接池代码思路RedisStandaloneConfiguration单机配置实例代码LettuceClientConfiguration连接池配置实例思路LettuceClientConfiguration连接池配置关键代码封装自定义的redis切库工具类实现一个自定义的RedisTemplate需要什么？切库关键代码redis中读取List序列化的byte数组关键步骤使
RedisTemplate批量往集合Set添加元素出现的转换异常问题分析
最新发布
02-01 477
在上篇文章《Java项目中实现敏感词过滤功能》中为了避免每次过滤敏感词都要查询数据库加载敏感词库，笔者设计将敏感词库缓存到了Redis中，缓存时间5分钟。在后续开发联调中，敏感词过滤逻辑报错：类型转换错误，无法将HashSet转为String类型。/*** 从数据库或缓存加载敏感词库，默认缓存5min* @return*/try {log.warn("远程获取敏感词信息失败！", e);// 具体过滤逻辑代码。
用RedisTemplate＜Object, Object＞把对象以json形式存入redis缓存
L'Étranger的博客
11-16 3666
对象可以不用实现序列化 public class User{ private Integer id ; private String userName ; private String password ; public User(Integer id, String userName, String password) { this.id = id; this.userName = userName; this.pass
定制RedisTemplate对象
爱驹一族的博客
07-12 296
package com.cy.redis.config; @Configuration public class RedisConfig { //RedisTemplate序列化默认使用的是jdkSerializeable,存储二级制字节码 @Bean public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){ RedisTemplate<Object,O
RedisTemplate-JDBCTemplate.zip
07-18
2. 在Spring配置中声明`RedisTemplate`，并指定键值序列化器（如StringRedisSerializer）和其他配置项。 3. 通过Spring容器获取`RedisTemplate`实例。 4. 使用`opsForValue()`、`opsForHash()`等方法进行数据操作，...
redis使用过程中由于序列化工具引起的问题
04-27
`RedisTemplate`内部涉及到了序列化，包括key和value的序列化。 博客中可能提到了以下两个关键类：`RedisTemplateDelegate`和`RedisStringTemplateDelegate`。这些类可能是用户自定义的扩展，用于定制`...
spring整合redis(spring模板+连接池+json序列化+cluster集群).zip
07-16
通过配置`RedisConnectionFactory`，我们可以创建一个`RedisTemplate`实例，并定义其Key、Value的序列化方式。例如，可以使用`StringRedisSerializer`作为Key的序列化器，而`Jackson2JsonRedisSerializer`作为Value...
RedisTemplate-redis-优雅玩法
05-21
本篇文章将深入探讨如何在Spring Boot项目中优雅地使用RedisTemplate，实现对象的自动序列化和反序列化，并通过示例代码来展示其魅力。 首先，让我们理解RedisTemplate的基本概念。RedisTemplate是Spring Data ...
chr-redis:redisTemplate工具类
03-31
在上述配置中，`RedisConnectionFactory`是从Redis服务器获取连接的工厂，而序列化器则是处理Java对象与Redis字符串之间的转换。通常，我们使用`StringRedisSerializer`处理字符串类型的key，而`...
自定义注解实现redis与对象相互转换
大智制杖
04-04 546
简介 本文则通过自定义注解的方式，来完成一个hash与POJO之间的转换。目标是为了简化代码结构。 类似的功能，Spring Data Redis是有的。 定义POJO在redis中的数据结构 这里随便定了几个，本文只实现了hash。 public enum RedisStorageStructure { SET, // 基本元素 HASH, // 哈希 LIST, // ...
Spring项目统一cacheManager出错：No CacheResolver specified, and no unique bean of type CacheManager found
北亮的专栏
01-09 7179
起因，一些基础数据的接口访问量居高不下，在高峰期很容易出现服务性能问题，并经常需要扩容。 最早的解决方案，是让各调用方，自己添加缓存，避免频繁访问基础服务接口。 该方案存在的问题，就是数据经常不一致，基础数据变了，但是调用方不知道，如果用MQ去通知，技术方案又复杂了。 第二期的解决方案，是在基础数据提供方添加缓存，因为这些数据是否变化，只有提供者知道并可以及时过期处理。 该方案效果还是比较明显的，但是监控数据上的TPS依旧存在，大量的HTTP请求也依然存在性能浪费的问题。而且各个服务的缓存方案各不一致，比如
SpringBoot缓存注解以及json序列化配置
LeopaLY的博客
05-04 2972
Spring缓存注解 Cache 缓存接口,定义缓存操作,实现由:RedisCache.EhCache.ConcurrentMapCache等 CacheManager : 缓存管理器,管理各种缓存(Cache)组件 @Cacheable : 主要针对方法配置,能够根据方法的请求参数对其结果进行缓存 @CacheEvict : 清空缓存 @CachePut : 保证方法被调用,又希望结果被缓存 @...
GenericJackson2JsonRedisSerializer序列化遇到的坑
热门推荐
pxwell的博客
09-12 1万+
GenericJackson2JsonRedisSerializer序列化遇到的坑问题现象Redis序列化设置jackson反序列化时Error提示改用fastJson作为序列化工具结论 问题现象 工程使用redis作为缓存，起初使用GenericJackson2JsonRedisSerializer作为序列化反序列化工具。一般正常的对象（set,get齐全），序列化以及解序列化都没有问题。但是一...
当使用@cacheable缓存数据遇到的序列化问题
Yangyg_0818的博客
12-06 4086
1.问题：使用@cacheable注解报错信息如下，很明显是jackson序列化时出的错误 Caused by: com.fasterxml.jackson.databind.exc.MismatchedInputException: Cannot deserialize instance of `java.lang.String` out of START_ARRAY token[["com.xxx.xxx.xxxxxxx.response.SummaryLeftResponse",{"mainpNam
java中json字符串的序列化,Java中Json字符串的序列化与反序列化
weixin_36455001的博客
03-09 619
[使用 JSON JavaScriptSerializer 进行序列化或反序列化时出错。字符串的长度超过了为 maxJsonLength 属性设置的值。 解决办法是在web.config增加如下节点到组件：com.fasterxml.jacksonPOM(局部)：[ javascript中如何反序列化json字符串呢 有如下两种方法: (1)使用万能的eval var jsonText =...
json序列化
qq_37369726的博客
01-11 5346
json模块作用 json模块可以将字典、列表等序列化对象转换成特殊的字符串，也就是json数据，再将这种特殊的字符串转换回来。主要的使用场景比如网络传输，文件存储数据。如果用str（）方法转换成普通的字符串，没有办法再转换回原来的数据类型。eval方法除外，不推荐使用。json数据还是各种编程语言通用的数据类型，python的json数据，java也可以获取使用，十分方便。 json方法： json主要的方法比较简单，有四个，两两一对使用。 json.dump()、json.load():只能用于文件数
springboot使用caffeine cache是出现暗坑
znice123的博客
07-29 3663
使用caffeine作为本地应用缓冲时，碰见一个暗坑，caffeine做了10分钟缓冲失效配置（expireAfterWrite（10）） 下面是具体数据表查询缓存代码 @Cacheable(cacheNames = MerchantCacheConfig.CACHE_NAME, key = "#merId") public MerchantDTO selectByMerId(String merId) { return this.selectByMerIdDB(merId); ...
SpringBoot整合Spring-data-redis实现集中式缓存
Stduent_的专栏
02-03 2309
Spring Data redis的几种序列化 从框架的角度来看，存储在Redis中的数据只是字节。虽然说Redis支持多种数据类型，但是那只是意味着存储数据的方式，而不是它所代表的内容。由我们将这些数据转化成字符串或者是其他对象。我们通过org.springframework.data.redis.serializer. RedisSerializer将自定义的对象数据和存储在Redis上
Redistemplate 序列化
03-31
Redistemplate 可以序列化对象，并将其存储在 Redis 中。序列化是将对象转换为字节流的过程，以便它可以在网络或文件系统中进行传输或存储。在 Redis 中，序列化是将对象转换为 Redis 协议格式的字符串。 Redistemplate 支持多种序列化方式，包括 JDK 序列化、JSON 序列化、Protobuf 序列化等。默认情况下，Redistemplate 使用 JDK 序列化方式。 在使用 Redistemplate 时，需要将需要存储的对象先进行序列化，然后再将序列化后的字节流存储到 Redis 中。在获取对象时，则需要先从 Redis 中读取字节流，然后将其反序列化为原始对象。 以下是示例代码： ```java // 定义一个需要存储的对象 class User { private String name; private int age; // getter 和 setter 方法省略 } // 在 Redistemplate 中使用 JSON 序列化方式 @Configuration public class RedisConfig { @Bean public RedisTemplate<String, User> redisTemplate(RedisConnectionFactory redisConnectionFactory) { RedisTemplate<String, User> template = new RedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory); template.setDefaultSerializer(new Jackson2JsonRedisSerializer<>(User.class)); return template; } } // 存储对象 User user = new User(); user.setName("Alice"); user.setAge(18); redisTemplate.opsForValue().set("user", user); // 获取对象 User user = redisTemplate.opsForValue().get("user"); ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值