1. 依赖
-
依赖
<!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- redis-pool --> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> </dependency> -
说明
-
spring boot已经集成，无需声明版本号 -
commons-pool2为redis的连接池
-
2.主配置文件
-
哨兵模式
spring: redis: lettuce: pool: max-active: 10 min-idle: 5 # 主的密码 password: passsword sentinel: # 主的地址，如果是 docker-compose，则为容器名 master: redis-master # sentinel 的地址，也可为容器名的地址 nodes: sentinel1:26379,sentinel2:26379,sentinel3:26379 -
集群模式
spring: redis: lettuce: pool: max-active: 10 min-idle: 5 # 集群的密码，密码要一致 password: passsword cluster: # 也可以逗号 , 分开 nodes: - 172.29.0.2:6379 - 172.29.0.3:6379 - 172.29.0.4:6379 - 172.29.0.5:6379 - 172.29.0.6:6379 - 172.29.0.7:6379 # 执行命令时的最大重定向次数 max-redirects: 3 -
单机模式
spring: redis: host: 120.25.207.44 port: 6379 password: password database: 1 lettuce: pool: min-idle: 5 max-active: 10
3. RedisConfig配置类
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.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* 说明：
*
* @author sheng
*/
@Configuration
public class RedisConfig {
/**
* 将 RedisTemplate 对象注册到容器中
*
* @param factory RedisConnectionFactory 工厂
* @return RedisTemplate 对象
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
// 对 key 进行序列化
// StringRedisSerializer 当需要存储 String 类型的 key 时序列化使用
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// 对 String 的 key 进行序列化
redisTemplate.setKeySerializer(stringRedisSerializer);
// 对 Hash 的 key 进行序列化
redisTemplate.setHashKeySerializer(stringRedisSerializer);
// 也可以使用 FastJsonRedisSerializer 来序列化，需要引入 fastjson 依赖
// 对值进行序列化
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
// 注入到 factory 工厂中
redisTemplate.setConnectionFactory(factory);
return redisTemplate;
}
/**
* 将操作 string redis 类型的 ValueOperations 对象注册到容器
*
* @param redisTemplate RedisTemplate 对象
* @return ValueOperations 对象
*/
@Bean
public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForValue();
}
/**
* 将操作 list redis 类型的 ListOperations 对象注册到容器
*
* @param redisTemplate RedisTemplate 对象
* @return ListOperations 对象
*/
@Bean
public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForList();
}
/**
* 将操作 set redis 类型的 SetOperations 对象注册到容器
*
* @param redisTemplate RedisTemplate 对象
* @return SetOperations 对象
*/
@Bean
public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForSet();
}
/**
* 将操作 zSet redis 类型的 ZSetOperations 对象注册到容器
*
* @param redisTemplate RedisTemplate 对象
* @return ZSetOperations 对象
*/
@Bean
public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForZSet();
}
/**
* 将操作 hash redis 类型的 ZSetOperations 对象注册到容器
*
* @param redisTemplate RedisTemplate 对象
* @return HashOperations 对象
*/
@Bean
public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForHash();
}
}
4. redis-dmo 源码
5. 工具类
-
service接口import org.springframework.data.redis.connection.DataType; import org.springframework.data.redis.core.Cursor; import org.springframework.data.redis.core.ScanOptions; import org.springframework.data.redis.core.ZSetOperations; import java.util.*; import java.util.concurrent.TimeUnit; /** * 说明：操作 redis 的工具类 * * @author sheng */ public interface RedisService { // key 的操作 /** * 删除 key * * @param key 要删除的 key * @return 成功返回 true */ Boolean delete(String key); /** * 批量删除 key * * @param keys 要删除的 key 的 Collection<String>集合 * @return 删除成功数 */ Long delete(Collection<String> keys); /** * 序列化 key * * @param key 要序列化的 key * @return byte[] 数组 */ byte[] dump(String key); /** * key 是否存在 * * @param key key * @return 存在则 true，否则 false */ Boolean hasKey(String key); /** * 设置过期时间 * * @param key 设置过期时间的 key * @param timeout 过期时间 * @param timeUnit TimeUnit 枚举类对象，单位 * @return 成功返回 true */ Boolean expire(String key, long timeout, TimeUnit timeUnit); /** * 设置过期时间 * * @param key 设置过期时间的 key * @param date 过期时间的日期，Date 对象 * @return 成功返回 true */ Boolean expireAt(String key, Date date); /** * 查找匹配的 key * * @param pattern 条件 * @return Set<String> */ Set<String> keys(String pattern); /** * 将当前数据库的 key 移动到给定的数据库 db 当中 * * @param key 移动的 key * @param dbIndex 目标数据库 * @return 成功返回 true */ Boolean move(String key, int dbIndex); /** * 移除 key 的过期时间，key 将持久保持 * * @param key 移除的 key * @return 成功返回 true */ Boolean persist(String key); /** * 返回 key 的剩余的过期时间 * * @param key 查看的 key * @param timeUnit TimeUnit 枚举类，单位 * @return 返回时间 */ Long getExpire(String key, TimeUnit timeUnit); /** * 返回 key 的剩余的过期时间 * * @param key key * @return 剩余过期时间 */ Long getExpire(String key); /** * 从当前数据库中随机返回一个 key * * @return 返回的 key */ String randomKey(); /** * 修改 key 的名称 * * @param oldKey key 原来的名称 * @param newKey 新的名称 */ void rename(String oldKey, String newKey); /** * 仅当 newKey 不存在时，将 oldKey 改名为 newKey * * @param oldKey key 原来的名称 * @param newKey 新的名称 * @return 成功返回 true */ Boolean renameIfAbsent(String oldKey, String newKey); /** * 返回 key 所储存的值的类型 * * @param key key * @return key 的类型 */ DataType type(String key); // string 相关操作 /** * 设置指定 key 的值 * * @param key key * @param value 值 */ void set(String key, Object value); /** * 获取指定 key 的值 * * @param key key * @return key 的值 */ Object get(String key); /** * 返回 key 中字符串值的子字符 * * @param key key * @param start 截取的初始索引 * @param end 截取的末索引 * @return 子字符串 */ Object get(String key, long start, long end); /** * 将给定 key 的值设为 value ，并返回 key 的旧值(old value) * * @param key key * @param value 要设定的新值 * @return key 原来的值 */ Object getAndSet(String key, String value); /** * 对 key 所储存的字符串值，获取指定偏移量上的位(bit) * * @param key key * @param offset 偏移量 * @return 成功返回 true */ Boolean getBit(String key, long offset); /** * 批量获取 * * @param keys key 集合 * @return key 对应的值的集合 */ List<Object> multiGet(Collection<String> keys); /** * 设置 ASCII 码, 字符串'a'的ASCII码是97, 转为二进制是'01100001', 此方法是将二进制第 offset 位值变为value * * @param key key * @param offset 位置，二进制的位数 * @param value 值，true为 1，false为 0 * @return 成功返回 true */ Boolean setBit(String key, long offset, boolean value); /** * 将值 value 关联到 key ，并将 key 的过期时间设为 timeout * * @param key key * @param value 值 * @param timeout 过期时间 * @param timeUnit 时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES * 秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS */ void set(String key, String value, long timeout, TimeUnit timeUnit); /** * 只有在 key 不存在时设置 key 的值 * * @param key key * @param value 值 * @return 之前已经存在返回false, 不存在返回true */ Boolean setIfAbsent(String key, String value); /** * 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始 * * @param key key * @param value 复写的参数值 * @param offset 从指定位置开始覆写 */ void set(String key, String value, long offset); /** * 获取字符串的长度 * * @param key key * @return key对应值的长度 */ Long size(String key); /** * 批量添加 * * @param maps 添加的字符串的 map */ void multiSet(Map<String, String> maps); /** * 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在 * * @param maps 添加的字符串的 map * @return 之前已经存在返回 false, 不存在返回 true */ Boolean multiSetIfAbsent(Map<String, String> maps); /** * 增加(自增长), 负数则为自减 * * @param key key * @param increment 整型，自增的 值 * @return 自增后的值 */ Long incrBy(String key, long increment); /** * 增加(自增长), 负数则为自减 * * @param key key * @param increment double，自增的值 * @return 自增后的值 */ Double incrByDouble(String key, double increment); /** * 追加到末尾 * * @param key key * @param value 追加的值 * @return key 的长度 */ Integer append(String key, String value); // hash相关操作 /** * 获取存储在哈希表中指定字段的值 * * @param key key * @param field hash的键 * @return 键对应的值 */ Object hGet(String key, String field); /** * 获取所有给定 key hash 的值 * * @param key key * @return key 对应的所有的键值对 map */ Map<String, Object> hGetAll(String key); /** * 获取所有给定字段的值 * * @param key key * @param fields key 对应的键的集合 * @return 键对应的值的集合 */ List<Object> hMultiGet(String key, List<String> fields); /** * 给名为 key 的 hash 增加 hashKey-value 键值对 * * @param key key * @param hashKey hash对应的键 * @param value 键对应的值 */ void hPut(String key, String hashKey, Object value); /** * 给名为 key 的 hash 增加 maps 所有的键值对 * * @param key 键 * @param maps 要增加的 map */ void hPutAll(String key, Map<String, String> maps); /** * 仅当 hashKey不存在时才设置 * * @param key key hash * @param hashKey hash 对应的键 * @param value 设置的值 * @return 成功返回 true */ Boolean hPutIfAbsent(String key, String hashKey, Object value); /** * 删除一个或多个哈希表字段 * * @param key hash * @param fields 删除的键 * @return 删除的个数 */ Long hDelete(String key, Object... fields); /** * 查看哈希表 key 中，指定的字段是否存在 * * @param key hash * @param field 要判断的键 * @return 存在返回 true */ boolean hHasKey(String key, String field); /** * 为哈希表 key 中的指定字段的整数值加上增量 increment * * @param key hash * @param field hash 对应的键 * @param increment 自增的值，负数为减 * @return 增加后的值 */ Long hIncrBy(String key, String field, long increment); /** * 为哈希表 key 中的指定字段的整数值加上增量 increment * * @param key hash * @param field hash 对应的键 * @param increment 自增的值，负数为减 * @return 增加后的值 */ Double hIncrByDouble(String key, String field, Double increment); /** * 获取所有哈希表中的字段 * * @param key hash * @return hash 所有的键的 Set 集合 */ Set<String> hKeys(String key); /** * 获取哈希表中字段的数量 * * @param key key * @return 键的数量 */ Long hSize(String key); /** * 获取哈希表中所有值 * * @param key hash * @return hash 所有的值的 List 集合 */ List<Object> hValues(String key); /** * 迭代哈希表中的键值对 * * @param key hash * @param options 迭代的条件 * @return 连接，如果报错，可以手动关闭，调用 .close() */ Cursor<Map.Entry<String, Object>> hScan(String key, ScanOptions options); // list相关操作 /** * 通过索引获取列表中的元素 * * @param key list 对应的 key * @param index 索引 * @return 对应的值 */ Object lIndex(String key, long index); /** * 获取列表指定范围内的元素 * * @param key key * @param start 开始位置, 0是开始位置 * @param end 结束位置, -1返回所有 * @return 元素的 集合 */ List<Object> lRange(String key, long start, long end); /** * 存储在list头部 * * @param key key * @param value 值 * @return 集合的长度 */ Long lLeftPush(String key, Object value); /** * 将值全部存储在头部 * * @param key key * @param value 值 * @return 集合的长度 */ Long lLeftPushAll(String key, Object... value); /** * 将集合里面的值全部存储在头部 * * @param key key * @param value Collection<String>集合 * @return 集合的长度 */ Long lLeftPushAll(String key, Collection<Object> value); /** * 当list存在的时候才加入 * * @param key key * @param value 值 * @return 集合的长度 */ Long lLeftPushIfPresent(String key, Object value); /** * 如果 pivot存在,再 pivot前面添加 * * @param key key * @param pivot 是否存在的值 * @param value pivot 存在则在其前面添加的值 * @return 集合的长度，失败返回 -1 */ Long lLeftPush(String key, Object pivot, Object value); /** * list 尾部添加 * * @param key key * @param value 值 * @return 集合的长度 */ Long lRightPush(String key, Object value); /** * 尾部添加所有 * * @param key key * @param value 添加的值 * @return 集合的长度 */ Long lRightPushAll(String key, Object... value); /** * 尾部添加所有 * * @param key list key * @param value 要添加的 Collection<String> 集合 * @return 集合的长度 */ Long lRightPushAll(String key, Collection<Object> value); /** * 为已存在的 list 列表添加值 * * @param key key * @param value 要添加的值 * @return 集合的长度 */ Long lRightPushIfPresent(String key, Object value); /** * 在 pivot 元素的右边添加值 * * @param key list * @param pivot list 存在的元素，在其右边添加 * @param value 添加的值 * @return 集合的长度 */ Long lRightPush(String key, Object pivot, Object value); /** * 通过索引设置列表元素的值 * * @param key list * @param index 位置 * @param value 添加的值 */ void lSet(String key, long index, String value); /** * 移出并获取列表的第一个元素 * * @param key key * @return 删除的元素 */ Object lLeftPop(String key); /** * 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止 * * @param key key * @param timeout 等待时间 * @param timeUnit 时间单位 * @return 移除的元素 */ Object lLeftPop(String key, long timeout, TimeUnit timeUnit); /** * 移除并获取列表最后一个元素 * * @param key key * @return 删除的元素 */ Object lRightPop(String key); /** * 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止 * * @param key key * @param timeout 等待时间 * @param timeUnit 时间单位 * @return 移除的元素 */ Object lRightPop(String key, long timeout, TimeUnit timeUnit); /** * 移除列表的最后一个元素，并将该元素添加到另一个列表并返回 * * @param sourceKey 源 list * @param destinationKey 目标 list * @return 源 list 移除的元素 */ Object lRightPopAndLeftPush(String sourceKey, String destinationKey); /** * 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止 * * @param sourceKey 源 list * @param destinationKey 目标 list * @param timeout 超时时间 * @param timeUnit TimeUnit 枚举类对象，单位 * @return 源 list 移除的元素 */ Object lRightPopAndLeftPush(String sourceKey, String destinationKey, long timeout, TimeUnit timeUnit); /** * 删除集合中值等于value得元素 * * @param key key * @param index index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素; * index<0, 从尾部开始删除第一个值等于value的元素; * @param value 要删除的值 * @return 删除的个数 */ Long lRemove(String key, long index, String value); /** * 裁剪list * * @param key key * @param start 裁剪的起始索引 * @param end 裁剪的末尾索引 */ void lTrim(String key, long start, long end); /** * 获取列表长度 * * @param key key * @return list 长度 */ Long lSize(String key); // set相关操作 /** * set添加元素 * * @param key key * @param values 添加的元素 * @return 成功个数 */ Long sAdd(String key, Object... values); /** * set移除元素 * * @param key key * @param values 删除的元素 * @return 删除成功个数 */ Long sRemove(String key, Object... values); /** * 移除并返回集合的一个随机元素 * * @param key set 集合 key * @return 移除的元素 */ Object sPop(String key); /** * 将元素value从一个集合移到另一个集合 * * @param key 源 set * @param value 移动的 值 * @param destKey 目标 set * @return 成功返回 true */ Boolean sMove(String key, String value, String destKey); /** * 获取集合的大小 * * @param key set 集合 * @return 集合大小 */ Long sSize(String key); /** * 判断集合是否包含value * * @param key set 集合 * @param value 是否包含的值 * @return 存在返回 true */ Boolean sIsMember(String key, Object value); /** * 获取两个集合的交集 * * @param key 集合 * @param otherKey 集合 * @return 两个集合的交集 */ Set<Object> sIntersect(String key, String otherKey); /** * 获取key集合与多个集合的交集 * * @param key 集合 * @param otherKeys 包含多个集合 key 的集合 Collection<String> * @return 交集 */ Set<Object> sIntersect(String key, Collection<String> otherKeys); /** * key集合与otherKey集合的交集存储到destKey集合中 * * @param key 求交集的集合 * @param otherKey 求交集的集合 * @param destKey 交集存储的目标集合 * @return 交集元素个数 */ Long sIntersectAndStore(String key, String otherKey, String destKey); /** * key集合与多个集合的交集存储到destKey集合中 * * @param key 集合 key * @param otherKeys 包含多个集合 key 的集合 Collection<String> * @param destKey 交集存储的目标集合 * @return 添加到 destKey 交集的个数 */ Long sIntersectAndStore(String key, Collection<String> otherKeys, String destKey); /** * 获取两个集合的并集 * * @param key 集合 * @param otherKeys 集合 * @return 并集 */ Set<Object> sUnion(String key, String otherKeys); /** * 获取key集合与多个集合的并集 * * @param key 集合 * @param otherKeys 包含多个集合 key 的集合 Collection<String> * @return 并集 */ Set<Object> sUnion(String key, Collection<String> otherKeys); /** * key集合与otherKey集合的并集存储到destKey中 * * @param key 求并集的集合 * @param otherKey 求并集的集合 * @param destKey 并集添加到的目标集合 * @return 添加到目标集合的值的个数 */ Long sUnionAndStore(String key, String otherKey, String destKey); /** * key集合与多个集合的并集存储到destKey中 * * @param key 集合 * @param otherKeys 包含多个集合 key 的集合 Collection<String> * @param destKey 并集添加到的目标集合 * @return 添加到目标集合的值的个数 */ Long sUnionAndStore(String key, Collection<String> otherKeys, String destKey); /** * 获取两个集合的差集 * * @param key 集合 * @param otherKey 集合 * @return 差集 */ Set<Object> sDifference(String key, String otherKey); /** * 获取key集合与多个集合的差集 * * @param key 集合 * @param otherKeys 包含多个集合 key 的集合 Collection<String> * @return 差集 */ Set<Object> sDifference(String key, Collection<String> otherKeys); /** * key集合与otherKey集合的差集存储到destKey中 * * @param key 求差集的集合 * @param otherKey 求差集的集合 * @param destKey 差集添加到的目标集合 * @return 添加到目标集合的值的个数 */ Long sDifference(String key, String otherKey, String destKey); /** * key集合与多个集合的差集存储到destKey中 * * @param key 求差集的集合 * @param otherKeys 包含多个集合 key 的集合 Collection<String> * @param destKey 差集添加到的目标集合 * @return 添加到目标集合的值的个数 */ Long sDifference(String key, Collection<String> otherKeys, String destKey); /** * 获取集合所有元素 * * @param key 集合 * @return 集合的所有元素 */ Set<Object> sMembers(String key); /** * 随机获取集合中的一个元素 * * @param key 集合 * @return 随机返回的元素 */ Object sRandomMember(String key); /** * 随机获取集合中count个元素，可能获取同一个元素多次 * * @param key 集合 * @param count 获取的个数 * @return 获取到的元素的集合 */ List<Object> sRandomMembers(String key, long count); /** * 随机获取集合中count个元素并且去除重复的 * * @param key 集合 * @param count 随机获取的元素个数 * @return 元素的集合 */ Set<Object> sDistinctRandomMembers(String key, long count); /** * 迭代 set 集合 * * @param key 要迭代的集合 * @param options 迭代的条件 * @return 连接，如果报错，可以手动关闭，调用 .close() */ Cursor<Object> sScan(String key, ScanOptions options); // zSet相关操作 /** * 添加元素,有序集合是按照元素的score值由小到大排列 * * @param key 集合 * @param value 添加的元素 * @param score 元素对应的分数 * @return 成功返回 true */ Boolean zAdd(String key, Object value, double score); /** * 将 values 集合的元素添加的 key 集合 * * @param key 集合 key * @param values Set<ZSetOperations.TypedTuple<Object>> 集合 * @return 添加的个数 */ Long zAdd(String key, Set<ZSetOperations.TypedTuple<Object>> values); /** * 删除元素 * * @param key 集合 * @param values 要删除的元素，可变参数 * @return 删除的个数 */ Long zRemove(String key, Object... values); /** * 增加元素的score值，并返回增加后的值 * * @param key 集合 * @param value 要添加 score 值的元素 * @param delta 添加的 score 的值 * @return 增加后的值 */ Double zIncrementScore(String key, Object value, double delta); /** * 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列 * * @param key 集合 * @param value 要返回排名的值 * @return 0表示第一位 */ Long zRank(String key, Object value); /** * 返回元素在集合的排名,按元素的score值由大到小排列 * * @param key 集合 * @param value 要返回排名的值 * @return 0表示第一位 */ Long zReverseRank(String key, Object value); /** * 获取集合的元素, 从小到大排序 * * @param key 集合 * @param start 开始位置 * @param end 结束位置, -1查询所有 * @return 元素的集合 */ Set<Object> zRange(String key, long start, long end); /** * 获取集合元素, 并且把score值也获取 * * @param key 集合 * @param start 开始位置 * @param end 结束位置, -1查询所有 * @return 元素的集合 */ Set<ZSetOperations.TypedTuple<Object>> zRangeWithScores(String key, long start, long end); /** * 根据Score值查询集合元素 * * @param key 集合 * @param min 最小值 * @param max 最大值 * @return 元素的集合 */ Set<Object> zRangeByScore(String key, double min, double max); /** * 根据Score值查询集合元素, 从小到大排序 * * @param key 集合 * @param min 最小值 * @param max 最大值 * @return 元素的集合 */ Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key, double min, double max); /** * 获取key集合中索引在 [start, end] 的分数在 [min, max] 范围内的所有元素及其分数 * * @param key 集合 * @param min score 最小值 * @param max score 最大值 * @param start 开始位置 * @param end 结束位置, -1查询所有 * @return 获取到的元素集合 */ Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key, double min, double max, long start, long end); /** * 获取集合的元素, 从大到小排序 * * @param key 集合 * @param start 开始位置 * @param end 结束位置, -1查询所有 * @return 获取到的元素集合 */ Set<Object> zReverseRange(String key, long start, long end); /** * 获取集合的元素, 从大到小排序, 并返回score值 * * @param key 集合 * @param start 开始位置 * @param end 结束位置, -1查询所有 * @return 元素的集合 */ Set<ZSetOperations.TypedTuple<Object>> zReverseRangeWithScores(String key, long start, long end); /** * 根据Score值查询集合元素, 从大到小排序 * * @param key 集合 * @param min score 最小值 * @param max score 最大值 * @return 元素集合 */ Set<Object> zReverseRangeByScore(String key, double min, double max); /** * 根据Score值查询集合元素及其分数, 从大到小排序 * * @param key 集合 * @param min score 最小值 * @param max score 最大值 * @return 元素集合 */ Set<ZSetOperations.TypedTuple<Object>> zReverseRangeByScoreWithScores(String key, double min, double max); /** * 获取key集合中索引在 [start, end] 的分数在 [min, max] 范围内的所有元素 * * @param key key 集合 * @param min score 最小值 * @param max score 最大值 * @param start 起始位置 * @param end 末尾位置 * @return 元素集合 */ Set<Object> zReverseRangeByScore(String key, double min, double max, long start, long end); /** * 根据score值获取集合元素个数 * * @param key 集合 * @param min score 最小值 * @param max score 最大值 * @return 元素个数 */ Long zCount(String key, double min, double max); /** * 获取集合大小 * * @param key 集合 * @return 包含的元素的个数 */ Long zSize(String key); /** * 获取集合大小 * * @param key 集合 * @return 集合大小 */ Long zCard(String key); /** * 获取集合中value元素的score值 * * @param key 集合 * @param value 要获取 score 值的元素 * @return score 值 */ Double zScore(String key, Object value); /** * 移除指定索引位置的成员 * * @param key 集合 * @param start 起始位置 * @param end 结束位置 * @return 移除的个数 */ Long zRemoveRange(String key, long start, long end); /** * 根据指定的score值的范围来移除成员 * * @param key 集合 * @param min score 最小值 * @param max score 最大值 * @return 移除的个数 */ Long zRemoveRangeByScore(String key, double min, double max); /** * 获取 key和 otherKey的并集并存储在destKey中 * * @param key 求并集的集合 * @param otherKey 求并集的集合 * @param destKey 并集存储的目标集合 * @return 添加到目标集合的个数 */ Long zUnionAndStore(String key, String otherKey, String destKey); /** * 获取 key和 otherKey 的并集并存储在destKey中 * * @param key 集合 key * @param otherKeys 多个集合 key 的 Collection<String> 集合 * @param destKey 并集添加到的目标集合 * @return 添加到目标集合的元素个数 */ Long zUnionAndStore(String key, Collection<String> otherKeys, String destKey); /** * 获取 key和 otherKey 的交集并存储在destKey中 * * @param key 集合 * @param otherKey 集合 * @param destKey 交集添加到的目标集合 * @return 添加到目标集合的元素个数 */ Long zIntersectAndStore(String key, String otherKey, String destKey); /** * 获取 key和 otherKey 的交集并存储在destKey中 * * @param key 求交集的集合 * @param otherKeys 求交集的集合 * @param destKey 交集添加到的目标集合 * @return 添加到目标集合的元素个数 */ Long zIntersectAndStore(String key, Collection<String> otherKeys, String destKey); /** * 迭代集合 * * @param key 要迭代的集合 * @param options 迭代的条件 * @return 连接，如果报错，调用 .close() 方法关闭 */ Cursor<ZSetOperations.TypedTuple<Object>> zScan(String key, ScanOptions options); } -
RedisServiceImpl实现import com.sheng.boot.redis.service.RedisService; import org.springframework.data.redis.connection.DataType; import org.springframework.data.redis.core.*; import org.springframework.stereotype.Service; import javax.annotation.Resource; import java.util.*; import java.util.concurrent.TimeUnit; /** * 说明： * * @author sheng */ @Service public class RedisServiceImpl implements RedisService { @Resource private RedisTemplate<String, Object> redisTemplate; @Resource private ValueOperations<String, Object> valueOperations; @Resource private HashOperations<String, String, Object> hashOperations; @Resource private ListOperations<String, Object> listOperations; @Resource private SetOperations<String, Object> setOperations; @Resource private ZSetOperations<String, Object> zSetOperations; @Override public Boolean delete(String key) { return redisTemplate.delete(key); } @Override public Long delete(Collection<String> keys) { return redisTemplate.delete(keys); } @Override public byte[] dump(String key) { return redisTemplate.dump(key); } @Override public Boolean hasKey(String key) { return redisTemplate.hasKey(key); } @Override public Boolean expire(String key, long timeout, TimeUnit timeUnit) { return redisTemplate.expire(key, timeout, timeUnit); } @Override public Boolean expireAt(String key, Date date) { return redisTemplate.expireAt(key, date); } @Override public Set<String> keys(String pattern) { return redisTemplate.keys(pattern); } @Override public Boolean move(String key, int dbIndex) { return redisTemplate.move(key, dbIndex); } @Override public Boolean persist(String key) { return redisTemplate.persist(key); } @Override public Long getExpire(String key, TimeUnit timeUnit) { return redisTemplate.getExpire(key, timeUnit); } @Override public Long getExpire(String key) { return redisTemplate.getExpire(key); } @Override public String randomKey() { return redisTemplate.randomKey(); } @Override public void rename(String oldKey, String newKey) { redisTemplate.rename(oldKey, newKey); } @Override public Boolean renameIfAbsent(String oldKey, String newKey) { return redisTemplate.renameIfAbsent(oldKey, newKey); } @Override public DataType type(String key) { return redisTemplate.type(key); } @Override public void set(String key, Object value) { valueOperations.set(key, value); } @Override public Object get(String key) { return valueOperations.get(key); } @Override public Object get(String key, long start, long end) { return valueOperations.get(key, start, end); } @Override public Object getAndSet(String key, String value) { return valueOperations.getAndSet(key, value); } @Override public Boolean getBit(String key, long offset) { return valueOperations.getBit(key, offset); } @Override public List<Object> multiGet(Collection<String> keys) { return valueOperations.multiGet(keys); } @Override public Boolean setBit(String key, long offset, boolean value) { return valueOperations.setBit(key, offset, value); } @Override public void set(String key, String value, long timeout, TimeUnit timeUnit) { valueOperations.set(key, value, timeout, timeUnit); } @Override public Boolean setIfAbsent(String key, String value) { return valueOperations.setIfAbsent(key, value); } @Override public void set(String key, String value, long offset) { valueOperations.set(key, value, offset); } @Override public Long size(String key) { return valueOperations.size(key); } @Override public void multiSet(Map<String, String> maps) { valueOperations.multiSet(maps); } @Override public Boolean multiSetIfAbsent(Map<String, String> maps) { return valueOperations.multiSetIfAbsent(maps); } @Override public Long incrBy(String key, long increment) { return valueOperations.increment(key, increment); } @Override public Double incrByDouble(String key, double increment) { return valueOperations.increment(key, increment); } @Override public Integer append(String key, String value) { return valueOperations.append(key, value); } @Override public Object hGet(String key, String field) { return hashOperations.get(key, field); } @Override public Map<String, Object> hGetAll(String key) { return hashOperations.entries(key); } @Override public List<Object> hMultiGet(String key, List<String> fields) { return hashOperations.multiGet(key, fields); } @Override public void hPut(String key, String hashKey, Object value) { hashOperations.put(key, hashKey, value); } @Override public void hPutAll(String key, Map<String, String> maps) { hashOperations.putAll(key, maps); } @Override public Boolean hPutIfAbsent(String key, String hashKey, Object value) { return hashOperations.putIfAbsent(key, hashKey, value); } @Override public Long hDelete(String key, Object... fields) { return hashOperations.delete(key, fields); } @Override public boolean hHasKey(String key, String field) { return hashOperations.hasKey(key, field); } @Override public Long hIncrBy(String key, String field, long increment) { return hashOperations.increment(key, field, increment); } @Override public Double hIncrByDouble(String key, String field, Double increment) { return hashOperations.increment(key, field, increment); } @Override public Set<String> hKeys(String key) { return hashOperations.keys(key); } @Override public Long hSize(String key) { return hashOperations.size(key); } @Override public List<Object> hValues(String key) { return hashOperations.values(key); } @Override public Cursor<Map.Entry<String, Object>> hScan(String key, ScanOptions options) { return hashOperations.scan(key, options); } @Override public Object lIndex(String key, long index) { return listOperations.index(key, index); } @Override public List<Object> lRange(String key, long start, long end) { return listOperations.range(key, start, end); } @Override public Long lLeftPush(String key, Object value) { return listOperations.leftPush(key, value); } @Override public Long lLeftPushAll(String key, Object... value) { return listOperations.leftPushAll(key, value); } @Override public Long lLeftPushAll(String key, Collection<Object> value) { return listOperations.leftPushAll(key, value); } @Override public Long lLeftPushIfPresent(String key, Object value) { return listOperations.leftPushIfPresent(key, value); } @Override public Long lLeftPush(String key, Object pivot, Object value) { return listOperations.leftPush(key, pivot, value); } @Override public Long lRightPush(String key, Object value) { return listOperations.rightPush(key, value); } @Override public Long lRightPushAll(String key, Object... value) { return listOperations.rightPushAll(key, value); } @Override public Long lRightPushAll(String key, Collection<Object> value) { return listOperations.rightPushAll(key, value); } @Override public Long lRightPushIfPresent(String key, Object value) { return listOperations.rightPushIfPresent(key, value); } @Override public Long lRightPush(String key, Object pivot, Object value) { return listOperations.rightPush(key, pivot, value); } @Override public void lSet(String key, long index, String value) { listOperations.set(key, index, value); } @Override public Object lLeftPop(String key) { return listOperations.leftPop(key); } @Override public Object lLeftPop(String key, long timeout, TimeUnit timeUnit) { return listOperations.leftPop(key, timeout, timeUnit); } @Override public Object lRightPop(String key) { return listOperations.rightPop(key); } @Override public Object lRightPop(String key, long timeout, TimeUnit timeUnit) { return listOperations.rightPop(key, timeout, timeUnit); } @Override public Object lRightPopAndLeftPush(String sourceKey, String destinationKey) { return listOperations.rightPopAndLeftPush(sourceKey, destinationKey); } @Override public Object lRightPopAndLeftPush(String sourceKey, String destinationKey, long timeout, TimeUnit timeUnit) { return listOperations.rightPopAndLeftPush(sourceKey, destinationKey, timeout, timeUnit); } @Override public Long lRemove(String key, long index, String value) { return listOperations.remove(key, index, value); } @Override public void lTrim(String key, long start, long end) { listOperations.trim(key, start, end); } @Override public Long lSize(String key) { return listOperations.size(key); } @Override public Long sAdd(String key, Object... values) { return setOperations.add(key, values); } @Override public Long sRemove(String key, Object... values) { return setOperations.remove(key, values); } @Override public Object sPop(String key) { return setOperations.pop(key); } @Override public Boolean sMove(String key, String value, String destKey) { return setOperations.move(key, value, destKey); } @Override public Long sSize(String key) { return setOperations.size(key); } @Override public Boolean sIsMember(String key, Object value) { return setOperations.isMember(key, value); } @Override public Set<Object> sIntersect(String key, String otherKey) { return setOperations.intersect(key, otherKey); } @Override public Set<Object> sIntersect(String key, Collection<String> otherKeys) { return setOperations.intersect(key, otherKeys); } @Override public Long sIntersectAndStore(String key, String otherKey, String destKey) { return setOperations.intersectAndStore(key, otherKey, destKey); } @Override public Long sIntersectAndStore(String key, Collection<String> otherKeys, String destKey) { return setOperations.intersectAndStore(key, otherKeys, destKey); } @Override public Set<Object> sUnion(String key, String otherKeys) { return setOperations.union(key, otherKeys); } @Override public Set<Object> sUnion(String key, Collection<String> otherKeys) { return setOperations.union(key, otherKeys); } @Override public Long sUnionAndStore(String key, String otherKey, String destKey) { return setOperations.unionAndStore(key, otherKey, destKey); } @Override public Long sUnionAndStore(String key, Collection<String> otherKeys, String destKey) { return setOperations.unionAndStore(key, otherKeys, destKey); } @Override public Set<Object> sDifference(String key, String otherKey) { return setOperations.difference(key, otherKey); } @Override public Set<Object> sDifference(String key, Collection<String> otherKeys) { return setOperations.difference(key, otherKeys); } @Override public Long sDifference(String key, String otherKey, String destKey) { return setOperations.differenceAndStore(key, otherKey, destKey); } @Override public Long sDifference(String key, Collection<String> otherKeys, String destKey) { return setOperations.differenceAndStore(key, otherKeys, destKey); } @Override public Set<Object> sMembers(String key) { return setOperations.members(key); } @Override public Object sRandomMember(String key) { return setOperations.randomMember(key); } @Override public List<Object> sRandomMembers(String key, long count) { return setOperations.randomMembers(key, count); } @Override public Set<Object> sDistinctRandomMembers(String key, long count) { return setOperations.distinctRandomMembers(key, count); } @Override public Cursor<Object> sScan(String key, ScanOptions options) { return setOperations.scan(key, options); } @Override public Boolean zAdd(String key, Object value, double score) { return zSetOperations.add(key, value, score); } @Override public Long zAdd(String key, Set<ZSetOperations.TypedTuple<Object>> values) { return zSetOperations.add(key, values); } @Override public Long zRemove(String key, Object... values) { return zSetOperations.remove(key, values); } @Override public Double zIncrementScore(String key, Object value, double delta) { return zSetOperations.incrementScore(key, value, delta); } @Override public Long zRank(String key, Object value) { return zSetOperations.rank(key, value); } @Override public Long zReverseRank(String key, Object value) { return zSetOperations.reverseRank(key, value); } @Override public Set<Object> zRange(String key, long start, long end) { return zSetOperations.range(key, start, end); } @Override public Set<ZSetOperations.TypedTuple<Object>> zRangeWithScores(String key, long start, long end) { return zSetOperations.rangeWithScores(key, start, end); } @Override public Set<Object> zRangeByScore(String key, double min, double max) { return zSetOperations.rangeByScore(key, min, max); } @Override public Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key, double min, double max) { return zSetOperations.rangeByScoreWithScores(key, min, max); } @Override public Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key, double min, double max, long start, long end) { return zSetOperations.rangeByScoreWithScores(key, min, max, start, end); } @Override public Set<Object> zReverseRange(String key, long start, long end) { return zSetOperations.reverseRange(key, start, end); } @Override public Set<ZSetOperations.TypedTuple<Object>> zReverseRangeWithScores(String key, long start, long end) { return zSetOperations.reverseRangeWithScores(key, start, end); } @Override public Set<Object> zReverseRangeByScore(String key, double min, double max) { return zSetOperations.reverseRangeByScore(key, min, max); } @Override public Set<ZSetOperations.TypedTuple<Object>> zReverseRangeByScoreWithScores(String key, double min, double max) { return zSetOperations.reverseRangeByScoreWithScores(key, min, max); } @Override public Set<Object> zReverseRangeByScore(String key, double min, double max, long start, long end) { return zSetOperations.reverseRangeByScore(key, min, max, start, end); } @Override public Long zCount(String key, double min, double max) { return zSetOperations.count(key, min, max); } @Override public Long zSize(String key) { return zSetOperations.size(key); } @Override public Long zCard(String key) { return zSetOperations.zCard(key); } @Override public Double zScore(String key, Object value) { return zSetOperations.score(key, value); } @Override public Long zRemoveRange(String key, long start, long end) { return zSetOperations.removeRange(key, start, end); } @Override public Long zRemoveRangeByScore(String key, double min, double max) { return zSetOperations.removeRangeByScore(key, min, max); } @Override public Long zUnionAndStore(String key, String otherKey, String destKey) { return zSetOperations.unionAndStore(key, otherKey, destKey); } @Override public Long zUnionAndStore(String key, Collection<String> otherKeys, String destKey) { return zSetOperations.unionAndStore(key, otherKeys, destKey); } @Override public Long zIntersectAndStore(String key, String otherKey, String destKey) { return zSetOperations.intersectAndStore(key, otherKey, destKey); } @Override public Long zIntersectAndStore(String key, Collection<String> otherKeys, String destKey) { return zSetOperations.intersectAndStore(key, otherKeys, destKey); } @Override public Cursor<ZSetOperations.TypedTuple<Object>> zScan(String key, ScanOptions options) { return zSetOperations.scan(key, options); } }
网友评论