top.tangyh.basic.cache.redis

类 RedisOps

java.lang.Object

top.tangyh.basic.cache.redis.RedisOps

public class RedisOps
extends Object

redis 操作类

本类参考类 CacheChanel 源码 同时参考redis 使用手册： http://redisdoc.com/

加锁解决缓存击穿， 缓存空值解决缓存穿透。参考：

https://blog.csdn.net/haoxin963/article/details/83245113

作者:

zuihou

构造器概要

构造器

构造器和说明
RedisOps(org.springframework.data.redis.core.RedisTemplate<String,Object> redisTemplate, org.springframework.data.redis.core.StringRedisTemplate stringRedisTemplate, boolean defaultCacheNullVal)

方法概要

限定符和类型	方法和说明
Integer	append(String key, String value) 如果键 key 已经存在并且它的值是一个字符串， APPEND 命令将把 value 追加到键 key 现有值的末尾。
Long	decr(CacheKey key) 为键 key 储存的数字值减去一。
Long	decrBy(CacheKey key, long decrement) 将 key 所储存的值减去减量 decrement 。
Long	del(CacheKey... keys) 删除给定的一个 key 或 多个key 不存在的 key 会被忽略。
Long	del(Collection<CacheKey> keys) 删除给定的一个 key 或 多个key 不存在的 key 会被忽略。
Long	del(List<String> keys) 删除给定的一个 key 或 多个key 不存在的 key 会被忽略。
Long	del(String... keys) 删除给定的一个 key 或 多个key 不存在的 key 会被忽略。
Boolean	exists(String key) 检查给定 key 是否存在。
Boolean	expire(String key, Duration timeout) 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
Boolean	expire(String key, long seconds) 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
Boolean	expireAt(String key, Date date) EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。
Boolean	expireAt(String key, long unixTimestamp) EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。
<T> T	get(CacheKey key, boolean... cacheNullValues) 返回与键 key 相关联的 value 值 如果键 key 不存在， 那么返回特殊值 null ； 否则， 返回键 key 的值。
<T> T	get(CacheKey key, Function<CacheKey,T> loader, boolean... cacheNullValues) 返回与键 key 相关联的 value 值 如果键 key 不存在， 那么返回特殊值 null ； 否则， 返回键 key 的值。
<T> T	get(String key, boolean... cacheNullValues) 返回与键 key 相关联的 value 值 如果键 key 不存在， 那么返回特殊值 null ； 否则， 返回键 key 的值。
<T> T	get(String key, Function<String,T> loader, boolean... cacheNullValues) 返回与键 key 相关联的 value 值 如果值不存在， 那么调用 loader 方法获取数据后，set 到缓存
Long	getCounter(CacheKey key, Function<CacheKey,Long> loader) 获取key中存放的Long值
Long	getCounter(CacheKey key, Long... defaultValue) 获取key中存放的Long值
String	getRange(String key, long start, long end) 返回键 key 储存的字符串值的指定部分， 字符串的截取范围由 start 和 end 两个偏移量决定 (包括 start 和 end 在内)。
<T> T	getSet(String key, Object value) 将键 key 的值设为 value ， 并返回键 key 在被设置之前的旧值。
Long	hDel(CacheHashKey key)
Long	hDel(String key, Object... fields) 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
Boolean	hExists(CacheHashKey cacheHashKey) 检查给定域 field 是否存在于哈希表 hash 当中
Boolean	hExists(String key, Object field) 检查给定域 field 是否存在于哈希表 hash 当中
<T> T	hGet(CacheHashKey key, boolean... cacheNullValues) 返回哈希表 key 中给定域 field 的值。
<T> T	hGet(CacheHashKey key, Function<CacheHashKey,T> loader, boolean... cacheNullValues) 返回哈希表 key 中给定域 field 的值。
<T> T	hGet(String key, Object field, BiFunction<String,Object,T> loader, boolean... cacheNullValues) 返回哈希表 key 中给定域 field 的值。
<T> T	hGet(String key, Object field, boolean... cacheNullValues) 返回哈希表 key 中给定域 field 的值。
<K,V> Map<K,V>	hGetAll(CacheHashKey key)
<K,V> Map<K,V>	hGetAll(CacheHashKey key, Function<CacheHashKey,Map<K,V>> loader, boolean... cacheNullValues) 返回哈希表 key 中给定域 field 的值。
<K,V> Map<K,V>	hGetAll(String key) 返回哈希表 key 中，所有的域和值。
Long	hIncrBy(CacheHashKey key, long increment) 为哈希表 key 中的域 field 的值加上增量 increment 。
Double	hIncrByFloat(CacheHashKey key, double increment) 为哈希表 key 中的域 field 加上浮点数增量 increment 。
<HK> Set<HK>	hKeys(String key) 返回哈希表 key 中的所有域。
Long	hLen(String key) 返回哈希表 key 中域的数量。
List<Object>	hmGet(String key, Collection<Object> fields) 返回哈希表 key 中，一个或多个给定域的值。
List<Object>	hmGet(String key, Object... fields) 返回哈希表 key 中，一个或多个给定域的值。
<K,V> void	hmSet(String key, Map<K,V> hash, boolean... cacheNullValues) 同时将多个 field-value (域-值)对设置到哈希表 key 中。
void	hSet(CacheHashKey key, Object value, boolean... cacheNullValues) 将哈希表 key 中的域 field 的值设为 value 。
void	hSet(String key, Object field, Object value, boolean... cacheNullValues) 将哈希表 key 中的域 field 的值设为 value 。
Long	hStrLen(String key, Object field) 返回哈希表 key 中， 与给定域 field 相关联的值的字符串长度
<HV> List<HV>	hVals(String key) 返回哈希表 key 中所有域的值。
Long	incr(CacheKey key) 为键 key 储存的数字值加上一。
Long	incrBy(CacheKey key, long increment) 为键 key 储存的数字值加上增量 increment 。
Double	incrByFloat(CacheKey key, double increment) 为键 key 储存的值加上浮点数增量 increment 。
Set<String>	keys(String pattern) 查找所有符合给定模式 pattern 的 key 。
<T> T	lIndex(String key, long index) 返回列表 key 中，下标为 index 的元素。
Long	lInsert(String key, Object pivot, Object value) 将值 value 插入到列表 key 当中，位于值 pivot 之前。
Long	lLen(String key) 返回列表 key 的长度。
<T> T	lPop(String key) 移除并返回列表 key 的头元素
Long	lPush(String key, Collection<Object> values) 将一个或多个值 value 插入到列表 key 的表头 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头： 比如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a ，这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。
Long	lPush(String key, Object... values) 将一个或多个值 value 插入到列表 key 的表头 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头： 比如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a ，这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。
Long	lPushX(String key, Object values) 将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。
List<Object>	lRange(String key, long start, long end) 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
Long	lRem(String key, long count, Object value) 根据参数 count 的值，移除列表中与参数 value 相等的元素。
void	lSet(String key, long index, Object value) 将列表 key 下标为 index 的元素的值设置为 value 。
void	lTrim(String key, long start, long end) 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
<T> List<T>	mGet(CacheKey... keys) 返回所有(一个或多个)给定 key 的值, 值按请求的键的顺序返回。
<T> List<T>	mGet(Collection<String> keys) 返回所有(一个或多个)给定 key 的值, 值按请求的键的顺序返回。
<T> List<T>	mGet(String... keys) 返回所有(一个或多个)给定 key 的值, 值按请求的键的顺序返回。
<T> List<T>	mGetByCacheKey(Collection<CacheKey> cacheKeys) 返回所有(一个或多个)给定 key 的值, 值按请求的键的顺序返回。
Boolean	move(String key, int dbIndex) 将当前数据库的 key 移动到给定的数据库 db 当中。
void	mSet(Map<String,Object> map) 同时为一个或多个键设置值。
void	mSet(Map<String,Object> map, boolean cacheNullVal) 同时为一个或多个键设置值。
void	mSetNx(Map<String,Object> map) 当且仅当所有给定键都不存在时， 为所有给定键设置值。
void	mSetNx(Map<String,Object> map, boolean cacheNullVal) 当且仅当所有给定键都不存在时， 为所有给定键设置值。
Boolean	persist(String key) 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。
Boolean	pExpire(String key, long milliseconds) 这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令那样，以秒为单位。
Long	pTtl(String key) 这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间，而不是像 TTL 命令那样，以秒为单位。
String	randomKey() 从当前数据库中随机返回(不删除)一个 key 。
void	rename(String oldKey, String newKey) 将 key 改名为 newkey 。
Boolean	renameNx(String oldKey, String newKey) 当且仅当 newkey 不存在时，将 key 改名为 newkey 。
Long	rInsert(String key, Object pivot, Object value) 将值 value 插入到列表 key 当中，位于值 pivot 之后。
<T> T	rPop(String key) 移除并返回列表 key 的尾元素。
<T> T	rPoplPush(String sourceKey, String destinationKey) 命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作： 1.将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。
Long	rPush(String key, Collection<Object> values) 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
Long	rPush(String key, Object... values) 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
Long	rPushX(String key, Object value) 将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。
<V> Long	sAdd(CacheKey key, Collection<V> members) 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
<V> Long	sAdd(CacheKey key, V... members) 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
List<String>	scan(String pattern) 查找所有符合给定模式 pattern 的 key 。
void	scanUnlink(String pattern) 批量扫描后删除 匹配到的key
Long	sCard(CacheKey key) 返回集合 key 的基数(集合中元素的数量)。
<V> Set<V>	sDiff(CacheKey key, CacheKey otherKey) 返回一个集合的全部成员，该集合是所有给定集合之间的差集。
<V> Set<V>	sDiff(Collection<CacheKey> otherKeys) 返回一个集合的全部成员，该集合是所有给定集合之间的差集。
Long	sDiffStore(CacheKey key, CacheKey otherKey, CacheKey distKey) 这个命令的作用和 SDIFF key [key …] 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。
Long	sDiffStore(Collection<CacheKey> otherKeys, CacheKey distKey) 返回一个集合的全部成员，该集合是所有给定集合之间的差集。
void	set(CacheKey cacheKey, Object value, boolean... cacheNullValues) 设置缓存
void	set(String key, Object value, boolean... cacheNullValues) 将字符串值 value 存放到 key 。
void	setEx(String key, Object value, Duration timeout, boolean... cacheNullValues) 将键 key 的值设置为 value ， 并将键 key 的生存时间设置为 seconds 秒钟。
void	setEx(String key, Object value, long seconds, boolean... cacheNullValues) 将键 key 的值设置为 value ， 并将键 key 的生存时间设置为 seconds 秒钟。
Boolean	setNx(String key, String value, boolean... cacheNullValues) 只在键 key 不存在的情况下， 将键 key 的值设置为 value 。
void	setRange(String key, String value, long offset) 从偏移量 offset 开始， 用 value 参数覆写(overwrite)键 key 储存的字符串值。
Boolean	setXx(String key, String value, boolean... cacheNullValues) 如果存在key，则设置key以保存字符串值。
Boolean	setXx(String key, String value, Duration timeout, boolean... cacheNullValues) 如果存在key，则设置key以保存字符串值。
Boolean	setXx(String key, String value, long seconds, boolean... cacheNullValues) 如果存在key，则设置key以保存字符串值。
<V> Set<V>	sInter(CacheKey key, CacheKey otherKey) 返回一个集合的全部成员，该集合是所有给定集合的交集。
Set<Object>	sInter(CacheKey key, Collection<CacheKey> otherKeys) 返回一个集合的全部成员，该集合是所有给定集合的交集。
<V> Set<V>	sInter(Collection<CacheKey> otherKeys) 返回一个集合的全部成员，该集合是所有给定集合的交集。
Long	sInterStore(CacheKey key, CacheKey otherKey, CacheKey destKey) 这个命令类似于 SINTER key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
Long	sInterStore(CacheKey key, Collection<CacheKey> otherKeys, CacheKey destKey) 这个命令类似于 SINTER key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
Long	sInterStore(Collection<CacheKey> otherKeys, CacheKey destKey) 这个命令类似于 SINTER key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
Boolean	sIsMember(CacheKey key, Object member) 判断 member 元素是否集合 key 的成员。
<V> Set<V>	sMembers(CacheKey key) 返回集合 key 中的所有成员。
<V> Boolean	sMove(CacheKey sourceKey, CacheKey destinationKey, V value) 将 member 元素从 source 集合移动到 destination 集合。
<T> T	sPop(CacheKey key) 移除并返回集合中的一个随机元素。
<T> T	sRandMember(CacheKey key) 返回集合中的一个随机元素。
<V> Set<V>	sRandMember(CacheKey key, long count) 返回集合中的count个随机元素。
<V> List<V>	sRandMembers(CacheKey key, long count) 返回集合中的count个随机元素。
Long	sRem(CacheKey key, Object... members) 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
Long	strLen(String key) 返回键 key 储存的字符串值的长度
<V> Set<V>	sUnion(CacheKey key, CacheKey otherKey) 返回多个集合的并集，多个集合由 keys 指定 不存在的 key 被视为空集。
<V> Set<V>	sUnion(CacheKey key, Collection<CacheKey> otherKeys) 返回多个集合的并集，多个集合由 keys 指定 不存在的 key 被视为空集。
<V> Set<V>	sUnion(Collection<CacheKey> otherKeys) 返回多个集合的并集，多个集合由 keys 指定 不存在的 key 被视为空集。
Long	sUnionStore(CacheKey key, CacheKey otherKey, CacheKey distKey) 这个命令类似于 SUNION key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
Long	sUnionStore(Collection<CacheKey> otherKeys, CacheKey distKey) 这个命令类似于 SUNION key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
Long	ttl(String key) 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
String	type(String key) 返回 key 所储存的值的类型。
Long	unlink(CacheKey... keys) 异步删除给定的一个 key 或 多个key 不存在的 key 会被忽略。
Long	unlink(String... keys) 异步删除给定的一个 key 或 多个key 不存在的 key 会被忽略。
Long	unlinkCacheKeys(Collection<CacheKey> keys) 异步删除给定的一个 key 或 多个key 不存在的 key 会被忽略。
Long	unlinkStrs(List<String> keys) 异步删除给定的一个 key 或 多个key 不存在的 key 会被忽略。
Long	zAdd(String key, Map<Object,Double> scoreMembers) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
Boolean	zAdd(String key, Object member, double score) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
Long	zCard(String key) 返回有序集 key 的基数。
Long	zCount(String key, double min, double max) 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
Double	zIncrBy(String key, Object member, double score) 为有序集 key 的成员 member 的 score 值加上增量 increment 。
Set<Object>	zRange(String key, long start, long end) 返回有序集 key 中，指定区间内的成员。
Set<Object>	zRangeByScore(String key, double min, double max) 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<Object>>	zRangeByScoreWithScores(String key, double min, double max) 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<Object>>	zRangeWithScores(String key, long start, long end) 返回有序集 key 中，指定区间内的成员。
Long	zRank(String key, Object member) 返回有序集 key 中成员 member 的排名。
Long	zRem(String key, long start, long end) 移除有序集 key 中，指定排名(rank)区间内的所有成员。
Long	zRem(String key, Object... members) 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。
Long	zRemRangeByScore(String key, double min, double max) 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
Set<Object>	zReverseRange(String key, double min, double max) 返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。
Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<Object>>	zReverseRangeByScoreWithScores(String key, double min, double max) 返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。
Set<Object>	zRevrange(String key, long start, long end) 返回有序集 key 中，指定区间内的成员。
Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<Object>>	zRevrangeWithScores(String key, long start, long end) 返回有序集 key 中，指定区间内的成员。
Long	zRevrank(String key, Object member) 返回有序集 key 中成员 member 的排名。
Double	zScore(String key, Object member) 返回有序集 key 中，成员 member 的 score 值。

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

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

构造器详细资料

RedisOps

public RedisOps(org.springframework.data.redis.core.RedisTemplate<String,Object> redisTemplate,
                org.springframework.data.redis.core.StringRedisTemplate stringRedisTemplate,
                boolean defaultCacheNullVal)

方法详细资料

del

public Long del(@NonNull
                CacheKey... keys)

删除给定的一个 key 或 多个key 不存在的 key 会被忽略。

参数:

keys - 一定不能为 null.

返回:

key 被删除返回true

另请参阅:

Redis Documentation: DEL

del

public Long del(@NonNull
                String... keys)

删除给定的一个 key 或 多个key 不存在的 key 会被忽略。

参数:

keys - 一定不能为 null.

返回:

key 被删除返回true

另请参阅:

Redis Documentation: DEL

del

public Long del(@NonNull
                List<String> keys)

删除给定的一个 key 或 多个key 不存在的 key 会被忽略。

参数:

keys - 一定不能为 null.

返回:

key 被删除返回true

另请参阅:

Redis Documentation: DEL

del

public Long del(@NonNull
                Collection<CacheKey> keys)

删除给定的一个 key 或 多个key 不存在的 key 会被忽略。

参数:

keys - 一定不能为 null.

返回:

key 被删除返回true

另请参阅:

Redis Documentation: DEL

unlink

public Long unlink(@NonNull
                   CacheKey... keys)

异步删除给定的一个 key 或 多个key 不存在的 key 会被忽略。

参数:

keys - 一定不能为 null.

返回:

key 被删除返回true

另请参阅:

Redis Documentation: DEL

unlink

public Long unlink(@NonNull
                   String... keys)

异步删除给定的一个 key 或 多个key 不存在的 key 会被忽略。

参数:

keys - 一定不能为 null.

返回:

key 被删除返回true

另请参阅:

Redis Documentation: DEL

unlinkCacheKeys

public Long unlinkCacheKeys(@NonNull
                            Collection<CacheKey> keys)

异步删除给定的一个 key 或 多个key 不存在的 key 会被忽略。

参数:

keys - 一定不能为 null.

返回:

key 被删除返回true

另请参阅:

Redis Documentation: DEL

unlinkStrs

public Long unlinkStrs(@NonNull
                       List<String> keys)

异步删除给定的一个 key 或 多个key 不存在的 key 会被忽略。

参数:

keys - 一定不能为 null.

返回:

key 被删除返回true

另请参阅:

Redis Documentation: DEL

scanUnlink

public void scanUnlink(@NonNull
                       String pattern)

批量扫描后删除 匹配到的key

参数:

pattern - pattern

scan

public List<String> scan(@NonNull
                         String pattern)

查找所有符合给定模式 pattern 的 key 。

例子： KEYS * 匹配数据库中所有 key 。 KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。 KEYS h*llo 匹配 hllo 和 heeeeello 等。 KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。

特殊符号用 \ 隔开

参数:

pattern - 表达式

返回:

符合给定模式的 key 列表

另请参阅:

Redis Documentation: KEYS

keys

public Set<String> keys(@NonNull
                        String pattern)

查找所有符合给定模式 pattern 的 key 。

例子： KEYS * 匹配数据库中所有 key 。 KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。 KEYS h*llo 匹配 hllo 和 heeeeello 等。 KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。

特殊符号用 \ 隔开

参数:

pattern - 表达式

返回:

符合给定模式的 key 列表

另请参阅:

Redis Documentation: KEYS

exists

public Boolean exists(@NonNull
                      String key)

检查给定 key 是否存在。

参数:

key - 一定不能为 null.

返回:

是否存在

另请参阅:

Redis Documentation: EXISTS

randomKey

public String randomKey()

从当前数据库中随机返回(不删除)一个 key 。

返回:

当数据库不为空时，返回一个 key 。 当数据库为空时，返回 nil 。

另请参阅:

Redis Documentation: RANDOMKEY

rename

public void rename(@NonNull
                   String oldKey,
                   @NonNull
                   String newKey)

将 key 改名为 newkey 。 当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。 当 newkey 已经存在时， RENAME 命令将覆盖旧值。

参数:

oldKey - 一定不能为 null.

newKey - 一定不能为 null.

另请参阅:

Redis Documentation: RENAME

renameNx

public Boolean renameNx(@NonNull
                        String oldKey,
                        String newKey)

当且仅当 newkey 不存在时，将 key 改名为 newkey 。

参数:

oldKey - 一定不能为 null.

newKey - 一定不能为 null.

返回:

是否成功

另请参阅:

Redis Documentation: RENAMENX

move

public Boolean move(@NonNull
                    String key,
                    int dbIndex)

将当前数据库的 key 移动到给定的数据库 db 当中。 如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。 因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)。

参数:

key - 一定不能为 null.

dbIndex - 数据库索引

返回:

是否成功

另请参阅:

Redis Documentation: MOVE

expire

public Boolean expire(@NonNull
                      String key,
                      long seconds)

为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。 在 Redis 中，带有生存时间的 key 被称为『易失的』(volatile)。

生存时间可以通过使用 DEL 命令来删除整个 key 来移除，或者被 SET 和 GETSET 命令覆写(overwrite)，这意味着，如果一个命令只是修改(alter)一个带生存时间的 key 的值而不是用一个新的 key 值来代替(replace)它的话，那么生存时间不会被改变。

比如说，对一个 key 执行 INCR 命令，对一个列表进行 LPUSH 命令，或者对一个哈希表执行 HSET 命令，这类操作都不会修改 key 本身的生存时间。

另一方面，如果使用 RENAME 对一个 key 进行改名，那么改名后的 key 的生存时间和改名前一样。

RENAME 命令的另一种可能是，尝试将一个带生存时间的 key 改名成另一个带生存时间的 another_key ，这时旧的 another_key (以及它的生存时间)会被删除，然后旧的 key 会改名为 another_key ，因此，新的 another_key 的生存时间也和原本的 key 一样。

使用 PERSIST 命令可以在不删除 key 的情况下，移除 key 的生存时间，让 key 重新成为一个『持久的』(persistent) key 。

参数:

key - 一定不能为 null.

seconds - 过期时间 单位：秒

返回:

是否成功

另请参阅:

Redis Documentation: EXPIRE

expire

public Boolean expire(@NonNull
                      String key,
                      @NonNull
                      Duration timeout)

为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。 在 Redis 中，带有生存时间的 key 被称为『易失的』(volatile)。

生存时间可以通过使用 DEL 命令来删除整个 key 来移除，或者被 SET 和 GETSET 命令覆写(overwrite)，这意味着，如果一个命令只是修改(alter)一个带生存时间的 key 的值而不是用一个新的 key 值来代替(replace)它的话，那么生存时间不会被改变。

比如说，对一个 key 执行 INCR 命令，对一个列表进行 LPUSH 命令，或者对一个哈希表执行 HSET 命令，这类操作都不会修改 key 本身的生存时间。

另一方面，如果使用 RENAME 对一个 key 进行改名，那么改名后的 key 的生存时间和改名前一样。

RENAME 命令的另一种可能是，尝试将一个带生存时间的 key 改名成另一个带生存时间的 another_key ，这时旧的 another_key (以及它的生存时间)会被删除，然后旧的 key 会改名为 another_key ，因此，新的 another_key 的生存时间也和原本的 key 一样。

使用 PERSIST 命令可以在不删除 key 的情况下，移除 key 的生存时间，让 key 重新成为一个『持久的』(persistent) key 。

参数:

key - 一定不能为 null.

timeout - 过期时间

返回:

是否成功

另请参阅:

Redis Documentation: EXPIRE

expireAt

public Boolean expireAt(@NonNull
                        String key,
                        @NonNull
                        Date date)

EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。

参数:

key - 一定不能为 null.

date - 过期时间

返回:

是否成功

另请参阅:

Redis Documentation: EXPIREAT

expireAt

public Boolean expireAt(@NonNull
                        String key,
                        long unixTimestamp)

EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。

参数:

key - 一定不能为 null.

unixTimestamp - 过期时间戳

返回:

是否成功

另请参阅:

Redis Documentation: EXPIREAT

pExpire

public Boolean pExpire(@NonNull
                       String key,
                       long milliseconds)

这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令那样，以秒为单位。

参数:

key - 一定不能为 null.

milliseconds - 过期时间 单位： 毫米

返回:

是否成功

另请参阅:

Redis Documentation: PEXPIRE

persist

public Boolean persist(@NonNull
                       String key)

移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。

参数:

key - 一定不能为 null.

返回:

是否成功

另请参阅:

Redis Documentation: PERSIST

type

public String type(@NonNull
                   String key)

返回 key 所储存的值的类型。

参数:

key - 一定不能为 null.

返回:

none (key不存在)、string (字符串)、list (列表)、set (集合)、zset (有序集)、hash (哈希表) 、stream （流）

另请参阅:

Redis Documentation: TYPE

ttl

public Long ttl(@NonNull
                String key)

以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。

参数:

key - 一定不能为 null.

返回:

当 key 不存在时，返回 -2 。 当 key 存在但没有设置剩余生存时间时，返回 -1 。 否则，以秒为单位，返回 key 的剩余生存时间。

另请参阅:

Redis Documentation: TTL

pTtl

public Long pTtl(@NonNull
                 String key)

这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间，而不是像 TTL 命令那样，以秒为单位。

参数:

key - 一定不能为 null.

返回:

当 key 不存在时，返回 -2 。当 key 存在但没有设置剩余生存时间时，返回 -1 。否则，以毫秒为单位，返回 key 的剩余生存时间

另请参阅:

Redis Documentation: PTTL

set

public void set(@NonNull
                String key,
                Object value,
                boolean... cacheNullValues)

将字符串值 value 存放到 key 。

如果 key 已经持有其他值， SET 就覆写旧值， 无视类型。 当 SET 命令对一个带有生存时间（TTL）的键进行设置之后， 该键原有的 TTL 将被清除.

参数:

key - 一定不能为 null.

value - 值

cacheNullValues - 是否缓存null对象

另请参阅:

Redis Documentation: SET

set

public void set(@NonNull
                CacheKey cacheKey,
                Object value,
                boolean... cacheNullValues)

设置缓存

参数:

cacheKey - 缓存key 一定不能为 null.

value - 缓存value

cacheNullValues - 是否缓存null对象

setEx

public void setEx(@NonNull
                  String key,
                  Object value,
                  Duration timeout,
                  boolean... cacheNullValues)

将键 key 的值设置为 value ， 并将键 key 的生存时间设置为 seconds 秒钟。 如果键 key 已经存在， 那么 SETEX 命令将覆盖已有的值。

SETEX 命令的效果和以下两个命令的效果类似： SET key value EXPIRE key seconds # 设置生存时间

SETEX 和这两个命令的不同之处在于 SETEX 是一个原子（atomic）操作， 它可以在同一时间内完成设置值和设置过期时间这两个操作， 因此 SETEX 命令在储存缓存的时候非常实用。

参数:

key - 一定不能为 null.

value - 值

timeout - 一定不能为 null.

cacheNullValues - 是否缓存null对象

抛出:

IllegalArgumentException - if either key, value or timeout is not present.

另请参阅:

Redis Documentation: SETEX

setEx

public void setEx(@NonNull
                  String key,
                  Object value,
                  long seconds,
                  boolean... cacheNullValues)

将键 key 的值设置为 value ， 并将键 key 的生存时间设置为 seconds 秒钟。 如果键 key 已经存在， 那么 SETEX 命令将覆盖已有的值。

SETEX 命令的效果和以下两个命令的效果类似： SET key value EXPIRE key seconds # 设置生存时间

SETEX 和这两个命令的不同之处在于 SETEX 是一个原子（atomic）操作， 它可以在同一时间内完成设置值和设置过期时间这两个操作， 因此 SETEX 命令在储存缓存的时候非常实用。

参数:

key - 一定不能为 null.

value - 值

cacheNullValues - 是否缓存null对象

seconds - 过期时间 单位秒

另请参阅:

Redis Documentation: SETEX

setXx

@Nullable
public Boolean setXx(@NonNull
                               String key,
                               String value,
                               boolean... cacheNullValues)

如果存在key，则设置key以保存字符串值。

参数:

key - 一定不能为 null.

value - 一定不能为 null.

返回:

设置成功返回true。

抛出:

IllegalArgumentException - 如果key 或 value 不存在

从以下版本开始:

2.1

另请参阅:

Redis Documentation: SET

setXx

@Nullable
public Boolean setXx(@NonNull
                               String key,
                               String value,
                               long seconds,
                               boolean... cacheNullValues)

如果存在key，则设置key以保存字符串值。

参数:

key - 一定不能为 null.

value - 一定不能为 null.

seconds - 过期时间 单位秒

返回:

设置成功返回true。

抛出:

IllegalArgumentException - 如果key 或 value 不存在

从以下版本开始:

2.1

另请参阅:

Redis Documentation: SET

setXx

@Nullable
public Boolean setXx(@NonNull
                               String key,
                               String value,
                               Duration timeout,
                               boolean... cacheNullValues)

如果存在key，则设置key以保存字符串值。

参数:

key - 一定不能为 null.

value - 一定不能为 null.

timeout - 一定不能为 null.

返回:

设置成功返回true。

抛出:

IllegalArgumentException - 如果key 或 value 不存在

从以下版本开始:

2.1

另请参阅:

Redis Documentation: SET

setNx

@Nullable
public Boolean setNx(@NonNull
                               String key,
                               String value,
                               boolean... cacheNullValues)

只在键 key 不存在的情况下， 将键 key 的值设置为 value 。

若键 key 已经存在， 则 SETNX 命令不做任何动作。

SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。

参数:

key - 一定不能为 null.

value - 一定不能为 null.

返回:

设置成功返回true

另请参阅:

Redis Documentation: SETNX

get

@Nullable
public <T> T get(@NonNull
                           String key,
                           boolean... cacheNullValues)

返回与键 key 相关联的 value 值

如果键 key 不存在， 那么返回特殊值 null ； 否则， 返回键 key 的值。

参数:

key - 一定不能为 null.

cacheNullValues - 是否缓存空值

返回:

如果键 key 不存在， 那么返回特殊值 null ； 否则， 返回键 key 的值。

另请参阅:

Redis Documentation: GET

get

@Nullable
public <T> T get(@NonNull
                           String key,
                           Function<String,T> loader,
                           boolean... cacheNullValues)

返回与键 key 相关联的 value 值

如果值不存在， 那么调用 loader 方法获取数据后，set 到缓存

参数:

key - 一定不能为 null.

loader - 缓存加载器

cacheNullValues - 是否缓存空值

返回:

如果redis中没值，先加载loader 的数据，若加载loader 的值为null，直接返回， 否则 设置后loader值后返回。

另请参阅:

Redis Documentation: GET

getSet

public <T> T getSet(@NonNull
                    String key,
                    Object value)

将键 key 的值设为 value ， 并返回键 key 在被设置之前的旧值。

返回给定键 key 的旧值。 如果键 key 没有旧值， 也即是说， 键 key 在被设置之前并不存在， 那么命令返回 nil 。 当键 key 存在但不是字符串类型时， 命令返回一个错误。

参数:

key - 一定不能为 null.

value - 值

返回:

如果键 key 不存在， 那么返回特殊值 null ； 否则， 返回给定键 key 的旧值

另请参阅:

Redis Documentation: GETSET

get

@Nullable
public <T> T get(@NonNull
                           CacheKey key,
                           boolean... cacheNullValues)

返回与键 key 相关联的 value 值

如果键 key 不存在， 那么返回特殊值 null ； 否则， 返回键 key 的值。

参数:

key - 一定不能为 null.

cacheNullValues - 是否缓存空值

返回:

如果键 key 不存在， 那么返回特殊值 null ； 否则， 返回键 key 的值。

另请参阅:

Redis Documentation: GET

get

@Nullable
public <T> T get(@NonNull
                           CacheKey key,
                           Function<CacheKey,T> loader,
                           boolean... cacheNullValues)

返回与键 key 相关联的 value 值

如果键 key 不存在， 那么返回特殊值 null ； 否则， 返回键 key 的值。

参数:

key - 一定不能为 null.

loader - 加载器

cacheNullValues - 是否缓存空值

返回:

如果键 key 不存在， 那么返回特殊值 null ； 否则， 返回键 key 的值。

另请参阅:

Redis Documentation: GET

strLen

@Nullable
public Long strLen(@NonNull
                             String key)

返回键 key 储存的字符串值的长度

参数:

key - 一定不能为 null.

返回:

字符串值的长度。 当键 key 不存在时， 命令返回 0

另请参阅:

Redis Documentation: STRLEN

append

@Nullable
public Integer append(@NonNull
                                String key,
                                String value)

如果键 key 已经存在并且它的值是一个字符串， APPEND 命令将把 value 追加到键 key 现有值的末尾。 如果 key 不存在， APPEND 就简单地将键 key 的值设为 value ， 就像执行 SET key value 一样。

参数:

key - 一定不能为 null.

返回:

追加 value 之后， 键 key 的值的长度

另请参阅:

Redis Documentation: APPEND

setRange

public void setRange(@NonNull
                     String key,
                     String value,
                     long offset)

从偏移量 offset 开始， 用 value 参数覆写(overwrite)键 key 储存的字符串值。

不存在的键 key 当作空白字符串处理。

SETRANGE 命令会确保字符串足够长以便将 value 设置到指定的偏移量上， 如果键 key 原来储存的字符串长度比偏移量小(比如字符串只有 5 个字符长，但你设置的 offset 是 10 )， 那么原字符和偏移量之间的空白将用零字节(zerobytes, "\x00" )进行填充。

因为 Redis 字符串的大小被限制在 512 兆(megabytes)以内， 所以用户能够使用的最大偏移量为 2^29-1(536870911) ， 如果你需要使用比这更大的空间， 请使用多个 key 。

参数:

key - 一定不能为 null.

value - 字符串

offset - 最大不能超过 536870911

另请参阅:

Redis Documentation: SETRANGE

getRange

public String getRange(@NonNull
                       String key,
                       long start,
                       long end)

返回键 key 储存的字符串值的指定部分， 字符串的截取范围由 start 和 end 两个偏移量决定 (包括 start 和 end 在内)。 负数偏移量表示从字符串的末尾开始计数， -1 表示最后一个字符， -2 表示倒数第二个字符， 以此类推。 GETRANGE 通过保证子字符串的值域(range)不超过实际字符串的值域来处理超出范围的值域请求。

参数:

key - 一定不能为 null.

start - 开始偏移量

end - 结束偏移量

返回:

GETRANGE 命令会返回字符串值的指定部分。

另请参阅:

Redis Documentation: GETRANGE

mSet

public void mSet(@NonNull
                 Map<String,Object> map,
                 boolean cacheNullVal)

同时为一个或多个键设置值。 如果某个给定键已经存在， 那么 MSET 将使用新值去覆盖旧值， 如果这不是你所希望的效果， 请考虑使用 MSETNX 命令， 这个命令只会在所有给定键都不存在的情况下进行设置。 MSET 是一个原子性(atomic)操作， 所有给定键都会在同一时间内被设置， 不会出现某些键被设置了但是另一些键没有被设置的情况。

参数:

map - 一定不能为 null.

cacheNullVal - 是否缓存空值

另请参阅:

Redis Documentation: MSET

mSet

public void mSet(@NonNull
                 Map<String,Object> map)

同时为一个或多个键设置值。 如果某个给定键已经存在， 那么 MSET 将使用新值去覆盖旧值， 如果这不是你所希望的效果， 请考虑使用 MSETNX 命令， 这个命令只会在所有给定键都不存在的情况下进行设置。 MSET 是一个原子性(atomic)操作， 所有给定键都会在同一时间内被设置， 不会出现某些键被设置了但是另一些键没有被设置的情况。

参数:

map - 一定不能为 null.

另请参阅:

Redis Documentation: MSET

mSetNx

public void mSetNx(@NonNull
                   Map<String,Object> map,
                   boolean cacheNullVal)

当且仅当所有给定键都不存在时， 为所有给定键设置值。 即使只有一个给定键已经存在， MSETNX 命令也会拒绝执行对所有键的设置操作。 MSETNX 是一个原子性(atomic)操作， 所有给定键要么就全部都被设置， 要么就全部都不设置， 不可能出现第三种状态。

参数:

map - 一定不能为 null.

cacheNullVal - 是否缓存空值

另请参阅:

Redis Documentation: MSET

mSetNx

public void mSetNx(@NonNull
                   Map<String,Object> map)

当且仅当所有给定键都不存在时， 为所有给定键设置值。 即使只有一个给定键已经存在， MSETNX 命令也会拒绝执行对所有键的设置操作。 MSETNX 是一个原子性(atomic)操作， 所有给定键要么就全部都被设置， 要么就全部都不设置， 不可能出现第三种状态。

参数:

map - 一定不能为 null.

另请参阅:

Redis Documentation: MSET

mGet

public <T> List<T> mGet(@NonNull
                        String... keys)

返回所有(一个或多个)给定 key 的值, 值按请求的键的顺序返回。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil

参数:

keys - 一定不能为 null.

返回:

返回一个列表， 列表中包含了所有给定键的值,并按给定key的顺序排列

另请参阅:

Redis Documentation: MGET

mGet

public <T> List<T> mGet(@NonNull
                        CacheKey... keys)

返回所有(一个或多个)给定 key 的值, 值按请求的键的顺序返回。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil

参数:

keys - 一定不能为 null.

返回:

返回一个列表， 列表中包含了所有给定键的值,并按给定key的顺序排列

另请参阅:

Redis Documentation: MGET

mGet

public <T> List<T> mGet(@NonNull
                        Collection<String> keys)

返回所有(一个或多个)给定 key 的值, 值按请求的键的顺序返回。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil

参数:

keys - 一定不能为 null.

返回:

返回一个列表， 列表中包含了所有给定键的值,并按给定key的顺序排列

另请参阅:

Redis Documentation: MGET

mGetByCacheKey

public <T> List<T> mGetByCacheKey(@NonNull
                                  Collection<CacheKey> cacheKeys)

返回所有(一个或多个)给定 key 的值, 值按请求的键的顺序返回。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil

参数:

cacheKeys - 一定不能为 null.

返回:

返回一个列表， 列表中包含了所有给定键的值,并按给定key的顺序排列

另请参阅:

Redis Documentation: MGET

incr

public Long incr(@NonNull
                 CacheKey key)

为键 key 储存的数字值加上一。 如果键 key 不存在， 那么它的值会先被初始化为 0 ， 然后再执行 INCR 命令。 如果键 key 储存的值不能被解释为数字， 那么 INCR 命令将返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内。

提示： INCR 命令是一个针对字符串的操作。 因为 Redis 并没有专用的整数类型， 所以键 key 储存的值在执行 INCR 命令时会被解释为十进制 64 位有符号整数。

参数:

key - 一定不能为 null.

返回:

返回键 key 在执行加一操作之后的值。

另请参阅:

Redis Documentation: INCR

incrBy

public Long incrBy(@NonNull
                   CacheKey key,
                   long increment)

为键 key 储存的数字值加上增量 increment 。 如果键 key 不存在， 那么键 key 的值会先被初始化为 0 ， 然后再执行 INCRBY 命令。 如果键 key 储存的值不能被解释为数字， 那么 INCRBY 命令将返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内。 关于递增(increment) / 递减(decrement)操作的更多信息， 请参见 INCR 命令的文档。

参数:

key - 一定不能为 null.

increment - 增量值

返回:

返回键 key 在执行加上 increment ，操作之后的值。

另请参阅:

Redis Documentation: INCRBY

incrByFloat

public Double incrByFloat(@NonNull
                          CacheKey key,
                          double increment)

为键 key 储存的值加上浮点数增量 increment 。 如果键 key 不存在， 那么 INCRBYFLOAT 会先将键 key 的值设为 0 ， 然后再执行加法操作。 如果命令执行成功， 那么键 key 的值会被更新为执行加法计算之后的新值， 并且新值会以字符串的形式返回给调用者。

无论是键 key 的值还是增量 increment ， 都可以使用像 2.0e7 、 3e5 、 90e-2 那样的指数符号(exponential notation)来表示， 但是， 执行 INCRBYFLOAT 命令之后的值总是以同样的形式储存， 也即是， 它们总是由一个数字， 一个（可选的）小数点和一个任意长度的小数部分组成（比如 3.14 、 69.768 ，诸如此类)， 小数部分尾随的 0 会被移除， 如果可能的话， 命令还会将浮点数转换为整数（比如 3.0 会被保存成 3 ）。 此外， 无论加法计算所得的浮点数的实际精度有多长， INCRBYFLOAT 命令的计算结果最多只保留小数点的后十七位。

当以下任意一个条件发生时， 命令返回一个错误： 键 key 的值不是字符串类型(因为 Redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型）； 键 key 当前的值或者给定的增量 increment 不能被解释(parse)为双精度浮点数。

参数:

key - 一定不能为 null.

increment - 增量值

返回:

在加上增量 increment 之后， 键 key 的值。

另请参阅:

Redis Documentation: INCRBYFLOAT

getCounter

public Long getCounter(@NonNull
                       CacheKey key,
                       Long... defaultValue)

获取key中存放的Long值

参数:

key - 一定不能为 null.

返回:

key中存储的的数字

getCounter

public Long getCounter(@NonNull
                       CacheKey key,
                       Function<CacheKey,Long> loader)

获取key中存放的Long值

参数:

key - 一定不能为 null.

返回:

key中存储的的数字

decr

public Long decr(@NonNull
                 CacheKey key)

为键 key 储存的数字值减去一。 如果键 key 不存在， 那么键 key 的值会先被初始化为 0 ， 然后再执行 DECR 操作。 如果键 key 储存的值不能被解释为数字， 那么 DECR 命令将返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内。

参数:

key - 一定不能为 null.

返回:

在减去增量 1 之后， 键 key 的值。

另请参阅:

Redis Documentation: DECR

decrBy

public Long decrBy(@NonNull
                   CacheKey key,
                   long decrement)

将 key 所储存的值减去减量 decrement 。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECRBY 操作。 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内。

参数:

key - 一定不能为 null.

返回:

在减去增量 decrement 之后， 键 key 的值。

另请参阅:

Redis Documentation: DECR

hSet

public void hSet(@NonNull
                 String key,
                 @NonNull
                 Object field,
                 Object value,
                 boolean... cacheNullValues)

将哈希表 key 中的域 field 的值设为 value 。 如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。 如果域 field 已经存在于哈希表中，旧值将被覆盖。

参数:

key - 一定不能为 null.

field - 一定不能为 null.

cacheNullValues - 是否缓存空对象

value - 值

另请参阅:

Redis Documentation: HSET

hSet

public void hSet(@NonNull
                 CacheHashKey key,
                 Object value,
                 boolean... cacheNullValues)

将哈希表 key 中的域 field 的值设为 value 。 如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。 如果域 field 已经存在于哈希表中，旧值将被覆盖。

参数:

key - 一定不能为 null.

value - 值

cacheNullValues - 是否缓存空对象

另请参阅:

Redis Documentation: HSET

hGet

@Nullable
public <T> T hGet(@NonNull
                            String key,
                            @NonNull
                            Object field,
                            boolean... cacheNullValues)

返回哈希表 key 中给定域 field 的值。

参数:

key - 一定不能为 null.

field - 一定不能为 null.

cacheNullValues - 是否缓存空值

返回:

默认情况下返回给定域的值, 如果给定域不存在于哈希表中， 又或者给定的哈希表并不存在， 那么命令返回 nil

另请参阅:

Redis Documentation: HGET

hGet

@Nullable
public <T> T hGet(@NonNull
                            String key,
                            @NonNull
                            Object field,
                            BiFunction<String,Object,T> loader,
                            boolean... cacheNullValues)

返回哈希表 key 中给定域 field 的值。

参数:

key - 一定不能为 null.

field - 一定不能为 null.

loader - 加载器

cacheNullValues - 是否缓存空值

返回:

默认情况下返回给定域的值, 如果给定域不存在于哈希表中， 又或者给定的哈希表并不存在， 那么命令返回 nil

另请参阅:

Redis Documentation: HGET

hGet

@Nullable
public <T> T hGet(@NonNull
                            CacheHashKey key,
                            boolean... cacheNullValues)

返回哈希表 key 中给定域 field 的值。

参数:

key - 一定不能为 null.

cacheNullValues - 是否缓存空值

返回:

默认情况下返回给定域的值, 如果给定域不存在于哈希表中， 又或者给定的哈希表并不存在， 那么命令返回 nil

另请参阅:

Redis Documentation: HGET

hGet

@Nullable
public <T> T hGet(@NonNull
                            CacheHashKey key,
                            Function<CacheHashKey,T> loader,
                            boolean... cacheNullValues)

返回哈希表 key 中给定域 field 的值。

参数:

key - 一定不能为 null.

cacheNullValues - 是否缓存空值

loader - 加载器

返回:

默认情况下返回给定域的值, 如果给定域不存在于哈希表中， 又或者给定的哈希表并不存在， 那么命令返回 nil

另请参阅:

Redis Documentation: HGET

hExists

public Boolean hExists(@NonNull
                       String key,
                       @NonNull
                       Object field)

检查给定域 field 是否存在于哈希表 hash 当中

参数:

key - 一定不能为 null.

field - 一定不能为 null.

返回:

是否存在

另请参阅:

Redis Documentation: HEXISTS

hExists

public Boolean hExists(@NonNull
                       CacheHashKey cacheHashKey)

检查给定域 field 是否存在于哈希表 hash 当中

参数:

cacheHashKey - 一定不能为 null.

返回:

是否存在

另请参阅:

Redis Documentation: HEXISTS

hDel

public Long hDel(@NonNull
                 String key,
                 Object... fields)

删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。

参数:

key - 一定不能为 null.

fields - 一定不能为 null.

返回:

删除的数量

另请参阅:

Redis Documentation: HDEL

hDel

public Long hDel(@NonNull
                 CacheHashKey key)

hLen

public Long hLen(@NonNull
                 String key)

返回哈希表 key 中域的数量。

参数:

key - 一定不能为 null.

返回:

哈希表中域的数量。

另请参阅:

Redis Documentation: HLEN

hStrLen

public Long hStrLen(@NonNull
                    String key,
                    @NonNull
                    Object field)

返回哈希表 key 中， 与给定域 field 相关联的值的字符串长度

参数:

key - 一定不能为 null.

field - 一定不能为 null.

返回:

返回哈希表 key 中， 与给定域 field 相关联的值的字符串长度。

另请参阅:

Redis Documentation: HSTRLEN

hIncrBy

public Long hIncrBy(@NonNull
                    CacheHashKey key,
                    long increment)

为哈希表 key 中的域 field 的值加上增量 increment 。 增量也可以为负数，相当于对给定域进行减法操作。 如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。 如果域 field 不存在，那么在执行命令前，域的值被初始化为 0 。 对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。 本操作的值被限制在 64 位(bit)有符号数字表示之内。

参数:

key - 一定不能为 null.

increment - 增量

返回:

执行 HINCRBY 命令之后，哈希表 key 中域 field 的值

另请参阅:

Redis Documentation: HINCRBY

hIncrByFloat

public Double hIncrByFloat(@NonNull
                           CacheHashKey key,
                           double increment)

为哈希表 key 中的域 field 加上浮点数增量 increment 。 如果哈希表中没有域 field ，那么 HINCRBYFLOAT 会先将域 field 的值设为 0 ，然后再执行加法操作。 如果键 key 不存在，那么 HINCRBYFLOAT 会先创建一个哈希表，再创建域 field ，最后再执行加法操作。 当以下任意一个条件发生时，返回一个错误： 1:域 field 的值不是字符串类型(因为 redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型） 2:域 field 当前的值或给定的增量 increment 不能解释(parse)为双精度浮点数(double precision floating point number) HINCRBYFLOAT 命令的详细功能和 INCRBYFLOAT 命令类似，请查看 INCRBYFLOAT 命令获取更多相关信息。

参数:

key - 一定不能为 null.

increment - 增量

返回:

执行 HINCRBY 命令之后，哈希表 key 中域 field 的值

另请参阅:

Redis Documentation: HINCRBYFLOAT

hmSet

public <K,V> void hmSet(@NonNull
                        String key,
                        @NonNull
                        Map<K,V> hash,
                        boolean... cacheNullValues)

同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。 如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。

参数:

key - 一定不能为 null.

hash - 一定不能为 null.

cacheNullValues - 是否缓存空值

另请参阅:

Redis Documentation: hmset

hmGet

public List<Object> hmGet(@NonNull
                          String key,
                          @NonNull
                          Object... fields)

返回哈希表 key 中，一个或多个给定域的值。 如果给定的域不存在于哈希表，那么返回一个 nil 值。 因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。

参数:

key - 一定不能为 null.

fields - 一定不能为 null.

另请参阅:

Redis Documentation: hmget

hmGet

public List<Object> hmGet(@NonNull
                          String key,
                          @NonNull
                          Collection<Object> fields)

返回哈希表 key 中，一个或多个给定域的值。 如果给定的域不存在于哈希表，那么返回一个 nil 值。 因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。

参数:

key - 一定不能为 null.

fields - 一定不能为 null.

另请参阅:

Redis Documentation: hmget

hKeys

public <HK> Set<HK> hKeys(@NonNull
                          String key)

返回哈希表 key 中的所有域。

参数:

key - 一定不能为 null.

返回:

所有的 filed

另请参阅:

Redis Documentation: hkeys

hVals

public <HV> List<HV> hVals(@NonNull
                           String key)

返回哈希表 key 中所有域的值。

参数:

key - 一定不能为 null.

返回:

一个包含哈希表中所有值的表。

另请参阅:

Redis Documentation: hvals

hGetAll

public <K,V> Map<K,V> hGetAll(@NonNull
                              String key)

返回哈希表 key 中，所有的域和值。 在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。

参数:

key - 一定不能为 null.

返回:

以列表形式返回哈希表的域和域的值

另请参阅:

Redis Documentation: hgetall

hGetAll

public <K,V> Map<K,V> hGetAll(@NonNull
                              CacheHashKey key)

hGetAll

@Nullable
public <K,V> Map<K,V> hGetAll(@NonNull
                                        CacheHashKey key,
                                        Function<CacheHashKey,Map<K,V>> loader,
                                        boolean... cacheNullValues)

返回哈希表 key 中给定域 field 的值。

参数:

key - 一定不能为 null.

cacheNullValues - 是否缓存空值

loader - 加载器

返回:

默认情况下返回给定域的值, 如果给定域不存在于哈希表中， 又或者给定的哈希表并不存在， 那么命令返回 nil

另请参阅:

Redis Documentation: HGET

lPush

@Nullable
public Long lPush(@NonNull
                            String key,
                            Object... values)

将一个或多个值 value 插入到列表 key 的表头 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头： 比如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a ，这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。 当 key 存在但不是列表类型时，返回一个错误。

参数:

key - 一定不能为 null.

values - 值

返回:

返回列表的长度

另请参阅:

Redis Documentation: LPUSH

lPush

@Nullable
public Long lPush(@NonNull
                            String key,
                            Collection<Object> values)

将一个或多个值 value 插入到列表 key 的表头 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头： 比如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a ，这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。 当 key 存在但不是列表类型时，返回一个错误。

参数:

key - 一定不能为 null.

values - 值

返回:

返回列表的长度

另请参阅:

Redis Documentation: LPUSH

lPushX

@Nullable
public Long lPushX(@NonNull
                             String key,
                             Object values)

将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。 和 LPUSH key value [value …] 命令相反，当 key 不存在时， LPUSHX 命令什么也不做

参数:

key - 一定不能为 null.

values - 值

返回:

返回列表的长度

另请参阅:

Redis Documentation: LPUSHX

rPush

@Nullable
public Long rPush(@NonNull
                            String key,
                            Object... values)

将一个或多个值 value 插入到列表 key 的表尾(最右边)。 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾：比如对一个空列表 mylist 执行 RPUSH mylist a b c ，得出的结果列表为 a b c ，等同于执行命令 RPUSH mylist a 、 RPUSH mylist b 、 RPUSH mylist c 。 如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。 当 key 存在但不是列表类型时，返回一个错误。

参数:

key - 一定不能为 null.

values - 值

返回:

返回列表的长度

另请参阅:

Redis Documentation: RPUSH

rPush

@Nullable
public Long rPush(@NonNull
                            String key,
                            Collection<Object> values)

将一个或多个值 value 插入到列表 key 的表尾(最右边)。 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾：比如对一个空列表 mylist 执行 RPUSH mylist a b c ，得出的结果列表为 a b c ，等同于执行命令 RPUSH mylist a 、 RPUSH mylist b 、 RPUSH mylist c 。 如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。 当 key 存在但不是列表类型时，返回一个错误。

参数:

key - 一定不能为 null.

values - 值

返回:

返回列表的长度

另请参阅:

Redis Documentation: RPUSH

rPushX

@Nullable
public Long rPushX(@NonNull
                             String key,
                             Object value)

将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。

和 RPUSH key value [value …] 命令相反，当 key 不存在时， RPUSHX 命令什么也不做。

参数:

key - 一定不能为 null.

value - 值

返回:

返回列表的长度

另请参阅:

Redis Documentation: RPUSHX

lPop

@Nullable
public <T> T lPop(@NonNull
                            String key)

移除并返回列表 key 的头元素

参数:

key - 一定不能为 null.

返回:

列表的头元素。 当 key 不存在时，返回 nil 。

另请参阅:

Redis Documentation: LPOP

rPop

public <T> T rPop(@NonNull
                  String key)

移除并返回列表 key 的尾元素。

参数:

key - 一定不能为 null.

返回:

列表的尾元素。 当 key 不存在时，返回 nil 。

另请参阅:

Redis Documentation: RPOP

rPoplPush

public <T> T rPoplPush(String sourceKey,
                       String destinationKey)

命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作： 1.将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。 2. 将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。

举个例子，你有两个列表 source 和 destination ， source 列表有元素 a, b, c ， destination 列表有元素 x, y, z ， 执行 RPOPLPUSH source destination 之后， source 列表包含元素 a, b ， destination 列表包含元素 c, x, y, z ，并且元素 c 会被返回给客户端。

如果 source 不存在，值 nil 被返回，并且不执行其他动作。 如果 source 和 destination 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转(rotation)操作。

参数:

sourceKey - 一定不能为 null.

destinationKey - 一定不能为 null.

返回:

被弹出的元素

另请参阅:

Redis Documentation: RPOPLPUSH

lRem

@Nullable
public Long lRem(@NonNull
                           String key,
                           long count,
                           Object value)

根据参数 count 的值，移除列表中与参数 value 相等的元素。

count 的值可以是以下几种： count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。 count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。 count = 0 : 移除表中所有与 value 相等的值。

参数:

key - 一定不能为 null.

count - 数量

value - 值

返回:

被移除元素的数量。 因为不存在的 key 被视作空表(empty list)，所以当 key 不存在时， LREM 命令总是返回 0 。

另请参阅:

Redis Documentation: LREM

lLen

@Nullable
public Long lLen(@NonNull
                           String key)

返回列表 key 的长度。 如果 key 不存在，则 key 被解释为一个空列表，返回 0 . 如果 key 不是列表类型，返回一个错误。

参数:

key - 一定不能为 null.

返回:

{列表 key 的长度

另请参阅:

Redis Documentation: LLEN

lIndex

@Nullable
public <T> T lIndex(@NonNull
                              String key,
                              long index)

返回列表 key 中，下标为 index 的元素。 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。 如果 key 不是列表类型，返回一个错误。

参数:

key - 一定不能为 null.

index - 索引

返回:

列表中下标为 index 的元素。 如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil 。

另请参阅:

Redis Documentation: LINDEX

lInsert

@Nullable
public Long lInsert(@NonNull
                              String key,
                              Object pivot,
                              Object value)

将值 value 插入到列表 key 当中，位于值 pivot 之前。 当 pivot 不存在于列表 key 时，不执行任何操作。 当 key 不存在时， key 被视为空列表，不执行任何操作。 如果 key 不是列表类型，返回一个错误。

参数:

key - 一定不能为 null.

pivot - 对比值

value - 值

返回:

如果命令执行成功，返回插入操作完成之后，列表的长度。 如果没有找到 pivot ，返回 -1 。 如果 key 不存在或为空列表，返回 0 。

另请参阅:

Redis Documentation: LINSERT

rInsert

@Nullable
public Long rInsert(@NonNull
                              String key,
                              Object pivot,
                              Object value)

将值 value 插入到列表 key 当中，位于值 pivot 之后。 当 pivot 不存在于列表 key 时，不执行任何操作。 当 key 不存在时， key 被视为空列表，不执行任何操作。 如果 key 不是列表类型，返回一个错误。

参数:

key - 一定不能为 null.

pivot - 对比值

value - 值

返回:

如果命令执行成功，返回插入操作完成之后，列表的长度。 如果没有找到 pivot ，返回 -1 。 如果 key 不存在或为空列表，返回 0 。

另请参阅:

Redis Documentation: LINSERT

lSet

public void lSet(@NonNull
                 String key,
                 long index,
                 Object value)

将列表 key 下标为 index 的元素的值设置为 value 。 当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。 关于列表下标的更多信息，请参考 LINDEX 命令。

参数:

key - 一定不能为 null.

index - 下标

value - 值

另请参阅:

Redis Documentation: LSET

lRange

@Nullable
public List<Object> lRange(@NonNull
                                     String key,
                                     long start,
                                     long end)

返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

 例子：
 获取 list 中所有数据：lRange(key, 0, -1);
 获取 list 中下标 1 到 3 的数据： lRange(key, 1, 3);
 

如果 start 下标比列表的最大下标 end ( LLEN list 减去 1 )还要大，那么 LRANGE 返回一个空列表。 如果 stop 下标比 end 下标还要大，Redis将 stop 的值设置为 end 。

参数:

key - 一定不能为 null.

start - 开始索引

end - 结束索引

返回:

一个列表，包含指定区间内的元素。

另请参阅:

Redis Documentation: LRANGE

lTrim

public void lTrim(@NonNull
                  String key,
                  long start,
                  long end)

对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。 举个例子，执行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。 当 key 不是列表类型时，返回一个错误。

参数:

key - 一定不能为 null.

start - 开始索引

end - 结束索引

另请参阅:

Redis Documentation: LTRIM

sAdd

public <V> Long sAdd(@NonNull
                     CacheKey key,
                     V... members)

将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。 假如 key 不存在，则创建一个只包含 member 元素作成员的集合。 当 key 不是集合类型时，返回一个错误。

参数:

key - 一定不能为 null.

members - 元素

返回:

被添加到集合中的新元素的数量，不包括被忽略的元素。

另请参阅:

Redis Documentation: SADD

sAdd

public <V> Long sAdd(@NonNull
                     CacheKey key,
                     Collection<V> members)

将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。 假如 key 不存在，则创建一个只包含 member 元素作成员的集合。 当 key 不是集合类型时，返回一个错误。

参数:

key - 一定不能为 null.

members - 元素

返回:

被添加到集合中的新元素的数量，不包括被忽略的元素。

另请参阅:

Redis Documentation: SADD

sIsMember

public Boolean sIsMember(@NonNull
                         CacheKey key,
                         Object member)

判断 member 元素是否集合 key 的成员。

参数:

key - 一定不能为 null.

member - 元素

返回:

如果 member 元素是集合的成员，返回 1 。 如果 member 元素不是集合的成员，或 key 不存在，返回 0 。

另请参阅:

Redis Documentation: SISMEMBER

sPop

@Nullable
public <T> T sPop(@NonNull
                            CacheKey key)

移除并返回集合中的一个随机元素。 如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER 命令。

参数:

key - 一定不能为 null.

返回:

被移除的随机元素。 当 key 不存在或 key 是空集时，返回 nil 。

另请参阅:

Redis Documentation: SPOP

sRandMember

@Nullable
public <T> T sRandMember(@NonNull
                                   CacheKey key)

返回集合中的一个随机元素。

参数:

key - 一定不能为 null.

返回:

只提供 key 参数时，返回一个元素；如果集合为空，返回 nil

另请参阅:

Redis Documentation: SRANDMEMBER

sRandMember

@Nullable
public <V> Set<V> sRandMember(@NonNull
                                        CacheKey key,
                                        long count)

返回集合中的count个随机元素。

如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。

参数:

key - 一定不能为 null.

count - 数量

返回:

只提供 key 参数时，返回一个元素；如果集合为空，返回 nil

另请参阅:

Redis Documentation: SRANDMEMBER

sRandMembers

@Nullable
public <V> List<V> sRandMembers(@NonNull
                                          CacheKey key,
                                          long count)

返回集合中的count个随机元素。

如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。

参数:

key - 一定不能为 null.

count - 数量

返回:

只提供 key 参数时，返回一个元素；如果集合为空，返回 nil

另请参阅:

Redis Documentation: SRANDMEMBER

sRem

@Nullable
public Long sRem(@NonNull
                           CacheKey key,
                           Object... members)

移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。 当 key 不是集合类型，返回一个错误。

参数:

key - 一定不能为 null.

members - 元素

返回:

被成功移除的元素的数量，不包括被忽略的元素

另请参阅:

Redis Documentation: SREM

sMove

public <V> Boolean sMove(@NonNull
                         CacheKey sourceKey,
                         CacheKey destinationKey,
                         V value)

将 member 元素从 source 集合移动到 destination 集合。 SMOVE 是原子性操作。 如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 0 。否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。 当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。 当 source 或 destination 不是集合类型时，返回一个错误。

参数:

sourceKey - 源key

destinationKey - 目的key

value - 值

返回:

是否成功

另请参阅:

Redis Documentation: SMOVE

sCard

public Long sCard(@NonNull
                  CacheKey key)

返回集合 key 的基数(集合中元素的数量)。

参数:

key - 一定不能为 null.

返回:

集合的基数。 当 key 不存在时，返回 0 。

另请参阅:

Redis Documentation: SCARD

sMembers

@Nullable
public <V> Set<V> sMembers(@NonNull
                                     CacheKey key)

返回集合 key 中的所有成员。 不存在的 key 被视为空集合。

参数:

key - 一定不能为 null.

返回:

集合中的所有成员。

另请参阅:

Redis Documentation: SMEMBERS

sInter

@Nullable
public <V> Set<V> sInter(@NonNull
                                   CacheKey key,
                                   @NonNull
                                   CacheKey otherKey)

返回一个集合的全部成员，该集合是所有给定集合的交集。

不存在的 key 被视为空集。

当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。

参数:

key - 一定不能为null.

otherKey - 一定不能为 null.

返回:

交集成员的列表。

另请参阅:

Redis Documentation: SINTER

sInter

@Nullable
public Set<Object> sInter(@NonNull
                                    CacheKey key,
                                    Collection<CacheKey> otherKeys)

返回一个集合的全部成员，该集合是所有给定集合的交集。

不存在的 key 被视为空集。

当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。

参数:

key - 一定不能为null.

otherKeys - 一定不能为 null.

返回:

交集成员的列表。

另请参阅:

Redis Documentation: SINTER

sInter

@Nullable
public <V> Set<V> sInter(Collection<CacheKey> otherKeys)

返回一个集合的全部成员，该集合是所有给定集合的交集。

不存在的 key 被视为空集。

当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。

参数:

otherKeys - 一定不能为 null.

返回:

交集成员的列表。

另请参阅:

Redis Documentation: SINTER

sInterStore

@Nullable
public Long sInterStore(@NonNull
                                  CacheKey key,
                                  @NonNull
                                  CacheKey otherKey,
                                  @NonNull
                                  CacheKey destKey)

这个命令类似于 SINTER key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。 如果 destination 集合已经存在，则将其覆盖。 destination 可以是 key 本身。

参数:

key - 一定不能为null.

otherKey - 一定不能为 null.

destKey - 一定不能为null.

返回:

结果集中的成员数量。

另请参阅:

Redis Documentation: SINTERSTORE

sInterStore

@Nullable
public Long sInterStore(@NonNull
                                  CacheKey key,
                                  @NonNull
                                  Collection<CacheKey> otherKeys,
                                  @NonNull
                                  CacheKey destKey)

这个命令类似于 SINTER key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。 如果 destination 集合已经存在，则将其覆盖。 destination 可以是 key 本身。

参数:

key - 一定不能为null.

otherKeys - 一定不能为 null.

destKey - 一定不能为null.

返回:

结果集中的成员数量。

另请参阅:

Redis Documentation: SINTERSTORE

sInterStore

@Nullable
public Long sInterStore(Collection<CacheKey> otherKeys,
                                  @NonNull
                                  CacheKey destKey)

这个命令类似于 SINTER key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。 如果 destination 集合已经存在，则将其覆盖。 destination 可以是 key 本身。

参数:

otherKeys - 一定不能为 null.

destKey - 一定不能为null.

返回:

结果集中的成员数量。

另请参阅:

Redis Documentation: SINTERSTORE

sUnion

@Nullable
public <V> Set<V> sUnion(@NonNull
                                   CacheKey key,
                                   @NonNull
                                   CacheKey otherKey)

返回多个集合的并集，多个集合由 keys 指定 不存在的 key 被视为空集。

参数:

key - 一定不能为 null.

otherKey - 一定不能为 null.

返回:

null when used in pipeline / transaction.

另请参阅:

Redis Documentation: SUNION

sUnion

@Nullable
public <V> Set<V> sUnion(@NonNull
                                   CacheKey key,
                                   Collection<CacheKey> otherKeys)

返回多个集合的并集，多个集合由 keys 指定 不存在的 key 被视为空集。

参数:

key - 一定不能为 null.

otherKeys - 一定不能为 null.

返回:

null when used in pipeline / transaction.

另请参阅:

Redis Documentation: SUNION

sUnion

@Nullable
public <V> Set<V> sUnion(Collection<CacheKey> otherKeys)

返回多个集合的并集，多个集合由 keys 指定 不存在的 key 被视为空集。

参数:

otherKeys - 一定不能为 null.

返回:

null when used in pipeline / transaction.

另请参阅:

Redis Documentation: SUNION

sUnionStore

public Long sUnionStore(@NonNull
                        CacheKey key,
                        @NonNull
                        CacheKey otherKey,
                        @NonNull
                        CacheKey distKey)

这个命令类似于 SUNION key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。 如果 destination 已经存在，则将其覆盖。 destination 可以是 key 本身。

参数:

key - 一定不能为 null.

otherKey - 一定不能为 null.

distKey - 一定不能为 null.

返回:

null when used in pipeline / transaction.

另请参阅:

Redis Documentation: SUNIONSTORE

sUnionStore

public Long sUnionStore(Collection<CacheKey> otherKeys,
                        @NonNull
                        CacheKey distKey)

这个命令类似于 SUNION key [key …] 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。 如果 destination 已经存在，则将其覆盖。 destination 可以是 key 本身。

参数:

otherKeys - 一定不能为 null.

distKey - 一定不能为 null.

返回:

null when used in pipeline / transaction.

另请参阅:

Redis Documentation: SUNIONSTORE

sDiff

@Nullable
public <V> Set<V> sDiff(@NonNull
                                  CacheKey key,
                                  @NonNull
                                  CacheKey otherKey)

返回一个集合的全部成员，该集合是所有给定集合之间的差集。 不存在的 key 被视为空集。

参数:

key - 一定不能为 null.

otherKey - 一定不能为 null.

返回:

一个包含差集成员的列表。

另请参阅:

Redis Documentation: SDIFF

sDiff

public <V> Set<V> sDiff(Collection<CacheKey> otherKeys)

返回一个集合的全部成员，该集合是所有给定集合之间的差集。 不存在的 key 被视为空集。

参数:

otherKeys - 一定不能为 null.

返回:

一个包含差集成员的列表。

另请参阅:

Redis Documentation: SDIFF

sDiffStore

public Long sDiffStore(@NonNull
                       CacheKey key,
                       @NonNull
                       CacheKey otherKey,
                       @NonNull
                       CacheKey distKey)

这个命令的作用和 SDIFF key [key …] 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。 如果 destination 集合已经存在，则将其覆盖。 destination 可以是 key 本身。

参数:

key - 一定不能为 null.

distKey - 一定不能为 null.

otherKey - 一定不能为 null.

返回:

结果集中的元素数量。。

另请参阅:

Redis Documentation: sdiffstore

sDiffStore

public Long sDiffStore(Collection<CacheKey> otherKeys,
                       @NonNull
                       CacheKey distKey)

返回一个集合的全部成员，该集合是所有给定集合之间的差集。 不存在的 key 被视为空集。

参数:

otherKeys - 一定不能为 null.

返回:

结果集中的元素数量。

另请参阅:

Redis Documentation: sdiffstore

zAdd

public Boolean zAdd(@NonNull
                    String key,
                    Object member,
                    double score)

将一个或多个 member 元素及其 score 值加入到有序集 key 当中。 如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。 score 值可以是整数值或双精度浮点数。 如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。 当 key 存在但不是有序集类型时，返回一个错误。

参数:

key - 一定不能为 null.

score - 得分

member - 值

返回:

是否成功

另请参阅:

Redis Documentation: ZADD

zAdd

public Long zAdd(@NonNull
                 String key,
                 Map<Object,Double> scoreMembers)

将一个或多个 member 元素及其 score 值加入到有序集 key 当中。 如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。 score 值可以是整数值或双精度浮点数。 如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。 当 key 存在但不是有序集类型时，返回一个错误。

参数:

key - 一定不能为 null.

scoreMembers - 一定不能为 null.

返回:

被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。

另请参阅:

Redis Documentation: ZADD

zScore

public Double zScore(@NonNull
                     String key,
                     Object member)

返回有序集 key 中，成员 member 的 score 值。 如果 member 元素不是有序集 key 的成员，或 key 不存在，返回 nil 。

参数:

key - 一定不能为 null.

member - the value.

返回:

member 成员的 score 值，以字符串形式表示

另请参阅:

Redis Documentation: ZSCORE

zIncrBy

public Double zIncrBy(@NonNull
                      String key,
                      Object member,
                      double score)

为有序集 key 的成员 member 的 score 值加上增量 increment 。 可以通过传递一个负数值 increment ，让 score 减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。 当 key 不存在，或 member 不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。 当 key 不是有序集类型时，返回一个错误。 score 值可以是整数值或双精度浮点数。

参数:

key - 一定不能为 null.

score - 得分

member - the value.

返回:

member 成员的新 score 值

另请参阅:

Redis Documentation: ZINCRBY

zCard

public Long zCard(@NonNull
                  String key)

返回有序集 key 的基数。

参数:

key - 一定不能为 null.

返回:

当 key 存在且是有序集类型时，返回有序集的基数。 当 key 不存在时，返回 0 。

另请参阅:

Redis Documentation: ZCARD

zCount

public Long zCount(@NonNull
                   String key,
                   double min,
                   double max)

返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。

参数:

key - 一定不能为 null.

min - 最小值

max - 最大值

返回:

null when used in pipeline / transaction.

另请参阅:

Redis Documentation: ZCOUNT

zRange

@Nullable
public Set<Object> zRange(@NonNull
                                    String key,
                                    long start,
                                    long end)

返回有序集 key 中，指定区间内的成员。 其中成员的位置按 score 值递增(从小到大)来排序。 具有相同 score 值的成员按字典序(lexicographical order )来排列。

下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。

超出范围的下标并不会引起错误。 比如说，当 start 的值比有序集的最大下标还要大，或是 start > stop 时， ZRANGE 命令只是简单地返回一个空列表。 另一方面，假如 stop 参数的值比有序集的最大下标还要大，那么 Redis 将 stop 当作最大下标来处理。

可以通过使用 WITHSCORES 选项，来让成员和它的 score 值一并返回，返回列表以 value1,score1, ..., valueN,scoreN 的格式表示。 客户端库可能会返回一些更复杂的数据类型，比如数组、元组等

参数:

key - 一定不能为 null.

start - 索引

end - 索引

返回:

指定区间内，不带有 score 值(可选)的有序集成员的列表。

另请参阅:

Redis Documentation: ZRANGE

zRangeWithScores

@Nullable
public Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<Object>> zRangeWithScores(@NonNull
                                                                                                             String key,
                                                                                                             long start,
                                                                                                             long end)

返回有序集 key 中，指定区间内的成员。 其中成员的位置按 score 值递增(从小到大)来排序。 具有相同 score 值的成员按字典序(lexicographical order )来排列。

下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。

超出范围的下标并不会引起错误。 比如说，当 start 的值比有序集的最大下标还要大，或是 start > stop 时， ZRANGE 命令只是简单地返回一个空列表。 另一方面，假如 stop 参数的值比有序集的最大下标还要大，那么 Redis 将 stop 当作最大下标来处理。

可以通过使用 WITHSCORES 选项，来让成员和它的 score 值一并返回，返回列表以 value1,score1, ..., valueN,scoreN 的格式表示。 客户端库可能会返回一些更复杂的数据类型，比如数组、元组等

参数:

key - 一定不能为 null.

start - 索引

end - 索引

返回:

指定区间内，带有 score 值(可选)的有序集成员的列表。

另请参阅:

Redis Documentation: ZRANGE

zRevrange

@Nullable
public Set<Object> zRevrange(@NonNull
                                       String key,
                                       long start,
                                       long end)

返回有序集 key 中，指定区间内的成员。 其中成员的位置按 score 值递减(从大到小)来排列。 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)排列。 除了成员按 score 值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE key start stop [WITHSCORES] 命令一样。

参数:

key - 一定不能为 null.

start - 索引

end - 索引

返回:

指定区间内，不带有 score 值(可选)的有序集成员的列表。

另请参阅:

Redis Documentation: ZREVRANGE

zRevrangeWithScores

@Nullable
public Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<Object>> zRevrangeWithScores(@NonNull
                                                                                                                String key,
                                                                                                                long start,
                                                                                                                long end)

返回有序集 key 中，指定区间内的成员。 其中成员的位置按 score 值递减(从大到小)来排列。 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)排列。 除了成员按 score 值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE key start stop [WITHSCORES] 命令一样。

参数:

key - 一定不能为 null.

start - 索引

end - 索引

返回:

指定区间内，不带有 score 值(可选)的有序集成员的列表。

另请参阅:

Redis Documentation: ZREVRANGE

zRangeByScore

public Set<Object> zRangeByScore(@NonNull
                                 String key,
                                 double min,
                                 double max)

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。 有序集成员按 score 值递增(从小到大)次序排列。 具有相同 score 值的成员按字典序(lexicographical order)来排列(该属性是有序集提供的，不需要额外的计算)。

参数:

key - 一定不能为 null.

min - 最小得分

max - 最大得分

返回:

指定区间内 不带有 score 值(可选)的有序集成员的列表。

另请参阅:

Redis Documentation: ZRANGEBYSCORE

zRangeByScoreWithScores

public Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(@NonNull
                                                                                                          String key,
                                                                                                          double min,
                                                                                                          double max)

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。 有序集成员按 score 值递增(从小到大)次序排列。 具有相同 score 值的成员按字典序(lexicographical order)来排列(该属性是有序集提供的，不需要额外的计算)。

参数:

key - 一定不能为 null.

min - 最小得分

max - 最大得分

返回:

指定区间内，带有 score 值(可选)的有序集成员的列表。

另请参阅:

Redis Documentation: ZRANGEBYSCORE

zReverseRange

public Set<Object> zReverseRange(@NonNull
                                 String key,
                                 double min,
                                 double max)

返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order )排列。

参数:

key - 一定不能为 null.

min - 最小得分

max - 最大得分

返回:

指定区间内 不带有 score 值(可选)的有序集成员的列表。

另请参阅:

Redis Documentation: ZRANGEBYSCORE

zReverseRangeByScoreWithScores

public Set<org.springframework.data.redis.core.ZSetOperations.TypedTuple<Object>> zReverseRangeByScoreWithScores(@NonNull
                                                                                                                 String key,
                                                                                                                 double min,
                                                                                                                 double max)

返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order )排列。

参数:

key - 一定不能为 null.

min - 最小得分

max - 最大得分

返回:

指定区间内，带有 score 值(可选)的有序集成员的列表。

另请参阅:

Redis Documentation: ZRANGEBYSCORE

zRank

@Nullable
public Long zRank(@NonNull
                            String key,
                            Object member)

返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。 排名以 0 为底，也就是说， score 值最小的成员排名为 0 。 使用 ZREVRANK key member 命令可以获得成员按 score 值递减(从大到小)排列的排名。

参数:

key - 一定不能为 null.

member - the value.

返回:

如果 member 是有序集 key 的成员，返回 member 的排名。 如果 member 不是有序集 key 的成员，返回 nil 。

另请参阅:

Redis Documentation: ZRANK

zRevrank

public Long zRevrank(@NonNull
                     String key,
                     Object member)

返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。 排名以 0 为底，也就是说， score 值最大的成员排名为 0 。 使用 ZRANK 命令可以获得成员按 score 值递增(从小到大)排列的排名。

参数:

key - 一定不能为 null.

member - the value.

返回:

如果 member 是有序集 key 的成员，返回 member 的排名。 如果 member 不是有序集 key 的成员，返回 nil 。

另请参阅:

Redis Documentation: ZREVRANK

zRem

public Long zRem(@NonNull
                 String key,
                 Object... members)

移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。 当 key 存在但不是有序集类型时，返回一个错误。

参数:

key - 一定不能为 null.

members - 一定不能为 null.

返回:

被成功移除的成员的数量，不包括被忽略的成员

另请参阅:

Redis Documentation: ZREM

zRem

public Long zRem(@NonNull
                 String key,
                 long start,
                 long end)

移除有序集 key 中，指定排名(rank)区间内的所有成员。 区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内。 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。 你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。

参数:

key - 一定不能为 null.

start - 下标

end - 下标

返回:

被移除成员的数量。

另请参阅:

Redis Documentation: ZREMRANGEBYRANK

zRemRangeByScore

public Long zRemRangeByScore(@NonNull
                             String key,
                             double min,
                             double max)

移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。 自版本2.1.6开始， score 值等于 min 或 max 的成员也可以不包括在内

参数:

key - 一定不能为 null.

min - 最小得分

max - 最大得分

返回:

被移除成员的数量。

另请参阅:

Redis Documentation: ZREMRANGEBYSCORE