最近在做 Spring Boot 项目,借此机会,我使用了 Spring Boot 3 和 JDK 17 的组合,整理了一下 Redis 的配置方式,并通过实践实现了常用的 Redis 工具类。我这里主要是整理一下如何在 Spring Boot 3 中使用 Redis,以及如何自定义工具类实现常见的 Redis 操作。
Spring Boot 3.x 和 JDK 17 兼容,特别是在 Spring Boot 3 中引入了 Jakarta EE 9 的命名空间(如包名从javax
改为jakarta
),因此在使用一些依赖时需要注意兼容性问题。
1、引入依赖
首先,我们要确保项目中已经引入了 Redis 相关的依赖。spring-boot-starter-data-redis
是使用 Redis 的核心依赖,它包含了 RedisTemplate
等必要的类。
在 pom.xml
文件中(如果使用 Maven),确保包含以下依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
如果使用 Gradle,确保 build.gradle
中有以下依赖:
implementation 'org.springframework.boot:spring-boot-starter-data-redis'
2、application的配置
在 application.yml
文件中添加 Redis 相关的配置,这里有一点需要注意。Springboot2 中的配置是spring.redis
,Springboot3 中的配置是spring.data.redis
。
参考配置如下所示:
spring:
data:
redis:
host: 127.0.0.1
port: 6379
database: 0
timeout: 1800s # 使用时间格式化
password:
lettuce:
pool:
max-active: 20 # 最大连接数
max-wait: -1 # 最大阻塞等待时间(负数表示没限制)
max-idle: 5 # 最大空闲
min-idle: 0 # 最小空闲
关键参数说明:
host
:Redis 服务器的主机地址。port
:Redis 服务器的端口。database
:使用的数据库索引。timeout
:连接超时时间。lettuce.pool
:Lettuce 连接池配置,控制 Redis 连接的并发数、空闲连接数等。
3、自定义某些配置
为了定制化 Redis 的使用方式,我们可以创建一个 RedisConfig
配置类,自定义 RedisTemplate
和 RedisCacheManager
,以便对 Redis 的键值进行序列化和缓存管理。这里定义对象序列化的方式,可以直接往Reids中存放对象,它实现自动转换。
@Configuration
@EnableCaching
public class RedisConfig {
// 配置 RedisTemplate,用于操作 Redis 数据库
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
// 创建 RedisTemplate 对象,用于执行 Redis 操作
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
// 设置连接工厂,用于与 Redis 建立连接
redisTemplate.setConnectionFactory(factory);
// 设置 key 的序列化器,使用 StringRedisSerializer 将 key 序列化为字符串
redisTemplate.setKeySerializer(new StringRedisSerializer());
// 设置 value 的序列化器,使用 GenericJackson2JsonRedisSerializer 将对象序列化为 JSON
redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
// 设置 hash key 的序列化器,使用 StringRedisSerializer 序列化 hash 的 key
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
// 设置 hash value 的序列化器,使用 Jackson2JsonRedisSerializer 将 hash 值序列化为 JSON
redisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));
// 返回配置好的 RedisTemplate
return redisTemplate;
}
// 配置 RedisCacheManager,用于管理 Redis 缓存
@Bean
public RedisCacheManager redisCacheManager(RedisTemplate redisTemplate) {
// 创建 RedisCacheWriter,nonLockingRedisCacheWriter 表示不使用锁机制进行缓存操作
RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisTemplate.getConnectionFactory());
// 配置 RedisCacheConfiguration,指定缓存值的序列化方式,使用 RedisTemplate 中配置的 ValueSerializer 进行序列化
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisTemplate.getValueSerializer()));
// 返回配置好的 RedisCacheManager
return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
}
}
-
@Configuration
注解:用于标记这是一个配置类,Spring 会在应用启动时加载该类中的配置,生成相关的 Bean 并将其管理。用于自定义 Redis 相关的 Bean。 -
@EnableCaching
注解:启用 Spring 的缓存支持。通过这个注解,Spring 将使用缓存机制,并根据配置的缓存管理器管理缓存。 -
RedisTemplate:用于执行 Redis 操作。自定义了键(
key
)使用字符串序列化,值(value
)使用 JSON 序列化。 -
RedisCacheManager:管理缓存配置。缓存的值也通过 JSON 序列化存储,便于处理复杂数据。
4、自定义工具类
为了简化 Redis 的常用操作(如增删改查),我们可以创建一个 RedisUtil
工具类,便于在项目中使用。
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
/**
* Redis工具类
*
* @author luoxiaodou
*/
@Component
public class RedisUtil {
private static final Logger logger = LoggerFactory.getLogger(RedisUtil.class);
private final RedisTemplate<String, Object> redisTemplate;
/**
* 在 Spring Boot 中,RedisTemplate 是由 Spring 自动配置的。
* Spring Boot 的 spring-boot-starter-data-redis 会自动根据 application.yml
* 或 application.properties 中的 Redis 配置生成
* RedisTemplate 实例,并将其作为一个 Bean 注入到 Spring 容器中。
*
* 从 Spring Framework 4.3 开始,如果类只有一个构造函数,Spring 会自动推断并使用这个构造函数进行依赖注入,无需显式地使用 @Autowired 注解。
* 由于 RedisUtil 类中只有一个构造函数,因此 Spring 自动会将 RedisTemplate<String, Object> 注入到 RedisUtil 中。
*
* @param redisTemplate
*/
@Autowired
public RedisUtil(RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}
/**
* 设置缓存失效时间
*
* @param key 键
* @param time 时间(秒)
*/
public boolean expire(String key, long time) {
if (time > 0) {
return Boolean.TRUE.equals(redisTemplate.expire(key, time, TimeUnit.SECONDS));
}
return false;
}
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key) {
return Boolean.TRUE.equals(redisTemplate.hasKey(key));
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
public void delete(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete(Arrays.asList(key));
}
}
}
/**
* 获取普通缓存
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue()
.get(key);
}
/**
* 泛型方法 get:<T> 使得 get 方法可以返回不同类型的对象,clazz 参数是对象的类型信息,传入后可以将存储的值反序列化为相应类型。
* Redis 中的数据必须是通过 GenericJackson2JsonRedisSerializer 或类似的 JSON 序列化器存储的,确保可以成功反序列化。
*
* @param key
* @param clazz
* @param <T>
* @return
*/
public <T> T get(String key, Class<T> clazz) {
try {
Object value = redisTemplate.opsForValue()
.get(key);
if (value != null) {
// 自动转换成指定类型
return clazz.cast(value);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean set(String key, Object value) {
try {
redisTemplate.opsForValue()
.set(key, value);
return true;
} catch (Exception e) {
logger.error(e.getMessage(), e);
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public boolean set(String key, Object value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue()
.set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
logger.error(e.getMessage(), e);
return false;
}
}
}
关键方法说明:
- expire:设置缓存的过期时间。
- getExpire:获取缓存项的过期时间。
- hasKey:判断缓存是否存在。
- delete:删除缓存。
- get:获取缓存中的值。
- set:设置缓存值,可选指定过期时间。