Spring Boot中集成Redis详解

最新推荐文章于 2025-05-30 14:25:53 发布

原创最新推荐文章于 2025-05-30 14:25:53 发布 · 660 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#spring boot #redis #后端

笔记专栏收录该内容

44 篇文章

订阅专栏

一、Redis 介绍

1、什么是 Redis

Redis（Remote Dictionary Server）是一个开源的高性能键值对存储数据库，属于非关系型数据库（NoSQL）。它通过在内存中存储数据来提供快速的读写访问，并使用磁盘持久化来保证数据的可靠性。

Redis 提供了丰富的数据结构支持，包括字符串（String）、哈希（Hash）、列表（List）、集合（Set）、有序集合（Sorted Set）等。这些数据结构非常灵活，能够满足各种实际应用场景的需求。

2、Redis 的主要特点包括

快速读写：Redis 的数据都存储在内存中，使得它具有非常高的读写性能。它还使用了一些优化技术，如异步和多线程，以提高性能。
持久化：Redis 提供了两种方式来持久化数据，即快照（snapshot）和日志（append-only file）。快照是将数据写入磁盘，而日志则是记录每个写操作，用以恢复数据。
分布式：Redis 支持分布式部署，可以通过集群（Cluster）、主从复制（Master-Slave）等方式来扩展容量和提高可用性。
数据类型丰富：除了基本的键值对存储，Redis 还提供了丰富的数据结构，如哈希（Hash）、列表（List）、集合（Set）、有序集合（Sorted Set）等，使得它能够适应各种不同的数据需求。
支持事务：Redis 支持事务操作，允许一系列命令按顺序执行，并且在执行期间不会被其他客户端的命令打断。
可扩展性：Redis 可以通过增加更多的节点来扩展容量和吞吐量，以满足大规模业务的需求。

Redis 可以用于广泛的应用场景，如缓存、消息队列、计数器、排行榜、实时发布/订阅等。其简单、高效和灵活的特性使其成为流行的数据存储解决方案。

3、Redis 的应用场景

排行榜
计数器
限速器
分布式锁
分布式会话
热点数据缓存

4、Redis 与其它 Key-Value 的区别

Redis 支持数据的备份，即 master - slave 模式的数据备份。
Redis 支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
Redis 不仅仅支持简单的 key - value 类型的数据，同时还提供 list、set、zset、hash 等数据结构的存储。

二、SpringBoot 操作 Redis

1、Maven 引入相关依赖

引入 SpringBoot 和 Redis 依赖，由于 SpringBoot 2.x + 版本后是用 lettuce 作为连接池，所以需要引入 commons-pool2 依赖。

<?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.3.4.RELEASE</version>
    </parent>

    <groupId>com.demo</groupId>
    <artifactId>springboot-redis-example</artifactId>
    <version>0.0.1</version>
    <name>springboot-redis-example</name>
    <description>Demo project for Spring Boot Redis</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <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>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

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

</project>

2、配置文件中添加相关参数

Redis 有多重部署方式，所以连接 Redis 又有多种方式，下面介绍下如何配置 单机、哨兵、集群 的连接参数，需要将这些参数配置到 SpringBoot 的 application 配置文件中。

Redis 单机配置：

spring:
  redis:
    database: 0             #数据库
    ssl: false              #是否开启ssl
    timeout: 1000           #超时时间，单位为毫秒
    host: 127.0.0.1         #Reids主机地址
    port: 6379              #Redis端口号
    lettuce:                #使用 lettuce 连接池
      pool:
        max-active: 20      #连接池最大连接数（使用负值表示没有限制）
        max-wait: -1        #连接池最大阻塞等待时间（使用负值表示没有限制）
        min-idle: 0         #连接池中的最大空闲连接
        max-idle: 10        #连接池中的最小空闲连接

Redis 哨兵配置：

spring:
  redis:
    sentinel:                 #哨兵配置
      master: my-master       #Redis服务器名称
      nodes:                  #Redis哨兵地址
        - 192.168.2.11:6379
        - 192.168.2.12:6379
        - 192.168.2.13:6379
    database: 0               #Redis 索引（0~15，默认为0）
    timeout: 1000             #Redis 连接的超时时间
    password: 123456          #Redis 密码，如果没有就默认不配置此参数  
    lettuce:                  #使用 lettuce 连接池
      pool:
        max-active: 20        #连接池最大连接数（使用负值表示没有限制）
        max-wait: -1          #连接池最大阻塞等待时间（使用负值表示没有限制）
        min-idle: 0           #连接池中的最大空闲连接
        max-idle: 10          #连接池中的最小空闲连接

Redis 集群配置：

spring:
  redis:
    database: 0               #Redis 索引（0~15，默认为0）
    timeout: 1000             #Redis 连接的超时时间
    password: 123456          #Redis 密码，如果没有就默认不配置此参数  
    cluster:                  #Redis 集群配置
      max-redirects: 5        #Redis 命令执行时最多转发次数    
      nodes:                  #Redis 集群地址  
        - 192.168.2.11:6379
        - 192.168.2.12:6379
        - 192.168.2.13:6379
        - 192.168.2.11:6380
        - 192.168.2.12:6380
        - 192.168.2.13:6380
    lettuce:                  #使用 lettuce 连接池
      pool:
        max-active: 20        #连接池最大连接数（使用负值表示没有限制）
        max-wait: -1          #连接池最大阻塞等待时间（使用负值表示没有限制）
        min-idle: 0           #连接池中的最大空闲连接
        max-idle: 10          #连接池中的最小空闲连接

3、配置 RedisTemplate 中序列化参数

在 RedisTemplate 默认是使用的 Java 字符串序列化，该序列化存入 Redis 并不能够提供可读性，比较流行的做法是替换成 Jackson 序列化，以 JSON 方式进行存储。

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.*;

/**
 * Redis 配置
 */
@Configuration
public class RedisConfig {

    /**
     * Redis 序列化配置
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        // 使用GenericJackson2JsonRedisSerializer替换默认序列化
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // 设置 Key 和 Value 的序列化规则
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        // 初始化 RedisTemplate 序列化完成
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

}

4、使用 RedisTemplate 操作 Redis

Redis 基本操作

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class RedisBase {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 指定 key 的过期时间
     *
     * @param key  键
     * @param time 时间(秒)
     */
    public void expire(String key, long time) {
        redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }

    /**
     * 根据 key 获取过期时间（-1 即为永不过期）
     *
     * @param key 键
     * @return 过期时间
     */
    public Long ttl(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }


    /**
     * 判断 key 是否存在
     *
     * @param key 键
     * @return 如果存在 key 则返回 true，否则返回 false
     */
    public Boolean exists(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 删除 key
     *
     * @param key 键
     */
    public Long del(String... key) {
        if (key == null || key.length < 1) {
            return 0L;
        }
        return redisTemplate.delete(Arrays.asList(key));
    }

    /**
     * 获取 Key 的类型
     *
     * @param key 键
     */
    public String type(String key) {
        DataType dataType = redisTemplate.type(key);
        assert dataType != null;
        return dataType.code();
    }

}

Redis 批量操作

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;

@Slf4j
@Service
public class RedisBatch {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 批量设置值
     *
     * @param map 要插入的 key value 集合
     */
    public void barchSet(Map<String, Object> map) {
        redisTemplate.opsForValue().multiSet(map);
    }

    /**
     * 批量获取值
     *
     * @param list 查询的 Key 列表
     * @return value 列表
     */
    public List<Object> batchGet(List<String> list) {
        return redisTemplate.opsForValue().multiGet(list);
    }

}

Redis 字符串操作

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class RedisString {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 获取指定 key 的值
     *
     * @param key 键
     * @return 返回 key 的值
     */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 获取所有一个或多个给定 key 的值
     *
     * @param list Key 集合
     * @return 值集合
     */
    public List<Object> mGet(Collection<String> list) {
        return redisTemplate.opsForValue().multiGet(list);
    }

    /**
     * 设置给定 key 的值（如果 key 已经存在就覆写旧值）
     *
     * @param key   键
     * @param value 值
     */
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 同时设置一个或多个 key-value 对
     *
     * @param map 键值集合
     */
    public void set(Map<String, Object> map) {
        redisTemplate.opsForValue().multiSet(map);
    }

    /**
     * 设置给定 key 的值，并设置过期时间
     *
     * @param key   键
     * @param value 值
     * @param time  过期时间(秒)
     */
    public void set(String key, Object value, long time) {
        if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            set(key, value);
        }
    }

    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return 递增后的值
     */
    public Long incr(String key, long delta) {
        if (delta > 0) {
            throw new IllegalArgumentException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return 递减后的值
     */
    public Long decr(String key, long delta) {
        if (delta < 0) {
            throw new IllegalArgumentException("递减因子必须小于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

}

Redis 哈希操作

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.Map;

@Slf4j
@Service
public class RedisHash {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private RedisBase redisBase;

    /**
     * 获取存储在哈希表中指定字段的值
     *
     * @param key  键
     * @param item 项
     * @return 值
     */
    public Object hGet(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 将哈希表 key 中的字段 field 的值设为 value（如果不存在将创建）
     *
     * @param key   键
     * @param item  项
     * @param value 值
     */
    public void hSet(String key, String item, Object value) {
        redisTemplate.opsForHash().put(key, item, value);
    }

    /**
     * 将哈希表 key 中的字段 field 的值设为 value，并设置过期时间
     * （如果不存在将创建，且如果已存在的hash表有时间,这里将会替换原有的时间）
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间（秒）
     */
    public void hSet(String key, String item, Object value, long time) {
        redisTemplate.opsForHash().put(key, item, value);
        if (time > 0) {
            redisBase.expire(key, time);
        }
    }

    /**
     * 获取所有给定字段的值
     *
     * @param key 键
     * @return 一个包含多个给定字段关联值的表，表值的排列顺序和指定字段的请求顺序一样
     */
    public Map<Object, Object> hmGet(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 同时将多个“域-值”对设置到哈希表 key 中
     *
     * @param key 键
     * @param map 对应多个键值
     */
    public void hmSet(String key, Map<String, Object> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }

    /**
     * 同时将多个“域-值”对设置到哈希表 key 中，并设置过期时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间（秒）
     */
    public void hmSet(String key, Map<String, Object> map, long time) {
        redisTemplate.opsForHash().putAll(key, map);
        if (time > 0) {
            redisBase.expire(key, time);
        }
    }

    /**
     * 删除一个或多个哈希表字段
     *
     * @param key  键
     * @param item 项（可以使多个）
     * @return 成功删除字段的数量
     */
    public Long hDel(String key, Object... item) {
        return redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 查看哈希表 key 中，指定的字段是否存在
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 如果存在则返回 true，不存在则返回 false
     */
    public Boolean hExists(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * 哈希证书递增或递减数（正数递增、负数递减），如果不存在,就会创建一个，并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   增加或减少的数
     * @return 执行操作后，哈希表中字段的值
     */
    public Double hIncrby(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

}

Redis 列表操作

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.List;

@Slf4j
@Service
public class RedisList {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private RedisBase redisBase;

    /**
     * 获取列表指定范围内的元素，正数则表示正向查找，负数则倒叙查找
     *
     * @param key   键
     * @param start 开始
     * @param end   结束
     * @return boolean
     * @see <a href="https://redis.io/commands/lrange">Redis Documentation: LRANGE</a>
     */
    public List<Object> lRange(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    /**
     * 获取列表长度
     *
     * @param key 键
     * @return 列表长度
     */
    public Long lLen(String key) {
        return redisTemplate.opsForList().size(key);
    }

    /**
     * 通过索引获取列表中的元素
     *
     * @param key   键
     * @param index 索引（index>=0时，0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推）
     * @return 列表中的元素
     */
    public Object lIndex(String key, long index) {
        return redisTemplate.opsForList().index(key, index);
    }

    /**
     * 在列表前端添加一个值
     *
     * @param key   键
     * @param value 值
     * @return 返回列表当前长度
     */
    public Long lPush(String key, Object value) {
        return redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 在列表前端添加一个值，并设置过期时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间（秒）
     * @return 返回列表当前长度
     */
    public Long lPush(String key, Object value, long time) {
        Long size = redisTemplate.opsForList().leftPush(key, value);
        if (time > 0) {
            redisBase.expire(key, time);
        }
        return size;
    }

    /**
     * 在列表前端添加多个值
     *
     * @param key   键
     * @param value 值
     * @return 返回列表当前长度
     */
    public Long lPush(String key, List<Object> value) {
        return redisTemplate.opsForList().leftPushAll(key, value);
    }

    /**
     * 在列表前端添加多个值，并设置过期时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间（秒）
     * @return 返回列表当前长度
     */
    public Long lPush(String key, List<Object> value, long time) {
        Long size = redisTemplate.opsForList().leftPushAll(key, value);
        if (time > 0) {
            redisBase.expire(key, time);
        }
        return size;
    }

    /**
     * 在列末尾端添加一个值
     *
     * @param key   键
     * @param value 值
     * @return 返回列表当前长度
     */
    public Long rPush(String key, Object value) {
        return redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 在列表末尾添加一个值，并设置过期时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间（秒）
     * @return 返回列表当前长度
     */
    public Long rPush(String key, Object value, long time) {
        Long size = redisTemplate.opsForList().leftPush(key, value);
        if (time > 0) {
            redisBase.expire(key, time);
        }
        return size;
    }

    /**
     * 在列表末尾添加多个值
     *
     * @param key   键
     * @param value 值
     * @return 返回列表当前长度
     */
    public Long rPush(String key, List<Object> value) {
        return redisTemplate.opsForList().rightPushAll(key, value);
    }

    /**
     * 在列表末尾添加多个值，并设置过期时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间（秒）
     * @return 返回列表当前长度
     */
    public Long rPush(String key, List<Object> value, long time) {
        Long size = redisTemplate.opsForList().rightPushAll(key, value);
        if (time > 0) {
            redisBase.expire(key, time);
        }
        return size;
    }

    /**
     * 通过索引设置列表元素的值
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     */
    public void lSet(String key, long index, Object value) {
        redisTemplate.opsForList().set(key, index, value);
    }

    /**
     * 移除列表元素
     *
     * @param key   键
     * @param count 移除数量（"负数"则从列表倒叙查找删除 count 个对应的值; "整数"则从列表正序查找删除 count 个对应的值;）
     * @param value 值
     * @return 成功移除的个数
     */
    public Long lRem(String key, long count, Object value) {
        return redisTemplate.opsForList().remove(key, count, value);
    }

}

Redis 集合操作

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.Set;

@Slf4j
@Service
public class RedisSet {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private RedisBase redisBase;

    /**
     * 返回集合中的所有成员
     *
     * @param key 键
     * @return 集合中的所有成员
     */
    public Set<Object> sMembers(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 判断 member 元素是否是集合 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 sAdd(String key, Object... values) {
        return redisTemplate.opsForSet().add(key, values);
    }

    /**
     * 向集合添加一个或多个成员，并设置过期时间
     *
     * @param key    键
     * @param time   时间（秒）
     * @param values 值（可以是多个）
     * @return 添加成功元素的个数
     */
    public Long sAdd(String key, long time, Object... values) {
        Long count = redisTemplate.opsForSet().add(key, values);
        if (time > 0) {
            redisBase.expire(key, time);
        }
        return count;
    }

    /**
     * 获取集合的成员数
     *
     * @param key 键
     * @return 返回集合中元素的数量
     */
    public Long sCard(String key) {
        return redisTemplate.opsForSet().size(key);
    }

    /**
     * 移除集合中一个或多个成员
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public Long sRem(String key, Object... values) {
        return redisTemplate.opsForSet().remove(key, values);
    }

}

Redis 有序集合操作

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;
import java.util.Set;

@Slf4j
@Service
public class RedisSortSet {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 向有序集合添加成员
     *
     * @param key   键
     * @param value 值
     * @param score 分数
     * @return 添加成功元素的个数
     */
    public Boolean zAdd(String key, Object value, double score) {
        return redisTemplate.opsForZSet().add(key, value, score);
    }

    /**
     * 向有序集合添加多个成员
     *
     * @param key 键
     * @param set 值
     * @return 添加成功元素的个数
     */
    public Long zAdd(String key, Set<ZSetOperations.TypedTuple<Object>> set) {
        return redisTemplate.opsForZSet().add(key, set);
    }

    /**
     * 移除有序集合中的一个或多个成员
     *
     * @param key    键
     * @param values 值
     */
    public Long zRem(String key, Object... values) {
        return redisTemplate.opsForZSet().remove(key, values);
    }

    /**
     * 有序集合操作分数的加/减
     *
     * @param key   键
     * @param value 值
     * @param score 分数
     * @return 成员的新分数值
     */
    public Double zincrby(String key, String value, double score) {
        return redisTemplate.opsForZSet().incrementScore(key, value, score);
    }

    /**
     * 返回有序集中，成员的分数值
     *
     * @param key   键
     * @param value 值
     * @return 成员的分数值
     */
    public Double zScore(String key, String value) {
        return redisTemplate.opsForZSet().score(key, value);
    }

    /**
     * 返回有序集合中指定成员的索引
     *
     * @param key   键
     * @param value 值
     * @return 成员的索引
     */
    public Long zRank(String key, String value) {
        return redisTemplate.opsForZSet().rank(key, value);
    }

    /**
     * 获取有序集合的成员数（集合长度）
     *
     * @param key 键
     * @return 成员总数
     */
    public Long zCard(String key) {
        return redisTemplate.opsForZSet().zCard(key);
    }

    /**
     * 通过索引区间返回有序集合指定区间内的成员（按分数从小到大排序）
     *
     * @param key   键
     * @param start 开始数（0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推）
     * @param end   结束数（-1 表示最后一个成员，-2 表示倒数第二个成员，以此类推）
     * @return 指定区间内，带有分数值(可选)的有序集成员的列表
     */
    public Set<Object> zrange(String key, int start, int end) {
        return redisTemplate.opsForZSet().range(key, start, end);
    }

    /**
     * 通过索引区间返回有序集合指定区间内的成员 & 分数
     *
     * @param key   键
     * @param start 开始数（0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推）
     * @param end   结束数（-1 表示最后一个成员，-2 表示倒数第二个成员，以此类推）
     * @return 指定区间内，带有分数值(可选)的有序集成员的列表
     */
    public Set<ZSetOperations.TypedTuple<Object>> zRange(String key, int start, int end) {
        return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
    }

    /**
     * 返回有序集中指定区间内的成员，通过索引，分数从高到低
     *
     * @param key   键
     * @param start 开始
     * @param end   结束
     * @return 指定区间内的成员
     */
    public Set<Object> zRevRange(String key, int start, int end) {
        return redisTemplate.opsForZSet().reverseRange(key, start, end);
    }

    /**
     * 通过分数返回有序集合指定区间内的成员
     *
     * @param key 键
     * @param min 最小
     * @param max 最大
     * @return 指定区间内的成员
     */
    public Set<Object> zRangeByScore(String key, int min, int max) {
        return redisTemplate.opsForZSet().rangeByScore(key, min, max);
    }

}

5、Redis 操作 Controller

这里写个简单的 Controller 类，简单的调用 Redis 字符串服务操作，内容如下：

import com.example.service.RedisBatch;
import com.example.service.RedisString;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
public class RedisController {

    @Autowired
    private RedisBatch redisBatch;

    @Autowired
    private RedisString redisString;

    /**
     * 存值
     *
     * @param key   键
     * @param value 值
     * @return 存储结果
     */
    @GetMapping("/set")
    public String redisStringSet(@RequestParam String key, @RequestParam String value) {
        redisString.set(key, value);
        return "存储成功";
    }

    /**
     * 取值
     *
     * @param key 键
     * @return 值
     */
    @GetMapping("/get")
    public Object redisStringGet(@RequestParam String key) {
        return redisString.get(key);
    }

    /**
     * 批量存值
     */
    @GetMapping("/batch/set")
    public void redisBatchSet() {
        Map<String, Object> map = new HashMap<>(3);
        map.put("test1", "value1");
        map.put("test2", "value2");
        map.put("test3", "value3");
        redisBatch.barchSet(map);
    }

    /**
     * 批量取值
     *
     * @return 值列表
     */
    @GetMapping("/batch/get")
    public List<Object> redisBatchGet() {
        // 批量取值，如果某个 key 不存在，则值为 null
        List<String> list = new ArrayList<>(3);
        list.add("test1");
        list.add("test2");
        list.add("test3");
        return redisBatch.batchGet(list);
    }

}

6、SpringBoot 启动类

SpringBoot 的启动类，内容如下：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}