RedisHelper (commons-springboot 1.1.5 API)

java.lang.Object
- top.isopen.commons.springboot.helper.RedisHelper

```
public class RedisHelper
extends Object
```
Redis 工具类

从以下版本开始:

2023/7/7 17:36

版本:

1.0

作者:

TimeChaser

嵌套类概要

嵌套类
限定符和类型类和说明

static class RedisHelper.Helper
提供一些基础功能支持

嵌套类
限定符和类型	类和说明
`static class`	`RedisHelper.Helper` 提供一些基础功能支持

字段概要

字段
限定符和类型字段和说明

long DEFAULT_LOCK_TIMEOUT
分布式锁默认（最大）存活时长

TimeUnit DEFAULT_TIMEOUT_UNIT
DEFAULT_LOCK_TIMEOUT的单位

字段
限定符和类型	字段和说明
`long`	`DEFAULT_LOCK_TIMEOUT` 分布式锁默认（最大）存活时长
`TimeUnit`	`DEFAULT_TIMEOUT_UNIT` DEFAULT_LOCK_TIMEOUT的单位

构造器概要

构造器
构造器和说明

RedisHelper(org.springframework.data.redis.core.StringRedisTemplate redisTemplate)

构造器
构造器和说明
`RedisHelper(org.springframework.data.redis.core.StringRedisTemplate redisTemplate)`

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`int`	`append(String key, String value)` 追加值到末尾注: 当 redis 中原本不存在 key 时，那么（从效果上来看）此方法就等价于 `set(String, String)`
`long`	`delete(Collection<String> keys)` 根据 keys, 批量删除 key-value 注：若 redis 中，不存在对应的 key, 那么计数不会加 1, 即: redis 中存在的 key-value 里，有名为 a1、a2 的 key，删除时，传的集合是 a1、a2、a3，那么返回结果为 2。
`boolean`	`delete(String key)` 根据 key, 删除 redis 中的对应 key-value 注：若删除失败, 则返回 false。
`byte[]`	`dump(String key)` 将 key 对应的 value 值进行序列化，并返回序列化后的 value 值。
`boolean`	`expire(String key, long timeToLive, TimeUnit unit)` 给指定的 key 对应的 key-value 设置：多久过时注：过时后，redis 会自动删除对应的 key-value。
`boolean`	`expireAt(String key, Date date)` 给指定的 key 对应的 key-value 设置：什么时候过时注：过时后，redis 会自动删除对应的 key-value。
`String`	`get(String key)` 根据 key，获取到对应的 value 值
`String`	`getAndSet(String key, String newValue)` 给指定 key 设置新的 value，并返回旧的 value 注: 若 redis 中不存在 key，那么此操作仍然可以成功，不过返回的旧值是 null
`boolean`	`getBit(String key, long offset)` 获取（key对应的）value 在二进制下，offset 位置的 bit 值。
`long`	`getExpire(String key)` 获取 key 对应的 key-value 的过期时间注：若 key-value 永不过期，那么返回的为 -1。
`long`	`getExpire(String key, TimeUnit unit)` 获取 key 对应的 key-value 的过期时间注：若 key-value 永不过期，那么返回的为 -1。
`boolean`	`getLock(String key, String value)` 获取(分布式)锁.
`boolean`	`getLock(String key, String value, long timeout, TimeUnit unit)` 获取(分布式)锁注: 获取结果是即时返回的、是非阻塞的。
`boolean`	`getLock(String key, String value, long timeout, TimeUnit unit, boolean recordLog)` 获取(分布式)锁注: 获取结果是即时返回的、是非阻塞的。
`boolean`	`getLockUntilTimeout(String key, String value, long retryTimeoutLimit)` 获取(分布式)锁。
`boolean`	`getLockUntilTimeout(String key, String value, long timeout, TimeUnit unit, long retryTimeoutLimit)` 获取(分布式)锁。
`String`	`getRange(String key, long start, long end)` 对（key 对应的）value 进行截取, 截取范围为 [start, end] 注：若 [start, end] 的范围不在 value 的范围中，那么返回的是空字符串 "" 注：若 value 只有一部分在 [start, end] 的范围中，那么返回的是 value 对应部分的内容（即：不足的地方，并不会以空来填充）
`boolean`	`hasKey(String key)` redis 中是否存在,指定 key 的 key-value
`long`	`hDelete(String key, Object... entryKeys)` （批量）删除（key 对应的）hash 中的对应 entryKey-entryValue 注: 1、若 redis 中不存在对应的 key，则返回 0; 2、若要删除的 entryKey，在 key 对应的 hash 中不存在，在 count 不会 +1, 如: RedisHelper.HashOps.hPut("ds", "name", "邓沙利文"); RedisHelper.HashOps.hPut("ds", "birthday", "1994-02-05"); RedisHelper.HashOps.hPut("ds", "hobby", "女"); 则调用 RedisUtil.HashOps.hDelete("ds", "name", "birthday", "hobby", "non-exist-entryKey") 的返回结果为 3 注：若（key 对应的）hash 中的所有 entry 都被删除了，那么该 key 也会被删除
`boolean`	`hExists(String key, String entryKey)` 查看（key 对应的）hash中，是否存在 entryKey 对应的 entry 注：若 redis 中不存在 key，则返回 false。
`Object`	`hGet(String key, String entryKey)` 获取到 key 对应的 hash 里面的对应字段的值注: 若 redis 中不存在对应的 key，则返回 null。
`Map<Object,Object>`	`hGetAll(String key)` 获取到 key 对应的 hash（即：获取到 key 对应的 Map）注：若 redis 中不存在对应的 key，则返回一个没有任何 entry 的空的 Map（而不是返回 null）。
`long`	`hIncrBy(String key, Object entryKey, long increment)` 增/减(hash中的某个entryValue值) 整数注: 负数则为减。
`double`	`hIncrByFloat(String key, Object entryKey, double increment)` 增/减(hash中的某个entryValue值) 浮点数注: 负数则为减。
`Set<Object>`	`hKeys(String key)` 获取(key对应的)hash中的所有entryKey 注: 若key不存在，则返回的是一个空的Set(，而不是返回null)
`List<Object>`	`hMultiGet(String key, Collection<Object> entryKeys)` 批量获取（key 对应的）hash 中的 entryKey 的 entryValue 注：若 hash 中对应的 entryKey 不存在，那么返回的对应的 entryValue 值为 null 注：redis 中 key 不存在，那么返回的 List 中，每个元素都为 null。
`void`	`hPut(String key, String entryKey, String entryValue)` 向 key 对应的 hash 中，增加一个键值对 entryKey-entryValue 注：同一个 hash 里面，若已存在相同的 entryKey，那么此操作将丢弃原来的 entryKey-entryValue，而使用新的 entryKey-entryValue。
`void`	`hPutAll(String key, Map<String,String> maps)` 向 key 对应的 hash 中，增加 maps（即: 批量增加 entry 集）注：同一个 hash 里面，若已存在相同的 entryKey，那么此操作将丢弃原来的 entryKey-entryValue，而使用新的 entryKey-entryValue
`boolean`	`hPutIfAbsent(String key, String entryKey, String entryValue)` 当 key 对应的 hash 中，不存在 entryKey 时，才（向 key 对应的 hash 中）增加 entryKey-entryValue 否者，不进行任何操作
`org.springframework.data.redis.core.Cursor<Map.Entry<Object,Object>>`	`hScan(String key, org.springframework.data.redis.core.ScanOptions options)` 根据options匹配到(key对应的)hash中的对应的entryKey, 并返回对应的entry集注: ScanOptions实例的创建方式举例: 1、ScanOptions.NONE 2、ScanOptions.scanOptions().match("n??
`long`	`hSize(String key)` 获取(key对应的)hash中的所有entry的数量注: 若redis中不存在对应的key, 则返回值为0
`List<Object>`	`hValues(String key)` 获取(key对应的)hash中的所有entryValue 注: 若key不存在，则返回的是一个空的List(，而不是返回null)
`long`	`incrBy(String key, long increment)` 增/减整数注：负数则为减。
`double`	`incrByFloat(String key, double increment)` 增/减浮点数注：慎用浮点数，会有精度问题。
`Set<String>`	`keys(String pattern)` 找到所有匹配 pattern 的 key,并返回该 key 的集合.
`String`	`lIndex(String key, long index)` 通过索引index, 获取(key对应的)list中的元素注: 若key不存在或 index超出(key对应的)list的索引范围，那么返回null
`String`	`lLeftPop(String key)` 【非阻塞队列】从左侧移出(key对应的)list中的第一个元素, 并将该元素返回注: 此方法是非阻塞的，即: 若(key对应的)list中的所有元素都被pop移出了，此时，再进行pop的话，会立即返回null 注: 此方法是非阻塞的，即: 若redis中不存在对应的key,那么会立即返回null 注: 若将(key对应的)list中的所有元素都pop完了，那么该key会被删除
`String`	`lLeftPop(String key, long timeout, TimeUnit unit)` 【阻塞队列】从左侧移出(key对应的)list中的第一个元素, 并将该元素返回注: 此方法是阻塞的，即: 若(key对应的)list中的所有元素都被pop移出了，此时，再进行pop的话，会阻塞timeout这么久，然后返回null 注: 此方法是阻塞的，即: 若redis中不存在对应的key,那么会阻塞timeout这么久，然后返回null 注: 若将(key对应的)list中的所有元素都pop完了，那么该key会被删除提示: 若阻塞过程中，目标key-list出现了，且里面有item了，那么会立马停止阻塞, 进行元素移出并返回
`long`	`lLeftPush(String key, String item)` 从左端推入元素进列表注: 若redis中不存在对应的key, 那么会自动创建
`long`	`lLeftPush(String key, String pivot, String item)` 若 key 对应的 list 中存在 pivot 项, 那么将 item 放入第一个 pivot 项前(即:放在第一个pivot项左边); 若 key 对应的 list 中不存在 pivot 项, 那么不做任何操作，直接返回 -1。
`long`	`lLeftPushAll(String key, Collection<String> items)` 从左端批量推入元素进列表注: 若redis中不存在对应的key, 那么会自动创建注: 这一批item中，那个item先从Collection取出来，就先push哪个
`long`	`lLeftPushAll(String key, String... items)` 从左端批量推入元素进列表注: 若redis中不存在对应的key, 那么会自动创建注: 这一批item中，先push左侧的, 后push右侧的
`long`	`lLeftPushIfPresent(String key, String item)` 如果redis中存在key, 则从左端批量推入元素进列表; 否则，不进行任何操作
`List<String>`	`lRange(String key, long start, long end)` 获取(key对应的)list中索引在[start, end]之间的item集注: 含start、含end。
`long`	`lRemove(String key, long expectCount, String item)` 删除(key对应的)list中，前expectCount个值等于item的项注: 若expectCount == 0，则表示删除list中所有的值等于item的项.
`String`	`lRightPop(String key)` 与`lLeftPop(String)`类比即可，不过是从list右侧移出元素
`String`	`lRightPop(String key, long timeout, TimeUnit unit)` 与`lLeftPop(String, long, TimeUnit)`类比即可，不过是从list右侧移出元素
`String`	`lRightPopAndLeftPush(String sourceKey, String destinationKey)` 【非阻塞队列】从sourceKey对应的sourceList右侧移出一个item, 并将这个item推入(destinationKey对应的)destinationList的左侧注: 若sourceKey对应的list中没有item了，则立马认为(从sourceKey对应的list中pop出来的)item为null, null并不会往destinationKey对应的list中push。
`String`	`lRightPopAndLeftPush(String sourceKey, String destinationKey, long timeout, TimeUnit unit)` 【阻塞队列】从sourceKey对应的sourceList右侧移出一个item, 并将这个item推入(destinationKey对应的)destinationList的左侧注: 若sourceKey对应的list中没有item了，则阻塞等待, 直到能从sourceList中移出一个非null的item(或等待时长超时); case1: 等到了一个非null的item, 那么继续下面的push操作，并返回这个item。
`long`	`lRightPush(String key, String item)` 与`lLeftPush(String, String)`类比即可，不过是从list右侧推入元素
`long`	`lRightPush(String key, String pivot, String item)` 与`lLeftPush(String, String, String)`类比即可，不过是从list右侧推入元素
`long`	`lRightPushAll(String key, Collection<String> items)` 与`#lLeftPushAll(String, Collection)`类比即可，不过是从list右侧推入元素
`long`	`lRightPushAll(String key, String... items)` 与`lLeftPushAll(String, String...)`类比即可，不过是从list右侧推入元素
`long`	`lRightPushIfPresent(String key, String item)` 与`lLeftPushIfPresent(String, String)`类比即可，不过是从list右侧推入元素
`void`	`lSet(String key, long index, String item)` 设置(key对应的)list中对应索引位置index处的元素为item 注: 若key不存在，则会抛出org.springframework.data.redis.RedisSystemException 注: 若索引越界，也会抛出org.springframework.data.redis.RedisSystemException
`long`	`lSize(String key)` 获取(key对应的)list的size 注: 当key不存在时，获取到的size为0.
`void`	`lTrim(String key, long start, long end)` 裁剪(即: 对list中的元素取交集。)
`List<String>`	`lWholeList(String key)` 获取(key对应的)list
`boolean`	`move(String key, int dbIndex)` 将当前数据库中的 key 对应的 key-value,移动到对应位置的数据库中。
`List<String>`	`multiGet(Collection<String> keys)` 批量获取 value 值注：若 redis 中，对应的 key 不存在，那么该 key 对应的返回的 value 值为 null
`void`	`multiSet(Map<String,String> maps)` 批量设置 key-value 注：若存在相同的 key, 则原来的 key-value会被丢弃。
`boolean`	`multiSetIfAbsent(Map<String,String> maps)` 当 redis 中，不存在任何一个 keys 时，才批量设置 key-value，并返回成功/失败。
`boolean`	`persist(String key)` 移除 key 对应的 key-value 的过期时间, 使该 key-value 一直存在注：若 key 对应的 key-value，本身就是一直存在（无过期时间的），那么 persist 方法会返回 false; 若没有 key 对应的 key-value 存在，本那么 persist 方法会返回 false;
`String`	`randomKey()` 从 redis 的所有 key 中，随机获取一个 key 注：若 redis 中不存在任何 key-value，那么这里返回 null
`boolean`	`releaseLock(String key, String value)` 释放(分布式)锁注: 此方式能(通过value的唯一性)保证: 自己加的锁, 只能被自己释放。
`void`	`rename(String oldKey, String newKey)` 重命名对应的 oldKey 为新的 newKey 注：若 oldKey 不存在，则会抛出异常.
`boolean`	`renameIfAbsent(String oldKey, String newKey)` 当 redis 中不存在 newKey 时, 重命名对应的 oldKey 为新的 newKey。
`void`	`restore(String key, byte[] value, long timeToLive, TimeUnit unit)` 将给定的 value 值，反序列化到 redis 中, 形成新的 key-value。
`void`	`restore(String key, byte[] value, long timeToLive, TimeUnit unit, boolean replace)` 将给定的 value 值，反序列化到 redis 中, 形成新的 key-value。
`long`	`sAdd(String key, String... items)` 向(key对应的)set中添加items 注: 若key不存在，则会自动创建。
`Set<String>`	`sDifference(String key, Collection<String> otherKeys)` 获取 (key对应的)Set 减去 (otherKeys对应的)Sets 的差集注: 如果被减数key不存在，那么结果为空的集合(，而不是null) 注: 如果被减数key存在，但减数key不存在，那么结果即为(被减数key对应的)Set 提示: 当有多个减数时，被减数先减去哪一个减数，后减去哪一个减数，是无所谓的，是不影响最终结果的。
`Set<String>`	`sDifference(String key, String otherKey)` 获取 (key对应的)Set 减去 (otherKey对应的)Set 的差集注: 如果被减数key不存在，那么结果为空的集合(，而不是null) 注: 如果被减数key存在，但减数key不存在，那么结果即为(被减数key对应的)Set
`long`	`sDifferenceAndStore(String key, Collection<String> otherKeys, String storeKey)` 获取 (key对应的)Set 减去 (otherKey对应的)Set 的差集, 并将结果add到storeKey对应的Set中。
`long`	`sDifferenceAndStore(String key, String otherKey, String storeKey)` 获取 (key对应的)Set 减去 (otherKey对应的)Set 的差集, 并将结果add到storeKey对应的Set中。
`Set<String>`	`sDistinctRandomMembers(String key, long count)` 从key对应的set中随机获取count个项注: 若count >= set的size, 那么返回的即为这个key对应的set。
`void`	`set(String key, String value)` 设置 key-value 注：若已存在相同的 key, 那么原来的 key-value 会被丢弃。
`boolean`	`setBit(String key, long offset, boolean value)` 处理 redis 中 key 对应的 value 值, 将第 offset 位的值, 设置为 1 或 0。
`void`	`setEx(String key, String value, long timeToLive, TimeUnit unit)` 设置 key-value 注：若已存在相同的 key，那么原来的 key-value 会被丢弃注：原子操作
`boolean`	`setIfAbsent(String key, String value)` 若不存在 key 时，向 redis 中添加 key-value, 返回成功/失败。
`boolean`	`setIfAbsent(String key, String value, long timeToLive, TimeUnit unit)` 若不存在 key 时, 向 redis 中添加一个（具有超时时长的）key-value, 返回成功/失败。
`void`	`setRange(String key, String replaceValue, long offset)` 从（redis 中 key 对应的）value 的 offset 位置起（包含该位置），用 replaceValue 替换对应长度的值。
`Set<String>`	`sIntersect(String key, Collection<String> otherKeys)` 获取多个(key对应的)Set的交集注: 若不存在任何交集，那么返回空的集合(, 而不是null) 注: 若>=1个key不存在，那么返回空的集合(, 而不是null)
`Set<String>`	`sIntersect(String key, String otherKey)` 获取两个(key对应的)Set的交集注: 若不存在任何交集，那么返回空的集合(, 而不是null) 注: 若其中一个key不存在(或两个key都不存在)，那么返回空的集合(, 而不是null)
`long`	`sIntersectAndStore(String key, Collection<String> otherKeys, String storeKey)` 获取多个(key对应的)Set的交集, 并将结果add到storeKey对应的Set中。
`long`	`sIntersectAndStore(String key, String otherKey, String storeKey)` 获取两个(key对应的)Set的交集, 并将结果add到storeKey对应的Set中。
`boolean`	`sIsMember(String key, Object item)` 判断(key对应的)set中是否含有item 注: 若key不存在，则返回false。
`long`	`size(String key)` 获取到 key 对应的 value 的长度。
`Set<String>`	`sMembers(String key)` 获取key对应的set 注: 若key不存在, 则返回的是空的set(, 而不是null)
`boolean`	`sMove(String sourceKey, String item, String destinationKey)` 将(sourceKey对应的)sourceSet中的元素item, 移动到(destinationKey对应的)destinationSet中注: 当sourceKey不存在时，返回false 注: 当item不存在时，返回false 注: 若destinationKey不存在，那么在移动时会自动创建注: 若已经将(sourceKey对应的)set中的项move出去完了，那么对应的sourceKey会被删除。
`String`	`sPop(String key)` 从(key对应的)set中随机移出一个item, 并返回这个item 注: 因为set是无序的，所以移出的这个item,是随机的; 并且，哪怕是数据一样的set,多次测试移出操作,移除的元素也是随机的。
`String`	`sRandomMember(String key)` 从key对应的set中随机获取一项
`List<String>`	`sRandomMembers(String key, long count)` 从key对应的set中获取count次随机项(, set中的同一个项可能被多次获取) 注: count可大于set的size。
`long`	`sRemove(String key, Object... items)` 从(key对应的)set中删除items 注: 若key不存在, 则返回0。
`org.springframework.data.redis.core.Cursor<String>`	`sScan(String key, org.springframework.data.redis.core.ScanOptions options)` 根据options匹配到(key对应的)set中的对应的item, 并返回对应的item集注: ScanOptions实例的创建方式举例: 1、ScanOptions.NONE 2、ScanOptions.scanOptions().match("n??
`long`	`sSize(String key)` 获取(key对应的)set中的元素个数注: 若key不存在，则返回0
`Set<String>`	`sUnion(String key, Collection<String> otherKeys)` 获取两个(key对应的)Set的并集注: 并集中的元素也是唯一的，这是Set保证的。
`Set<String>`	`sUnion(String key, String otherKey)` 获取两个(key对应的)Set的并集注: 并集中的元素也是唯一的，这是Set保证的。
`long`	`sUnionAndStore(String key, Collection<String> otherKeys, String storeKey)` 获取两个(key对应的)Set的并集, 并将结果add到storeKey对应的Set中。
`long`	`sUnionAndStore(String key, String otherKey, String storeKey)` 获取两个(key对应的)Set的并集, 并将结果add到storeKey对应的Set中。
`org.springframework.data.redis.connection.DataType`	`type(String key)` 获取 key 对应的 value 的数据类型注：若 redis 中不存在该 key 对应的 key-value，那么这里返回 NONE。
`long`	`zAdd(String key, Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>> entries)` 批量添加entry 注: 若entry集中存在item相同的项(, score不一样)，那么redis在执行真正的批量add操作前,会将其中一个item过滤掉。
`boolean`	`zAdd(String key, String item, double score)` 向(key对应的)zset中添加(item, score) 注: item为entryKey成员项， score为entryValue分数值。
`long`	`zCount(String key, double minScore, double maxScore)` 统计(key对应的zset中)score处于[minScore, maxScore]中的item的个数
`double`	`zIncrementScore(String key, String item, double delta)` 增/减 (key对应的zset中,)item的分数值
`long`	`zIntersectAndStore(String key, Collection<String> otherKeys, String storeKey)` 获取多个(key对应的)ZSet的交集, 并将结果add到storeKey对应的ZSet中。
`long`	`zIntersectAndStore(String key, String otherKey, String storeKey)` 获取两个(key对应的)ZSet的交集, 并将结果add到storeKey对应的ZSet中。
`Set<String>`	`zRange(String key, long start, long end)` 根据索引位置，获取(key对应的)zset中排名处于[start, end]中的item项集注: 不论是使用正向排名，还是使用反向排名, 使用此方法时, 应保证 startIndex代表的元素的位置在endIndex代表的元素的位置的前面，如: 示例一: .zRange("name", 0, 2); 示例二: .zRange("site", -2, -1); 示例三: .zRange("foo", 0, -1); 注: 若key不存在, 则返回空的集合。
`Set<String>`	`zRangeByScore(String key, double minScore, double maxScore)` 根据score，获取(key对应的)zset中分数值处于[minScore, maxScore]中的item项集注: 若key不存在, 则返回空的集合。
`Set<String>`	`zRangeByScore(String key, double minScore, double maxScore, long offset, long count)` 根据score，获取(key对应的)zset中分数值处于[minScore, maxScore]中的, score处于[minScore, 排名大于等于offset的count个item项特别注意: 对于不是特别熟悉redis的人来说, offset 和 count最好都使用正数，避免引起理解上的歧义。
`Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>>`	`zRangeByScoreWithScores(String key, double minScore, double maxScore)` 获取(key对应的)zset中的所有score处于[minScore, maxScore]中的entry
`Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>>`	`zRangeByScoreWithScores(String key, double minScore, double maxScore, long offset, long count)` 获取(key对应的)zset中, score处于[minScore, maxScore]里的、排名大于等于offset的count个entry 特别注意: 对于不是特别熟悉redis的人来说, offset 和 count最好都使用正数，避免引起理解上的歧义。
`Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>>`	`zRangeWithScores(String key, long start, long end)` 根据索引位置，获取(key对应的)zset中排名处于[start, end]中的entry集注: 不论是使用正向排名，还是使用反向排名, 使用此方法时, 应保证 startIndex代表的元素的位置在endIndex代表的元素的位置的前面，如: 示例一: .zRange("name", 0, 2); 示例二: .zRange("site", -2, -1); 示例三: .zRange("foo", 0, -1); 注: 若key不存在, 则返回空的集合。
`long`	`zRank(String key, Object item)` 返回item在(key对应的)zset中的(按score从小到大的)排名注: 排名从0开始。
`long`	`zRemove(String key, Object... items)` 从(key对应的)zset中移除项注:若key不存在，则返回0
`long`	`zRemoveRange(String key, long startRange, long endRange)` 移除(key对应的)zset中, 排名范围在[startIndex, endIndex]内的item 注:默认的，按score.item升序排名，排名从0开始注: 类似于List中的索引, 排名可以分为多个方式: 从前到后(正向)的排名: 0、1、2...
`long`	`zRemoveRangeByScore(String key, double minScore, double maxScore)` 移除(key对应的)zset中, score范围在[minScore, maxScore]内的item 提示: 虽然删除范围包含两侧的端点(即:包含minScore和maxScore), 但是由于double存在精度问题，所以建议: 设置值时，minScore应该设置得比要删除的项里，最小的score还小一点 maxScore应该设置得比要删除的项里，最大的score还大一点追注: 本人简单测试了几组数据，暂未出现精度问题。
`Set<String>`	`zReverseRange(String key, long start, long end)` 获取时, 先按score倒序, 然后根据索引位置，获取(key对应的)zset中排名处于[start, end]中的item项集
`Set<String>`	`zReverseRangeByScore(String key, double minScore, double maxScore)` 获取时, 先按score倒序, 然后根据score，获取(key对应的)zset中分数值处于[minScore, maxScore]中的item项集
`Set<String>`	`zReverseRangeByScore(String key, double minScore, double maxScore, long offset, long count)` 获取时, 先按score倒序, 然后根据score，获取(key对应的)zset中分数值处于[minScore, maxScore]中的, score处于[minScore,排名大于等于offset的count个item项
`Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>>`	`zReverseRangeByScoreWithScores(String key, double minScore, double maxScore)` 获取时, 先按score倒序, 然后获取(key对应的)zset中的所有score处于[minScore, maxScore]中的entry
`Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>>`	`zReverseRangeWithScores(String key, long start, long end)` 获取时, 先按score倒序, 然后根据索引位置，获取(key对应的)zset中排名处于[start, end]中的entry集
`long`	`zReverseRank(String key, Object item)` 返回item在(key对应的)zset中的(按score从大到小的)排名注: 排名从0开始。
`double`	`zScore(String key, Object item)` 统计(key对应的)zset中指定item的score
`long`	`zSize(String key)` 统计(key对应的)zset中item的个数注: 此方法等价于`zZCard(String)`
`long`	`zUnionAndStore(String key, Collection<String> otherKeys, String storeKey)` 获取两个(key对应的)ZSet的并集, 并将结果add到storeKey对应的ZSet中。
`long`	`zUnionAndStore(String key, String otherKey, String storeKey)` 获取两个(key对应的)ZSet的并集, 并将结果add到storeKey对应的ZSet中。
`Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>>`	`zWholeZSetEntry(String key)` 获取(key对应的)zset中的所有entry
`Set<String>`	`zWholeZSetItem(String key)` 获取(key对应的)zset中的所有item项
`long`	`zZCard(String key)` 统计(key对应的)zset中item的个数注: 此方法等价于`zSize(String)`

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - DEFAULT_LOCK_TIMEOUT
```
public final long DEFAULT_LOCK_TIMEOUT
```
    分布式锁默认（最大）存活时长
    
    另请参阅:
    
    常量字段值
  - DEFAULT_TIMEOUT_UNIT
```
public final TimeUnit DEFAULT_TIMEOUT_UNIT
```
    DEFAULT_LOCK_TIMEOUT的单位
- 构造器详细资料
  - RedisHelper
```
public RedisHelper(org.springframework.data.redis.core.StringRedisTemplate redisTemplate)
```
- 方法详细资料
  - delete
```
public boolean delete(String key)
```
    根据 key, 删除 redis 中的对应 key-value
    注：若删除失败, 则返回 false。
    若 redis 中，不存在该 key, 那么返回的也是 false。所以，不能因为返回了 false,就认为 redis 中一定还存在该 key 对应的 key-value。
    
    参数:
    
    key - 要删除的 key
    
    返回:
    
    删除是否成功
    
    从以下版本开始:
    
    2020/3/7 17:15:02
  - delete
```
public long delete(Collection<String> keys)
```
    根据 keys, 批量删除 key-value
    注：若 redis 中，不存在对应的 key, 那么计数不会加 1, 即: redis 中存在的 key-value 里，有名为 a1、a2 的 key，删除时，传的集合是 a1、a2、a3，那么返回结果为 2。
    
    参数:
    
    keys - 要删除的 key 集合
    
    返回:
    
    删除了的 key-value 个数
    
    从以下版本开始:
    
    2020/3/7 17:48:04
  - dump
```
public byte[] dump(String key)
```
    将 key 对应的 value 值进行序列化，并返回序列化后的 value 值。
    注：若不存在对应的 key, 则返回 null。注：dump 时，并不会删除 redis 中的对应 key-value。注：dump 功能与 restore 相反。
    
    参数:
    
    key - 要序列化的 value 的 key
    
    返回:
    
    序列化后的 value 值
    
    从以下版本开始:
    
    2020/3/8 11:34:13
  - restore
```
public void restore(String key,
                    byte[] value,
                    long timeToLive,
                    TimeUnit unit)
```
    将给定的 value 值，反序列化到 redis 中, 形成新的 key-value。
    
    参数:
    
    key - value 对应的 key
    
    value - 要反序列的 value 值。注：这个值可以由 dump(String) 获得
    
    timeToLive - 反序列化后的 key-value 的存活时长
    
    unit - timeToLive 的单位
    
    抛出:
    
    org.springframework.data.redis.RedisSystemException - 如果 redis 中已存在同样的 key 时，抛出此异常
    
    从以下版本开始:
    
    2020/3/8 11:36:45
  - restore
```
public void restore(String key,
                    byte[] value,
                    long timeToLive,
                    TimeUnit unit,
                    boolean replace)
```
    将给定的 value 值，反序列化到 redis 中, 形成新的 key-value。
    
    参数:
    
    key - value 对应的 key
    
    value - 要反序列的 value 值。注：这个值可以由 dump(String) 获得
    
    timeToLive - 反序列化后的 key-value 的存活时长
    
    unit - timeToLive 的单位
    
    replace - 若 redis 中已经存在了相同的 key, 是否替代原来的 key-value
    
    抛出:
    
    org.springframework.data.redis.RedisSystemException - 如果 redis 中已存在同样的key, 且 replace 为 false 时，抛出此异常
    
    从以下版本开始:
    
    2020/3/8 11:36:45
  - hasKey
```
public boolean hasKey(String key)
```
    redis 中是否存在,指定 key 的 key-value
    
    参数:
    
    key - 指定的 key
    
    返回:
    
    是否存在对应的 key-value
    
    从以下版本开始:
    
    2020/3/8 12:16:46
  - expire
```
public boolean expire(String key,
                      long timeToLive,
                      TimeUnit unit)
```
    给指定的 key 对应的 key-value 设置：多久过时
    注：过时后，redis 会自动删除对应的 key-value。注：若 key 不存在，那么也会返回 false。
    
    参数:
    
    key - 指定的 key
    
    timeToLive - 过时时间
    
    unit - timeout 的单位
    
    返回:
    
    操作是否成功
    
    从以下版本开始:
    
    2020/3/8 12:18:58
  - expireAt
```
public boolean expireAt(String key,
                        Date date)
```
    给指定的 key 对应的 key-value 设置：什么时候过时
    注：过时后，redis 会自动删除对应的 key-value。注：若 key 不存在，那么也会返回 false。
    
    参数:
    
    key - 指定的 key
    
    date - 啥时候过时
    
    返回:
    
    操作是否成功
    
    从以下版本开始:
    
    2020/3/8 12:19:29
  - keys
```
public Set<String> keys(String pattern)
```
    找到所有匹配 pattern 的 key,并返回该 key 的集合.
    提示：若 redis 中键值对较多，此方法耗时相对较长，慎用！慎用！慎用！
    
    参数:
    
    pattern - 匹配模板。注：常用的通配符有： ? 有且只有一个; * >=0 哥;
    
    返回:
    
    匹配 pattern 的 key 的集合。可能为 null。
    
    从以下版本开始:
    
    2020/3/8 12:38:38
  - move
```
public boolean move(String key,
                    int dbIndex)
```
    将当前数据库中的 key 对应的 key-value,移动到对应位置的数据库中。
    注：单机版的 redis,默认将存储分为 16 个 db, index 为 0 到 15。注：同一个 db 下，key 唯一；但是在不同 db 中，key 可以相同。注：若目标 db 下，已存在相同的 key, 那么 move 会失败，返回 false。
    
    参数:
    
    key - 定位要移动的 key-value 的 key
    
    dbIndex - 要移动到哪个 db
    
    返回:
    
    移动是否成功。注：若目标 db 下，已存在相同的 key, 那么 move 会失败，返回 false。
    
    从以下版本开始:
    
    2020/3/8 13:01:00
  - persist
```
public boolean persist(String key)
```
    移除 key 对应的 key-value 的过期时间, 使该 key-value 一直存在
    注：若 key 对应的 key-value，本身就是一直存在（无过期时间的），那么 persist 方法会返回 false; 若没有 key 对应的 key-value 存在，本那么 persist 方法会返回 false;
    
    参数:
    
    key - 定位 key-value 的 key
    
    返回:
    
    操作是否成功
    
    从以下版本开始:
    
    2020/3/8 13:10:02
  - getExpire
```
public long getExpire(String key)
```
    获取 key 对应的 key-value 的过期时间
    注：若 key-value 永不过期，那么返回的为 -1。注：若不存在 key 对应的 key-value，那么返回的为 -2 注：若存在零碎时间不足 1 SECONDS，则（大体上）四舍五入到 SECONDS 级别。
    
    参数:
    
    key - 定位 key-value 的 key
    
    返回:
    
    过期时间（单位s）
    
    从以下版本开始:
    
    2020/3/8 13:17:35
  - getExpire
```
public long getExpire(String key,
                      TimeUnit unit)
```
    获取 key 对应的 key-value 的过期时间
    注：若 key-value 永不过期，那么返回的为 -1。注：若不存在 key 对应的 key-value，那么返回的为 -2 注：若存在零碎时间不足 1 unit，则（大体上）四舍五入到 unit 别。
    
    参数:
    
    key - 定位 key-value 的 key
    
    返回:
    
    过期时间（单位 unit）
    
    从以下版本开始:
    
    2020/3/8 13:17:35
  - randomKey
```
public String randomKey()
```
    从 redis 的所有 key 中，随机获取一个 key
    注：若 redis 中不存在任何 key-value，那么这里返回 null
    
    返回:
    
    随机获取到的一个 key
    
    从以下版本开始:
    
    2020/3/8 14:11:43
  - rename
```
public void rename(String oldKey,
                   String newKey)
```
    重命名对应的 oldKey 为新的 newKey
    注：若 oldKey 不存在，则会抛出异常. 注：若 redis 中已存在与 newKey 一样的 key, 那么原 key-value 会被丢弃，只留下新的 key，以及原来的 value 示例说明：假设 redis 中已有（keyAlpha, valueAlpha）和（keyBeta, valueBeat）, 在使用 rename（keyAlpha, keyBeta）替换后, redis 中只会剩下（keyBeta, valueAlpha）
    
    参数:
    
    oldKey - 旧的 key
    
    newKey - 新的 key
    
    抛出:
    
    org.springframework.data.redis.RedisSystemException - 若 oldKey 不存在时，抛出此异常
    
    从以下版本开始:
    
    2020/3/8 14:14:17
  - renameIfAbsent
```
public boolean renameIfAbsent(String oldKey,
                              String newKey)
```
    当 redis 中不存在 newKey 时, 重命名对应的 oldKey 为新的 newKey。否者不进行重命名操作。
    注：若 oldKey 不存在，则会抛出异常.
    
    参数:
    
    oldKey - 旧的 key
    
    newKey - 新的 key
    
    抛出:
    
    org.springframework.data.redis.RedisSystemException - 若 oldKey 不存在时，抛出此异常
    
    从以下版本开始:
    
    2020/3/8 14:14:17
  - type
```
public org.springframework.data.redis.connection.DataType type(String key)
```
    获取 key 对应的 value 的数据类型
    注：若 redis 中不存在该 key 对应的 key-value，那么这里返回 NONE。
    
    参数:
    
    key - 用于定位的 key
    
    返回:
    
    key 对应的 value 的数据类型的枚举
    
    从以下版本开始:
    
    2020/3/8 14:40:16
  - set
```
public void set(String key,
                String value)
```
    设置 key-value
    注：若已存在相同的 key, 那么原来的 key-value 会被丢弃。
    
    参数:
    
    key - key
    
    value - key 对应的 value
    
    从以下版本开始:
    
    2020/3/8 15:40:59
  - setBit
```
public boolean setBit(String key,
                      long offset,
                      boolean value)
```
    处理 redis 中 key 对应的 value 值, 将第 offset 位的值, 设置为 1 或 0。
    说明：在 redis 中，存储的字符串都是以二级制的进行存在的；如存储的 key-value 里，值为 abc，实际上，在 redis 里面存储的是 011000010110001001100011，前 8 位对应 a，中间 8 位对应 b，后面 8 位对应 c。示例：这里如果 setBit(key, 6, true) 的话，就是将索引位置 6 的那个数，设置值为 1，值就变成了 011000110110001001100011 追注：offset 即 index，从 0 开始。
    注：参数 value 为 true，则设置为 1；参数 value 为 false，则设置为 0。
    注：若 redis 中不存在对应的 key，那么会自动创建新的。注：offset 可以超过 value 在二进制下的索引长度。
    
    参数:
    
    key - 定位 value 的 key
    
    offset - 要改变的 bit 的索引
    
    value - 改为 1 或 0，true - 改为 1，false - 改为 0
    
    返回:
    
    set 是否成功
    
    从以下版本开始:
    
    2020/3/8 16:30:37
  - setEx
```
public void setEx(String key,
                  String value,
                  long timeToLive,
                  TimeUnit unit)
```
    设置 key-value
    注：若已存在相同的 key，那么原来的 key-value 会被丢弃
    注：原子操作
    
    参数:
    
    key - key
    
    value - key 对应的 value
    
    timeToLive - 过时时长
    
    unit - timeToLive 的单位
    
    从以下版本开始:
    
    2020/3/8 15:40:59
  - setIfAbsent
```
public boolean setIfAbsent(String key,
                           String value)
```
    若不存在 key 时，向 redis 中添加 key-value, 返回成功/失败。若存在，则不作任何操作，返回 false。
    
    参数:
    
    key - key
    
    value - key 对应的 value
    
    返回:
    
    set 是否成功
    
    从以下版本开始:
    
    2020/3/8 16:51:36
  - setIfAbsent
```
public boolean setIfAbsent(String key,
                           String value,
                           long timeToLive,
                           TimeUnit unit)
```
    若不存在 key 时, 向 redis 中添加一个（具有超时时长的）key-value, 返回成功/失败。若存在，则不作任何操作，返回 false。
    
    参数:
    
    key - key
    
    value - key 对应的 value
    
    timeToLive - 超时时长
    
    unit - timeToLive 的单位
    
    返回:
    
    set 是否成功
    
    从以下版本开始:
    
    2020/3/8 16:51:36
  - setRange
```
public void setRange(String key,
                     String replaceValue,
                     long offset)
```
    从（redis 中 key 对应的）value 的 offset 位置起（包含该位置），用 replaceValue 替换对应长度的值。
    举例说明： 1. 假设 redis 中存在 key-value("ds", "0123456789"); 调用 setRange("ds", "abcdefghijk", 3)后，redis 中该 value 值就变为了 [012abcdefghijk]
    2. 假设 redis 中存在 key-value("jd", "0123456789"); 调用 setRange("jd", "xyz", 3)后，redis 中该 value 值就变为了 [012xyz6789]
    3. 假设 redis 中存在 key-value("ey", "0123456789"); 调用 setRange("ey", "qwer", 15)后，redis 中该 value 值就变为了 [0123456789 qwer] 注：case3 比较特殊，offset 超过了原 value 的长度了。中间就会有一些空格来填充，但是如果在程序中直接输出的话，中间那部分空格可能会出现乱码。
    
    参数:
    
    key - 定位 key-value 的 key
    
    replaceValue - 要替换的值
    
    offset - 起始位置
    
    从以下版本开始:
    
    2020/3/8 17:04:31
  - size
```
public long size(String key)
```
    获取到 key 对应的 value 的长度。
    注：长度等于 String.length()。注：若 redis 中不存在对应的 key-value，则返回值为 0.
    
    参数:
    
    key - 定位 value 的 key
    
    返回:
    
    value 的长度
    
    从以下版本开始:
    
    2020/3/8 17:14:30
  - multiSet
```
public void multiSet(Map<String,String> maps)
```
    批量设置 key-value
    注：若存在相同的 key, 则原来的 key-value会被丢弃。
    
    参数:
    
    maps - key-value 集
    
    从以下版本开始:
    
    2020/3/8 17:21:19
  - multiSetIfAbsent
```
public boolean multiSetIfAbsent(Map<String,String> maps)
```
    当 redis 中，不存在任何一个 keys 时，才批量设置 key-value，并返回成功/失败。否者，不进行任何操作，并返回 false。
    即：假设调用此方法时传入的参数 map 是这样的：{k1=v1, k2=v2, k3=v3} 那么 redis 中，k1、k2、k3 都不存在时，才会批量设置 key-value；否则不会设置任何 key-value。
    注：若存在相同的 key，则原来的 key-value 会被丢弃。
    
    参数:
    
    maps - key-value 集
    
    返回:
    
    操作是否成功
    
    从以下版本开始:
    
    2020/3/8 17:21:19
  - incrBy
```
public long incrBy(String key,
                   long increment)
```
    增/减整数
    注：负数则为减。
    注：若 key 对应的 value 值不支持增/减操作（即：value不是数字），那么会抛出 org.springframework.data.redis.RedisSystemException
    
    参数:
    
    key - 用于定位 value 的 key
    
    increment - 增加多少
    
    返回:
    
    增加后的总值。
    
    抛出:
    
    org.springframework.data.redis.RedisSystemException - key 对应的 value 值不支持增/减操作时
    
    从以下版本开始:
    
    2020/3/8 17:45:51
  - incrByFloat
```
public double incrByFloat(String key,
                          double increment)
```
    增/减浮点数
    注：慎用浮点数，会有精度问题。
    如: 先 RedisHelper.StringOps.set("ds", "123"); 然后再 RedisUtil.StringOps.incrByFloat("ds", 100.6); 就会看到精度问题。
    注：负数则为减。
    注：若 key 对应的 value 值不支持增/减操作（即：value不是数字），那么会抛出 org.springframework.data.redis.RedisSystemException
    
    参数:
    
    key - 用于定位value的key
    
    increment - 增加多少
    
    返回:
    
    增加后的总值。
    
    抛出:
    
    org.springframework.data.redis.RedisSystemException - key对应的value值不支持增/减操作时
    
    从以下版本开始:
    
    2020/3/8 17:45:51
  - append
```
public int append(String key,
                  String value)
```
    追加值到末尾
    注: 当 redis 中原本不存在 key 时，那么（从效果上来看）此方法就等价于 set(String, String)
    
    参数:
    
    key - 定位 value 的 key
    
    value - 要追加的 value 值
    
    返回:
    
    追加后，整个 value 的长度
    
    从以下版本开始:
    
    2020/3/8 17:59:21
  - get
```
public String get(String key)
```
    根据 key，获取到对应的 value 值
    
    参数:
    
    key - key-value 对应的 key
    
    返回:
    
    该 key 对应的值。注: 若 key 不存在，则返回 null。
    
    从以下版本开始:
    
    2020/3/8 16:27:41
  - getRange
```
public String getRange(String key,
                       long start,
                       long end)
```
    对（key 对应的）value 进行截取, 截取范围为 [start, end]
    注：若 [start, end] 的范围不在 value 的范围中，那么返回的是空字符串 ""
    注：若 value 只有一部分在 [start, end] 的范围中，那么返回的是 value 对应部分的内容（即：不足的地方，并不会以空来填充）
    
    参数:
    
    key - 定位 value 的 key
    
    start - 起始位置（从0开始）
    
    end - 结尾位置（从0开始）
    
    返回:
    
    截取后的字符串
    
    从以下版本开始:
    
    2020/3/8 18:08:45
  - getAndSet
```
public String getAndSet(String key,
                        String newValue)
```
    给指定 key 设置新的 value，并返回旧的 value
    注: 若 redis 中不存在 key，那么此操作仍然可以成功，不过返回的旧值是 null
    
    参数:
    
    key - 定位 value 的 key
    
    newValue - 要为该 key 设置的新的 value 值
    
    返回:
    
    旧的 value 值
    
    从以下版本开始:
    
    2020/3/8 18:14:24
  - getBit
```
public boolean getBit(String key,
                      long offset)
```
    获取（key对应的）value 在二进制下，offset 位置的 bit 值。
    注：当 offset 的值在（二进制下的 value 的）索引范围外时，返回的也是 false。
    示例： RedisHelper.StringOps.set("akey", "a"); 字符串 a，转换为二进制为 01100001 那么 getBit("akey", 6) 获取到的结果为 false。
    
    参数:
    
    key - 定位 value 的 key
    
    offset - 定位 bit 的索引
    
    返回:
    
    offset 位置对应的 bit 的值（true - 1, false - 0）
    
    从以下版本开始:
    
    2020/3/8 18:21:10
  - multiGet
```
public List<String> multiGet(Collection<String> keys)
```
    批量获取 value 值
    注：若 redis 中，对应的 key 不存在，那么该 key 对应的返回的 value 值为 null
    
    参数:
    
    keys - key 集
    
    返回:
    
    value 值集合
    
    从以下版本开始:
    
    2020/3/8 18:26:33
  - hPut
```
public void hPut(String key,
                 String entryKey,
                 String entryValue)
```
    向 key 对应的 hash 中，增加一个键值对 entryKey-entryValue
    注：同一个 hash 里面，若已存在相同的 entryKey，那么此操作将丢弃原来的 entryKey-entryValue，而使用新的 entryKey-entryValue。
    
    参数:
    
    key - 定位 hash 的 key
    
    entryKey - 要向 hash 中增加的键值对里的键
    
    entryValue - 要向 hash 中增加的键值对里的值
    
    从以下版本开始:
    
    2020/3/8 23:49:52
  - hPutAll
```
public void hPutAll(String key,
                    Map<String,String> maps)
```
    向 key 对应的 hash 中，增加 maps（即: 批量增加 entry 集）
    注：同一个 hash 里面，若已存在相同的 entryKey，那么此操作将丢弃原来的 entryKey-entryValue，而使用新的 entryKey-entryValue
    
    参数:
    
    key - 定位 hash 的 key
    
    maps - 要向 hash 中增加的键值对集
    
    从以下版本开始:
    
    2020/3/8 23:49:52
  - hPutIfAbsent
```
public boolean hPutIfAbsent(String key,
                            String entryKey,
                            String entryValue)
```
    当 key 对应的 hash 中，不存在 entryKey 时，才（向 key 对应的 hash 中）增加 entryKey-entryValue 否者，不进行任何操作
    
    参数:
    
    key - 定位 hash 的 key
    
    entryKey - 要向 hash 中增加的键值对里的键
    
    entryValue - 要向 hash 中增加的键值对里的值
    
    返回:
    
    操作是否成功。
    
    从以下版本开始:
    
    2020/3/8 23:49:52
  - hGet
```
public Object hGet(String key,
                   String entryKey)
```
    获取到 key 对应的 hash 里面的对应字段的值
    注: 若 redis 中不存在对应的 key，则返回 null。若 key 对应的 hash 中不存在对应的 entryKey，也会返回 null。
    
    参数:
    
    key - 定位 hash 的 key
    
    entryKey - 定位 hash 里面的 entryValue 的 entryKey
    
    返回:
    
    key 对应的 hash 里的 entryKey 对应的 entryValue 值
    
    从以下版本开始:
    
    2020/3/9 9:09:30
  - hGetAll
```
public Map<Object,Object> hGetAll(String key)
```
    获取到 key 对应的 hash（即：获取到 key 对应的 Map）
    注：若 redis 中不存在对应的 key，则返回一个没有任何 entry 的空的 Map（而不是返回 null）。
    
    参数:
    
    key - 定位 hash 的 key
    
    返回:
    
    key 对应的 hash。
    
    从以下版本开始:
    
    2020/3/9 9:09:30
  - hMultiGet
```
public List<Object> hMultiGet(String key,
                              Collection<Object> entryKeys)
```
    批量获取（key 对应的）hash 中的 entryKey 的 entryValue
    注：若 hash 中对应的 entryKey 不存在，那么返回的对应的 entryValue 值为 null
    注：redis 中 key 不存在，那么返回的 List 中，每个元素都为 null。
    追注：这个 List 本身不为 null，size 也不为 0，只是每个 list 中的每个元素为 null 而已。
    
    参数:
    
    key - 定位 hash 的 key
    
    entryKeys - 需要获取的 hash 中的字段集
    
    返回:
    
    hash 中对应 entryKeys 的对应 entryValue 集
    
    从以下版本开始:
    
    2020/3/9 9:25:38
  - hDelete
```
public long hDelete(String key,
                    Object... entryKeys)
```
    （批量）删除（key 对应的）hash 中的对应 entryKey-entryValue
    注: 1、若 redis 中不存在对应的 key，则返回 0; 2、若要删除的 entryKey，在 key 对应的 hash 中不存在，在 count 不会 +1, 如:
    RedisHelper.HashOps.hPut("ds", "name", "邓沙利文"); RedisHelper.HashOps.hPut("ds", "birthday", "1994-02-05"); RedisHelper.HashOps.hPut("ds", "hobby", "女"); 则调用 RedisUtil.HashOps.hDelete("ds", "name", "birthday", "hobby", "non-exist-entryKey") 的返回结果为 3 注：若（key 对应的）hash 中的所有 entry 都被删除了，那么该 key 也会被删除
    
    参数:
    
    key - 定位 hash 的 key
    
    entryKeys - 定位要删除的 entryKey-entryValue 的 entryKey
    
    返回:
    
    删除了对应 hash 中多少个 entry
    
    从以下版本开始:
    
    2020/3/9 9:37:47
  - hExists
```
public boolean hExists(String key,
                       String entryKey)
```
    查看（key 对应的）hash中，是否存在 entryKey 对应的 entry
    注：若 redis 中不存在 key，则返回 false。注：若 key 对应的 hash 中不存在对应的 entryKey，也会返回 false。
    
    参数:
    
    key - 定位 hash 的 key
    
    entryKey - 定位 hash 中 entry 的 entryKey
    
    返回:
    
    hash 中是否存在 entryKey 对应的 entry.
    
    从以下版本开始:
    
    2020/3/9 9:51:55
  - hIncrBy
```
public long hIncrBy(String key,
                    Object entryKey,
                    long increment)
```
    增/减(hash中的某个entryValue值) 整数
    注: 负数则为减。注: 若key不存在，那么会自动创建对应的hash,并创建对应的entryKey、entryValue,entryValue的初始值为increment。注: 若entryKey不存在，那么会自动创建对应的entryValue,entryValue的初始值为increment。注: 若key对应的value值不支持增/减操作(即: value不是数字)，那么会抛出org.springframework.data.redis.RedisSystemException
    
    参数:
    
    key - 用于定位hash的key
    
    entryKey - 用于定位entryValue的entryKey
    
    increment - 增加多少
    
    返回:
    
    增加后的总值。
    
    抛出:
    
    org.springframework.data.redis.RedisSystemException - key对应的value值不支持增/减操作时
    
    从以下版本开始:
    
    2020/3/9 10:09:28
  - hIncrByFloat
```
public double hIncrByFloat(String key,
                           Object entryKey,
                           double increment)
```
    增/减(hash中的某个entryValue值) 浮点数
    注: 负数则为减。注: 若key不存在，那么会自动创建对应的hash,并创建对应的entryKey、entryValue,entryValue的初始值为increment。注: 若entryKey不存在，那么会自动创建对应的entryValue,entryValue的初始值为increment。注: 若key对应的value值不支持增/减操作(即: value不是数字)，那么会抛出org.springframework.data.redis.RedisSystemException 注: 因为是浮点数，所以可能会和incrByFloat(String, double)一样，出现精度问题。追注: 本人简单测试了几组数据，暂未出现精度问题。
    
    参数:
    
    key - 用于定位hash的key
    
    entryKey - 用于定位entryValue的entryKey
    
    increment - 增加多少
    
    返回:
    
    增加后的总值。
    
    抛出:
    
    org.springframework.data.redis.RedisSystemException - key对应的value值不支持增/减操作时
    
    从以下版本开始:
    
    2020/3/9 10:09:28
  - hKeys
```
public Set<Object> hKeys(String key)
```
    获取(key对应的)hash中的所有entryKey
    注: 若key不存在，则返回的是一个空的Set(，而不是返回null)
    
    参数:
    
    key - 定位hash的key
    
    返回:
    
    hash中的所有entryKey
    
    从以下版本开始:
    
    2020/3/9 10:30:13
  - hValues
```
public List<Object> hValues(String key)
```
    获取(key对应的)hash中的所有entryValue
    注: 若key不存在，则返回的是一个空的List(，而不是返回null)
    
    参数:
    
    key - 定位hash的key
    
    返回:
    
    hash中的所有entryValue
    
    从以下版本开始:
    
    2020/3/9 10:30:13
  - hSize
```
public long hSize(String key)
```
    获取(key对应的)hash中的所有entry的数量
    注: 若redis中不存在对应的key, 则返回值为0
    
    参数:
    
    key - 定位hash的key
    
    返回:
    
    (key对应的)hash中, entry的个数
    
    从以下版本开始:
    
    2020/3/9 10:41:01
  - hScan
```
public org.springframework.data.redis.core.Cursor<Map.Entry<Object,Object>> hScan(String key,
                                                                                  org.springframework.data.redis.core.ScanOptions options)
```
    根据options匹配到(key对应的)hash中的对应的entryKey, 并返回对应的entry集
    注: ScanOptions实例的创建方式举例: 1、ScanOptions.NONE 2、ScanOptions.scanOptions().match("n??e").build()
    
    参数:
    
    key - 定位hash的key
    
    options - 匹配entryKey的条件注: ScanOptions.NONE表示全部匹配。注: ScanOptions.scanOptions().match(pattern).build()表示按照pattern匹配, 其中pattern中可以使用通配符 * ? 等, * 表示>=0个字符？表示有且只有一个字符此处的匹配规则与keys(String)处的一样。
    
    返回:
    
    匹配到的(key对应的)hash中的entry
    
    从以下版本开始:
    
    2020/3/9 10:49:27
  - lLeftPush
```
public long lLeftPush(String key,
                      String item)
```
    从左端推入元素进列表
    注: 若redis中不存在对应的key, 那么会自动创建
    
    参数:
    
    key - 定位list的key
    
    item - 要推入list的元素
    
    返回:
    
    推入后，(key对应的)list的size
    
    从以下版本开始:
    
    2020/3/9 11:56:05
  - lLeftPushAll
```
public long lLeftPushAll(String key,
                         String... items)
```
    从左端批量推入元素进列表
    注: 若redis中不存在对应的key, 那么会自动创建注: 这一批item中，先push左侧的, 后push右侧的
    
    参数:
    
    key - 定位list的key
    
    items - 要批量推入list的元素集
    
    返回:
    
    推入后，(key对应的)list的size
    
    从以下版本开始:
    
    2020/3/9 11:56:05
  - lLeftPushAll
```
public long lLeftPushAll(String key,
                         Collection<String> items)
```
    从左端批量推入元素进列表
    注: 若redis中不存在对应的key, 那么会自动创建注: 这一批item中，那个item先从Collection取出来，就先push哪个
    
    参数:
    
    key - 定位list的key
    
    items - 要批量推入list的元素集
    
    返回:
    
    推入后，(key对应的)list的size
    
    从以下版本开始:
    
    2020/3/9 11:56:05
  - lLeftPushIfPresent
```
public long lLeftPushIfPresent(String key,
                               String item)
```
    如果redis中存在key, 则从左端批量推入元素进列表; 否则，不进行任何操作
    
    参数:
    
    key - 定位list的key
    
    item - 要推入list的项
    
    返回:
    
    推入后，(key对应的)list的size
    
    从以下版本开始:
    
    2020/3/9 13:40:08
  - lLeftPush
```
public long lLeftPush(String key,
                      String pivot,
                      String item)
```
    若 key 对应的 list 中存在 pivot 项, 那么将 item 放入第一个 pivot 项前(即:放在第一个pivot项左边); 若 key 对应的 list 中不存在 pivot 项, 那么不做任何操作，直接返回 -1。
    注: 若 redis 中不存在对应的 key, 那么会自动创建
    
    参数:
    
    key - 定位list的key
    
    item - 要推入list的元素
    
    返回:
    
    推入后，(key对应的)list的size
    
    从以下版本开始:
    
    2020/3/9 11:56:05
  - lRightPush
```
public long lRightPush(String key,
                       String item)
```
    与lLeftPush(String, String)类比即可，不过是从list右侧推入元素
  - lRightPushAll
```
public long lRightPushAll(String key,
                          String... items)
```
    与lLeftPushAll(String, String...)类比即可，不过是从list右侧推入元素
  - lRightPushAll
```
public long lRightPushAll(String key,
                          Collection<String> items)
```
    与#lLeftPushAll(String, Collection)类比即可，不过是从list右侧推入元素
  - lRightPushIfPresent
```
public long lRightPushIfPresent(String key,
                                String item)
```
    与lLeftPushIfPresent(String, String)类比即可，不过是从list右侧推入元素
  - lRightPush
```
public long lRightPush(String key,
                       String pivot,
                       String item)
```
    与lLeftPush(String, String, String)类比即可，不过是从list右侧推入元素
  - lLeftPop
```
public String lLeftPop(String key)
```
    【非阻塞队列】从左侧移出(key对应的)list中的第一个元素, 并将该元素返回
    注: 此方法是非阻塞的，即: 若(key对应的)list中的所有元素都被pop移出了，此时，再进行pop的话，会立即返回null 注: 此方法是非阻塞的，即: 若redis中不存在对应的key,那么会立即返回null 注: 若将(key对应的)list中的所有元素都pop完了，那么该key会被删除
    
    参数:
    
    key - 定位list的key
    
    返回:
    
    移出的那个元素
    
    从以下版本开始:
    
    2020/3/9 14:33:56
  - lLeftPop
```
public String lLeftPop(String key,
                       long timeout,
                       TimeUnit unit)
```
    【阻塞队列】从左侧移出(key对应的)list中的第一个元素, 并将该元素返回
    注: 此方法是阻塞的，即: 若(key对应的)list中的所有元素都被pop移出了，此时，再进行pop的话，会阻塞timeout这么久，然后返回null 注: 此方法是阻塞的，即: 若redis中不存在对应的key,那么会阻塞timeout这么久，然后返回null 注: 若将(key对应的)list中的所有元素都pop完了，那么该key会被删除
    提示: 若阻塞过程中，目标key-list出现了，且里面有item了，那么会立马停止阻塞, 进行元素移出并返回
    
    参数:
    
    key - 定位list的key
    
    timeout - 超时时间
    
    unit - timeout的单位
    
    返回:
    
    移出的那个元素
    
    从以下版本开始:
    
    2020/3/9 14:33:56
  - lRightPop
```
public String lRightPop(String key)
```
    与lLeftPop(String)类比即可，不过是从list右侧移出元素
  - lRightPop
```
public String lRightPop(String key,
                        long timeout,
                        TimeUnit unit)
```
    与lLeftPop(String, long, TimeUnit)类比即可，不过是从list右侧移出元素
  - lRightPopAndLeftPush
```
public String lRightPopAndLeftPush(String sourceKey,
                                   String destinationKey)
```
    【非阻塞队列】从sourceKey对应的sourceList右侧移出一个item, 并将这个item推入(destinationKey对应的)destinationList的左侧
    注: 若sourceKey对应的list中没有item了，则立马认为(从sourceKey对应的list中pop出来的)item为null, null并不会往destinationKey对应的list中push。追注: 此时，此方法的返回值是null。
    注: 若将(sourceKey对应的)list中的所有元素都pop完了，那么该sourceKey会被删除。
    
    参数:
    
    sourceKey - 定位sourceList的key
    
    destinationKey - 定位destinationList的key
    
    返回:
    
    移动的这个元素
    
    从以下版本开始:
    
    2020/3/9 15:06:59
  - lRightPopAndLeftPush
```
public String lRightPopAndLeftPush(String sourceKey,
                                   String destinationKey,
                                   long timeout,
                                   TimeUnit unit)
```
    【阻塞队列】从sourceKey对应的sourceList右侧移出一个item, 并将这个item推入(destinationKey对应的)destinationList的左侧
    注: 若sourceKey对应的list中没有item了，则阻塞等待, 直到能从sourceList中移出一个非null的item(或等待时长超时); case1: 等到了一个非null的item, 那么继续下面的push操作，并返回这个item。 case2: 超时了，还没等到非null的item, 那么pop出的结果就未null,此时并不会往destinationList进行push。此时，此方法的返回值是null。
    注: 若将(sourceKey对应的)list中的所有元素都pop完了，那么该sourceKey会被删除。
    
    参数:
    
    sourceKey - 定位sourceList的key
    
    destinationKey - 定位destinationList的key
    
    timeout - 超时时间
    
    unit - timeout的单位
    
    返回:
    
    移动的这个元素
    
    从以下版本开始:
    
    2020/3/9 15:06:59
  - lSet
```
public void lSet(String key,
                 long index,
                 String item)
```
    设置(key对应的)list中对应索引位置index处的元素为item
    注: 若key不存在，则会抛出org.springframework.data.redis.RedisSystemException 注: 若索引越界，也会抛出org.springframework.data.redis.RedisSystemException
    
    参数:
    
    key - 定位list的key
    
    index - 定位list中的元素的索引
    
    item - 要替换成的值
    
    从以下版本开始:
    
    2020/3/9 15:39:50
  - lIndex
```
public String lIndex(String key,
                     long index)
```
    通过索引index, 获取(key对应的)list中的元素
    注: 若key不存在或 index超出(key对应的)list的索引范围，那么返回null
    
    参数:
    
    key - 定位list的key
    
    index - 定位list中的item的索引
    
    返回:
    
    list中索引index对应的item
    
    从以下版本开始:
    
    2020/3/10 0:27:23
  - lRange
```
public List<String> lRange(String key,
                           long start,
                           long end)
```
    获取(key对应的)list中索引在[start, end]之间的item集
    注: 含start、含end。注: 当key不存在时，获取到的是空的集合。注: 当获取的范围比list的范围还要大时，获取到的是这两个范围的交集。
    提示: 可通过RedisUtil.ListOps.lRange(key, 0, -1)来获取到该key对应的整个list
    
    参数:
    
    key - 定位list的key
    
    start - 起始元素的index
    
    end - 结尾元素的index
    
    返回:
    
    对应的元素集合
    
    从以下版本开始:
    
    2020/3/10 0:34:59
  - lWholeList
```
public List<String> lWholeList(String key)
```
    获取(key对应的)list
    
    参数:
    
    key - 定位list的key
    
    返回:
    
    (key对应的)list
    
    从以下版本开始:
    
    2020/3/10 0:46:50
    
    另请参阅:
    
    lRange(String, long, long)
  - lSize
```
public long lSize(String key)
```
    获取(key对应的)list的size
    注: 当key不存在时，获取到的size为0.
    
    参数:
    
    key - 定位list的key
    
    返回:
    
    list的size。
    
    从以下版本开始:
    
    2020/3/10 0:48:40
  - lRemove
```
public long lRemove(String key,
                    long expectCount,
                    String item)
```
    删除(key对应的)list中，前expectCount个值等于item的项
    注: 若expectCount == 0，则表示删除list中所有的值等于item的项. 注: 若expectCount > 0，则表示删除从左往右进行注: 若expectCount < 0，则表示删除从右往左进行
    注: 若list中,值等于item的项的个数少于expectCount时，那么会删除list中所有的值等于item的项。注: 当key不存在时, 返回0。注: 若lRemove后，将(key对应的)list中没有任何元素了，那么该key会被删除。
    
    参数:
    
    key - 定位list的key
    
    expectCount - 要删除的item的个数
    
    item - 要删除的item
    
    返回:
    
    实际删除了的item的个数
    
    从以下版本开始:
    
    2020/3/10 0:52:57
  - lTrim
```
public void lTrim(String key,
                  long start,
                  long end)
```
    裁剪(即: 对list中的元素取交集。)
    举例说明: list中的元素索引范围是[0, 8], 而这个方法传入的[start, end]为 [3, 10]，那么裁剪就是对[0, 8]和[3, 10]进行取交集，得到[3, 8], 那么裁剪后的list中，只剩下(原来裁剪前)索引在[3, 8]之间的元素了。
    注: 若裁剪后的(key对应的)list就是空的,那么该key会被删除。
    
    参数:
    
    key - 定位list的key
    
    start - 要删除的item集的起始项的索引
    
    end - 要删除的item集的结尾项的索引
    
    从以下版本开始:
    
    2020/3/10 1:16:58
  - sAdd
```
public long sAdd(String key,
                 String... items)
```
    向(key对应的)set中添加items
    注: 若key不存在，则会自动创建。注: set中的元素会去重。
    
    参数:
    
    key - 定位set的key
    
    items - 要向(key对应的)set中添加的items
    
    返回:
    
    此次添加操作, 添加到set中的元素的个数
    
    从以下版本开始:
    
    2020/3/11 8:16:00
  - sRemove
```
public long sRemove(String key,
                    Object... items)
```
    从(key对应的)set中删除items
    注: 若key不存在, 则返回0。注: 若已经将(key对应的)set中的项删除完了，那么对应的key也会被删除。
    
    参数:
    
    key - 定位set的key
    
    items - 要移除的items
    
    返回:
    
    实际删除了的个数
    
    从以下版本开始:
    
    2020/3/11 8:26:43
  - sPop
```
public String sPop(String key)
```
    从(key对应的)set中随机移出一个item, 并返回这个item
    注: 因为set是无序的，所以移出的这个item,是随机的; 并且，哪怕是数据一样的set,多次测试移出操作,移除的元素也是随机的。
    注: 若已经将(key对应的)set中的项pop完了，那么对应的key会被删除。
    
    参数:
    
    key - 定位set的key
    
    返回:
    
    移出的项
    
    从以下版本开始:
    
    2020/3/11 8:32:40
  - sMove
```
public boolean sMove(String sourceKey,
                     String item,
                     String destinationKey)
```
    将(sourceKey对应的)sourceSet中的元素item, 移动到(destinationKey对应的)destinationSet中
    注: 当sourceKey不存在时，返回false 注: 当item不存在时，返回false 注: 若destinationKey不存在，那么在移动时会自动创建注: 若已经将(sourceKey对应的)set中的项move出去完了，那么对应的sourceKey会被删除。
    
    参数:
    
    sourceKey - 定位sourceSet的key
    
    item - 要移动的项目
    
    destinationKey - 定位destinationSet的key
    
    返回:
    
    移动成功与否
    
    从以下版本开始:
    
    2020/3/11 8:43:32
  - sSize
```
public long sSize(String key)
```
    获取(key对应的)set中的元素个数
    注: 若key不存在，则返回0
    
    参数:
    
    key - 定位set的key
    
    返回:
    
    (key对应的)set中的元素个数
    
    从以下版本开始:
    
    2020/3/11 8:57:19
  - sIsMember
```
public boolean sIsMember(String key,
                         Object item)
```
    判断(key对应的)set中是否含有item
    注: 若key不存在，则返回false。
    
    参数:
    
    key - 定位set的key
    
    item - 被查找的项
    
    返回:
    
    (key对应的)set中是否含有item
    
    从以下版本开始:
    
    2020/3/11 9:03:29
  - sIntersect
```
public Set<String> sIntersect(String key,
                              String otherKey)
```
    获取两个(key对应的)Set的交集
    注: 若不存在任何交集，那么返回空的集合(, 而不是null) 注: 若其中一个key不存在(或两个key都不存在)，那么返回空的集合(, 而不是null)
    
    参数:
    
    key - 定位其中一个set的键
    
    otherKey - 定位其中另一个set的键
    
    返回:
    
    item交集
    
    从以下版本开始:
    
    2020/3/11 9:31:25
  - sIntersect
```
public Set<String> sIntersect(String key,
                              Collection<String> otherKeys)
```
    获取多个(key对应的)Set的交集
    注: 若不存在任何交集，那么返回空的集合(, 而不是null) 注: 若>=1个key不存在，那么返回空的集合(, 而不是null)
    
    参数:
    
    key - 定位其中一个set的键
    
    otherKeys - 定位其它set的键集
    
    返回:
    
    item交集
    
    从以下版本开始:
    
    2020/3/11 9:39:23
  - sIntersectAndStore
```
public long sIntersectAndStore(String key,
                               String otherKey,
                               String storeKey)
```
    获取两个(key对应的)Set的交集, 并将结果add到storeKey对应的Set中。
    case1: 交集不为空, storeKey不存在，则会创建对应的storeKey，并将交集添加到(storeKey对应的)set中 case2: 交集不为空, storeKey已存在，则会清除原(storeKey对应的)set中所有的项，然后将交集添加到(storeKey对应的)set中 case3: 交集为空, 则不进行下面的操作, 直接返回0
    注: 求交集的部分，详见sIntersect(String, String)
    
    参数:
    
    key - 定位其中一个set的键
    
    otherKey - 定位其中另一个set的键
    
    storeKey - 定位(要把交集添加到哪个)set的key
    
    返回:
    
    add到(storeKey对应的)Set后, 该set对应的size
    
    从以下版本开始:
    
    2020/3/11 9:46:46
  - sIntersectAndStore
```
public long sIntersectAndStore(String key,
                               Collection<String> otherKeys,
                               String storeKey)
```
    获取多个(key对应的)Set的交集, 并将结果add到storeKey对应的Set中。
    case1: 交集不为空, storeKey不存在，则会创建对应的storeKey，并将交集添加到(storeKey对应的)set中 case2: 交集不为空, storeKey已存在，则会清除原(storeKey对应的)set中所有的项，然后将交集添加到(storeKey对应的)set中 case3: 交集为空, 则不进行下面的操作, 直接返回0
    注: 求交集的部分，详见sIntersect(String, Collection)
    
    从以下版本开始:
    
    2020/3/11 11:04:29
  - sUnion
```
public Set<String> sUnion(String key,
                          String otherKey)
```
    获取两个(key对应的)Set的并集
    注: 并集中的元素也是唯一的，这是Set保证的。
    
    参数:
    
    key - 定位其中一个set的键
    
    otherKey - 定位其中另一个set的键
    
    返回:
    
    item并集
    
    从以下版本开始:
    
    2020/3/11 11:18:35
  - sUnion
```
public Set<String> sUnion(String key,
                          Collection<String> otherKeys)
```
    获取两个(key对应的)Set的并集
    注: 并集中的元素也是唯一的，这是Set保证的。
    
    参数:
    
    key - 定位其中一个set的键
    
    otherKeys - 定位其它set的键集
    
    返回:
    
    item并集
    
    从以下版本开始:
    
    2020/3/11 11:18:35
  - sUnionAndStore
```
public long sUnionAndStore(String key,
                           String otherKey,
                           String storeKey)
```
    获取两个(key对应的)Set的并集, 并将结果add到storeKey对应的Set中。
    case1: 并集不为空, storeKey不存在，则会创建对应的storeKey，并将并集添加到(storeKey对应的)set中 case2: 并集不为空, storeKey已存在，则会清除原(storeKey对应的)set中所有的项，然后将并集添加到(storeKey对应的)set中 case3: 并集为空, 则不进行下面的操作, 直接返回0
    注: 求并集的部分，详见sUnion(String, String)
    
    参数:
    
    key - 定位其中一个set的键
    
    otherKey - 定位其中另一个set的键
    
    storeKey - 定位(要把并集添加到哪个)set的key
    
    返回:
    
    add到(storeKey对应的)Set后, 该set对应的size
    
    从以下版本开始:
    
    2020/3/11 12:26:24
  - sUnionAndStore
```
public long sUnionAndStore(String key,
                           Collection<String> otherKeys,
                           String storeKey)
```
    获取两个(key对应的)Set的并集, 并将结果add到storeKey对应的Set中。
    case1: 并集不为空, storeKey不存在，则会创建对应的storeKey，并将并集添加到(storeKey对应的)set中 case2: 并集不为空, storeKey已存在，则会清除原(storeKey对应的)set中所有的项，然后将并集添加到(storeKey对应的)set中 case3: 并集为空, 则不进行下面的操作, 直接返回0
    注: 求并集的部分，详见sUnion(String, Collection)
    
    参数:
    
    key - 定位其中一个set的键
    
    otherKeys - 定位其它set的键集
    
    storeKey - 定位(要把并集添加到哪个)set的key
    
    返回:
    
    add到(storeKey对应的)Set后, 该set对应的size
    
    从以下版本开始:
    
    2020/3/11 12:26:24
  - sDifference
```
public Set<String> sDifference(String key,
                               String otherKey)
```
    获取 (key对应的)Set 减去 (otherKey对应的)Set 的差集
    注: 如果被减数key不存在，那么结果为空的集合(，而不是null) 注: 如果被减数key存在，但减数key不存在，那么结果即为(被减数key对应的)Set
    
    参数:
    
    key - 定位"被减数set"的键
    
    otherKey - 定位"减数set"的键
    
    返回:
    
    item差集
    
    从以下版本开始:
    
    2020/3/11 14:03:57
  - sDifference
```
public Set<String> sDifference(String key,
                               Collection<String> otherKeys)
```
    获取 (key对应的)Set 减去 (otherKeys对应的)Sets 的差集
    注: 如果被减数key不存在，那么结果为空的集合(，而不是null) 注: 如果被减数key存在，但减数key不存在，那么结果即为(被减数key对应的)Set
    提示: 当有多个减数时，被减数先减去哪一个减数，后减去哪一个减数，是无所谓的，是不影响最终结果的。
    
    参数:
    
    key - 定位"被减数set"的键
    
    otherKeys - 定位"减数集sets"的键集
    
    返回:
    
    item差集
    
    从以下版本开始:
    
    2020/3/11 14:03:57
  - sDifferenceAndStore
```
public long sDifferenceAndStore(String key,
                                String otherKey,
                                String storeKey)
```
    获取 (key对应的)Set 减去 (otherKey对应的)Set 的差集, 并将结果add到storeKey对应的Set中。
    case1: 差集不为空, storeKey不存在，则会创建对应的storeKey，并将差集添加到(storeKey对应的)set中 case2: 差集不为空, storeKey已存在，则会清除原(storeKey对应的)set中所有的项，然后将差集添加到(storeKey对应的)set中 case3: 差集为空, 则不进行下面的操作, 直接返回0
    注: 求并集的部分，详见sDifference(String, String)
    
    参数:
    
    key - 定位"被减数set"的键
    
    otherKey - 定位"减数set"的键
    
    storeKey - 定位(要把差集添加到哪个)set的key
    
    返回:
    
    add到(storeKey对应的)Set后, 该set对应的size
    
    从以下版本开始:
    
    2020/3/11 14:33:36
  - sDifferenceAndStore
```
public long sDifferenceAndStore(String key,
                                Collection<String> otherKeys,
                                String storeKey)
```
    获取 (key对应的)Set 减去 (otherKey对应的)Set 的差集, 并将结果add到storeKey对应的Set中。
    case1: 差集不为空, storeKey不存在，则会创建对应的storeKey，并将差集添加到(storeKey对应的)set中 case2: 差集不为空, storeKey已存在，则会清除原(storeKey对应的)set中所有的项，然后将差集添加到(storeKey对应的)set中 case3: 差集为空, 则不进行下面的操作, 直接返回0
    注: 求并集的部分，详见sDifference(String, String)
    
    参数:
    
    key - 定位"被减数set"的键
    
    otherKeys - 定位"减数集sets"的键集
    
    storeKey - 定位(要把差集添加到哪个)set的key
    
    返回:
    
    add到(storeKey对应的)Set后, 该set对应的size
    
    从以下版本开始:
    
    2020/3/11 14:33:36
  - sMembers
```
public Set<String> sMembers(String key)
```
    获取key对应的set
    注: 若key不存在, 则返回的是空的set(, 而不是null)
    
    参数:
    
    key - 定位set的key
    
    返回:
    
    (key对应的)set
    
    从以下版本开始:
    
    2020/3/11 14:49:39
  - sRandomMember
```
public String sRandomMember(String key)
```
    从key对应的set中随机获取一项
    
    参数:
    
    key - 定位set的key
    
    返回:
    
    随机获取到的项
    
    从以下版本开始:
    
    2020/3/11 14:54:58
  - sRandomMembers
```
public List<String> sRandomMembers(String key,
                                   long count)
```
    从key对应的set中获取count次随机项(, set中的同一个项可能被多次获取)
    注: count可大于set的size。注: 取出来的结果里可能存在相同的值。
    
    参数:
    
    key - 定位set的key
    
    count - 要取多少项
    
    返回:
    
    随机获取到的项集
    
    从以下版本开始:
    
    2020/3/11 14:54:58
  - sDistinctRandomMembers
```
public Set<String> sDistinctRandomMembers(String key,
                                          long count)
```
    从key对应的set中随机获取count个项
    注: 若count >= set的size, 那么返回的即为这个key对应的set。注: 取出来的结果里没有重复的项。
    
    参数:
    
    key - 定位set的key
    
    count - 要取多少项
    
    返回:
    
    随机获取到的项集
    
    从以下版本开始:
    
    2020/3/11 14:54:58
  - sScan
```
public org.springframework.data.redis.core.Cursor<String> sScan(String key,
                                                                org.springframework.data.redis.core.ScanOptions options)
```
    根据options匹配到(key对应的)set中的对应的item, 并返回对应的item集
    
    注: ScanOptions实例的创建方式举例: 1、ScanOptions.NONE 2、ScanOptions.scanOptions().match("n??e").build()
    
    参数:
    
    key - 定位set的key
    
    options - 匹配set中的item的条件注: ScanOptions.NONE表示全部匹配。注: ScanOptions.scanOptions().match(pattern).build()表示按照pattern匹配, 其中pattern中可以使用通配符 * ? 等, * 表示>=0个字符？表示有且只有一个字符此处的匹配规则与keys(String)处的一样。
    
    返回:
    
    匹配到的(key对应的)set中的项
    
    从以下版本开始:
    
    2020/3/9 10:49:27
  - zAdd
```
public boolean zAdd(String key,
                    String item,
                    double score)
```
    向(key对应的)zset中添加(item, score)
    注: item为entryKey成员项， score为entryValue分数值。
    注: 若(key对应的)zset中已存在(与此次要添加的项)相同的item项，那么此次添加操作会失败，返回false；但是！！！ zset中原item的score会被更新为此次add的相同item项的score。所以, 也可以通过zAdd达到更新item对应score的目的。
    注: score可为正、可为负、可为0; 总之, double范围内都可以。
    注: 若score的值一样，则按照item排序。
    
    参数:
    
    key - 定位set的key
    
    item - 要往(key对应的)zset中添加的成员项
    
    score - item的分值
    
    返回:
    
    是否添加成功
    
    从以下版本开始:
    
    2020/3/11 15:35:30
  - zAdd
```
public long zAdd(String key,
                 Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>> entries)
```
    批量添加entry
    注: 若entry集中存在item相同的项(, score不一样)，那么redis在执行真正的批量add操作前,会将其中一个item过滤掉。注: 同样的，若(key对应的)zset中已存在(与此次要添加的项)相同的item项，那么此次批量添加操作中，对该item项的添加会失败，会失败，成功计数器不会加1；但是！！！ zset中原item的score会被更新为此次add的相同item项的score。所以, 也可以通过zAdd达到更新item对应score的目的。
    
    参数:
    
    key - 定位set的key
    
    entries - 要添加的entry集
    
    返回:
    
    本次添加进(key对应的)zset中的entry的个数
    
    从以下版本开始:
    
    2020/3/11 16:45:45
  - zRemove
```
public long zRemove(String key,
                    Object... items)
```
    从(key对应的)zset中移除项
    注:若key不存在，则返回0
    
    参数:
    
    key - 定位set的key
    
    items - 要移除的项集
    
    返回:
    
    实际移除了的项的个数
    
    从以下版本开始:
    
    2020/3/11 17:20:12
  - zRemoveRange
```
public long zRemoveRange(String key,
                         long startRange,
                         long endRange)
```
    移除(key对应的)zset中, 排名范围在[startIndex, endIndex]内的item
    注:默认的，按score.item升序排名，排名从0开始
    注: 类似于List中的索引, 排名可以分为多个方式: 从前到后(正向)的排名: 0、1、2... 从后到前(反向)的排名: -1、-2、-3...
    注: 不论是使用正向排名，还是使用反向排名, 使用此方法时, 应保证 startRange代表的元素的位置在endRange代表的元素的位置的前面，如: 示例一: .zRemoveRange("name", 0, 2); 示例二: .zRemoveRange("site", -2, -1); 示例三: .zRemoveRange("foo", 0, -1);
    注:若key不存在，则返回0
    
    参数:
    
    key - 定位set的key
    
    startRange - 开始项的排名
    
    endRange - 结尾项的排名
    
    返回:
    
    实际移除了的项的个数
    
    从以下版本开始:
    
    2020/3/11 17:20:12
  - zRemoveRangeByScore
```
public long zRemoveRangeByScore(String key,
                                double minScore,
                                double maxScore)
```
    移除(key对应的)zset中, score范围在[minScore, maxScore]内的item
    提示: 虽然删除范围包含两侧的端点(即:包含minScore和maxScore), 但是由于double存在精度问题，所以建议: 设置值时，minScore应该设置得比要删除的项里，最小的score还小一点 maxScore应该设置得比要删除的项里，最大的score还大一点追注: 本人简单测试了几组数据，暂未出现精度问题。
    注:若key不存在，则返回0
    
    参数:
    
    key - 定位set的key
    
    minScore - score下限(含这个值)
    
    maxScore - score上限(含这个值)
    
    返回:
    
    实际移除了的项的个数
    
    从以下版本开始:
    
    2020/3/11 17:20:12
  - zIncrementScore
```
public double zIncrementScore(String key,
                              String item,
                              double delta)
```
    增/减 (key对应的zset中,)item的分数值
    
    参数:
    
    key - 定位zset的key
    
    item - 项
    
    delta - 变化量(正 - 增, 负 - 减)
    
    返回:
    
    修改后的score值
    
    从以下版本开始:
    
    2020/3/12 8:55:38
  - zRank
```
public long zRank(String key,
                  Object item)
```
    返回item在(key对应的)zset中的(按score从小到大的)排名
    注: 排名从0开始。即意味着，此方法等价于: 返回item在(key对应的)zset中的位置索引。注: 若key或item不存在，返回null。注: 排序规则是score,item, 即:优先以score排序，若score相同，则再按item排序。
    
    参数:
    
    key - 定位zset的key
    
    item - 项
    
    返回:
    
    排名(等价于 : 索引)
    
    从以下版本开始:
    
    2020/3/12 9:14:09
  - zReverseRank
```
public long zReverseRank(String key,
                         Object item)
```
    返回item在(key对应的)zset中的(按score从大到小的)排名
    注: 排名从0开始。补充: 因为是按score从大到小排序的, 所以最大score对应的item的排名为0。注: 若key或item不存在，返回null。注: 排序规则是score,item, 即:优先以score排序，若score相同，则再按item排序。
    
    参数:
    
    key - 定位zset的key
    
    item - 项
    
    返回:
    
    排名(等价于 : 索引)
    
    从以下版本开始:
    
    2020/3/12 9:14:09
  - zRange
```
public Set<String> zRange(String key,
                          long start,
                          long end)
```
    根据索引位置，获取(key对应的)zset中排名处于[start, end]中的item项集
    注: 不论是使用正向排名，还是使用反向排名, 使用此方法时, 应保证 startIndex代表的元素的位置在endIndex代表的元素的位置的前面，如: 示例一: .zRange("name", 0, 2); 示例二: .zRange("site", -2, -1); 示例三: .zRange("foo", 0, -1);
    注: 若key不存在, 则返回空的集合。
    注: 当[start, end]的范围比实际zset的范围大时, 返回范围上"交集"对应的项集合。
    
    参数:
    
    key - 定位zset的key
    
    start - 排名开始位置
    
    end - 排名结束位置
    
    返回:
    
    对应的item项集
    
    从以下版本开始:
    
    2020/3/12 9:50:40
  - zWholeZSetItem
```
public Set<String> zWholeZSetItem(String key)
```
    获取(key对应的)zset中的所有item项
    
    参数:
    
    key - 定位zset的键
    
    返回:
    
    (key对应的)zset中的所有item项
    
    从以下版本开始:
    
    2020/3/12 10:02:07
    
    另请参阅:
    
    zRange(String, long, long)
  - zRangeWithScores
```
public Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>> zRangeWithScores(String key,
                                                                                                   long start,
                                                                                                   long end)
```
    根据索引位置，获取(key对应的)zset中排名处于[start, end]中的entry集
    注: 不论是使用正向排名，还是使用反向排名, 使用此方法时, 应保证 startIndex代表的元素的位置在endIndex代表的元素的位置的前面，如: 示例一: .zRange("name", 0, 2); 示例二: .zRange("site", -2, -1); 示例三: .zRange("foo", 0, -1);
    注: 若key不存在, 则返回空的集合。
    注: 当[start, end]的范围比实际zset的范围大时, 返回范围上"交集"对应的项集合。
    注: 此方法和zRange(String, long, long)类似，不过此方法返回的不是item集，而是entry集
    
    参数:
    
    key - 定位zset的key
    
    start - 排名开始位置
    
    end - 排名结束位置
    
    返回:
    
    对应的entry集
    
    从以下版本开始:
    
    2020/3/12 9:50:40
  - zWholeZSetEntry
```
public Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>> zWholeZSetEntry(String key)
```
    获取(key对应的)zset中的所有entry
    
    参数:
    
    key - 定位zset的键
    
    返回:
    
    (key对应的)zset中的所有entry
    
    从以下版本开始:
    
    2020/3/12 10:02:07
    
    另请参阅:
    
    zRangeWithScores(String, long, long)
  - zRangeByScore
```
public Set<String> zRangeByScore(String key,
                                 double minScore,
                                 double maxScore)
```
    根据score，获取(key对应的)zset中分数值处于[minScore, maxScore]中的item项集
    注: 若key不存在, 则返回空的集合。注: 当[minScore, maxScore]的范围比实际zset中score的范围大时, 返回范围上"交集"对应的项集合。
    提示: 虽然删除范围包含两侧的端点(即:包含minScore和maxScore), 但是由于double存在精度问题，所以建议: 设置值时，minScore应该设置得比要删除的项里，最小的score还小一点 maxScore应该设置得比要删除的项里，最大的score还大一点追注: 本人简单测试了几组数据，暂未出现精度问题。
    
    参数:
    
    key - 定位zset的key
    
    minScore - score下限
    
    maxScore - score上限
    
    返回:
    
    对应的item项集
    
    从以下版本开始:
    
    2020/3/12 9:50:40
  - zRangeByScore
```
public Set<String> zRangeByScore(String key,
                                 double minScore,
                                 double maxScore,
                                 long offset,
                                 long count)
```
    根据score，获取(key对应的)zset中分数值处于[minScore, maxScore]中的, score处于[minScore, 排名大于等于offset的count个item项
    特别注意: 对于不是特别熟悉redis的人来说, offset 和 count最好都使用正数，避免引起理解上的歧义。
    注: 若key不存在, 则返回空的集合。
    提示: 虽然删除范围包含两侧的端点(即:包含minScore和maxScore), 但是由于double存在精度问题，所以建议: 设置值时，minScore应该设置得比要删除的项里，最小的score还小一点 maxScore应该设置得比要删除的项里，最大的score还大一点追注: 本人简单测试了几组数据，暂未出现精度问题。
    
    参数:
    
    key - 定位zset的key
    
    minScore - score下限
    
    maxScore - score上限
    
    offset - 偏移量(即:排名下限)
    
    count - 期望获取到的元素个数
    
    返回:
    
    对应的item项集
    
    从以下版本开始:
    
    2020/3/12 9:50:40
  - zRangeByScoreWithScores
```
public Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>> zRangeByScoreWithScores(String key,
                                                                                                          double minScore,
                                                                                                          double maxScore)
```
    获取(key对应的)zset中的所有score处于[minScore, maxScore]中的entry
    
    参数:
    
    key - 定位zset的键
    
    minScore - score下限
    
    maxScore - score上限
    
    返回:
    
    (key对应的)zset中的所有score处于[minScore, maxScore]中的entry
    
    从以下版本开始:
    
    2020/3/12 10:02:07
    
    另请参阅:
    
    注: 若key不存在, 则返回空的集合。注: 当[minScore, maxScore]的范围比实际zset中score的范围大时, 返回范围上"交集"对应的项集合。
  - zRangeByScoreWithScores
```
public Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>> zRangeByScoreWithScores(String key,
                                                                                                          double minScore,
                                                                                                          double maxScore,
                                                                                                          long offset,
                                                                                                          long count)
```
    获取(key对应的)zset中, score处于[minScore, maxScore]里的、排名大于等于offset的count个entry
    特别注意: 对于不是特别熟悉redis的人来说, offset 和 count最好都使用正数，避免引起理解上的歧义。
    
    参数:
    
    key - 定位zset的键
    
    minScore - score下限
    
    maxScore - score上限
    
    offset - 偏移量(即:排名下限)
    
    count - 期望获取到的元素个数
    
    返回:
    
    [startIndex, endIndex] & [minScore, maxScore]里的entry
    
    从以下版本开始:
    
    2020/3/12 11:09:06
  - zReverseRange
```
public Set<String> zReverseRange(String key,
                                 long start,
                                 long end)
```
    获取时, 先按score倒序, 然后根据索引位置，获取(key对应的)zset中排名处于[start, end]中的item项集
    
    另请参阅:
    
    只是zReverseRange这里会提前多一个倒序。
  - zReverseRangeWithScores
```
public Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>> zReverseRangeWithScores(String key,
                                                                                                          long start,
                                                                                                          long end)
```
    获取时, 先按score倒序, 然后根据索引位置，获取(key对应的)zset中排名处于[start, end]中的entry集
    
    另请参阅:
    
    只是zReverseRangeWithScores这里会提前多一个倒序。
  - zReverseRangeByScore
```
public Set<String> zReverseRangeByScore(String key,
                                        double minScore,
                                        double maxScore)
```
    获取时, 先按score倒序, 然后根据score，获取(key对应的)zset中分数值处于[minScore, maxScore]中的item项集
    
    另请参阅:
    
    只是zReverseRangeByScore这里会提前多一个倒序。
  - zReverseRangeByScoreWithScores
```
public Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<String>> zReverseRangeByScoreWithScores(String key,
                                                                                                                 double minScore,
                                                                                                                 double maxScore)
```
    获取时, 先按score倒序, 然后获取(key对应的)zset中的所有score处于[minScore, maxScore]中的entry
    
    另请参阅:
    
    只是zReverseRangeByScoreWithScores这里会提前多一个倒序。
  - zReverseRangeByScore
```
public Set<String> zReverseRangeByScore(String key,
                                        double minScore,
                                        double maxScore,
                                        long offset,
                                        long count)
```
    获取时, 先按score倒序, 然后根据score，获取(key对应的)zset中分数值处于[minScore, maxScore]中的, score处于[minScore,排名大于等于offset的count个item项
    
    另请参阅:
    
    只是zReverseRangeByScore这里会提前多一个倒序。
  - zCount
```
public long zCount(String key,
                   double minScore,
                   double maxScore)
```
    统计(key对应的zset中)score处于[minScore, maxScore]中的item的个数
    
    参数:
    
    key - 定位zset的key
    
    minScore - score下限
    
    maxScore - score上限
    
    返回:
    
    [minScore, maxScore]中item的个数
    
    从以下版本开始:
    
    2020/3/13 12:20:43
  - zSize
```
public long zSize(String key)
```
    统计(key对应的)zset中item的个数
    注: 此方法等价于zZCard(String)
    
    参数:
    
    key - 定位zset的key
    
    返回:
    
    zset中item的个数
    
    从以下版本开始:
    
    2020/3/13 12:20:43
  - zZCard
```
public long zZCard(String key)
```
    统计(key对应的)zset中item的个数
    注: 此方法等价于zSize(String)
    
    参数:
    
    key - 定位zset的key
    
    返回:
    
    zset中item的个数
    
    从以下版本开始:
    
    2020/3/13 12:20:43
  - zScore
```
public double zScore(String key,
                     Object item)
```
    统计(key对应的)zset中指定item的score
    
    参数:
    
    key - 定位zset的key
    
    item - zset中的item
    
    返回:
    
    item的score
    
    从以下版本开始:
    
    2020/3/13 14:51:43
  - zUnionAndStore
```
public long zUnionAndStore(String key,
                           String otherKey,
                           String storeKey)
```
    获取两个(key对应的)ZSet的并集, 并将结果add到storeKey对应的ZSet中。
    注: 和set一样，zset中item是唯一的，在多个zset进行Union时, 处理相同的item时， score的值会变为对应的score之和，如： .zAdd("name1", "a", 1);和RedisUtil.ZSetOps.zAdd("name2", "a", 2); 对(name1和name2对应的)zset进行zUnionAndStore之后，新的zset中的项a,对应的score值为3
    case1: 交集不为空, storeKey不存在，则会创建对应的storeKey，并将并集添加到(storeKey对应的)ZSet中 case2: 交集不为空, storeKey已存在，则会清除原(storeKey对应的)ZSet中所有的项，然后将并集添加到(storeKey对应的)ZSet中 case3: 交集为空, 则不进行下面的操作, 直接返回0
    
    参数:
    
    key - 定位其中一个zset的键
    
    otherKey - 定位另外的zset的键
    
    storeKey - 定位(要把交集添加到哪个)set的key
    
    返回:
    
    add到(storeKey对应的)ZSet后, 该ZSet对应的size
    
    从以下版本开始:
    
    2020/3/11 12:26:24
  - zUnionAndStore
```
public long zUnionAndStore(String key,
                           Collection<String> otherKeys,
                           String storeKey)
```
    获取两个(key对应的)ZSet的并集, 并将结果add到storeKey对应的ZSet中。
    注: 和set一样，zset中item是唯一的，在多个zset进行Union时, 处理相同的item时， score的值会变为对应的score之和，如： .zAdd("name1", "a", 1);和RedisUtil.ZSetOps.zAdd("name2", "a", 2); 对(name1和name2对应的)zset进行zUnionAndStore之后，新的zset中的项a,对应的score值为3
    case1: 并集不为空, storeKey不存在，则会创建对应的storeKey，并将并集添加到(storeKey对应的)ZSet中 case2: 并集不为空, storeKey已存在，则会清除原(storeKey对应的)ZSet中所有的项，然后将并集添加到(storeKey对应的)ZSet中 case3: 并集为空, 则不进行下面的操作, 直接返回0
    
    参数:
    
    key - 定位其中一个set的键
    
    otherKeys - 定位其它set的键集
    
    storeKey - 定位(要把并集添加到哪个)set的key
    
    返回:
    
    add到(storeKey对应的)ZSet后, 该ZSet对应的size
    
    从以下版本开始:
    
    2020/3/11 12:26:24
  - zIntersectAndStore
```
public long zIntersectAndStore(String key,
                               String otherKey,
                               String storeKey)
```
    获取两个(key对应的)ZSet的交集, 并将结果add到storeKey对应的ZSet中。
    注: 和set一样，zset中item是唯一的，在多个zset进行Intersect时, 处理相同的item时， score的值会变为对应的score之和，如： .zAdd("name1", "a", 1); .zAdd("name1", "b", 100); 和R edisUtil.ZSetOps.zAdd("name2", "a", 2); edisUtil.ZSetOps.zAdd("name2", "c", 200); 对(name1和name2对应的)zset进行zIntersectAndStore之后，新的zset中的项a,对应的score值为3
    case1: 交集不为空, storeKey不存在，则会创建对应的storeKey，并将交集添加到(storeKey对应的)ZSet中 case2: 交集不为空, storeKey已存在，则会清除原(storeKey对应的)ZSet中所有的项，然后将交集添加到(storeKey对应的)ZSet中 case3: 交集为空, 则不进行下面的操作, 直接返回0
    
    参数:
    
    key - 定位其中一个ZSet的键
    
    otherKey - 定位其中另一个ZSet的键
    
    storeKey - 定位(要把交集添加到哪个)ZSet的key
    
    返回:
    
    add到(storeKey对应的)ZSet后, 该ZSet对应的size
    
    从以下版本开始:
    
    2020/3/11 9:46:46
  - zIntersectAndStore
```
public long zIntersectAndStore(String key,
                               Collection<String> otherKeys,
                               String storeKey)
```
    获取多个(key对应的)ZSet的交集, 并将结果add到storeKey对应的ZSet中。
    case1: 交集不为空, storeKey不存在，则会创建对应的storeKey，并将交集添加到(storeKey对应的)ZSet中 case2: 交集不为空, storeKey已存在，则会清除原(storeKey对应的)ZSet中所有的项，然后将交集添加到(storeKey对应的)ZSet中 case3: 交集为空, 则不进行下面的操作, 直接返回0
    
    参数:
    
    key - 定位其中一个set的键
    
    otherKeys - 定位其它set的键集
    
    storeKey - 定位(要把并集添加到哪个)set的key
    
    返回:
    
    add到(storeKey对应的)ZSet后, 该ZSet对应的size
    
    从以下版本开始:
    
    2020/3/11 11:04:29
  - getLock
```
public boolean getLock(String key,
                       String value)
```
    获取(分布式)锁.
    注: 获取结果是即时返回的、是非阻塞的。
    
    另请参阅:
    
    getLock(String, String, long, TimeUnit)
  - getLockUntilTimeout
```
public boolean getLockUntilTimeout(String key,
                                   String value,
                                   long retryTimeoutLimit)
```
    获取(分布式)锁。若成功, 则直接返回; 若失败, 则进行重试, 直到成功或超时为止。
    注: 获取结果是阻塞的，要么成功, 要么超时, 才返回。
    
    参数:
    
    retryTimeoutLimit - 重试的超时时长(ms) 其它参数可详见:
    
    返回:
    
    是否成功
    
    另请参阅:
    
    getLock(String, String, long, TimeUnit)
  - getLockUntilTimeout
```
public boolean getLockUntilTimeout(String key,
                                   String value,
                                   long timeout,
                                   TimeUnit unit,
                                   long retryTimeoutLimit)
```
    获取(分布式)锁。若成功, 则直接返回; 若失败, 则进行重试, 直到成功或超时为止。
    注: 获取结果是阻塞的，要么成功, 要么超时, 才返回。
    
    参数:
    
    retryTimeoutLimit - 重试的超时时长(ms) 其它参数可详见:
    
    返回:
    
    是否成功
    
    另请参阅:
    
    getLock(String, String, long, TimeUnit, boolean)
  - getLock
```
public boolean getLock(String key,
                       String value,
                       long timeout,
                       TimeUnit unit)
```
    获取(分布式)锁
    注: 获取结果是即时返回的、是非阻塞的。
    
    另请参阅:
    
    getLock(String, String, long, TimeUnit, boolean)
  - getLock
```
public boolean getLock(String key,
                       String value,
                       long timeout,
                       TimeUnit unit,
                       boolean recordLog)
```
    获取(分布式)锁
    注: 获取结果是即时返回的、是非阻塞的。
    
    参数:
    
    key - 锁名
    
    value - 锁名对应的value 注: value一般采用全局唯一的值，如: requestId、uuid等。这样，释放锁的时候, 可以再次验证value值, 保证自己上的锁只能被自己释放, 而不会被别人释放。当然, 如果锁超时时, 会被redis自动删除释放。
    
    timeout - 锁的(最大)存活时长注: 一般的，获取锁与释放锁都是成对使用的, 在锁在达到(最大)存活时长之前，都会被主动释放。但是在某些情况下(如:程序获取锁后,释放锁前,崩了),锁得不到释放, 这时就需要等锁过了(最大)存活时长后，被redis自动删除清理了。这样就能保证redis中不会留下死数据。
    
    unit - timeout的单位
    
    recordLog - 是否记录日志
    
    返回:
    
    是否成功
  - releaseLock
```
public boolean releaseLock(String key,
                           String value)
```
    释放(分布式)锁
    注: 此方式能(通过value的唯一性)保证: 自己加的锁, 只能被自己释放。注: 锁超时时, 也会被redis自动删除释放。
    
    参数:
    
    key - 锁名
    
    value - 锁名对应的value
    
    返回:
    
    释放锁是否成功
    
    从以下版本开始:
    
    2020/3/15 17:00:45

类 RedisHelper

嵌套类概要

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

DEFAULT_LOCK_TIMEOUT

DEFAULT_TIMEOUT_UNIT

构造器详细资料

RedisHelper

方法详细资料

delete

delete

dump

restore

restore

hasKey

expire

expireAt

keys

move

persist

getExpire

getExpire

randomKey

rename

renameIfAbsent

type

set

setBit

setEx

setIfAbsent

setIfAbsent

setRange

size

multiSet

multiSetIfAbsent

incrBy

incrByFloat

append

get

getRange

getAndSet

getBit

multiGet

hPut

hPutAll

hPutIfAbsent

hGet

hGetAll

hMultiGet

hDelete

hExists

hIncrBy

hIncrByFloat

hKeys

hValues

hSize

hScan

lLeftPush

lLeftPushAll

lLeftPushAll

lLeftPushIfPresent

lLeftPush

lRightPush

lRightPushAll

lRightPushAll

lRightPushIfPresent

lRightPush

lLeftPop

lLeftPop

lRightPop

lRightPop

lRightPopAndLeftPush

lRightPopAndLeftPush

lSet

lIndex

lRange

lWholeList