SpringBoot 操作 Redis 详解
文章目录
!版权声明：本博客内容均为原创,每篇博文作为知识积累,写博不易,转载请注明出处。
系统环境：
- Redis 版本：5.0.7
- SpringBoot 版本：2.2.2.RELEASE
参考地址：
- Redus 官方网址：https://redis.io/
- 博文示例项目 Github 地址：https://github.com/my-dlq/blog-example/tree/master/springboot/springboot-redis-example
一、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 依赖。
1<?xml version="1.0" encoding="UTF-8"?>
2<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
4 <modelVersion>4.0.0</modelVersion>
5
6 <parent>
7 <groupId>org.springframework.boot</groupId>
8 <artifactId>spring-boot-starter-parent</artifactId>
9 <version>2.3.4.RELEASE</version>
10 </parent>
11
12 <groupId>mydlq.club</groupId>
13 <artifactId>springboot-redis-example</artifactId>
14 <version>0.0.1</version>
15 <name>springboot-redis-example</name>
16 <description>Demo project for Spring Boot Redis</description>
17
18 <properties>
19 <java.version>1.8</java.version>
20 </properties>
21
22 <dependencies>
23 <dependency>
24 <groupId>org.springframework.boot</groupId>
25 <artifactId>spring-boot-starter-web</artifactId>
26 </dependency>
27 <dependency>
28 <groupId>org.springframework.boot</groupId>
29 <artifactId>spring-boot-starter-data-redis</artifactId>
30 </dependency>
31 <dependency>
32 <groupId>org.apache.commons</groupId>
33 <artifactId>commons-pool2</artifactId>
34 </dependency>
35 <dependency>
36 <groupId>org.projectlombok</groupId>
37 <artifactId>lombok</artifactId>
38 </dependency>
39 </dependencies>
40
41 <build>
42 <plugins>
43 <plugin>
44 <groupId>org.springframework.boot</groupId>
45 <artifactId>spring-boot-maven-plugin</artifactId>
46 </plugin>
47 </plugins>
48 </build>
49
50</project>
2、配置文件中添加相关参数
Redis 有多重部署方式，所以连接 Redis 又有多种方式，下面介绍下如何配置 单机、哨兵、集群 的连接参数，需要将这些参数配置到 SpringBoot 的 application 配置文件中。
- Redis 单机配置：
1spring:
2 redis:
3 database: 0 #数据库
4 ssl: false #是否开启ssl
5 timeout: 1000 #超时时间，单位为毫秒
6 host: 127.0.0.1 #Reids主机地址
7 port: 6379 #Redis端口号
8 lettuce: #使用 lettuce 连接池
9 pool:
10 max-active: 20 #连接池最大连接数（使用负值表示没有限制）
11 max-wait: -1 #连接池最大阻塞等待时间（使用负值表示没有限制）
12 min-idle: 0 #连接池中的最大空闲连接
13 max-idle: 10 #连接池中的最小空闲连接
- Redis 哨兵配置：
1spring:
2 redis:
3 sentinel: #哨兵配置
4 master: my-master #Redis服务器名称
5 nodes: #Redis哨兵地址
6 - 192.168.2.11:6379
7 - 192.168.2.12:6379
8 - 192.168.2.13:6379
9 database: 0 #Redis 索引（0~15，默认为0）
10 timeout: 1000 #Redis 连接的超时时间
11 password: 123456 #Redis 密码，如果没有就默认不配置此参数
12 lettuce: #使用 lettuce 连接池
13 pool:
14 max-active: 20 #连接池最大连接数（使用负值表示没有限制）
15 max-wait: -1 #连接池最大阻塞等待时间（使用负值表示没有限制）
16 min-idle: 0 #连接池中的最大空闲连接
17 max-idle: 10 #连接池中的最小空闲连接
- Redis 集群配置：
1spring:
2 redis:
3 database: 0 #Redis 索引（0~15，默认为0）
4 timeout: 1000 #Redis 连接的超时时间
5 password: 123456 #Redis 密码，如果没有就默认不配置此参数
6 cluster: #Redis 集群配置
7 max-redirects: 5 #Redis 命令执行时最多转发次数
8 nodes: #Redis 集群地址
9 - 192.168.2.11:6379
10 - 192.168.2.12:6379
11 - 192.168.2.13:6379
12 - 192.168.2.11:6380
13 - 192.168.2.12:6380
14 - 192.168.2.13:6380
15 lettuce: #使用 lettuce 连接池
16 pool:
17 max-active: 20 #连接池最大连接数（使用负值表示没有限制）
18 max-wait: -1 #连接池最大阻塞等待时间（使用负值表示没有限制）
19 min-idle: 0 #连接池中的最大空闲连接
20 max-idle: 10 #连接池中的最小空闲连接
3、配置 RedisTemplate 中序列化参数
在 RedisTemplate 默认是使用的 Java 字符串序列化，该序列化存入 Redis 并不能够提供可读性，比较流行的做法是替换成 Jackson 序列化，以 JSON 方式进行存储。
1import org.springframework.context.annotation.Bean;
2import org.springframework.context.annotation.Configuration;
3import org.springframework.data.redis.connection.RedisConnectionFactory;
4import org.springframework.data.redis.core.RedisTemplate;
5import org.springframework.data.redis.serializer.*;
6
7/**
8 * Redis 配置
9 *
10 * @author mydlq
11 */
12@Configuration
13public class RedisConfig {
14
15 /**
16 * Redis 序列化配置
17 */
18 @Bean
19 public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
20 RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
21 redisTemplate.setConnectionFactory(connectionFactory);
22 // 使用GenericJackson2JsonRedisSerializer替换默认序列化
23 GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
24 // 设置 Key 和 Value 的序列化规则
25 redisTemplate.setKeySerializer(new StringRedisSerializer());
26 redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
27 redisTemplate.setHashKeySerializer(new StringRedisSerializer());
28 redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
29 // 初始化 RedisTemplate 序列化完成
30 redisTemplate.afterPropertiesSet();
31 return redisTemplate;
32 }
33
34}
4、使用 RedisTemplate 操作 Redis
(1)、Redis 基本操作
1import lombok.extern.slf4j.Slf4j;
2import org.springframework.beans.factory.annotation.Autowired;
3import org.springframework.data.redis.connection.DataType;
4import org.springframework.data.redis.core.RedisTemplate;
5import org.springframework.stereotype.Service;
6import java.util.Arrays;
7import java.util.concurrent.TimeUnit;
8
9@Slf4j
10@Service
11public class RedisBase {
12
13 @Autowired
14 private RedisTemplate<String, Object> redisTemplate;
15
16 /**
17 * 指定 key 的过期时间
18 *
19 * @param key 键
20 * @param time 时间(秒)
21 */
22 public void expire(String key, long time) {
23 redisTemplate.expire(key, time, TimeUnit.SECONDS);
24 }
25
26 /**
27 * 根据 key 获取过期时间（-1 即为永不过期）
28 *
29 * @param key 键
30 * @return 过期时间
31 */
32 public Long ttl(String key) {
33 return redisTemplate.getExpire(key, TimeUnit.SECONDS);
34 }
35
36
37 /**
38 * 判断 key 是否存在
39 *
40 * @param key 键
41 * @return 如果存在 key 则返回 true，否则返回 false
42 */
43 public Boolean exists(String key) {
44 return redisTemplate.hasKey(key);
45 }
46
47 /**
48 * 删除 key
49 *
50 * @param key 键
51 */
52 public Long del(String... key) {
53 if (key == null || key.length < 1) {
54 return 0L;
55 }
56 return redisTemplate.delete(Arrays.asList(key));
57 }
58
59 /**
60 * 获取 Key 的类型
61 *
62 * @param key 键
63 */
64 public String type(String key) {
65 DataType dataType = redisTemplate.type(key);
66 assert dataType != null;
67 return dataType.code();
68 }
69
70}
(2)、Redis 批量操作
1import lombok.extern.slf4j.Slf4j;
2import org.springframework.beans.factory.annotation.Autowired;
3import org.springframework.data.redis.core.RedisTemplate;
4import org.springframework.stereotype.Service;
5import java.util.List;
6import java.util.Map;
7
8@Slf4j
9@Service
10public class RedisBatch {
11
12 @Autowired
13 private RedisTemplate<String, Object> redisTemplate;
14
15 /**
16 * 批量设置值
17 *
18 * @param map 要插入的 key value 集合
19 */
20 public void barchSet(Map<String, Object> map) {
21 redisTemplate.opsForValue().multiSet(map);
22 }
23
24 /**
25 * 批量获取值
26 *
27 * @param list 查询的 Key 列表
28 * @return value 列表
29 */
30 public List<Object> batchGet(List<String> list) {
31 return redisTemplate.opsForValue().multiGet(list);
32 }
33
34}
(3)、Redis 字符串操作
1import lombok.extern.slf4j.Slf4j;
2import org.springframework.beans.factory.annotation.Autowired;
3import org.springframework.data.redis.core.RedisTemplate;
4import org.springframework.stereotype.Service;
5import java.util.Collection;
6import java.util.List;
7import java.util.Map;
8import java.util.concurrent.TimeUnit;
9
10@Slf4j
11@Service
12public class RedisString {
13
14 @Autowired
15 private RedisTemplate<String, Object> redisTemplate;
16
17 /**
18 * 获取指定 key 的值
19 *
20 * @param key 键
21 * @return 返回 key 的值
22 */
23 public Object get(String key) {
24 return redisTemplate.opsForValue().get(key);
25 }
26
27 /**
28 * 获取所有一个或多个给定 key 的值
29 *
30 * @param list Key 集合
31 * @return 值集合
32 */
33 public List<Object> mGet(Collection<String> list) {
34 return redisTemplate.opsForValue().multiGet(list);
35 }
36
37 /**
38 * 设置给定 key 的值（如果 key 已经存在就覆写旧值）
39 *
40 * @param key 键
41 * @param value 值
42 */
43 public void set(String key, Object value) {
44 redisTemplate.opsForValue().set(key, value);
45 }
46
47 /**
48 * 同时设置一个或多个 key-value 对
49 *
50 * @param map 键值集合
51 */
52 public void set(Map<String, Object> map) {
53 redisTemplate.opsForValue().multiSet(map);
54 }
55
56 /**
57 * 设置给定 key 的值，并设置过期时间
58 *
59 * @param key 键
60 * @param value 值
61 * @param time 过期时间(秒)
62 */
63 public void set(String key, Object value, long time) {
64 if (time > 0) {
65 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
66 } else {
67 set(key, value);
68 }
69 }
70
71 /**
72 * 递增
73 *
74 * @param key 键
75 * @param delta 要增加几(大于0)
76 * @return 递增后的值
77 */
78 public Long incr(String key, long delta) {
79 if (delta > 0) {
80 throw new IllegalArgumentException("递减因子必须大于0");
81 }
82 return redisTemplate.opsForValue().increment(key, delta);
83 }
84
85 /**
86 * 递减
87 *
88 * @param key 键
89 * @param delta 要减少几(小于0)
90 * @return 递减后的值
91 */
92 public Long decr(String key, long delta) {
93 if (delta < 0) {
94 throw new IllegalArgumentException("递减因子必须小于0");
95 }
96 return redisTemplate.opsForValue().increment(key, -delta);
97 }
98
99}
(4)、Redis 哈希操作
1import lombok.extern.slf4j.Slf4j;
2import org.springframework.beans.factory.annotation.Autowired;
3import org.springframework.data.redis.core.RedisTemplate;
4import org.springframework.stereotype.Service;
5import java.util.Map;
6
7@Slf4j
8@Service
9public class RedisHash {
10
11 @Autowired
12 private RedisTemplate<String, Object> redisTemplate;
13
14 @Autowired
15 private RedisBase redisBase;
16
17 /**
18 * 获取存储在哈希表中指定字段的值
19 *
20 * @param key 键
21 * @param item 项
22 * @return 值
23 */
24 public Object hGet(String key, String item) {
25 return redisTemplate.opsForHash().get(key, item);
26 }
27
28 /**
29 * 将哈希表 key 中的字段 field 的值设为 value（如果不存在将创建）
30 *
31 * @param key 键
32 * @param item 项
33 * @param value 值
34 */
35 public void hSet(String key, String item, Object value) {
36 redisTemplate.opsForHash().put(key, item, value);
37 }
38
39 /**
40 * 将哈希表 key 中的字段 field 的值设为 value，并设置过期时间
41 * （如果不存在将创建，且如果已存在的hash表有时间,这里将会替换原有的时间）
42 *
43 * @param key 键
44 * @param item 项
45 * @param value 值
46 * @param time 时间（秒）
47 */
48 public void hSet(String key, String item, Object value, long time) {
49 redisTemplate.opsForHash().put(key, item, value);
50 if (time > 0) {
51 redisBase.expire(key, time);
52 }
53 }
54
55 /**
56 * 获取所有给定字段的值
57 *
58 * @param key 键
59 * @return 一个包含多个给定字段关联值的表，表值的排列顺序和指定字段的请求顺序一样
60 */
61 public Map<Object, Object> hmGet(String key) {
62 return redisTemplate.opsForHash().entries(key);
63 }
64
65 /**
66 * 同时将多个“域-值”对设置到哈希表 key 中
67 *
68 * @param key 键
69 * @param map 对应多个键值
70 */
71 public void hmSet(String key, Map<String, Object> map) {
72 redisTemplate.opsForHash().putAll(key, map);
73 }
74
75 /**
76 * 同时将多个“域-值”对设置到哈希表 key 中，并设置过期时间
77 *
78 * @param key 键
79 * @param map 对应多个键值
80 * @param time 时间（秒）
81 */
82 public void hmSet(String key, Map<String, Object> map, long time) {
83 redisTemplate.opsForHash().putAll(key, map);
84 if (time > 0) {
85 redisBase.expire(key, time);
86 }
87 }
88
89 /**
90 * 删除一个或多个哈希表字段
91 *
92 * @param key 键
93 * @param item 项（可以使多个）
94 * @return 成功删除字段的数量
95 */
96 public Long hDel(String key, Object... item) {
97 return redisTemplate.opsForHash().delete(key, item);
98 }
99
100 /**
101 * 查看哈希表 key 中，指定的字段是否存在
102 *
103 * @param key 键 不能为null
104 * @param item 项 不能为null
105 * @return 如果存在则返回 true，不存在则返回 false
106 */
107 public Boolean hExists(String key, String item) {
108 return redisTemplate.opsForHash().hasKey(key, item);
109 }
110
111 /**
112 * 哈希证书递增或递减数（正数递增、负数递减），如果不存在,就会创建一个，并把新增后的值返回
113 *
114 * @param key 键
115 * @param item 项
116 * @param by 增加或减少的数
117 * @return 执行操作后，哈希表中字段的值
118 */
119 public Double hIncrby(String key, String item, double by) {
120 return redisTemplate.opsForHash().increment(key, item, by);
121 }
122
123}
(5)、Redis 列表操作
1import lombok.extern.slf4j.Slf4j;
2import org.springframework.beans.factory.annotation.Autowired;
3import org.springframework.data.redis.core.RedisTemplate;
4import org.springframework.stereotype.Service;
5import java.util.List;
6
7@Slf4j
8@Service
9public class RedisList {
10
11 @Autowired
12 private RedisTemplate<String, Object> redisTemplate;
13
14 @Autowired
15 private RedisBase redisBase;
16
17 /**
18 * 获取列表指定范围内的元素，正数则表示正向查找，负数则倒叙查找
19 *
20 * @param key 键
21 * @param start 开始
22 * @param end 结束
23 * @return boolean
24 * @see <a href="https://redis.io/commands/lrange">Redis Documentation: LRANGE</a>
25 */
26 public List<Object> lRange(String key, long start, long end) {
27 return redisTemplate.opsForList().range(key, start, end);
28 }
29
30 /**
31 * 获取列表长度
32 *
33 * @param key 键
34 * @return 列表长度
35 */
36 public Long lLen(String key) {
37 return redisTemplate.opsForList().size(key);
38 }
39
40 /**
41 * 通过索引获取列表中的元素
42 *
43 * @param key 键
44 * @param index 索引（index>=0时，0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推）
45 * @return 列表中的元素
46 */
47 public Object lIndex(String key, long index) {
48 return redisTemplate.opsForList().index(key, index);
49 }
50
51 /**
52 * 在列表前端添加一个值
53 *
54 * @param key 键
55 * @param value 值
56 * @return 返回列表当前长度
57 */
58 public Long lPush(String key, Object value) {
59 return redisTemplate.opsForList().rightPush(key, value);
60 }
61
62 /**
63 * 在列表前端添加一个值，并设置过期时间
64 *
65 * @param key 键
66 * @param value 值
67 * @param time 时间（秒）
68 * @return 返回列表当前长度
69 */
70 public Long lPush(String key, Object value, long time) {
71 Long size = redisTemplate.opsForList().leftPush(key, value);
72 if (time > 0) {
73 redisBase.expire(key, time);
74 }
75 return size;
76 }
77
78 /**
79 * 在列表前端添加多个值
80 *
81 * @param key 键
82 * @param value 值
83 * @return 返回列表当前长度
84 */
85 public Long lPush(String key, List<Object> value) {
86 return redisTemplate.opsForList().leftPushAll(key, value);
87 }
88
89 /**
90 * 在列表前端添加多个值，并设置过期时间
91 *
92 * @param key 键
93 * @param value 值
94 * @param time 时间（秒）
95 * @return 返回列表当前长度
96 */
97 public Long lPush(String key, List<Object> value, long time) {
98 Long size = redisTemplate.opsForList().leftPushAll(key, value);
99 if (time > 0) {
100 redisBase.expire(key, time);
101 }
102 return size;
103 }
104
105 /**
106 * 在列末尾端添加一个值
107 *
108 * @param key 键
109 * @param value 值
110 * @return 返回列表当前长度
111 */
112 public Long rPush(String key, Object value) {
113 return redisTemplate.opsForList().rightPush(key, value);
114 }
115
116 /**
117 * 在列表末尾添加一个值，并设置过期时间
118 *
119 * @param key 键
120 * @param value 值
121 * @param time 时间（秒）
122 * @return 返回列表当前长度
123 */
124 public Long rPush(String key, Object value, long time) {
125 Long size = redisTemplate.opsForList().leftPush(key, value);
126 if (time > 0) {
127 redisBase.expire(key, time);
128 }
129 return size;
130 }
131
132 /**
133 * 在列表末尾添加多个值
134 *
135 * @param key 键
136 * @param value 值
137 * @return 返回列表当前长度
138 */
139 public Long rPush(String key, List<Object> value) {
140 return redisTemplate.opsForList().rightPushAll(key, value);
141 }
142
143 /**
144 * 在列表末尾添加多个值，并设置过期时间
145 *
146 * @param key 键
147 * @param value 值
148 * @param time 时间（秒）
149 * @return 返回列表当前长度
150 */
151 public Long rPush(String key, List<Object> value, long time) {
152 Long size = redisTemplate.opsForList().rightPushAll(key, value);
153 if (time > 0) {
154 redisBase.expire(key, time);
155 }
156 return size;
157 }
158
159 /**
160 * 通过索引设置列表元素的值
161 *
162 * @param key 键
163 * @param index 索引
164 * @param value 值
165 */
166 public void lSet(String key, long index, Object value) {
167 redisTemplate.opsForList().set(key, index, value);
168 }
169
170 /**
171 * 移除列表元素
172 *
173 * @param key 键
174 * @param count 移除数量（"负数"则从列表倒叙查找删除 count 个对应的值; "整数"则从列表正序查找删除 count 个对应的值;）
175 * @param value 值
176 * @return 成功移除的个数
177 */
178 public Long lRem(String key, long count, Object value) {
179 return redisTemplate.opsForList().remove(key, count, value);
180 }
181
182}
(6)、Redis 集合操作
1import lombok.extern.slf4j.Slf4j;
2import org.springframework.beans.factory.annotation.Autowired;
3import org.springframework.data.redis.core.RedisTemplate;
4import org.springframework.stereotype.Service;
5import java.util.Set;
6
7@Slf4j
8@Service
9public class RedisSet {
10
11 @Autowired
12 private RedisTemplate<String, Object> redisTemplate;
13
14 @Autowired
15 private RedisBase redisBase;
16
17 /**
18 * 返回集合中的所有成员
19 *
20 * @param key 键
21 * @return 集合中的所有成员
22 */
23 public Set<Object> sMembers(String key) {
24 return redisTemplate.opsForSet().members(key);
25 }
26
27 /**
28 * 判断 member 元素是否是集合 key 的成员
29 *
30 * @param key 键
31 * @param value 值
32 * @return 如果存在则返回 true 否则返回 false
33 */
34 public Boolean sisMember(String key, Object value) {
35 return redisTemplate.opsForSet().isMember(key, value);
36 }
37
38 /**
39 * 向集合添加一个或多个成员
40 *
41 * @param key 键
42 * @param values 值
43 * @return 添加成功元素的个数
44 */
45 public Long sAdd(String key, Object... values) {
46 return redisTemplate.opsForSet().add(key, values);
47 }
48
49 /**
50 * 向集合添加一个或多个成员，并设置过期时间
51 *
52 * @param key 键
53 * @param time 时间（秒）
54 * @param values 值（可以是多个）
55 * @return 添加成功元素的个数
56 */
57 public Long sAdd(String key, long time, Object... values) {
58 Long count = redisTemplate.opsForSet().add(key, values);
59 if (time > 0) {
60 redisBase.expire(key, time);
61 }
62 return count;
63 }
64
65 /**
66 * 获取集合的成员数
67 *
68 * @param key 键
69 * @return 返回集合中元素的数量
70 */
71 public Long sCard(String key) {
72 return redisTemplate.opsForSet().size(key);
73 }
74
75 /**
76 * 移除集合中一个或多个成员
77 *
78 * @param key 键
79 * @param values 值 可以是多个
80 * @return 移除的个数
81 */
82 public Long sRem(String key, Object... values) {
83 return redisTemplate.opsForSet().remove(key, values);
84 }
85
86}
(7)、Redis 有序集合操作
1import lombok.extern.slf4j.Slf4j;
2import org.springframework.beans.factory.annotation.Autowired;
3import org.springframework.data.redis.core.RedisTemplate;
4import org.springframework.data.redis.core.ZSetOperations;
5import org.springframework.stereotype.Service;
6import java.util.Set;
7
8@Slf4j
9@Service
10public class RedisSortSet {
11
12 @Autowired
13 private RedisTemplate<String, Object> redisTemplate;
14
15 /**
16 * 向有序集合添加成员
17 *
18 * @param key 键
19 * @param value 值
20 * @param score 分数
21 * @return 添加成功元素的个数
22 */
23 public Boolean zAdd(String key, Object value, double score) {
24 return redisTemplate.opsForZSet().add(key, value, score);
25 }
26
27 /**
28 * 向有序集合添加多个成员
29 *
30 * @param key 键
31 * @param set 值
32 * @return 添加成功元素的个数
33 */
34 public Long zAdd(String key, Set<ZSetOperations.TypedTuple<Object>> set) {
35 return redisTemplate.opsForZSet().add(key, set);
36 }
37
38 /**
39 * 移除有序集合中的一个或多个成员
40 *
41 * @param key 键
42 * @param values 值
43 */
44 public Long zRem(String key, Object... values) {
45 return redisTemplate.opsForZSet().remove(key, values);
46 }
47
48 /**
49 * 有序集合操作分数的加/减
50 *
51 * @param key 键
52 * @param value 值
53 * @param score 分数
54 * @return 成员的新分数值
55 */
56 public Double zincrby(String key, String value, double score) {
57 return redisTemplate.opsForZSet().incrementScore(key, value, score);
58 }
59
60 /**
61 * 返回有序集中，成员的分数值
62 *
63 * @param key 键
64 * @param value 值
65 * @return 成员的分数值
66 */
67 public Double zScore(String key, String value) {
68 return redisTemplate.opsForZSet().score(key, value);
69 }
70
71 /**
72 * 返回有序集合中指定成员的索引
73 *
74 * @param key 键
75 * @param value 值
76 * @return 成员的索引
77 */
78 public Long zRank(String key, String value) {
79 return redisTemplate.opsForZSet().rank(key, value);
80 }
81
82 /**
83 * 获取有序集合的成员数（集合长度）
84 *
85 * @param key 键
86 * @return 成员总数
87 */
88 public Long zCard(String key) {
89 return redisTemplate.opsForZSet().zCard(key);
90 }
91
92 /**
93 * 通过索引区间返回有序集合指定区间内的成员（按分数从小到大排序）
94 *
95 * @param key 键
96 * @param start 开始数（0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推）
97 * @param end 结束数（-1 表示最后一个成员，-2 表示倒数第二个成员，以此类推）
98 * @return 指定区间内，带有分数值(可选)的有序集成员的列表
99 */
100 public Set<Object> zrange(String key, int start, int end) {
101 return redisTemplate.opsForZSet().range(key, start, end);
102 }
103
104 /**
105 * 通过索引区间返回有序集合指定区间内的成员 & 分数
106 *
107 * @param key 键
108 * @param start 开始数（0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推）
109 * @param end 结束数（-1 表示最后一个成员，-2 表示倒数第二个成员，以此类推）
110 * @return 指定区间内，带有分数值(可选)的有序集成员的列表
111 */
112 public Set<ZSetOperations.TypedTuple<Object>> zRange(String key, int start, int end) {
113 return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
114 }
115
116 /**
117 * 返回有序集中指定区间内的成员，通过索引，分数从高到低
118 *
119 * @param key 键
120 * @param start 开始
121 * @param end 结束
122 * @return 指定区间内的成员
123 */
124 public Set<Object> zRevRange(String key, int start, int end) {
125 return redisTemplate.opsForZSet().reverseRange(key, start, end);
126 }
127
128 /**
129 * 通过分数返回有序集合指定区间内的成员
130 *
131 * @param key 键
132 * @param min 最小
133 * @param max 最大
134 * @return 指定区间内的成员
135 */
136 public Set<Object> zRangeByScore(String key, int min, int max) {
137 return redisTemplate.opsForZSet().rangeByScore(key, min, max);
138 }
139
140}
5、Redis 操作 Controller
这里写个简单的 Controller 类，简单的调用 Redis 字符串服务操作，内容如下：
1import mydlq.club.example.service.RedisBatch;
2import mydlq.club.example.service.RedisString;
3import org.springframework.beans.factory.annotation.Autowired;
4import org.springframework.web.bind.annotation.GetMapping;
5import org.springframework.web.bind.annotation.RequestParam;
6import org.springframework.web.bind.annotation.RestController;
7import java.util.ArrayList;
8import java.util.HashMap;
9import java.util.List;
10import java.util.Map;
11
12@RestController
13public class RedisController {
14
15 @Autowired
16 private RedisBatch redisBatch;
17
18 @Autowired
19 private RedisString redisString;
20
21 /**
22 * 存值
23 *
24 * @param key 键
25 * @param value 值
26 * @return 存储结果
27 */
28 @GetMapping("/set")
29 public String redisStringSet(@RequestParam String key, @RequestParam String value) {
30 redisString.set(key, value);
31 return "存储成功";
32 }
33
34 /**
35 * 取值
36 *
37 * @param key 键
38 * @return 值
39 */
40 @GetMapping("/get")
41 public Object redisStringGet(@RequestParam String key) {
42 return redisString.get(key);
43 }
44
45 /**
46 * 批量存值
47 */
48 @GetMapping("/batch/set")
49 public void redisBatchSet() {
50 Map<String, Object> map = new HashMap<>(3);
51 map.put("test1", "value1");
52 map.put("test2", "value2");
53 map.put("test3", "value3");
54 redisBatch.barchSet(map);
55 }
56
57 /**
58 * 批量取值
59 *
60 * @return 值列表
61 */
62 @GetMapping("/batch/get")
63 public List<Object> redisBatchGet() {
64 // 批量取值，如果某个 key 不存在，则值为 null
65 List<String> list = new ArrayList<>(3);
66 list.add("test1");
67 list.add("test2");
68 list.add("test3");
69 return redisBatch.batchGet(list);
70 }
71
72}
6、SpringBoot 启动类
SpringBoot 的启动类，内容如下：
1import org.springframework.boot.SpringApplication;
2import org.springframework.boot.autoconfigure.SpringBootApplication;
3
4@SpringBootApplication
5public class Application {
6
7 public static void main(String[] args) {
8 SpringApplication.run(Application.class, args);
9 }
10
11}
---END---
!版权声明：本博客内容均为原创,每篇博文作为知识积累,写博不易,转载请注明出处。