封装Redis模块（最全面的教程！）

1.环境搭建

1.创建模块

2.查看是否交给父模块管理

3.引入依靠

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0"
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.     <modelVersion>4.0.0</modelVersion>
6.     <parent>
7.         <groupId>com.sunxiansheng</groupId>
8.         <artifactId>sunrays-common</artifactId>
9.         <version>1.0</version>
10.     </parent>
12.     <version>1.0</version>
14.     <artifactId>common-redis-starter</artifactId>
16.     <dependencies>
17.         <!-- redis -->
18.         <dependency>
19.             <groupId>org.springframework.boot</groupId>
20.             <artifactId>spring-boot-starter-data-redis</artifactId>
21.             <!-- 排除，防止日志冲突 -->
22.             <exclusions>
23.                 <exclusion>
24.                     <artifactId>spring-boot-starter-logging</artifactId>
25.                     <groupId>org.springframework.boot</groupId>
26.                 </exclusion>
27.             </exclusions>
28.         </dependency>
29.         <!-- 集成 redis 所需 commons-pool2 -->
30.         <dependency>
31.             <groupId>org.apache.commons</groupId>
32.             <artifactId>commons-pool2</artifactId>
33.         </dependency>
34.     </dependencies>
36. </project>

复制代码

4.自动配置

1.目次

2.RedisAutoConfiguration.java

1. package com.sunxiansheng.redis.config;
3. import org.springframework.context.annotation.Configuration;
5. /**
6. * Description: Redis自动配置类
7. *
8. * @Author sun
9. * @Create 2024/11/15 20:41
10. * @Version 1.0
11. */
12. @Configuration
13. public class RedisAutoConfiguration {
14. }

复制代码

3.spring.factories

1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
2. com.sunxiansheng.redis.config.RedisAutoConfiguration

复制代码

2.重写RedisTemplate

1.引入Jackson

1.         <!-- 重写RedisTemplate所需要的Jackson -->
2.         <dependency>
3.             <groupId>com.fasterxml.jackson.core</groupId>
4.             <artifactId>jackson-databind</artifactId>
5.         </dependency>
6.         <dependency>
7.             <groupId>com.fasterxml.jackson.core</groupId>
8.             <artifactId>jackson-annotations</artifactId>
9.         </dependency>

复制代码

2.编写RedisConfig.java

1. package com.sunxiansheng.redis.config;
3. import com.fasterxml.jackson.annotation.JsonAutoDetect;
4. import com.fasterxml.jackson.annotation.JsonInclude;
5. import com.fasterxml.jackson.annotation.PropertyAccessor;
6. import com.fasterxml.jackson.databind.DeserializationFeature;
7. import com.fasterxml.jackson.databind.ObjectMapper;
8. import com.fasterxml.jackson.databind.jsontype.BasicPolymorphicTypeValidator;
9. import org.springframework.context.annotation.Bean;
10. import org.springframework.context.annotation.Configuration;
11. import org.springframework.data.redis.connection.RedisConnectionFactory;
12. import org.springframework.data.redis.core.RedisTemplate;
13. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
14. import org.springframework.data.redis.serializer.RedisSerializer;
15. import org.springframework.data.redis.serializer.StringRedisSerializer;
17. /**
18. * Redis配置类，会将 Object 类型序列化为 JSON 格式，然后将其作为字符串存储在 Redis 中。
19. * 当从 Redis 中读取时，会将 JSON 字符串反序列化回具体的 Object 类型数据，直接强制转换即可，无需手动解析 JSON。
20. */
21. @Configuration
22. public class RedisConfig {
24.     /**
25.      * 自定义RedisTemplate Bean，配置Key和Value的序列化方式。
26.      * Key采用String序列化，Value采用JSON序列化，支持对象直接转为JSON格式存储在Redis中。
27.      *
28.      * @param redisConnectionFactory Redis连接工厂，用于创建RedisTemplate连接
29.      * @return 配置完成的RedisTemplate实例，用于Redis数据操作
30.      */
31.     @Bean
32.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
33.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
34.         redisTemplate.setConnectionFactory(redisConnectionFactory);
36.         // 设置Key的序列化方式为StringRedisSerializer，以便Key以字符串格式存储，便于人类读取
37.         RedisSerializer<String> stringSerializer = new StringRedisSerializer();
38.         redisTemplate.setKeySerializer(stringSerializer);          // 序列化Redis键
39.         redisTemplate.setHashKeySerializer(stringSerializer);      // 序列化Hash结构的键
41.         // 设置Value和HashValue的序列化方式为Jackson2JsonRedisSerializer，以便Value以JSON格式存储
42.         Jackson2JsonRedisSerializer<Object> jacksonSerializer = jackson2JsonRedisSerializer();
43.         redisTemplate.setValueSerializer(jacksonSerializer);       // 序列化Redis值
44.         redisTemplate.setHashValueSerializer(jacksonSerializer);   // 序列化Hash结构的值
46.         // 初始化设置的配置
47.         redisTemplate.afterPropertiesSet();
48.         return redisTemplate;
49.     }
51.     /**
52.      * 配置Jackson序列化器，以支持复杂Java对象的序列化和反序列化。
53.      * 使用Jackson2JsonRedisSerializer将对象序列化为JSON字符串，从而提高Redis中的可读性和兼容性。
54.      *
55.      * @return 配置好的Jackson2JsonRedisSerializer实例，指定序列化格式为JSON
56.      */
57.     private Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer() {
58.         // 创建Jackson2JsonRedisSerializer，指定泛型为Object，支持序列化任意Java对象
59.         Jackson2JsonRedisSerializer<Object> jacksonSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
61.         // 创建ObjectMapper用于配置JSON序列化方式
62.         ObjectMapper objectMapper = new ObjectMapper();
64.         // 设置可见性，允许访问所有字段（包括私有和保护字段），确保所有属性都被序列化和反序列化
65.         objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
67.         // 配置反序列化时忽略未知属性，防止因JSON中多余字段导致反序列化错误
68.         objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
70.         // 序列化时忽略空值属性，节省存储空间
71.         objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
73.         // 启用类型信息，确保反序列化时能够恢复原始对象类型
74.         objectMapper.activateDefaultTyping(
75.                 BasicPolymorphicTypeValidator.builder()
76.                         .allowIfSubType(Object.class)
77.                         .build(),
78.                 ObjectMapper.DefaultTyping.NON_FINAL
79.         );
81.         // 将配置好的ObjectMapper设置到Jackson2JsonRedisSerializer中，应用上述配置
82.         jacksonSerializer.setObjectMapper(objectMapper);
83.         return jacksonSerializer;
84.     }
85. }

复制代码

3.RedisAutoConfiguration.java 导入配置类

3.Redis工具类

1.RBase.java Redis基础工具类

1. package com.sunxiansheng.redis.utils;
3. import org.springframework.data.redis.core.RedisTemplate;
5. import java.util.Collection;
6. import java.util.concurrent.TimeUnit;
8. /**
9. * Redis基础工具类，提供一些基础的操作
10. *
11. * @Author sun
12. * @Create 2024/11/14 14:25
13. * @Version 1.0
14. */
15. public class RBase {
17.     protected RedisTemplate<String, Object> redisTemplate;
19.     public RBase(RedisTemplate<String, Object> redisTemplate) {
20.         this.redisTemplate = redisTemplate;
21.     }
23.     /**
24.      * 默认的key分隔符
25.      */
26.     private static final String DEFAULT_KEY_SEPARATOR = ":";
28.     /**
29.      * 构建缓存key（使用默认的key分隔符）
30.      *
31.      * @param parts 多个字符串拼接成缓存key
32.      * @return 拼接后的缓存key
33.      */
34.     public String buildKeyByDefaultSeparator(String... parts) {
35.         return String.join(DEFAULT_KEY_SEPARATOR, parts);
36.     }
38.     /**
39.      * 构建缓存key（使用自定义的key分隔符）
40.      *
41.      * @param separator 自定义的key分隔符
42.      * @param parts     多个字符串拼接成缓存key
43.      * @return 拼接后的缓存key
44.      */
45.     public String buildKeyByCustomSeparator(String separator, String... parts) {
46.         return String.join(separator, parts);
47.     }
49.     /**
50.      * 删除单个key
51.      *
52.      * @param key 键
53.      * @return 如果键不存在，返回false；如果删除成功，返回true
54.      */
55.     public Boolean delete(String key) {
56.         if (key == null || key.isEmpty()) {
57.             throw new IllegalArgumentException("Key cannot be null or empty");
58.         }
59.         return redisTemplate.delete(key);
60.     }
62.     /**
63.      * 批量删除key
64.      *
65.      * @param keys 键的集合
66.      * @return 成功删除的键的数量，键不存在不计数
67.      */
68.     public Long deleteBatch(Collection<String> keys) {
69.         if (keys == null || keys.isEmpty()) {
70.             return 0L;
71.         }
72.         return redisTemplate.delete(keys);
73.     }
75.     /**
76.      * 指定缓存失效时间
77.      *
78.      * @param key     键
79.      * @param timeout 失效时间（小于等于0 表示 永久有效）
80.      * @param unit    时间单位
81.      * @return 设置成功返回true，失败返回false
82.      */
83.     public Boolean expire(String key, long timeout, TimeUnit unit) {
84.         if (key == null || key.isEmpty()) {
85.             throw new IllegalArgumentException("Key cannot be null or empty");
86.         }
87.         if (timeout <= 0) {
88.             // 或直接返回 true，表示设置为永久有效
89.             return false;
90.         }
91.         return redisTemplate.expire(key, timeout, unit);
92.     }
94.     /**
95.      * 指定缓存失效时间（时间单位：秒）
96.      *
97.      * @param key     键
98.      * @param timeout 失效时间（单位：秒，小于等于0 表示 永久有效）
99.      * @return 设置成功返回true，失败返回false
100.      */
101.     public Boolean expire(String key, long timeout) {
102.         return expire(key, timeout, TimeUnit.SECONDS);
103.     }
105.     /**
106.      * 获取缓存失效时间
107.      *
108.      * @param key 键
109.      * @return 缓存失效时间（秒）。键不存在返回-2，键存在但没有设置过期时间返回-1
110.      */
111.     public Long getExpire(String key) {
112.         if (key == null || key.isEmpty()) {
113.             throw new IllegalArgumentException("Key cannot be null or empty");
114.         }
115.         return redisTemplate.getExpire(key);
116.     }
118.     /**
119.      * 判断key是否存在
120.      *
121.      * @param key 键
122.      * @return 存在返回true，不存在返回false
123.      */
124.     public Boolean hasKey(String key) {
125.         if (key == null || key.isEmpty()) {
126.             throw new IllegalArgumentException("Key cannot be null or empty");
127.         }
128.         return redisTemplate.hasKey(key);
129.     }
131.     /**
132.      * 转换缓存中的对象为指定类型
133.      *
134.      * @param value 缓存中的对象
135.      * @param type  要转换的目标类型
136.      * @param <T>   返回的泛型类型
137.      * @return 转换后的对象
138.      * @throws ClassCastException 如果对象不能转换为指定类型
139.      */
140.     protected <T> T convertValue(Object value, Class<T> type) {
141.         if (value == null) {
142.             return null;
143.         }
145.         // Long类型的特殊处理，因为Redis中的数据会自动反序列化为Integer
146.         if (type == Long.class && value instanceof Integer) {
147.             return type.cast(((Integer) value).longValue());
148.         }
150.         if (type.isInstance(value)) {
151.             return type.cast(value);
152.         } else {
153.             throw new ClassCastException("Redis中的对象运行类型与请求转换的类型不匹配，请优先检查Redis配置类是否保存了对象原始信息！期待类型："
154.                     + type.getName() + "，实际类型："
155.                     + value.getClass().getName());
156.         }
157.     }
158. }

复制代码

2.RString.java

1. package com.sunxiansheng.redis.utils;
3. import org.springframework.data.redis.core.RedisTemplate;
5. import java.util.concurrent.TimeUnit;
7. /**
8. * Description: Redis的String类型操作
9. *
10. * @Author sun
11. * @Create 2024/11/14 14:50
12. * @Version 1.1
13. */
14. public class RString extends RBase {
16.     /**
17.      * 构造器给父类注入RedisTemplate
18.      *
19.      * @param redisTemplate RedisTemplate实例
20.      */
21.     public RString(RedisTemplate<String, Object> redisTemplate) {
22.         super(redisTemplate);
23.     }
25.     /**
26.      * 设置缓存值
27.      *
28.      * @param key   键
29.      * @param value 值
30.      */
31.     public void set(String key, Object value) {
32.         validateKeyAndValue(key, value);
33.         redisTemplate.opsForValue().set(key, value);
34.     }
36.     /**
37.      * 设置缓存值并设置过期时间
38.      *
39.      * @param key     键
40.      * @param value   值
41.      * @param timeout 过期时间
42.      * @param unit    时间单位
43.      */
44.     public void setWithExpire(String key, Object value, final long timeout, final TimeUnit unit) {
45.         validateKeyAndValue(key, value);
46.         validateTimeoutAndUnit(timeout, unit);
47.         redisTemplate.opsForValue().set(key, value, timeout, unit);
48.     }
50.     /**
51.      * 设置缓存值并设置过期时间（单位：秒）
52.      *
53.      * @param key     键
54.      * @param value   值
55.      * @param timeout 过期时间
56.      */
57.     public void setWithExpire(String key, Object value, final long timeout) {
58.         setWithExpire(key, value, timeout, TimeUnit.SECONDS);
59.     }
61.     /**
62.      * 设置缓存值，如果key不存在，则设置成功，并指定过期时间
63.      *
64.      * @param key     键
65.      * @param value   值
66.      * @param timeout 过期时间
67.      * @param unit    时间单位
68.      * @return 是否设置成功
69.      */
70.     public Boolean setIfAbsent(String key, Object value, long timeout, TimeUnit unit) {
71.         validateKeyAndValue(key, value);
72.         validateTimeoutAndUnit(timeout, unit);
73.         return redisTemplate.opsForValue().setIfAbsent(key, value, timeout, unit);
74.     }
76.     /**
77.      * 设置缓存值，如果key不存在，则设置成功，并指定过期时间（单位：秒）
78.      *
79.      * @param key     键
80.      * @param value   值
81.      * @param timeout 过期时间
82.      * @return 是否设置成功
83.      */
84.     public Boolean setIfAbsent(String key, Object value, long timeout) {
85.         return setIfAbsent(key, value, timeout, TimeUnit.SECONDS);
86.     }
88.     /**
89.      * 获取缓存值并进行类型转换
90.      *
91.      * @param key  键
92.      * @param type 返回值的类型
93.      * @return 转换后的对象，若类型不匹配则抛出异常
94.      */
95.     public <T> T get(String key, Class<T> type) {
96.         Object value = redisTemplate.opsForValue().get(key);
97.         return convertValue(value, type);
98.     }
100.     /**
101.      * 获取缓存值并设置新值
102.      *
103.      * @param key   键
104.      * @param value 新值
105.      * @param type  返回值的类型
106.      * @param <T>   返回值的类型
107.      * @return 旧值，类型为 T
108.      */
109.     public <T> T getAndSet(String key, T value, Class<T> type) {
110.         Object oldValue = redisTemplate.opsForValue().getAndSet(key, value);
111.         return convertValue(oldValue, type);
112.     }
114.     /**
115.      * 根据 delta 值调整缓存中的数值
116.      *
117.      * @param key   键
118.      * @param delta 调整步长，正数表示增加，负数表示减少
119.      * @return 调整后的值
120.      */
121.     public Long changeByDelta(String key, long delta) {
122.         if (key == null) {
123.             throw new IllegalArgumentException("Key 不能为空！");
124.         }
125.         return redisTemplate.opsForValue().increment(key, delta);
126.     }
128.     /**
129.      * 验证键和值的合法性
130.      */
131.     private void validateKeyAndValue(String key, Object value) {
132.         if (key == null || value == null) {
133.             throw new IllegalArgumentException("Key 和 Value 不能为空！");
134.         }
135.     }
137.     /**
138.      * 验证超时时间和单位的合法性
139.      */
140.     private void validateTimeoutAndUnit(long timeout, TimeUnit unit) {
141.         if (timeout <= 0 || unit == null) {
142.             throw new IllegalArgumentException("超时时间必须大于 0，时间单位不能为空！");
143.         }
144.     }
145. }

复制代码

3.RList.java

1. package com.sunxiansheng.redis.utils;
3. import org.springframework.data.redis.core.RedisTemplate;
5. import java.util.ArrayList;
6. import java.util.Collection;
7. import java.util.List;
9. /**
10. * Description: Redis的List类型操作
11. *
12. * @Author sun
13. * @Create 2024/11/14 14:50
14. * @Version 1.0
15. */
16. public class RList extends RBase {
18.     /**
19.      * 构造器给父类注入RedisTemplate
20.      *
21.      * @param redisTemplate RedisTemplate实例
22.      */
23.     public RList(RedisTemplate<String, Object> redisTemplate) {
24.         super(redisTemplate);
25.     }
27.     /**
28.      * 左侧添加单个值
29.      *
30.      * @param key   键
31.      * @param value 要添加的值
32.      * @return 添加后的List长度
33.      */
34.     public Long leftPush(String key, Object value) {
35.         return redisTemplate.opsForList().leftPush(key, value);
36.     }
38.     /**
39.      * 左侧批量添加多个值（使用List参数方式）
40.      *
41.      * @param key      键
42.      * @param dataList 要添加的值列表
43.      * @param <V>      值类型
44.      * @return 添加后的List长度，调用方可以忽略返回值
45.      */
46.     public <V> Long leftPushAll(String key, List<V> dataList) {
47.         return redisTemplate.opsForList().leftPushAll(key, dataList.toArray());
48.     }
50.     /**
51.      * 左侧批量添加多个值（使用Collection参数方式）
52.      *
53.      * @param key           键
54.      * @param dataCollection 要添加的值集合
55.      * @param <V>           值类型
56.      * @return 添加后的List长度
57.      */
58.     public <V> Long leftPushAll(String key, Collection<V> dataCollection) {
59.         return redisTemplate.opsForList().leftPushAll(key, dataCollection.toArray());
60.     }
62.     /**
63.      * 右侧添加单个值
64.      *
65.      * @param key   键
66.      * @param value 要添加的值
67.      * @return 添加后的List长度
68.      */
69.     public Long rightPush(String key, Object value) {
70.         return redisTemplate.opsForList().rightPush(key, value);
71.     }
73.     /**
74.      * 右侧批量添加多个值（使用List参数方式）
75.      *
76.      * @param key      键
77.      * @param dataList 要添加的值列表
78.      * @param <V>      值类型
79.      * @return 添加后的List长度
80.      */
81.     public <V> Long rightPushAll(String key, List<V> dataList) {
82.         return redisTemplate.opsForList().rightPushAll(key, dataList.toArray());
83.     }
85.     /**
86.      * 右侧批量添加多个值（使用Collection参数方式）
87.      *
88.      * @param key           键
89.      * @param dataCollection 要添加的值集合
90.      * @param <V>           值类型
91.      * @return 添加后的List长度
92.      */
93.     public <V> Long rightPushAll(String key, Collection<V> dataCollection) {
94.         return redisTemplate.opsForList().rightPushAll(key, dataCollection.toArray());
95.     }
97.     /**
98.      * 根据值移除指定数量的匹配元素
99.      *
100.      * @param key   键
101.      * @param count 要移除的元素数量
102.      * @param value 要移除的值
103.      * @return 移除的元素数量
104.      */
105.     public Long removeByValue(String key, long count, Object value) {
106.         return redisTemplate.opsForList().remove(key, count, value);
107.     }
109.     /**
110.      * 从右侧弹出元素并转换为指定类型
111.      *
112.      * @param key  键
113.      * @param type 期望的返回值类型
114.      * @param <T>  泛型，表示期望的返回类型
115.      * @return 弹出并转换后的元素
116.      */
117.     public <T> T popRight(String key, Class<T> type) {
118.         Object value = redisTemplate.opsForList().rightPop(key);
119.         return convertValue(value, type);
120.     }
122.     /**
123.      * 从左侧弹出元素并转换为指定类型
124.      *
125.      * @param key  键
126.      * @param type 期望的返回值类型
127.      * @param <T>  泛型，表示期望的返回类型
128.      * @return 弹出并转换后的元素
129.      */
130.     public <T> T popLeft(String key, Class<T> type) {
131.         Object value = redisTemplate.opsForList().leftPop(key);
132.         return convertValue(value, type);
133.     }
135.     /**
136.      * 根据索引设置List中的值
137.      *
138.      * @param key   键
139.      * @param index 索引位置，从0开始
140.      * @param value 设置的值
141.      */
142.     public void set(String key, final long index, Object value) {
143.         redisTemplate.opsForList().set(key, index, value);
144.     }
146.     /**
147.      * 获取List中的所有数据，并将每个元素转换为指定类型
148.      *
149.      * @param key  键
150.      * @param type 要转换的值类型
151.      * @param <T>  要转换的值类型
152.      * @return 转换后的List
153.      */
154.     public <T> List<T> rangeAll(String key, Class<T> type) {
155.         List<Object> range = redisTemplate.opsForList().range(key, 0, -1);
156.         List<T> result = new ArrayList<>();
158.         if (range != null) {
159.             for (Object item : range) {
160.                 result.add(convertValue(item, type));
161.             }
162.         }
163.         return result;
164.     }
166.     /**
167.      * 根据索引获取List中的元素并转换为指定类型
168.      *
169.      * @param key   键
170.      * @param index 索引位置，从0开始
171.      * @param type  期望的返回值类型
172.      * @param <T>   泛型，表示期望的返回类型
173.      * @return 转换后的元素
174.      */
175.     public <T> T getElementByIndex(String key, long index, Class<T> type) {
176.         Object value = redisTemplate.opsForList().index(key, index);
177.         return convertValue(value, type);
178.     }
180.     /**
181.      * 获取List的长度
182.      *
183.      * @param key 键
184.      * @return List的长度
185.      */
186.     public Long size(String key) {
187.         return redisTemplate.opsForList().size(key);
188.     }
189. }

复制代码

4.RSet.java

1. package com.sunxiansheng.redis.utils;
3. import org.springframework.data.redis.core.RedisTemplate;
5. import java.util.HashSet;
6. import java.util.Set;
8. /**
9. * Description: Redis的Set类型操作
10. *
11. * @Author sun
12. * @Create 2024/11/14 14:50
13. * @Version 1.0
14. */
15. public class RSet extends RBase {
17.     /**
18.      * 构造器给父类注入RedisTemplate
19.      *
20.      * @param redisTemplate RedisTemplate实例
21.      */
22.     public RSet(RedisTemplate<String, Object> redisTemplate) {
23.         super(redisTemplate);
24.     }
26.     /**
27.      * 添加一个元素
28.      *
29.      * @param key  键
30.      * @param data 值
31.      * @return 添加成功的个数
32.      */
33.     public Long add(String key, Object data) {
34.         return redisTemplate.opsForSet().add(key, data);
35.     }
37.     /**
38.      * 批量添加元素，并返回添加成功的个数
39.      *
40.      * @param key     键
41.      * @param dataSet 值集合
42.      * @param <T>     添加的元素类型
43.      * @return 添加成功的个数
44.      */
45.     public <T> Long addBatch(String key, Set<T> dataSet) {
46.         return redisTemplate.opsForSet().add(key, dataSet.toArray());
47.     }
49.     /**
50.      * 移除特定的元素，并返回移除成功的个数
51.      *
52.      * @param key     键
53.      * @param dataSet 要移除的元素集合
54.      * @param <T>     要移除的元素类型
55.      * @return 移除成功的个数
56.      */
57.     public <T> Long remove(String key, Set<T> dataSet) {
58.         return redisTemplate.opsForSet().remove(key, dataSet.toArray());
59.     }
61.     /**
62.      * 获取集合，并将每个元素转换为指定类型
63.      *
64.      * @param key  键
65.      * @param type 集合中元素的目标类型
66.      * @param <T>  元素的类型
67.      * @return 转换后的集合
68.      */
69.     public <T> Set<T> members(String key, Class<T> type) {
70.         Set<Object> members = redisTemplate.opsForSet().members(key);
71.         Set<T> result = new HashSet<>();
73.         if (members != null) {
74.             for (Object member : members) {
75.                 result.add(convertValue(member, type));
76.             }
77.         }
78.         return result;
79.     }
81.     /**
82.      * 判断集合中是否有该值
83.      *
84.      * @param key  键
85.      * @param data 值
86.      * @return 是否包含该值
87.      */
88.     public Boolean isMember(String key, Object data) {
89.         return redisTemplate.opsForSet().isMember(key, data);
90.     }
92.     /**
93.      * 获取set的长度
94.      *
95.      * @param key 键
96.      * @return 集合的长度
97.      */
98.     public Long size(String key) {
99.         return redisTemplate.opsForSet().size(key);
100.     }
101. }

复制代码

5.RHash.java

1. package com.sunxiansheng.redis.utils;
3. import org.springframework.data.redis.core.RedisTemplate;
5. import java.util.*;
7. /**
8. * Description: Redis的Hash类型操作
9. *
10. * @Author sun
11. * @Create 2024/11/14 14:50
12. * @Version 1.1
13. */
14. public class RHash extends RBase {
16.     /**
17.      * 构造器给父类注入RedisTemplate
18.      *
19.      * @param redisTemplate RedisTemplate实例
20.      */
21.     public RHash(RedisTemplate<String, Object> redisTemplate) {
22.         super(redisTemplate);
23.     }
25.     /**
26.      * 设置单个hash值
27.      *
28.      * @param key       key
29.      * @param hashKey   hashKey
30.      * @param hashValue hashValue
31.      */
32.     public void put(String key, String hashKey, Object hashValue) {
33.         redisTemplate.opsForHash().put(key, hashKey, hashValue);
34.     }
36.     /**
37.      * 设置多个hash值
38.      *
39.      * @param key key
40.      * @param map map
41.      */
42.     public void putAll(String key, Map<String, ?> map) {
43.         if (map == null || map.isEmpty()) {
44.             throw new IllegalArgumentException("Map不能为空！");
45.         }
46.         redisTemplate.opsForHash().putAll(key, map);
47.     }
49.     /**
50.      * 删除hash中的一些值
51.      *
52.      * @param key      key
53.      * @param hashKeys hashKeys
54.      * @return 删除的个数
55.      */
56.     public Long delete(String key, List<String> hashKeys) {
57.         if (hashKeys == null || hashKeys.isEmpty()) {
58.             return 0L;
59.         }
60.         return redisTemplate.opsForHash().delete(key, hashKeys.toArray());
61.     }
63.     /**
64.      * 删除hash中的一个值
65.      *
66.      * @param key     key
67.      * @param hashKey hashKey
68.      * @return 删除的个数
69.      */
70.     public Long delete(String key, String hashKey) {
71.         if (hashKey == null) {
72.             return 0L;
73.         }
74.         return redisTemplate.opsForHash().delete(key, hashKey);
75.     }
77.     /**
78.      * 获取单个hash值，并转换为指定类型
79.      *
80.      * @param key     key
81.      * @param hashKey hashKey
82.      * @param type    类型
83.      * @param <T>     要转换的类型
84.      * @return hash值
85.      */
86.     public <T> T getOneMapValue(String key, String hashKey, Class<T> type) {
87.         if (hashKey == null) {
88.             return null;
89.         }
90.         Object object = redisTemplate.opsForHash().get(key, hashKey);
91.         return convertValue(object, type);
92.     }
94.     /**
95.      * 获取多个hash值，并转换为指定类型
96.      *
97.      * @param key      Redis键
98.      * @param hashKeys Hash键集合
99.      * @param type     转换的目标类型
100.      * @param <T>      返回的泛型类型
101.      * @return 转换后的Hash对象集合
102.      */
103.     public <T> List<T> getMultiMapValue(String key, Collection<String> hashKeys, Class<T> type) {
104.         if (hashKeys == null || hashKeys.isEmpty()) {
105.             return Collections.emptyList();
106.         }
108.         Collection<Object> keys = new ArrayList<>(hashKeys);
109.         List<Object> objects = redisTemplate.opsForHash().multiGet(key, keys);
111.         List<T> result = new ArrayList<>();
112.         for (Object obj : objects) {
113.             result.add(convertValue(obj, type));
114.         }
115.         return result;
116.     }
118.     /**
119.      * 获取所有键值对，并将其转换为指定类型
120.      *
121.      * @param key  键
122.      * @param type 返回值的类型
123.      * @param <T>  值类型
124.      * @return 转换后的Map，键为String类型，值为T类型
125.      */
126.     public <T> Map<String, T> getAll(String key, Class<T> type) {
127.         Map<Object, Object> entries = redisTemplate.opsForHash().entries(key);
129.         if (entries.isEmpty()) {
130.             return Collections.emptyMap();
131.         }
133.         Map<String, T> result = new HashMap<>();
134.         for (Map.Entry<Object, Object> entry : entries.entrySet()) {
135.             if (entry.getKey() instanceof String) {
136.                 String strKey = (String) entry.getKey();
137.                 T value = convertValue(entry.getValue(), type);
138.                 result.put(strKey, value);
139.             } else {
140.                 throw new ClassCastException("Redis中Hash的键不是String类型：实际类型为 " + entry.getKey().getClass().getName());
141.             }
142.         }
143.         return result;
144.     }
146.     /**
147.      * 判断hash中是否存在某个键
148.      *
149.      * @param key     key
150.      * @param hashKey hashKey
151.      * @return 是否存在
152.      */
153.     public Boolean hasHashKey(String key, String hashKey) {
154.         if (hashKey == null) {
155.             return false;
156.         }
157.         return redisTemplate.opsForHash().hasKey(key, hashKey);
158.     }
159. }

复制代码

6.RSortedSet.java

1. package com.sunxiansheng.redis.utils;
3. import org.springframework.data.redis.core.RedisTemplate;
4. import org.springframework.data.redis.core.ZSetOperations;
6. import java.util.HashSet;
7. import java.util.Set;
8. import java.util.TreeSet;
10. /**
11. * Description: Redis的ZSet类型操作
12. *
13. * @Author sun
14. * @Create 2024/11/14 14:50
15. * @Version 1.0
16. */
17. public class RSortedSet extends RBase {
19.     /**
20.      * 构造器给父类注入RedisTemplate
21.      *
22.      * @param redisTemplate RedisTemplate实例
23.      */
24.     public RSortedSet(RedisTemplate<String, Object> redisTemplate) {
25.         super(redisTemplate);
26.     }
28.     /**
29.      * 添加一个元素，并设置分数
30.      *
31.      * @param key   键
32.      * @param data  元素
33.      * @param score 分数
34.      * @return 是否添加成功，成功返回true
35.      */
36.     public Boolean add(String key, Object data, double score) {
37.         return redisTemplate.opsForZSet().add(key, data, score);
38.     }
40.     /**
41.      * 自定义的数据分数类型，用于批量添加元素
42.      *
43.      * @param <T> 元素的类型
44.      */
45.     public static class DataScore<T> {
46.         /**
47.          * 数据
48.          */
49.         private T data;
50.         /**
51.          * 分数
52.          */
53.         private Double score;
55.         public DataScore() {
56.         }
58.         public DataScore(T data, Double score) {
59.             this.data = data;
60.             this.score = score;
61.         }
63.         public T getData() {
64.             return data;
65.         }
67.         public void setData(T data) {
68.             this.data = data;
69.         }
71.         public Double getScore() {
72.             return score;
73.         }
75.         public void setScore(Double score) {
76.             this.score = score;
77.         }
78.     }
80.     /**
81.      * 批量添加元素，并设置分数
82.      *
83.      * @param key        键
84.      * @param dataScores 自定义数据结构集合，包含元素及分数
85.      * @param <T>        元素的类型
86.      * @return 添加成功的元素数量
87.      */
88.     public <T> Long addBatch(String key, Set<DataScore<T>> dataScores) {
89.         // 将 Set<DataScore<T>> 转换为 Set<ZSetOperations.TypedTuple<Object>>
90.         Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
91.         for (DataScore<T> dataScore : dataScores) {
92.             tuples.add(new ZSetOperations.TypedTuple<Object>() {
93.                 @Override
94.                 public Object getValue() {
95.                     return dataScore.getData(); // 调用 getData 方法
96.                 }
98.                 @Override
99.                 public Double getScore() {
100.                     return dataScore.getScore();
101.                 }
103.                 /**
104.                  * 比较器，从大到小排序
105.                  */
106.                 @Override
107.                 public int compareTo(ZSetOperations.TypedTuple<Object> o) {
108.                     return Double.compare(o.getScore(), this.getScore());
109.                 }
110.             });
111.         }
113.         // 添加到 Redis 的 ZSet
114.         return redisTemplate.opsForZSet().add(key, tuples);
115.     }
117.     /**
118.      * 移除特定的元素
119.      *
120.      * @param key     键
121.      * @param dataSet 要移除的元素集合
122.      * @param <T>     元素类型
123.      * @return 移除成功的元素数量
124.      */
125.     public <T> Long remove(String key, Set<T> dataSet) {
126.         return redisTemplate.opsForZSet().remove(key, dataSet.toArray());
127.     }
129.     /**
130.      * 删除指定分数范围的元素
131.      *
132.      * @param key 键
133.      * @param min 最小分数
134.      * @param max 最大分数
135.      * @return 删除成功的元素数量
136.      */
137.     public Long removeRangeByScore(String key, double min, double max) {
138.         return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
139.     }
141.     /**
142.      * 根据delta值调整指定元素的分数
143.      *
144.      * @param key   键
145.      * @param data  元素
146.      * @param delta 增加或减少的分数值
147.      * @return 调整后的分数
148.      */
149.     public Double changeByDelta(String key, Object data, double delta) {
150.         return redisTemplate.opsForZSet().incrementScore(key, data, delta);
151.     }
153.     /**
154.      * 获取全部ZSet元素（分数从大到小），并将值转换为指定类型
155.      *
156.      * @param key  Redis键
157.      * @param type 元素的目标类型
158.      * @param <T>  元素类型
159.      * @return 转换后的ZSet集合，包含分值和对应的值
160.      */
161.     public <T> Set<ZSetOperations.TypedTuple<T>> reverseRangeWithScores(String key, Class<T> type) {
162.         // 获取 Redis 中的 ZSet 数据
163.         Set<ZSetOperations.TypedTuple<Object>> typedTuples = redisTemplate.opsForZSet().reverseRangeWithScores(key, 0, -1);
164.         // 使用 TreeSet 并提供自定义比较器，从大到小排序
165.         Set<ZSetOperations.TypedTuple<T>> result = new TreeSet<>((a, b) -> Double.compare(b.getScore(), a.getScore()));
167.         // 遍历并进行类型转换
168.         if (typedTuples != null) {
169.             for (ZSetOperations.TypedTuple<Object> tuple : typedTuples) {
170.                 T value = convertValue(tuple.getValue(), type);
171.                 Double score = tuple.getScore();
172.                 result.add(new ZSetOperations.TypedTuple<T>() {
173.                     @Override
174.                     public T getValue() {
175.                         return value;
176.                     }
178.                     @Override
179.                     public Double getScore() {
180.                         return score;
181.                     }
183.                     /**
184.                      * 比较器，从大到小排序
185.                      */
186.                     @Override
187.                     public int compareTo(ZSetOperations.TypedTuple<T> o) {
188.                         return Double.compare(o.getScore(), this.getScore());
189.                     }
190.                 });
191.             }
192.         }
193.         return result;
194.     }
196.     /**
197.      * 获取指定元素的分数
198.      *
199.      * @param key  键
200.      * @param data 元素
201.      * @return 元素的分数
202.      */
203.     public Double score(String key, Object data) {
204.         return redisTemplate.opsForZSet().score(key, data);
205.     }
207.     /**
208.      * 获取指定元素的排名（从大到小）
209.      *
210.      * @param key  键
211.      * @param data 元素
212.      * @return 排名（从0开始）
213.      */
214.     public Long reverseRank(String key, Object data) {
215.         return redisTemplate.boundZSetOps(key).reverseRank(data);
216.     }
218.     /**
219.      * 获取ZSet中的元素总数
220.      *
221.      * @param key 键
222.      * @return 元素个数
223.      */
224.     public Long zCard(String key) {
225.         return redisTemplate.opsForZSet().zCard(key);
226.     }
228.     /**
229.      * 获取指定分数范围内的元素数量
230.      *
231.      * @param key 键
232.      * @param min 最小分数
233.      * @param max 最大分数
234.      * @return 元素数量
235.      */
236.     public Long count(String key, double min, double max) {
237.         return redisTemplate.opsForZSet().count(key, min, max);
238.     }
239. }

复制代码

4.测试

1.创建测试模块

2.引入依靠

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0"
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.     <modelVersion>4.0.0</modelVersion>
6.     <parent>
7.         <groupId>com.sunxiansheng</groupId>
8.         <artifactId>sunrays-demo</artifactId>
9.         <version>1.0</version>
10.     </parent>
12.     <artifactId>common-redis-starter-demo</artifactId>
14.     <dependencies>
15.         <!-- 引入自定义的 common-redis-starter -->
16.         <dependency>
17.             <groupId>com.sunxiansheng</groupId>
18.             <artifactId>common-redis-starter</artifactId>
19.             <version>1.0</version>
20.         </dependency>
21.         <!-- 引入自定义的 common-log4j2-starter -->
22.         <dependency>
23.             <groupId>com.sunxiansheng</groupId>
24.             <artifactId>common-log4j2-starter</artifactId>
25.             <version>1.0</version>
26.         </dependency>
27.         <!-- 引入自定义的 common-web-starter -->
28.         <dependency>
29.             <groupId>com.sunxiansheng</groupId>
30.             <artifactId>common-web-starter</artifactId>
31.             <version>1.0</version>
32.         </dependency>
33.     </dependencies>
35. </project>

复制代码

3.启动类

1. package com.sunxiansheng.redis;
3. import org.springframework.boot.SpringApplication;
4. import org.springframework.boot.autoconfigure.SpringBootApplication;
6. /**
7. * Description: Redis启动类
8. *
9. * @Author sun
10. * @Create 2024/11/15 20:56
11. * @Version 1.0
12. */
13. @SpringBootApplication
14. public class RedisApplication {
16.     public static void main(String[] args) {
17.         SpringApplication.run(RedisApplication.class, args);
18.     }
19. }

复制代码

4.编写application.yml

1. spring:
2.   redis:
3.     host:  # Redis服务器地址
4.     port:  # Redis服务器端口
5.     password:  # Redis服务器密码
6.     database: 0 # 默认数据库为0号
7.     timeout: 1800000 # 连接超时时间是1800秒
8.     lettuce:
9.       pool:
10.         max-active: 20 # 最大活跃连接数,使用负值表示没有限制
11.         max-wait: -1 # 最大等待时间,单位为毫秒,使用负值表示没有限制
12.         max-idle: 10 # 最大空闲连接数
13.         min-idle: 0 # 最小空闲连接数

复制代码

5.测试

1.RStringController.java

1. package com.sunxiansheng.redis.controller;
3. import com.sunxiansheng.redis.utils.RString;
4. import org.springframework.web.bind.annotation.*;
6. import javax.annotation.Resource;
7. import java.util.concurrent.TimeUnit;
9. /**
10. * Description: 测试 RString 工具类的 Controller
11. *
12. * @Author sun
13. * @Create 2024/11/14 15:20
14. * @Version 1.0
15. */
16. @RestController
17. @RequestMapping("/rstring")
18. public class RStringController {
20.     @Resource
21.     private RString rString;
23.     /**
24.      * 设置缓存值
25.      */
26.     @PostMapping("/set")
27.     public String set(@RequestParam String key, @RequestParam Long value) {
28.         rString.set(key, value);
29.         return "Value set successfully!";
30.     }
32.     /**
33.      * 设置缓存值并设置过期时间
34.      */
35.     @PostMapping("/setWithExpire")
36.     public String setWithExpire(@RequestParam String key,
37.                                 @RequestParam Long value,
38.                                 @RequestParam long timeout) {
39.         rString.setWithExpire(key, value, timeout);
40.         return "Value set with expiration successfully!";
41.     }
43.     /**
44.      * 设置缓存值并设置过期时间（自定义时间单位）
45.      */
46.     @PostMapping("/setWithExpireUnit")
47.     public String setWithExpireUnit(@RequestParam String key,
48.                                     @RequestParam Long value,
49.                                     @RequestParam long timeout) {
50.         rString.setWithExpire(key, value, timeout, TimeUnit.DAYS);
51.         return "Value set with custom expiration successfully!";
52.     }
54.     /**
55.      * 设置缓存值，如果key不存在，则设置成功
56.      */
57.     @PostMapping("/setIfAbsent")
58.     public String setIfAbsent(@RequestParam String key,
59.                               @RequestParam Long value,
60.                               @RequestParam long timeout) {
61.         boolean result = rString.setIfAbsent(key, value, timeout);
62.         return result ? "Value set successfully!" : "Key already exists!";
63.     }
65.     /**
66.      * 获取缓存值
67.      */
68.     @GetMapping("/get")
69.     public Long get(@RequestParam String key) {
70.         return rString.get(key, Long.class);
71.     }
73.     /**
74.      * 获取缓存值并设置新值
75.      */
76.     @PostMapping("/getAndSet")
77.     public Long getAndSet(@RequestParam String key, @RequestParam Long value) {
78.         return rString.getAndSet(key, value, Long.class);
79.     }
81.     /**
82.      * 根据 delta 值调整缓存中的数值
83.      */
84.     @PostMapping("/changeByDelta")
85.     public Long changeByDelta(@RequestParam String key, @RequestParam long delta) {
86.         return rString.changeByDelta(key, delta);
87.     }
88. }

复制代码

2.RListController.java

1. package com.sunxiansheng.redis.controller;
3. import com.sunxiansheng.redis.utils.RList;
4. import lombok.AllArgsConstructor;
5. import lombok.Data;
6. import lombok.NoArgsConstructor;
7. import org.springframework.beans.factory.annotation.Autowired;
8. import org.springframework.web.bind.annotation.*;
10. import java.util.List;
12. /**
13. * 测试 RList 工具类的 Controller
14. *
15. * @Author sun
16. * @Create 2024/11/14 16:00
17. * @Version 1.0
18. */
19. @RestController
20. @RequestMapping("/rlist")
21. public class RListController {
23.     @Autowired
24.     private RList rList;
26.     /**
27.      * 左侧添加单个值
28.      */
29.     @PostMapping("/leftPush")
30.     public String leftPush(@RequestParam String key, @RequestBody User user) {
31.         rList.leftPush(key, user);
32.         return "User added to the left of the list.";
33.     }
35.     /**
36.      * 左侧批量添加多个值
37.      */
38.     @PostMapping("/leftPushAll")
39.     public String leftPushAll(@RequestParam String key, @RequestBody List<User> users) {
40.         rList.leftPushAll(key, users);
41.         return "Users added to the left of the list.";
42.     }
44.     /**
45.      * 右侧添加单个值
46.      */
47.     @PostMapping("/rightPush")
48.     public String rightPush(@RequestParam String key, @RequestBody User user) {
49.         rList.rightPush(key, user);
50.         return "User added to the right of the list.";
51.     }
53.     /**
54.      * 右侧批量添加多个值
55.      */
56.     @PostMapping("/rightPushAll")
57.     public String rightPushAll(@RequestParam String key, @RequestBody List<User> users) {
58.         rList.rightPushAll(key, users);
59.         return "Users added to the right of the list.";
60.     }
62.     /**
63.      * 根据索引设置List中的值
64.      */
65.     @PutMapping("/set")
66.     public String set(@RequestParam String key, @RequestParam int index, @RequestBody User user) {
67.         rList.set(key, index, user);
68.         return "User updated at index " + index;
69.     }
71.     /**
72.      * 获取List中的所有数据
73.      */
74.     @GetMapping("/rangeAll")
75.     public List<User> rangeAll(@RequestParam String key) {
76.         return rList.rangeAll(key, User.class);
77.     }
79.     /**
80.      * 根据索引获取List中的元素
81.      */
82.     @GetMapping("/getElementByIndex")
83.     public User getElementByIndex(@RequestParam String key, @RequestParam int index) {
84.         return rList.getElementByIndex(key, index, User.class);
85.     }
87.     /**
88.      * 获取List的长度
89.      */
90.     @GetMapping("/size")
91.     public Long size(@RequestParam String key) {
92.         return rList.size(key);
93.     }
95.     /**
96.      * 从右侧弹出元素
97.      */
98.     @DeleteMapping("/popRight")
99.     public User popRight(@RequestParam String key) {
100.         return rList.popRight(key, User.class);
101.     }
103.     /**
104.      * 从左侧弹出元素
105.      */
106.     @DeleteMapping("/popLeft")
107.     public User popLeft(@RequestParam String key) {
108.         return rList.popLeft(key, User.class);
109.     }
111.     /**
112.      * 根据值移除指定数量的匹配元素
113.      */
114.     @DeleteMapping("/removeByValue")
115.     public String removeByValue(@RequestParam String key, @RequestParam int count, @RequestBody User user) {
116.         Long removedCount = rList.removeByValue(key, count, user);
117.         return removedCount + " matching users removed.";
118.     }
119. }
122. /**
123. * 简单的自定义类型 User
124. *
125. * @Author sun
126. * @Create 2024/11/14 15:50
127. * @Version 1.0
128. */
129. @NoArgsConstructor
130. @Data
131. @AllArgsConstructor
132. class User implements java.io.Serializable {
133.     private String id;
134.     private String name;
135. }

复制代码

3.RSetController.java

1. package com.sunxiansheng.redis.controller;
3. import com.sunxiansheng.redis.utils.RSet;
4. import lombok.AllArgsConstructor;
5. import lombok.Data;
6. import lombok.NoArgsConstructor;
7. import org.springframework.beans.factory.annotation.Autowired;
8. import org.springframework.web.bind.annotation.*;
10. import java.io.Serializable;
11. import java.util.Set;
13. /**
14. * Description: RSet的测试Controller
15. *
16. * @Author sun
17. * @Create 2024/11/15
18. * @Version 1.0
19. */
20. @RestController
21. @RequestMapping("/rset")
22. public class RSetController {
24.     @Autowired
25.     private RSet rSet;
27.     /**
28.      * 静态内部类表示简单的自定义对象
29.      */
30.     @Data
31.     @NoArgsConstructor
32.     @AllArgsConstructor
33.     public static class Element implements Serializable {
34.         private Long id;
35.         private String name;
36.     }
38.     /**
39.      * 添加一个元素
40.      */
41.     @PostMapping("/add")
42.     public Long add(@RequestParam String key, @RequestBody Element element) {
43.         return rSet.add(key, element);
44.     }
46.     /**
47.      * 批量添加元素
48.      */
49.     @PostMapping("/addBatch")
50.     public Long addBatch(@RequestParam String key, @RequestBody Set<Element> elements) {
51.         return rSet.addBatch(key, elements);
52.     }
54.     /**
55.      * 移除元素
56.      */
57.     @PostMapping("/remove")
58.     public Long remove(@RequestParam String key, @RequestBody Set<Element> elements) {
59.         return rSet.remove(key, elements);
60.     }
62.     /**
63.      * 获取集合
64.      */
65.     @GetMapping("/members")
66.     public Set<Element> members(@RequestParam String key) {
67.         return rSet.members(key, Element.class);
68.     }
70.     /**
71.      * 判断是否包含某元素
72.      */
73.     @GetMapping("/isMember")
74.     public Boolean isMember(@RequestParam String key, @RequestBody Element element) {
75.         return rSet.isMember(key, element);
76.     }
78.     /**
79.      * 获取集合大小
80.      */
81.     @GetMapping("/size")
82.     public Long size(@RequestParam String key) {
83.         return rSet.size(key);
84.     }
85. }

复制代码

4.RHashController.java

1. package com.sunxiansheng.redis.controller;
3. import com.sunxiansheng.redis.utils.RHash;
4. import lombok.AllArgsConstructor;
5. import lombok.Data;
6. import lombok.NoArgsConstructor;
7. import org.springframework.web.bind.annotation.*;
9. import java.util.*;
11. @RestController
12. @RequestMapping("/rhash")
13. public class RHashController {
15.     private final RHash rHash;
17.     public RHashController(RHash rHash) {
18.         this.rHash = rHash;
19.     }
21.     @NoArgsConstructor
22.     @AllArgsConstructor
23.     @Data
24.     public static class User {
25.         private Long id;
26.         private String name;
27.         private Integer age;
28.     }
30.     /**
31.      * 设置单个hash值
32.      */
33.     @PostMapping("/put")
34.     public void put(@RequestParam String key, @RequestParam String hashKey, @RequestBody User user) {
35.         rHash.put(key, hashKey, user);
36.     }
38.     /**
39.      * 设置多个hash值
40.      */
41.     @PostMapping("/putAll")
42.     public void putAll(@RequestParam String key, @RequestBody Map<String, User> userMap) {
43.         rHash.putAll(key, userMap);
44.     }
46.     /**
47.      * 删除hash中的多个值
48.      */
49.     @DeleteMapping("/deleteMultiple")
50.     public Long deleteMultiple(@RequestParam String key, @RequestBody List<String> hashKeys) {
51.         return rHash.delete(key, hashKeys);
52.     }
54.     /**
55.      * 删除hash中的单个值
56.      */
57.     @DeleteMapping("/deleteSingle")
58.     public Long deleteSingle(@RequestParam String key, @RequestParam String hashKey) {
59.         return rHash.delete(key, hashKey);
60.     }
62.     /**
63.      * 获取单个hash值并转换为指定类型
64.      */
65.     @GetMapping("/getOne")
66.     public User getOneMapValue(@RequestParam String key, @RequestParam String hashKey) {
67.         return rHash.getOneMapValue(key, hashKey, User.class);
68.     }
70.     /**
71.      * 获取多个hash值并转换为指定类型
72.      */
73.     @GetMapping("/getMulti")
74.     public List<User> getMultiMapValue(@RequestParam String key, @RequestBody List<String> hashKeys) {
75.         return rHash.getMultiMapValue(key, hashKeys, User.class);
76.     }
78.     /**
79.      * 获取所有键值对并转换为指定类型
80.      */
81.     @GetMapping("/getAll")
82.     public Map<String, User> getAll(@RequestParam String key) {
83.         return rHash.getAll(key, User.class);
84.     }
86.     /**
87.      * 判断hash中是否存在某个键
88.      */
89.     @GetMapping("/hasHashKey")
90.     public Boolean hasHashKey(@RequestParam String key, @RequestParam String hashKey) {
91.         return rHash.hasHashKey(key, hashKey);
92.     }
93. }

复制代码

5.RSortedSetController.java

1. package com.sunxiansheng.redis.controller;
3. import com.sunxiansheng.redis.utils.RSortedSet;
4. import lombok.AllArgsConstructor;
5. import lombok.Data;
6. import lombok.NoArgsConstructor;
7. import org.springframework.beans.factory.annotation.Autowired;
8. import org.springframework.data.redis.core.ZSetOperations;
9. import org.springframework.web.bind.annotation.*;
11. import java.util.Set;
13. /**
14. * Description: 测试 RSortedSet 工具类
15. *
16. * @Author sun
17. * @Create 2024/11/16
18. * @Version 1.0
19. */
20. @RestController
21. @RequestMapping("/rsortedset")
22. public class RSortedSetController {
24.     @Autowired
25.     private RSortedSet rSortedSet;
27.     // 自定义类型
28.     @Data
29.     @NoArgsConstructor
30.     @AllArgsConstructor
31.     public static class CustomValue {
32.         private Long id;
33.         private String name;
34.     }
36.     @PostMapping("/add")
37.     public Boolean add(@RequestParam String key, @RequestBody CustomValue value, @RequestParam double score) {
38.         return rSortedSet.add(key, value, score);
39.     }
41.     @PostMapping("/addBatch")
42.     public Long addBatch(@RequestParam String key, @RequestBody Set<RSortedSet.DataScore<CustomValue>> dataScores) {
43.         return rSortedSet.addBatch(key, dataScores);
44.     }
46.     @PostMapping("/remove")
47.     public Long remove(@RequestParam String key, @RequestBody Set<CustomValue> values) {
48.         return rSortedSet.remove(key, values);
49.     }
51.     @PostMapping("/removeRangeByScore")
52.     public Long removeRangeByScore(@RequestParam String key, @RequestParam double min, @RequestParam double max) {
53.         return rSortedSet.removeRangeByScore(key, min, max);
54.     }
56.     @PostMapping("/changeByDelta")
57.     public Double changeByDelta(@RequestParam String key, @RequestBody CustomValue value, @RequestParam double delta) {
58.         return rSortedSet.changeByDelta(key, value, delta);
59.     }
61.     @GetMapping("/reverseRangeWithScores")
62.     public Set<ZSetOperations.TypedTuple<CustomValue>> reverseRangeWithScores(@RequestParam String key) {
63.         return rSortedSet.reverseRangeWithScores(key, CustomValue.class);
64.     }
66.     @GetMapping("/score")
67.     public Double score(@RequestParam String key, @RequestBody CustomValue value) {
68.         return rSortedSet.score(key, value);
69.     }
71.     @GetMapping("/reverseRank")
72.     public Long reverseRank(@RequestParam String key, @RequestBody CustomValue value) {
73.         return rSortedSet.reverseRank(key, value);
74.     }
76.     @GetMapping("/zCard")
77.     public Long zCard(@RequestParam String key) {
78.         return rSortedSet.zCard(key);
79.     }
81.     @GetMapping("/count")
82.     public Long count(@RequestParam String key, @RequestParam double min, @RequestParam double max) {
83.         return rSortedSet.count(key, min, max);
84.     }
85. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。