SpringBoot 05 集成redis实现对象序列化缓存

最新推荐文章于 2024-06-14 06:00:00 发布
最新推荐文章于 2024-06-14 06:00:00 发布
阅读量978 收藏 3
点赞数 1
分类专栏： Redis Spring 文章标签： spring boot redis java
本文为CSDN博主「=PNZ=BeijingL」的原创文章，遵循 CC-BY-NC-SA 版权协议，转载请附上原文出处链接及本声明。CC-BY-NC-SA协议为创作共用-署名-非商业性-相同方式共享
本文链接：https://blog.csdn.net/Beijing_L/article/details/122722028
版权

1.为什么用Spring Data 

        Spring Data 的目标是为数据访问提供一个基于Spring的普遍常用的编程模型，同时仍然保留底层数据存储的特殊特性， 它让使用数据访问技术、关系和非关系数据库和基于云的数据服务变得容易，它包含了很多的子项目例如Spring Data JDBC, Spring Data Redis,Spring Data MongoDB等。

       Spring Data Redis是Spring Data项目的一个子项目， 它提供了从Spring应用程序对Redis的简单配置和轻松访问的方法，将开发人员从基础设置问题中解放出来。它消除了存储交互所需啊哟的冗余任务和样板代码，使得编写使用 Redis键值存储的Spring 应用程序变得非常容易

2.SpringBoot+Redis 示例

1. 创建SpringBoot项目，参考目录结构如下

 

pom中增加spring-data-redis依赖，参考Pom.xml如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.boot</groupId>
    <artifactId>demo-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo-redis</name>
    <description>Demo project for Spring Boot + SpringData Redis</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <!-- redis 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!-- redis 依赖 -->

        <!-- WEB应用 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

参考application.properties文件

server.port=8002


## Redis数据库索引,默认为0
spring.redis.database=0
## Redis数据库地址，默认为localhost
spring.redis.host=127.0.0.1
## Redis数据库端口，默认为6379
spring.redis.port=6379
# Redis服务器连接密码，默认为空
spring.redis.password=
## Redis连接超时时间，单位毫秒
spring.redis.timeout=3000
## Redis链接超时时间
spring.redis.connect-timeout=3000
## Redis连接池中的最小空闲连接数
spring.redis.jedis.pool.min-idle=0
## Redis连接池中的最大空闲连接数
spring.redis.jedis.pool.max-idle=8

注： 启动SpringBoot后自动装配会加载自动配置类RedisAutoConfiguration ，其上使用了注解@EnableConfigurationProperties(RedisProperties.class)， 将RedisProperties配置生效

application.properties的配置信息会注入对象org.springframework.boot.autoconfigure.data.redis。RedisProperties 中，因此其他可用属性（spring.redis.**）可以参考RedisProperties 对象上的批注说明

3. 创建测试类UserDTO

package com.boot.redis.domain;

import java.io.Serializable;

public class UserDTO implements Serializable {

    private Long id;
    private String name;
    private String code;

    //省略getter和setter

    @Override
    public String toString() {
        return "UserDTO{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", code='" + code + '\'' +
                '}';
    }
}

通过@Configuration注解创建Bean对象RedisTemplate，

package com.boot.redis.conf;

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.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        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;
    }
}

4. 创建测试Controller,并注入RedisTemplate，这个类只是用于测试，实际项目中并不会以此方式处理登录信息

/login 用于模拟登录

  • @RequestParam表示登录请求中如果没有带参数，默认为zhangsan ,即/login和/login?username=zhangsan相同

  • index 每次自增长1，用于模拟不同的ID

  • redisTemplate #execute执行的时候先生成KEY 然后将对象系列化后保存到Redis中

/login 用于模拟获取登录信息

  • @RequestParam表示登录请求中如果没有带参数，默认为1,即/get和/get?uuserid=1相同
  • redisTemplate #execute执行的时候先获取Redis中的值然后再转换成对象返回
package com.boot.redis.controller;


import com.boot.redis.domain.UserDTO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;


@RestController
public class LoginController {

    //顺序生成ID,用于测试
    private static Long index = 1L;

    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping("/login")
    public String login(@RequestParam(value = "username", defaultValue = "zhangsan") String name) {
        UserDTO user = new UserDTO();
        user.setCode(""+1000+index);
        user.setName(name);
        user.setId(index++);

        redisTemplate.execute(new RedisCallback<Object>() {
            @Override
            public Object doInRedis(RedisConnection connection)
                    throws DataAccessException {

                byte[] key = redisTemplate.getStringSerializer().serialize("user.id." + user.getId());

                JdkSerializationRedisSerializer s = (JdkSerializationRedisSerializer) redisTemplate.getValueSerializer();

                connection.set(key, s.serialize(user));
                System.out.println("add");
                return null;
            }
        });

        return String.format("success", name);
    }

    @GetMapping("/get")
    public String get(@RequestParam(value = "userid", defaultValue = "1") String userId) {

        Object object = redisTemplate.execute(new RedisCallback() {

            public Object doInRedis(RedisConnection connection)
                    throws DataAccessException {
                byte[] key = redisTemplate.getStringSerializer().serialize("user.id." + userId);
                if (connection.exists(key)) {
                    JdkSerializationRedisSerializer s = (JdkSerializationRedisSerializer) redisTemplate.getValueSerializer();
                    return s.deserialize(connection.get(key));
                }
                return null;
            }
        });

        if (object == null) {
            return "null";
        } else {
            return ((UserDTO) object).toString();
        }

    }
}

测试：

先启动一个Redis Server ，这部分内容可以参考 Redis 安装_学然后知不足！-CSDN博客 ，这里不再重复说明 

1. 测试请求 ：http://127.0.0.1:8002/login?username=zhangsan

 

2. 测试请求：http://127.0.0.1:8002/get?userid=1

3. 通过RedisDesktopManager工具查看Redis中的信息

3.参考源码

https://github.com/PNZBEIJINGL/springboot/tree/master/demo-redis

4.常见问题

ClassNotFoundException: org.apache.commons.pool.impl.GenericObjectPool$Config

Caused by: java.lang.ClassNotFoundException: org.apache.commons.pool.impl.GenericObjectPool$Config
	at java.net.URLClassLoader$1.run(URLClassLoader.java:202)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.net.URLClassLoader.findClass(URLClassLoader.java:190)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:306)
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:247)

Spring-Data-Redis版本问题，一般是commons-pool2不匹配引起的,可以查看Maven官网中建议的匹配版本， 例如下图

 

              

                   

      

前一篇：SpringBoot 04 集成Flyway实现数据库版本控制

=PNZ=BeijingL
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Springboot整合Redis的序列化
qq_41270560的博客
02-01 2521
创建RedisTemplate对象，配置连接工厂获取json序列化工具对象设置key和value的序列化方式RedisTemplate对象加入容器中@Bean//1.创建//json序列化工具//设置key的序列化//设置值的valueredisTemplate.opsForValue().set("user",new User("小老虎",11));redis-cli中结果。
详解SpringBoot集成Redis来实现缓存技术方案
08-30
SpringBoot集成Redis实现缓存技术方案 本篇文章主要介绍了使用SpringBoot集成Redis来实现缓存技术方案的详细过程，整个方案的实现是基于SpringBoot提供的自动配置功能，通过配置Redis连接、实现Redis配置类，完成...
memcached组件缓存的对象必须实现序列化
善于模仿，乐于接受
01-03 3213
在测试用Memcached组件缓存对象的时候，发现总是无法正确存储，保存的地方也没有报告任何异常，从服务器控制台看到的信息也没有保存成功的信息，但是取数据的时候，取出来的也是空的，在获取user对象name属性的地方抛出了空指针异常。很显然没有保存成功，这是为什么呢？昨天用字符串测试都OK,今天用对象就不行了呢？Memcached不号称是内存对象缓存组件吗？ 想了下，终于知道为什么了？因为M
SpringBoot系列——使用Spring Cache和Redis实现查询数据缓存
最新发布
weixin_73588491的博客
06-14 2744
在现代应用程序中，查询缓存的使用已经变得越来越普遍。它不仅能够显著提高系统的性能，还能提升用户体验。缓存通过在内存中存储频繁访问的数据，减少对数据库或其他存储系统的访问，从而加快数据读取速度。在这篇文章中，我们将探讨缓存的基本概念、重要性以及如何使用Spring Cache和Redis实现查询数据缓存。缓存是一种临时存储机制，用于在内存中保存频繁访问的数据。它可以是硬件（如CPU缓存）或软件（如应用程序缓存）。缓存的主要目的是通过减少数据访问的延迟，提高系统的响应速度。临时性。
Spring Boot整合Redis时序列化设置
OriSu
06-08 251
整合Redis时默认使用的是JDK序列化，但是这不符合日常使用，会有乱码的出现，可以通过以下配置代码进行更改 import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.spri
spring boot 中redis的应用及序列化
qq_34775966的博客
04-27 1829
1、用处    1.1、作为缓存存储工具，方便查看缓存数据    1.2、做短时间身份认证的存储工具，例如：token2、用法   2.1在pom.xml中引入依赖  2.2application.properties中的配置3、只做存储的话直接注入redis模板调取增删改查就可以4、如果作为缓存的存储工具就要集成CachingConfigurerSupport类实现方法5、序列化完成上述做法我们...
springboot实现redis序列化和反序列化
一剑光寒的博客
01-31 2080
是指将字节序列恢复为对象的过程。在序列化中，对象的状态信息被转换为字节流以便于存储或传输，而在反序列化中，这些字节流将被重新转换为原始对象的状态。（PS：作者很久之前被问到当时脑子断片了没答出来哈哈~~）是指将对象转换为字节序列的过程，以便于存储或传输。在序列化过程中，对象的状态信息将被转换为字节流，可以保存到文件中或通过网络传输给其他计算机。反序列化则是将字节序列恢复为对象的过程。SpringBoot集成Redis有多种序列化和反序列化的方式（这里只举例常用的几种）
springBoot集成redis的key,value序列化的相关问题
08-25
SpringBoot 集成 Redis 的 key,value 序列化相关问题 在 SpringBoot 应用程序中集成 Redis 是非常常见的场景，Redis 作为一个高性能的 NoSQL 数据库，可以很好地用于缓存、Session 存储、消息队列等场景。但是，在...
SpringBoot学习秒杀一、SpringBoot集成Redis (使用Jedis实现)
12-22
【SpringBoot集成Redis (使用Jedis实现)】 在Spring Boot应用中集成Redis是一个常见的需求，因为Redis作为一个高性能的键值数据库，常用于缓存、消息队列等多种场景。本篇文章将介绍如何通过Jedis库来实现Spring ...
Springboot集成Redis
12-21
SpringBoot集成Redis提供了便捷的方式，通过简单的配置和`RedisTemplate`，开发者可以轻松地实现数据缓存和快速读写。在实际应用中，根据业务需求，合理利用Redis的特性，可以显著提升系统的响应速度和并发能力。...
Spring Boot集成Redis实现缓存机制(从零开始学Spring Boot)
08-30
Spring Boot集成Redis实现缓存机制是一项常见的优化技术，它能够提高数据访问速度，减少数据库压力。Redis是一款高性能的键值存储系统，适用于处理大量数据的快速读取和写入操作，特别适合用作缓存解决方案。 集成...
Jedis出现connection timeout问题解决方法（JedisPool连接池使用实例）
09-04
主要介绍了Jedis出现connection timeout问题解决方法,使用Jedis的JedisPool连接池解决了这个问题,需要的朋友可以参考下
如何在SpringBoot中设置RedisTemplate的序列化方式
简的博客
06-17 2245
第一种方式：采用自动序列化的方式，会将类的class类型写入json数据中，一并存入到Redis数据库当中。会带来额外的内存开销。第二种方式：采用手动序列化的方式，需要我们手动序列化java对象与json对象。不会带来额外的内存开销。
SpringBoot中RedisTemplate序列化的几种方式
Lyndon的专栏
09-03 1万+
SpringBoot中RedisTemplate序列化的几种方式 JdkSerializationRedisSerializer、StringRedisSerializer、Jackson2JsonRedisSerializer*
org.springframework.data.redis.serializer.JdkSerializationRedisSerializer序列化工具
zsg88的专栏
05-28 5022
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer; /** * 序列化工具类 */ public class SerializerUtil { private static final JdkSerializationRedisSerializer jdkSerializ
Springboot整合Redis
yaoct的博客
07-01 421
1.springboot 2整合redis参考：1.0 Spring boot整合Redis实现发布订阅（超详细）_BBQ__XB的博客-CSDN博客_springboot 发布订阅1.1 连不上redis，改redis配置Unable to connect to Redis; nested exception is io.lettuce.core.RedisConnectionException: 解决办法_浪里小菜鸟的博客-CSDN博客1.2 Redis工具类 参考redis知识整理_安迪爸爸的博客-C
解决redis远程连接超时：Connection timed out
qq_34449717的博客
04-10 7132
今天在项目中连接远程redis时，抛出连接超时异常：connect timed out。 详细信息例如以下： org.springframework.data.redis.connection.PoolException: Could not get a resource from the pool; nested exception is io.lettuce.core.RedisConnectionException: Unable to connect to 192.168.xxx.xxx:6379
Redis08_SpringBoot与Redis整合
热门推荐
BLU_111的博客
08-31 10万+
Redis08_SpringBoot与Redis整合 RedisAutoConfiguration 源码分析： /** * @ConditionalOnMissingBean(name = "redisTemplate") * 这个注解表示如果name为“redisTemplate”的bean已存在，则该注解修饰的代码块不执行。 * 所以我们可以自定义一个RedisTemplate来替换该默认配置 * * 两个泛型都是Object类型，所以我们使用需要强制转换：<String, Obj
springboot 集成redis 实现键值序列化 最全最优化最高性能的 代码实现
05-24
以下是一个基于Spring Boot和Redis的键值序列化的示例代码： 首先，在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> </dependency> ``` 然后，在application.properties文件中配置Redis连接信息： ```properties spring.redis.host=127.0.0.1 spring.redis.port=6379 spring.redis.password= spring.redis.database=0 spring.redis.pool.max-active=8 spring.redis.pool.max-wait=-1 spring.redis.pool.max-idle=8 spring.redis.pool.min-idle=0 ``` 接下来，我们可以创建一个RedisConfig类，用于配置RedisTemplate和RedisCacheManager： ```java @Configuration @EnableCaching public class RedisConfig extends CachingConfigurerSupport { @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(factory); // 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式） Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class); ObjectMapper mapper = new ObjectMapper(); mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); serializer.setObjectMapper(mapper); // 设置value的序列化规则和key的序列化规则 template.setValueSerializer(serializer); template.setKeySerializer(new StringRedisSerializer()); template.afterPropertiesSet(); return template; } @Bean public CacheManager cacheManager(RedisConnectionFactory factory) { RedisCacheManager cacheManager = RedisCacheManager.create(factory); cacheManager.setDefaultExpiration(1800); // 设置缓存过期时间（单位：秒） return cacheManager; } } ``` 现在，我们可以在任何需要使用Redis的地方注入RedisTemplate，并使用它来存储和读取数据。例如： ```java @Service public class UserService { @Autowired private RedisTemplate<String, Object> redisTemplate; public User getUserById(Long id) { String key = "user:" + id; User user = (User) redisTemplate.opsForValue().get(key); if (user == null) { // 从数据库中获取用户信息 user = userRepository.findById(id).orElse(null); if (user != null) { redisTemplate.opsForValue().set(key, user); } } return user; } } ``` 在上面的示例中，我们将用户信息存储在Redis中，并设置了一个过期时间。当需要获取用户信息时，首先从缓存中查找，如果缓存中没有，则从数据库中获取，并将结果存储在缓存中，以便下一次使用。这样可以大大提高系统的性能和响应速度。 总结：以上是一个基于Spring Boot和Redis的键值序列化的示例代码，通过使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值，可以实现最优化最高性能的键值序列化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

=PNZ=BeijingL

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值