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