RedisHelper (commons-springboot 1.1.9 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.RedisTemplate<String,Object> redisTemplate)

构造器
构造器和说明
`RedisHelper(org.springframework.data.redis.core.RedisTemplate<String,Object> redisTemplate)`

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`int`	`append(String key, String value)` 追加值到末尾注: 当 redis 中原本不存在 key 时，那么（从效果上来看）此方法就等价于 `set(String, Object)`
`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。
`Object`	`get(String key)` 根据 key，获取到对应的 value 值
`Object`	`getAndSet(String key, Object 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, Object entryValue)` 向 key 对应的 hash 中，增加一个键值对 entryKey-entryValue 注：同一个 hash 里面，若已存在相同的 entryKey，那么此操作将丢弃原来的 entryKey-entryValue，而使用新的 entryKey-entryValue。
`void`	`hPutAll(String key, Map<String,Object> maps)` 向 key 对应的 hash 中，增加 maps（即: 批量增加 entry 集）注：同一个 hash 里面，若已存在相同的 entryKey，那么此操作将丢弃原来的 entryKey-entryValue，而使用新的 entryKey-entryValue
`boolean`	`hPutIfAbsent(String key, String entryKey, Object 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 的集合.
`Object`	`lIndex(String key, long index)` 通过索引index, 获取(key对应的)list中的元素注: 若key不存在或 index超出(key对应的)list的索引范围，那么返回null
`Object`	`lLeftPop(String key)` 【非阻塞队列】从左侧移出(key对应的)list中的第一个元素, 并将该元素返回注: 此方法是非阻塞的，即: 若(key对应的)list中的所有元素都被pop移出了，此时，再进行pop的话，会立即返回null 注: 此方法是非阻塞的，即: 若redis中不存在对应的key,那么会立即返回null 注: 若将(key对应的)list中的所有元素都pop完了，那么该key会被删除
`Object`	`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, Object value)` 从左端推入元素进列表注: 若redis中不存在对应的key, 那么会自动创建
`long`	`lLeftPush(String key, String pivot, Object item)` 若 key 对应的 list 中存在 pivot 项, 那么将 item 放入第一个 pivot 项前(即:放在第一个pivot项左边); 若 key 对应的 list 中不存在 pivot 项, 那么不做任何操作，直接返回 -1。
`long`	`lLeftPushAll(String key, Collection<Object> items)` 从左端批量推入元素进列表注: 若redis中不存在对应的key, 那么会自动创建注: 这一批item中，那个item先从Collection取出来，就先push哪个
`long`	`lLeftPushAll(String key, Object... items)` 从左端批量推入元素进列表注: 若redis中不存在对应的key, 那么会自动创建注: 这一批item中，先push左侧的, 后push右侧的
`long`	`lLeftPushIfPresent(String key, Object item)` 如果redis中存在key, 则从左端批量推入元素进列表; 否则，不进行任何操作
`List<Object>`	`lRange(String key, long start, long end)` 获取(key对应的)list中索引在[start, end]之间的item集注: 含start、含end。
`long`	`lRemove(String key, long expectCount, Object item)` 删除(key对应的)list中，前expectCount个值等于item的项注: 若expectCount == 0，则表示删除list中所有的值等于item的项.
`Object`	`lRightPop(String key)` 与`lLeftPop(String)`类比即可，不过是从list右侧移出元素
`Object`	`lRightPop(String key, long timeout, TimeUnit unit)` 与`lLeftPop(String, long, TimeUnit)`类比即可，不过是从list右侧移出元素
`Object`	`lRightPopAndLeftPush(String sourceKey, String destinationKey)` 【非阻塞队列】从sourceKey对应的sourceList右侧移出一个item, 并将这个item推入(destinationKey对应的)destinationList的左侧注: 若sourceKey对应的list中没有item了，则立马认为(从sourceKey对应的list中pop出来的)item为null, null并不会往destinationKey对应的list中push。
`Object`	`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, Object item)` 与`lLeftPush(String, Object)`类比即可，不过是从list右侧推入元素
`long`	`lRightPush(String key, String pivot, Object item)` 与`lLeftPush(String, String, Object)`类比即可，不过是从list右侧推入元素
`long`	`lRightPushAll(String key, Collection<Object> items)` 与`#lLeftPushAll(String, Collection`
`long`	`lRightPushAll(String key, Object... items)` 与`lLeftPushAll(String, Object...)`类比即可，不过是从list右侧推入元素
`long`	`lRightPushIfPresent(String key, Object item)` 与`lLeftPushIfPresent(String, Object)`类比即可，不过是从list右侧推入元素
`void`	`lSet(String key, long index, Object 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<Object>`	`lWholeList(String key)` 获取(key对应的)list
`boolean`	`move(String key, int dbIndex)` 将当前数据库中的 key 对应的 key-value,移动到对应位置的数据库中。
`List<Object>`	`multiGet(Collection<String> keys)` 批量获取 value 值注：若 redis 中，对应的 key 不存在，那么该 key 对应的返回的 value 值为 null
`void`	`multiSet(Map<String,Object> maps)` 批量设置 key-value 注：若存在相同的 key, 则原来的 key-value会被丢弃。
`boolean`	`multiSetIfAbsent(Map<String,Object> 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, Object... items)` 向(key对应的)set中添加items 注: 若key不存在，则会自动创建。
`Set<Object>`	`sDifference(String key, Collection<String> otherKeys)` 获取 (key对应的)Set 减去 (otherKeys对应的)Sets 的差集注: 如果被减数key不存在，那么结果为空的集合(，而不是null) 注: 如果被减数key存在，但减数key不存在，那么结果即为(被减数key对应的)Set 提示: 当有多个减数时，被减数先减去哪一个减数，后减去哪一个减数，是无所谓的，是不影响最终结果的。
`Set<Object>`	`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<Object>`	`sDistinctRandomMembers(String key, long count)` 从key对应的set中随机获取count个项注: 若count >= set的size, 那么返回的即为这个key对应的set。
`void`	`set(String key, Object value)` 设置 key-value 注：若已存在相同的 key, 那么原来的 key-value 会被丢弃。
`boolean`	`setBit(String key, long offset, boolean value)` 处理 redis 中 key 对应的 value 值, 将第 offset 位的值, 设置为 1 或 0。
`void`	`setEx(String key, Object value, long timeToLive, TimeUnit unit)` 设置 key-value 注：若已存在相同的 key，那么原来的 key-value 会被丢弃注：原子操作
`boolean`	`setIfAbsent(String key, Object value)` 若不存在 key 时，向 redis 中添加 key-value, 返回成功/失败。
`boolean`	`setIfAbsent(String key, Object value, long timeToLive, TimeUnit unit)` 若不存在 key 时, 向 redis 中添加一个（具有超时时长的）key-value, 返回成功/失败。
`void`	`setRange(String key, String replaceValue, long offset)` 从（redis 中 key 对应的）value 的 offset 位置起（包含该位置），用 replaceValue 替换对应长度的值。
`Set<Object>`	`sIntersect(String key, Collection<String> otherKeys)` 获取多个(key对应的)Set的交集注: 若不存在任何交集，那么返回空的集合(, 而不是null) 注: 若>=1个key不存在，那么返回空的集合(, 而不是null)
`Set<Object>`	`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<Object>`	`sMembers(String key)` 获取key对应的set 注: 若key不存在, 则返回的是空的set(, 而不是null)
`boolean`	`sMove(String sourceKey, Object item, String destinationKey)` 将(sourceKey对应的)sourceSet中的元素item, 移动到(destinationKey对应的)destinationSet中注: 当sourceKey不存在时，返回false 注: 当item不存在时，返回false 注: 若destinationKey不存在，那么在移动时会自动创建注: 若已经将(sourceKey对应的)set中的项move出去完了，那么对应的sourceKey会被删除。
`Object`	`sPop(String key)` 从(key对应的)set中随机移出一个item, 并返回这个item 注: 因为set是无序的，所以移出的这个item,是随机的; 并且，哪怕是数据一样的set,多次测试移出操作,移除的元素也是随机的。
`Object`	`sRandomMember(String key)` 从key对应的set中随机获取一项
`List<Object>`	`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<Object>`	`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<Object>`	`sUnion(String key, Collection<String> otherKeys)` 获取两个(key对应的)Set的并集注: 并集中的元素也是唯一的，这是Set保证的。
`Set<Object>`	`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。
`boolean`	`zAdd(String key, Object item, double score)` 向(key对应的)zset中添加(item, score) 注: item为entryKey成员项， score为entryValue分数值。
`long`	`zAdd(String key, Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<Object>> entries)` 批量添加entry 注: 若entry集中存在item相同的项(, score不一样)，那么redis在执行真正的批量add操作前,会将其中一个item过滤掉。
`long`	`zCount(String key, double minScore, double maxScore)` 统计(key对应的zset中)score处于[minScore, maxScore]中的item的个数
`double`	`zIncrementScore(String key, Object 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<Object>`	`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<Object>`	`zRangeByScore(String key, double minScore, double maxScore)` 根据score，获取(key对应的)zset中分数值处于[minScore, maxScore]中的item项集注: 若key不存在, 则返回空的集合。
`Set<Object>`	`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<Object>>`	`zRangeByScoreWithScores(String key, double minScore, double maxScore)` 获取(key对应的)zset中的所有score处于[minScore, maxScore]中的entry
`Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<Object>>`	`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<Object>>`	`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<Object>`	`zReverseRange(String key, long start, long end)` 获取时, 先按score倒序, 然后根据索引位置，获取(key对应的)zset中排名处于[start, end]中的item项集
`Set<Object>`	`zReverseRangeByScore(String key, double minScore, double maxScore)` 获取时, 先按score倒序, 然后根据score，获取(key对应的)zset中分数值处于[minScore, maxScore]中的item项集
`Set<Object>`	`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<Object>>`	`zReverseRangeByScoreWithScores(String key, double minScore, double maxScore)` 获取时, 先按score倒序, 然后获取(key对应的)zset中的所有score处于[minScore, maxScore]中的entry
`Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<Object>>`	`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<Object>>`	`zWholeZSetEntry(String key)` 获取(key对应的)zset中的所有entry
`Set<Object>`	`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.RedisTemplate<String,Object> 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,
                Object 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,
                  Object 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,
                           Object value)
若不存在 key 时，向 redis 中添加 key-value, 返回成功/失败。
 若存在，则不作任何操作，返回 false。

参数:
key - key
value - key 对应的 value
返回:
set 是否成功
从以下版本开始:
2020/3/8 16:51:36








setIfAbsent
public boolean setIfAbsent(String key,
                           Object 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,Object> maps)
批量设置 key-value
 
 注：若存在相同的 key, 则原来的 key-value会 被丢弃。

参数:
maps - key-value 集
从以下版本开始:
2020/3/8 17:21:19








multiSetIfAbsent
public boolean multiSetIfAbsent(Map<String,Object> 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, Object)

参数:
key - 定位 value 的 key
value - 要追加的 value 值
返回:
追加后，整个 value 的长度
从以下版本开始:
2020/3/8 17:59:21








get
public Object 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 Object getAndSet(String key,
                        Object 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<Object> 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,
                 Object 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,Object> 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,
                            Object 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,
                      Object value)
从左端推入元素进列表
 
 注: 若redis中不存在对应的key, 那么会自动创建

参数:
key - 定位list的key
value - 要推入list的元素
返回:
推入后，(key对应的)list的size
从以下版本开始:
2020/3/9 11:56:05








lLeftPushAll
public long lLeftPushAll(String key,
                         Object... 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<Object> 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,
                               Object 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,
                      Object 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,
                       Object item)
与lLeftPush(String, Object)类比即可， 不过是从list右侧推入元素







lRightPushAll
public long lRightPushAll(String key,
                          Object... items)
与lLeftPushAll(String, Object...)类比即可， 不过是从list右侧推入元素







lRightPushAll
public long lRightPushAll(String key,
                          Collection<Object> items)
与#lLeftPushAll(String, Collection

类 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