SpringBoot 操作 Redis 详解


  !版权声明:本博客内容均均为原创,每篇博文作为知识积累,写博不易,转载请注明出处。

目录[-]


系统环境:

  • Redis 版本:5.0.7
  • SpringBoot 版本:2.2.2.RELEASE

参考地址:

一、Redis 介绍

1、什么是 Redis

Redis 是一个高性能的 Key-Value 数据库,它是完全开源免费的,而且 Redis 是一个 NoSQL 类型数据库,是为了解决 高并发高扩展大数据存储 等一系列的问题而产生的数据库解决方案,是一个非关系型的数据库。但是,它也是不能替代关系型数据库,只能作为特定环境下的扩充。

2、redis的优势和特点

  • redis 数据读写速度非常快,因为它把数据都读取到内存当中操作,而且 redis 是用 C 语言编写的,是最“接近“”操作系统的语言,所以执行速度相对较快。
  • redis 虽然数据的读取都存在内存当中,但是最终它是支持数据持久化到磁盘当中。
  • redis 提供了丰富的数据结构。
  • redis 的所有操作都是原子性,支持事务,所谓的原子性就是对数据的更改要么全部执行,要么全部不执行。
  • redis 支持主从复制,主机会自动将数据同步到从机,可以进行读写分离。

3、Redis 支持的数据结构类型包括:

集合(set):

set 是 string 类型的无序集合,不同于 list,set 中的元素不可以重复。

哈希表(hash):

hash 类似于 java 中的 map,是一个键值对集合,在 redis 中可以用来存储对象。

列表(list):

list 是一个链表结构,主要功能是 push、pop 获取一个范围的所有值等等。操作中 key 理解为链表的名字。

有序集合(zset):

zset 和 set 一样,也是 string 类型的元素的集合,不同的是ZSET中的每个元素都会关联一个 double 类型的分数,zset 中的成员都是唯一的,但是所关联的分数可以重复。

字符串(string):

string 是 redis 中最基本的数据类型,redis 中的 string 类型是二进制安全的,即它可以包含任何数据,比如一个序列化的对象甚至一个图片(注意的是 redis 中的字符串大小上限是 512M)。

4、Redis 的应用场景

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

5、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>mydlq.club</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 又有多种方式,下面介绍下如何配置 单机哨兵集群 的连接参数,需要将这些参数配置到 SpringBootapplication 配置文件中。

  • 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 配置
 *
 * @author mydlq
 */
@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

(1)、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();
    }

}

(2)、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);
    }

}

(3)、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);
    }

}

(4)、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);
    }

}

(5)、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);
    }

}

(6)、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);
    }

}

(7)、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 mydlq.club.example.service.RedisBatch;
import mydlq.club.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);
    }

}

—END—