Spring Boot中引入Redis，以及RedisUtils完整工具类

Spring Boot 集成Redis

pom.xml

<parent>
	  <groupId>org.springframework.boot</groupId>
	  <artifactId>spring-boot-starter-parent</artifactId>
	  <version>2.7.15</version>
	  <relativePath/> <!-- lookup parent from repository -->
</parent>
<!-- Spring Boot Redis 依赖 -->
<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>
<!-- Redis 连接池依赖 -->
<dependency>
     <groupId>org.apache.commons</groupId>
     <artifactId>commons-pool2</artifactId>
 </dependency>
 <!-- Json解析器 -->
 <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.83</version>
  </dependency>

application.yml

spring:
  # redis 缓存
  redis:
    host: localhost
    port: 6379
    password: 
    database: 0
    # 连接超时时间，单位毫秒
    timeout: 5000
    lettuce:
      pool:
        # 连接池最大连接数（使用负值表示没有限制）
        max-active: 8
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池中的最小空闲连接
        min-idle: 0

Redis配置类、自定义序列化

@Configuration
public class RedisConfigure {

    /**
     * 自定义RedisTemplate配置
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // 使用StringRedisSerializer来序列化和反序列化redis的key
        StringRedisSerializer stringSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringSerializer);
        template.setHashKeySerializer(stringSerializer);

        // 使用FastJsonRedisSerializer来序列化和反序列化redis的value
        FastJsonRedisSerializer<Object> jsonSerializer = new FastJsonRedisSerializer<>(Object.class);
        template.setValueSerializer(jsonSerializer);
        template.setHashValueSerializer(jsonSerializer);

        template.afterPropertiesSet();
        return template;
    }

    /**
     * 自定义FastJson序列化器
     */
    static class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
        private final Class<T> clazz;

        static {
            // 全局设置FastJson的自动类型支持
            ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        }

        public FastJsonRedisSerializer(Class<T> clazz) {
            super();
            this.clazz = clazz;
        }

        @Override
        public byte[] serialize(T t) {
            if (t == null) {
                return new byte[0];
            }
            return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(StandardCharsets.UTF_8);
        }

        @Override
        public T deserialize(byte[] bytes) {
            if (bytes == null || bytes.length == 0) {
                return null;
            }
            String str = new String(bytes, StandardCharsets.UTF_8);
            return JSON.parseObject(str, clazz);
        }
    }
}

RedisUtils工具类

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author neo
 * @date 2025-03-07
 * @description Redis 常用工具类
 **/
@Component
public class RedisUtils {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;


    /**
     * 删除指定键
     * @param key 键名
     * @return true表示删除成功，false表示键不存在
     */
    public Boolean delete(String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 批量删除键
     * @param keys 键集合
     * @return 实际删除的键数量
     */
    public Long delete(List<String> keys) {
        return redisTemplate.delete(keys);
    }


    /**
     * 设置键的过期时间
     * @param key 键名
     * @param timeout 时间数值
     * @param unit 时间单位（秒/分钟/小时等）
     * @return true表示设置成功，false表示键不存在或设置失败
     */
    public Boolean expire(String key, long timeout, TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获取键的剩余过期时间
     * @param key 键名
     * @return 剩余时间（秒），-2表示键不存在，-1表示永久有效
     */
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断键是否存在
     * @param key 键名
     * @return true存在，false不存在
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }


// ---------------------- String 操作 ----------------------

    /**
     * 设置键值（永久有效）
     * @param key 键名
     * @param value 存储值，支持任意可序列化对象
     */
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 设置键值并指定过期时间
     * @param key 键名
     * @param value 存储值
     * @param timeout 时间数值
     * @param unit 时间单位
     */
    public void set(String key, Object value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    /**
     * 获取键值并自动反序列化
     * @param key 键名
     * @param clazz 目标类型Class对象
     * @return 值对象，类型不匹配时返回null
     */
    public <T> T get(String key, Class<T> clazz) {
        Object value = redisTemplate.opsForValue().get(key);
        return clazz.isInstance(value) ? clazz.cast(value) : null;
    }

    /**
     * 对数值类型的值进行递增
     * @param key 键名
     * @param delta 递增幅度（正数）
     * @return 递增后的新值
     */
    public Long increment(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }

    // ---------------------- Hash 操作 ----------------------

    /**
     * 设置哈希表字段值
     * @param key 哈希表键名
     * @param hashKey 字段名
     * @param value 字段值
     */
    public void hPut(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

    /**
     * 批量设置哈希表字段
     * @param key 哈希表键名
     * @param map 字段键值对集合
     */
    public void hPutAll(String key, Map<String, ?> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }

    /**
     * 获取哈希表字段值
     * @param key 哈希表键名
     * @param hashKey 字段名
     * @param clazz 目标类型Class对象
     * @return 字段值，类型不匹配返回null
     */
    public <T> T hGet(String key, String hashKey, Class<T> clazz) {
        Object value = redisTemplate.opsForHash().get(key, hashKey);
        return clazz.isInstance(value) ? clazz.cast(value) : null;
    }

    /**
     * 获取整个哈希表
     * @param key 哈希表键名
     * @return Map结构的所有字段和值
     */
    public Map<String, Object> hGetAll(String key) {
        return redisTemplate.<String, Object>opsForHash().entries(key);
    }

    /**
     * 删除哈希表字段
     * @param key 哈希表键名
     * @param hashKeys 要删除的字段数组
     * @return 实际删除的字段数量
     */
    public Long hDelete(String key, Object... hashKeys) {
        return redisTemplate.opsForHash().delete(key, hashKeys);
    }

    /**
     * 判断哈希表是否存在字段
     * @param key 哈希表键名
     * @param hashKey 字段名
     * @return true存在，false不存在
     */
    public Boolean hHasKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    /**
     * 获取哈希表字段数量
     * @param key 哈希表键名
     * @return 字段总数
     */
    public Long hSize(String key) {
        return redisTemplate.opsForHash().size(key);
    }

    // ---------------------- List 操作 ----------------------

    /**
     * 左端插入元素（队列头）
     * @param key 列表键名
     * @param value 插入值
     * @return 插入后列表长度
     */
    public Long lPush(String key, Object value) {
        return redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 批量左端插入
     * @param key 列表键名
     * @param values 值集合
     * @return 插入后列表长度
     */
    public Long lPushAll(String key, Collection<?> values) {
        return redisTemplate.opsForList().leftPushAll(key, values);
    }

    /**
     * 右端插入元素（队列尾）
     * @param key 列表键名
     * @param value 插入值
     * @return 插入后列表长度
     */
    public Long rPush(String key, Object value) {
        return redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 左端弹出元素
     * @param key 列表键名
     * @param clazz 返回值类型Class
     * @return 元素对象，类型不匹配返回null
     */
    public <T> T lPop(String key, Class<T> clazz) {
        Object value = redisTemplate.opsForList().leftPop(key);
        return clazz.isInstance(value) ? clazz.cast(value) : null;
    }

    /**
     * 右端弹出元素
     * @param key 列表键名
     * @param clazz 返回值类型Class
     * @return 元素对象，类型不匹配返回null
     */
    public <T> T rPop(String key, Class<T> clazz) {
        Object value = redisTemplate.opsForList().rightPop(key);
        return clazz.isInstance(value) ? clazz.cast(value) : null;
    }

    /**
     * 获取列表指定范围元素
     * @param key 列表键名
     * @param start 起始索引（包含）
     * @param end 结束索引（包含）
     * @return 元素集合（未反序列化）
     */
    public List<Object> lRange(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    /**
     * 获取列表长度
     * @param key 列表键名
     * @return 元素总数
     */
    public Long lSize(String key) {
        return redisTemplate.opsForList().size(key);
    }

    // ---------------------- Set 操作 ----------------------

    /**
     * 向集合添加元素
     * @param key 集合键名
     * @param values 元素数组
     * @return 成功添加的新元素数量
     */
    public Long sAdd(String key, Object... values) {
        return redisTemplate.opsForSet().add(key, values);
    }

    /**
     * 获取集合所有元素
     * @param key 集合键名
     * @return 元素集合（未反序列化）
     */
    public Set<Object> sMembers(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 判断元素是否在集合中
     * @param key 集合键名
     * @param value 查询值
     * @return true存在，false不存在
     */
    public Boolean sIsMember(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }

    /**
     * 删除集合元素
     * @param key 集合键名
     * @param values 元素数组
     * @return 成功删除的元素数量
     */
    public Long sRemove(String key, Object... values) {
        return redisTemplate.opsForSet().remove(key, values);
    }

    /**
     * 获取集合元素总数
     * @param key 集合键名
     * @return 元素数量
     */
    public Long sSize(String key) {
        return redisTemplate.opsForSet().size(key);
    }

    // ---------------------- ZSet 操作 ----------------------

    /**
     * 向有序集合添加元素
     * @param key 有序集合键名
     * @param value 元素值
     * @param score 排序分数
     * @return true表示新元素添加成功，false表示元素已存在
     */
    public Boolean zAdd(String key, Object value, double score) {
        return redisTemplate.opsForZSet().add(key, value, score);
    }

    /**
     * 按分数范围获取元素（闭区间）
     * @param key 有序集合键名
     * @param min 最小分数
     * @param max 最大分数
     * @return 元素集合（按分数升序排列）
     */
    public Set<Object> zRangeByScore(String key, double min, double max) {
        return redisTemplate.opsForZSet().rangeByScore(key, min, max);
    }

    /**
     * 增加元素的分数值
     * @param key 有序集合键名
     * @param value 元素值
     * @param delta 增量值
     * @return 更新后的分数值
     */
    public Double zIncrementScore(String key, Object value, double delta) {
        return redisTemplate.opsForZSet().incrementScore(key, value, delta);
    }

    /**
     * 删除有序集合元素
     * @param key 有序集合键名
     * @param values 元素数组
     * @return 成功删除的元素数量
     */
    public Long zRemove(String key, Object... values) {
        return redisTemplate.opsForZSet().remove(key, values);
    }

    /**
     * 获取元素排名（升序排名，从0开始）
     * @param key 有序集合键名
     * @param value 元素值
     * @return 排名序号，null表示元素不存在
     */
    public Long zRank(String key, Object value) {
        return redisTemplate.opsForZSet().rank(key, value);
    }

    /**
     * 获取有序集合元素总数
     * @param key 有序集合键名
     * @return 元素数量
     */
    public Long zSize(String key) {
        return redisTemplate.opsForZSet().size(key);
    }


    // ---------------------- 事务操作 ----------------------
    /**
     * 执行Redis事务
     * @param sessionCallback 事务会话回调
     * @return 事务执行结果
     * 使用示例：
     * List<Object> results = (List<Object>) redisUtil.executeTransaction(new SessionCallback<>() {
     *     @Override
     *     public Object execute(RedisOperations operations) {
     *         operations.multi();
     *         operations.opsForValue().set("key1", "value1");
     *         operations.opsForValue().increment("counter");
     *         return operations.exec();
     *     }
     * });
     */
    public Object executeTransaction(SessionCallback<?> sessionCallback) {
        return redisTemplate.execute(sessionCallback);
    }
}