SpringBoot3中引入Redis并封装常用的 RedisUtils 工具类

最近在做 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：设置缓存值，可选指定过期时间。