com.litongjava.redis

Class RedisDb

java.lang.Object

com.litongjava.redis.RedisDb

public class RedisDb
extends Object

Cache. Cache api 添加了中文注释，便于工程师更方便使用，另外还原样保持了 Jedis api 的方法名称及使用方法，以便于仅仅通过查看 Redis 文档 即可快速掌握使用方法 Redis 命令参考: http://redisdoc.com/ 注意：不要提供 strlen、append、setrange、getrange，经测试这类操作字符串的方法在序列化模式下无法工作 因为 String 序列化后的 value 值为会多出来一些额外的字符

Field Summary

Fields

Modifier and Type	Field and Description
protected redis.clients.jedis.JedisPool	jedisPool
protected IKeyNamingPolicy	keyNamingPolicy
protected String	name
protected ISerializer	serializer
protected ThreadLocal<redis.clients.jedis.Jedis>	threadLocalJedis

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	RedisDb()
	RedisDb(String name, redis.clients.jedis.JedisPool jedisPool, ISerializer serializer, IKeyNamingPolicy keyNamingPolicy)

Method Summary

Modifier and Type	Method and Description
List	blpop(int timeout, Object... keys) BLPOP 是列表的阻塞式(blocking)弹出原语。 它是 LPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。 参考：http://redisdoc.com/list/blpop.html 命令行：BLPOP key [key ...] timeout
List	brpop(int timeout, Object... keys) BRPOP 是列表的阻塞式(blocking)弹出原语。 它是 RPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BRPOP 命令阻塞，直到等待超时或发现可弹出元素为止。 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的尾部元素。 关于阻塞操作的更多信息，请查看 BLPOP 命令， BRPOP 除了弹出元素的位置和 BLPOP 不同之外，其他表现一致。 参考：http://redisdoc.com/list/brpop.html 命令行：BRPOP key [key ...] timeout
<R> R	call(java.util.function.Function<redis.clients.jedis.Jedis,R> jedis) 使用 lambda 开放 Jedis API，建议优先使用本方法
void	close(redis.clients.jedis.Jedis jedis)
Long	decr(Object key) 将 key 中储存的数字值减一。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内。 关于递增(increment) / 递减(decrement)操作的更多信息，请参见 INCR 命令。
Long	decrBy(Object key, long longValue) 将 key 所储存的值减去减量 decrement 。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECRBY 操作。 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内。 关于更多递增(increment) / 递减(decrement)操作的更多信息，请参见 INCR 命令。
Long	del(Object... keys) 删除给定的多个 key 不存在的 key 会被忽略。
Long	del(Object key) 删除给定的一个 key 不存在的 key 会被忽略。
Object	eval(String script)
Object	eval(String script, int keyCount, String... params)
Object	eval(String script, List<String> keys, List<String> args)
Object	evalsha(String sha1)
Object	evalsha(String sha1, int keyCount, String... params)
Object	evalsha(String sha1, List<String> keys, List<String> args)
boolean	exists(Object key) 检查给定 key 是否存在。
Long	expire(Object key, long seconds) 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。 在 Redis 中，带有生存时间的 key 被称为『易失的』(volatile)。
Long	expireAt(Object key, long unixTime) EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。
protected Object	fieldFromBytes(byte[] bytes)
protected void	fieldSetFromBytesSet(Set<byte[]> data, Set<Object> result)
protected byte[][]	fieldsToBytesArray(Object... fieldsArray)
protected byte[]	fieldToBytes(Object field)
String	flushAll() 删除所有 db 的所有数据
String	flushDB() 删除当前 db 所有数据
<T> T	get(Object key) 返回 key 所关联的 value 值 如果 key 不存在那么返回特殊值 nil 。
<R> R	getBean(String key, Class<R> type)
Long	getCounter(Object key) 获取记数器的值
Integer	getInt(String key)
redis.clients.jedis.Jedis	getJedis()
IKeyNamingPolicy	getKeyNamingPolicy()
Long	getLong(String key)
String	getName()
ISerializer	getSerializer()
<T> T	getSet(Object key, Object value) 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。 当 key 存在但不是字符串类型时，返回一个错误。
String	getStr(String key)
redis.clients.jedis.Jedis	getThreadLocalJedis()
boolean	hasKey(Object key) 检查给定 key 是否存在。
Long	hdel(Object key, Object... fields) 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
Long	hdelRaw(String key, String... fields)
boolean	hexists(Object key, Object field) 查看哈希表 key 中，给定域 field 是否存在。
<T> T	hget(Object key, Object field) 返回哈希表 key 中给定域 field 的值。
Map	hgetAll(Object key) 返回哈希表 key 中，所有的域和值。 在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。
Long	hgetCounter(Object key, Object field) 获取哈希表内记数器的值
Double	hgetFloatCounter(Object key, Object field)
<R> List<R>	hgetList(String key, String field, Class<R> elementType)
String	hgetRawString(String key, String field) 返回哈希表 key 中给定域 field 的值。
Long	hincrBy(Object key, Object field, long value) 为哈希表 key 中的域 field 的值加上增量 increment 。 增量也可以为负数，相当于对给定域进行减法操作。 如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。 如果域 field 不存在，那么在执行命令前，域的值被初始化为 0 。 对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。 本操作的值被限制在 64 位(bit)有符号数字表示之内。
Double	hincrByFloat(Object key, Object field, double value) 为哈希表 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 命令获取更多相关信息。
Set<Object>	hkeys(Object key) 返回哈希表 key 中的所有域。 底层实现此方法取名为 hfields 更为合适，在此仅为与底层保持一致
Set<String>	hkeysRawString(String key)
Long	hlen(Object key) 返回哈希表 key 中域的数量。
List	hmget(Object key, Object... fields) 返回哈希表 key 中，一个或多个给定域的值。 如果给定的域不存在于哈希表，那么返回一个 nil 值。 因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。
List<String>	hmget(String key, String... fields) 返回哈希表 key 中，一个或多个给定域的值。 如果给定的域不存在于哈希表，那么返回一个 nil 值。 因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。
String	hmgetRawString(String key, String field) 返回哈希表 key 中给定域 field 的值。
String	hmset(Object key, Map<Object,Object> hash) 同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。 如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。
String	hmsetRawString(String key, Map<String,String> hash)
Long	hset(Object key, Object field, Object value) 将哈希表 key 中的域 field 的值设为 value 。 如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。 如果域 field 已经存在于哈希表中，旧值将被覆盖。
Long	hsetList(String key, String field, List<?> list)
Long	hsetList(String key, String field, List<?> list, long seconds)
Long	hsetRawString(String key, String field, String value) Sets the value of a field in a hash stored at key.
List	hvals(Object key) 返回哈希表 key 中所有域的值。
Long	incr(Object key) 将 key 中储存的数字值增一。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内。
Long	incrBy(Object key, long longValue) 将 key 所储存的值加上增量 increment 。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCRBY 命令。 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内。 关于递增(increment) / 递减(decrement)操作的更多信息，参见 INCR 命令。
protected Object	keyFromBytes(byte[] bytes)
Set<String>	keys(String pattern) 查找所有符合给定模式 pattern 的 key 。 KEYS * 匹配数据库中所有 key 。 KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。 KEYS h*llo 匹配 hllo 和 heeeeello 等。 KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。 特殊符号用 \ 隔开
protected byte[][]	keysToBytesArray(Object... keys)
protected byte[]	keyToBytes(Object key)
protected List	keyValueListFromBytesList(List<byte[]> data)
<T> T	lindex(Object key, long index) 返回列表 key 中，下标为 index 的元素。 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。 如果 key 不是列表类型，返回一个错误。
Long	llen(Object key) 返回列表 key 的长度。 如果 key 不存在，则 key 被解释为一个空列表，返回 0 .
String	lock(String name, int secondsToExpire, int secondsToTimeout) 利用 set 方法实现锁
<T> T	lpop(Object key) 移除并返回列表 key 的头元素。
Long	lpush(Object 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 存在但不是列表类型时，返回一个错误。
Long	lpushx(Object key, Object... values) 将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。 和 LPUSH key value [value …] 命令相反，当 key 不存在时， LPUSHX 命令什么也不做。
List	lrange(Object key, long start, long end) 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
Long	lrem(Object key, long count, Object value) 根据参数 count 的值，移除列表中与参数 value 相等的元素。 count 的值可以是以下几种： count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。 count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。 count = 0 : 移除表中所有与 value 相等的值。
String	lset(Object key, long index, Object value) 将列表 key 下标为 index 的元素的值设置为 value 。 当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。 关于列表下标的更多信息，请参考 LINDEX 命令。
String	ltrim(Object key, long start, long end) 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。 举个例子，执行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。 当 key 不是列表类型时，返回一个错误。
List	mget(Object... keys) 返回所有(一个或多个)给定 key 的值。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil 。因此，该命令永不失败。
String	migrate(String host, int port, Object key, int destinationDb, int timeout) 将 key 原子性地从当前实例传送到目标实例的指定数据库上，一旦传送成功， key 保证会出现在目标实例上，而当前实例上的 key 会被删除。
Long	move(Object key, int dbIndex) 将当前数据库的 key 移动到给定的数据库 db 当中。 如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。 因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)。
String	mset(Object... keysValues) 同时设置一个或多个 key-value 对。 如果某个给定 key 已经存在，那么 MSET 会用新值覆盖原来的旧值，如果这不是你所希望的效果，请考虑使用 MSETNX 命令：它只会在所有给定 key 都不存在的情况下进行设置操作。 MSET 是一个原子性(atomic)操作，所有给定 key 都会在同一时间内被设置，某些给定 key 被更新而另一些给定 key 没有改变的情况，不可能发生。
Long	msetnx(Object... keysValues) 当且仅当所有给定键都不存在时， 为所有给定键设置值。 即使只有一个给定键已经存在， MSETNX 命令也会拒绝执行对所有键的设置操作。 MSETNX 是一个原子性(atomic)操作， 所有给定键要么就全部都被设置， 要么就全部都不设置， 不可能出现第三种状态。
Long	objectIdletime(Object key) 对象没有被访问的空闲时间
Long	objectRefcount(Object key) 对象被引用的数量
Long	persist(Object key) 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。
Long	pexpire(Object key, long milliseconds) 这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令那样，以秒为单位。
Long	pexpireAt(Object key, long millisecondsTimestamp) 这个命令和 EXPIREAT 命令类似，但它以毫秒为单位设置 key 的过期 unix 时间戳，而不是像 EXPIREAT 那样，以秒为单位。
String	ping() 使用客户端向 Redis 服务器发送一个 PING ，如果服务器运作正常的话，会返回一个 PONG 。 通常用于测试与服务器的连接是否仍然生效，或者用于测量延迟值。
String	psetex(Object key, long milliseconds, Object value) psetex 与 setex 功能相同，但是生存时间为 milliseconds (以毫秒为单位)。
void	psubscribe(redis.clients.jedis.JedisPubSub jedisPubSub, String... patterns) psubscribe pattern [pattern …] 订阅给定模式相匹配的所有频道 PS： 取消订阅在 jedisPubSub 中的 punsubscribe 方法。 重要：订阅后代码会阻塞监听发布的内容
redis.clients.jedis.JedisPubSub	psubscribeThread(redis.clients.jedis.JedisPubSub jedisPubSub, String... patterns) psubscribe pattern [pattern …] 订阅给定模式相匹配的所有频道 PS： 取消订阅在 jedisPubSub 中的 punsubscribe 方法。
Long	pttl(Object key) 这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间，而不是像 TTL 命令那样，以秒为单位。
Long	publish(String channel, String message) publish channel message 给指定的频道发消息
String	randomKey() 从当前数据库中随机返回(不删除)一个 key 。
void	removeThreadLocalJedis()
String	rename(Object oldkey, Object newkey) 将 key 改名为 newkey 。 当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。 当 newkey 已经存在时， RENAME 命令将覆盖旧值。
Long	renamenx(Object oldkey, Object newkey) 当且仅当 newkey 不存在时，将 key 改名为 newkey 修改成功时，返回 1 ； 如果 newkey 已经存在，返回 0
<T> T	rpop(Object key) 移除并返回列表 key 的尾元素。
<T> T	rpoplpush(Object srcKey, Object dstKey) 命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作： 将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端。 将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。
Long	rpush(Object 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 存在但不是列表类型时，返回一个错误。
Long	rpushx(Object key, Object... values) 将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。 和 RPUSH key value [value …] 命令相反，当 key 不存在时， RPUSHX 命令什么也不做。
Long	sadd(Object key, Object... members) 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。 假如 key 不存在，则创建一个只包含 member 元素作成员的集合。 当 key 不是集合类型时，返回一个错误。
void	scan(Integer cursor, Func.F11<List<String>,Boolean> keyList)
void	scan(Integer cursor, String pattern, Func.F11<List<String>,Boolean> keyList)
void	scan(Integer cursor, String pattern, Integer count, Func.F11<List<String>,Boolean> keyList) scan 命令查找符合给定模式 pattern 的 key
Long	scard(Object key) 返回集合 key 的基数(集合中元素的数量)。
List<Boolean>	scriptExists(String... sha1)
Boolean	scriptExists(String sha1)
String	scriptLoad(String script)
Set	sdiff(Object... keys) 返回一个集合的全部成员，该集合是所有给定集合之间的差集。 不存在的 key 被视为空集。
String	select(int databaseIndex) 切换到指定的数据库，数据库索引号 index 用数字值指定，以 0 作为起始索引值。 默认使用 0 号数据库。 注意：在 Jedis 对象被关闭时，数据库又会重新被设置为初始值，所以本方法 select(...) 正常工作需要使用如下方式之一： 1：使用 RedisInterceptor，在本线程内共享同一个 Jedis 对象 2：使用 Redis.call(ICallback) 进行操作 3：自行获取 Jedis 对象进行操作
String	set(Object key, Object value) 存放 key value 对到 redis 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。 对于某个原本带有生存时间（TTL）的键来说， 当 SET 命令成功在这个键上执行时， 这个键原有的 TTL 将被清除。
String	set(String key, long seconds, String input)
String	setBean(String key, long seconds, Object input)
String	setBean(String key, Object input)
String	setex(Object key, long seconds, Object value) 存放 key value 对到 redis，并将 key 的生存时间设为 seconds (以秒为单位)。 如果 key 已经存在， SETEX 命令将覆写旧值。
Boolean	setIfAbsent(Object key, Object value) Set key to hold the string value if key is absent.
Boolean	setIfAbsent(Object key, Object value, long timeout) Set key to hold the string value and expiration timeout if key is absent.
Boolean	setIfPresent(Object key, Object value) Set key to hold the string value if key is present.
Boolean	setIfPresent(Object key, Object value, long timeout, TimeUnit unit) Set key to hold the string value and expiration timeout if key is present.
String	setInt(String key, int value)
String	setInt(String key, long seconds, int value)
String	setLong(String key, long value)
String	setLong(String key, long seconds, long value)
Long	setnx(Object key, Object value) setnx 的工作原理与 set 完全相同，唯一的区别是，如果 key 已经存在，则不执行任何操作
Boolean	setRawIfAbsent(String key, String value)
Boolean	setRawIfAbsent(String key, String value, long timeout)
Boolean	setRawIfPresent(String key, String value)
Boolean	setRawIfPresent(String key, String value, long timeout, TimeUnit unit)
String	setStr(String key, String input)
void	setThreadLocalJedis(redis.clients.jedis.Jedis jedis)
Set	sinter(Object... keys) 返回多个集合的交集，多个集合由 keys 指定
boolean	sismember(Object key, Object member) 判断 member 元素是否集合 key 的成员。
Set	smembers(Object key) 返回集合 key 中的所有成员。 不存在的 key 被视为空集合。
<T> T	spop(Object key) 移除并返回集合中的一个随机元素。 如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER 命令。
<T> T	srandmember(Object key) 返回集合中的一个随机元素。
List	srandmember(Object key, int count) 返回集合中的 count 个随机元素。 从 Redis 2.6 版本开始， SRANDMEMBER 命令接受可选的 count 参数： 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。 如果 count 大于等于集合基数，那么返回整个集合。 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。 该操作和 SPOP 相似，但 SPOP 将随机元素从集合中移除并返回，而 SRANDMEMBER 则仅仅返回随机元素，而不对集合进行任何改动。
Long	srem(Object key, Object... members) 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
void	subscribe(redis.clients.jedis.JedisPubSub jedisPubSub, String... channels) subscribe channel [channel …] 订阅一个或多个频道 PS： 取消订阅在 jedisPubSub 中的 unsubscribe 方法。 重要：订阅后代码会阻塞监听发布的内容
redis.clients.jedis.JedisPubSub	subscribeThread(redis.clients.jedis.JedisPubSub jedisPubSub, String... channels) subscribe channel [channel …] 订阅一个或多个频道 PS： 取消订阅在 jedisPubSub 中的 unsubscribe 方法。
Set	sunion(Object... keys) 返回多个集合的并集，多个集合由 keys 指定 不存在的 key 被视为空集。
Long	ttl(Object key) 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
List<Object>	tx(Func.F10<redis.clients.jedis.Transaction> tx)
List<Object>	tx(String watchKeys, Func.F10<redis.clients.jedis.Transaction> tx) redis 事务，返回值为非 null 时表示 redis 事务执行成功，否则执行失败 被监视的 watchKey 值发生变化时，事务将会执行失败
String	type(Object key) 返回 key 所储存的值的类型。
void	unlock(String name, String lockId) 释放锁
protected Object	valueFromBytes(byte[] bytes)
protected List	valueListFromBytesList(List<byte[]> data)
protected void	valueSetFromBytesSet(List<byte[]> data, Set<Object> result)
protected void	valueSetFromBytesSet(Set<byte[]> data, Set<Object> result)
protected byte[][]	valuesToBytesArray(Object... valuesArray)
protected byte[]	valueToBytes(Object value)
boolean	withLock(String name, int secondsToExpire, int secondsToTimeout, Func.F00 fun) 为业务封装分布式锁，免去锁的获取、释放 Redis.use().withLock("lockStock", 120, 5, () -> { // 业务操作代码 });
Long	zadd(Object key, double score, Object member) 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。 如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值， 并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
Long	zadd(Object key, Map<Object,Double> scoreMembers)
Long	zcard(Object key) 返回有序集 key 的基数。
Long	zcount(Object key, double min, double max) 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。 关于参数 min 和 max 的详细使用方法，请参考 ZRANGEBYSCORE 命令。
Double	zincrby(Object key, double score, Object member) 为有序集 key 的成员 member 的 score 值加上增量 increment 。
Set	zrange(Object key, long start, long end) 返回有序集 key 中，指定区间内的成员。 其中成员的位置按 score 值递增(从小到大)来排序。 具有相同 score 值的成员按字典序(lexicographical order )来排列。 如果你需要成员按 score 值递减(从大到小)来排列，请使用 ZREVRANGE 命令。
Set	zrangeByScore(Object key, double min, double max) 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。 有序集成员按 score 值递增(从小到大)次序排列。
Long	zrank(Object key, Object member) 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。 排名以 0 为底，也就是说， score 值最小的成员排名为 0 。 使用 ZREVRANK 命令可以获得成员按 score 值递减(从大到小)排列的排名。
Long	zrem(Object key, Object... members) 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。 当 key 存在但不是有序集类型时，返回一个错误。
Set	zrevrange(Object key, long start, long end) 返回有序集 key 中，指定区间内的成员。 其中成员的位置按 score 值递减(从大到小)来排列。 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)排列。 除了成员按 score 值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE 命令一样。
Long	zrevrank(Object key, Object member) 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。 排名以 0 为底，也就是说， score 值最大的成员排名为 0 。 使用 ZRANK 命令可以获得成员按 score 值递增(从小到大)排列的排名。
Double	zscore(Object key, Object member) 返回有序集 key 中，成员 member 的 score 值。 如果 member 元素不是有序集 key 的成员，或 key 不存在，返回 nil 。

Methods inherited from class java.lang.Object

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

Field Detail

name

protected String name

jedisPool

protected redis.clients.jedis.JedisPool jedisPool

serializer

protected ISerializer serializer

keyNamingPolicy

protected IKeyNamingPolicy keyNamingPolicy

threadLocalJedis

protected final ThreadLocal<redis.clients.jedis.Jedis> threadLocalJedis

Constructor Detail

RedisDb

protected RedisDb()

RedisDb

public RedisDb(String name,
               redis.clients.jedis.JedisPool jedisPool,
               ISerializer serializer,
               IKeyNamingPolicy keyNamingPolicy)

Method Detail

call

public <R> R call(java.util.function.Function<redis.clients.jedis.Jedis,R> jedis)

使用 lambda 开放 Jedis API，建议优先使用本方法

 例子 1：
   Long ret = Redis.use().call(j -> j.incrBy("key", 1));

 例子 2：
   Long ret = Redis.use().call(jedis -> {
       return jedis.incrBy("key", 1);
   });
 

set

public String set(Object key,
                  Object value)

存放 key value 对到 redis 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。 对于某个原本带有生存时间（TTL）的键来说， 当 SET 命令成功在这个键上执行时， 这个键原有的 TTL 将被清除。

setnx

public Long setnx(Object key,
                  Object value)

setnx 的工作原理与 set 完全相同，唯一的区别是，如果 key 已经存在，则不执行任何操作

Returns:

1 表示 key 不存在，0 表示 key 存在

setex

public String setex(Object key,
                    long seconds,
                    Object value)

存放 key value 对到 redis，并将 key 的生存时间设为 seconds (以秒为单位)。 如果 key 已经存在， SETEX 命令将覆写旧值。

psetex

public String psetex(Object key,
                     long milliseconds,
                     Object value)

psetex 与 setex 功能相同，但是生存时间为 milliseconds (以毫秒为单位)。

get

public <T> T get(Object key)

返回 key 所关联的 value 值 如果 key 不存在那么返回特殊值 nil 。

del

public Long del(Object key)

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

del

public Long del(Object... keys)

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

keys

public Set<String> keys(String pattern)

查找所有符合给定模式 pattern 的 key 。 KEYS * 匹配数据库中所有 key 。 KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。 KEYS h*llo 匹配 hllo 和 heeeeello 等。 KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。 特殊符号用 \ 隔开

mset

public String mset(Object... keysValues)

同时设置一个或多个 key-value 对。 如果某个给定 key 已经存在，那么 MSET 会用新值覆盖原来的旧值，如果这不是你所希望的效果，请考虑使用 MSETNX 命令：它只会在所有给定 key 都不存在的情况下进行设置操作。 MSET 是一个原子性(atomic)操作，所有给定 key 都会在同一时间内被设置，某些给定 key 被更新而另一些给定 key 没有改变的情况，不可能发生。

 例子：
 Cache cache = RedisKit.use();                  // 使用 Redis 的 cache
 cache.mset("k1", "v1", "k2", "v2");            // 放入多个 key value 键值对
 List list = cache.mget("k1", "k2");            // 利用多个键值得到上面代码放入的值
 

msetnx

public Long msetnx(Object... keysValues)

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

mget

public List mget(Object... keys)

返回所有(一个或多个)给定 key 的值。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil 。因此，该命令永不失败。

decr

public Long decr(Object key)

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

decrBy

public Long decrBy(Object key,
                   long longValue)

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

incr

public Long incr(Object key)

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

getCounter

public Long getCounter(Object key)

获取记数器的值

incrBy

public Long incrBy(Object key,
                   long longValue)

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

exists

public boolean exists(Object key)

检查给定 key 是否存在。

hasKey

public boolean hasKey(Object key)

检查给定 key 是否存在。

randomKey

public String randomKey()

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

rename

public String rename(Object oldkey,
                     Object newkey)

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

renamenx

public Long renamenx(Object oldkey,
                     Object newkey)

当且仅当 newkey 不存在时，将 key 改名为 newkey 修改成功时，返回 1 ； 如果 newkey 已经存在，返回 0

move

public Long move(Object key,
                 int dbIndex)

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

migrate

public String migrate(String host,
                      int port,
                      Object key,
                      int destinationDb,
                      int timeout)

将 key 原子性地从当前实例传送到目标实例的指定数据库上，一旦传送成功， key 保证会出现在目标实例上，而当前实例上的 key 会被删除。

select

public String select(int databaseIndex)

切换到指定的数据库，数据库索引号 index 用数字值指定，以 0 作为起始索引值。 默认使用 0 号数据库。 注意：在 Jedis 对象被关闭时，数据库又会重新被设置为初始值，所以本方法 select(...) 正常工作需要使用如下方式之一： 1：使用 RedisInterceptor，在本线程内共享同一个 Jedis 对象 2：使用 Redis.call(ICallback) 进行操作 3：自行获取 Jedis 对象进行操作

expire

public Long expire(Object key,
                   long seconds)

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

expireAt

public Long expireAt(Object key,
                     long unixTime)

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

pexpire

public Long pexpire(Object key,
                    long milliseconds)

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

pexpireAt

public Long pexpireAt(Object key,
                      long millisecondsTimestamp)

这个命令和 EXPIREAT 命令类似，但它以毫秒为单位设置 key 的过期 unix 时间戳，而不是像 EXPIREAT 那样，以秒为单位。

getSet

public <T> T getSet(Object key,
                    Object value)

将给定 key 的值设为 value ，并返回 key 的旧值(old value)。 当 key 存在但不是字符串类型时，返回一个错误。

persist

public Long persist(Object key)

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

type

public String type(Object key)

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

ttl

public Long ttl(Object key)

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

pttl

public Long pttl(Object key)

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

objectRefcount

public Long objectRefcount(Object key)

对象被引用的数量

objectIdletime

public Long objectIdletime(Object key)

对象没有被访问的空闲时间

hset

public Long hset(Object key,
                 Object field,
                 Object value)

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

hsetRawString

public Long hsetRawString(String key,
                          String field,
                          String value)

Sets the value of a field in a hash stored at key. If the key does not exist, a new hash is created and the field-value pair is added. If the field already exists in the hash, the existing value is overwritten with the new value.

Parameters:

key - The key of the hash.

field - The field in the hash to set.

value - The value to set for the field.

Returns:

The number of fields that were added to the hash, not including fields already present and updated.

hgetRawString

public String hgetRawString(String key,
                            String field)

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

hmset

public String hmset(Object key,
                    Map<Object,Object> hash)

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

hget

public <T> T hget(Object key,
                  Object field)

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

hmsetRawString

public String hmsetRawString(String key,
                             Map<String,String> hash)

hmgetRawString

public String hmgetRawString(String key,
                             String field)

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

Parameters:

key - 哈希表的键

field - 哈希表中的字段

Returns:

返回字段对应的值，如果字段不存在则返回 null

hmget

public List hmget(Object key,
                  Object... fields)

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

hmget

public List<String> hmget(String key,
                          String... fields)

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

Parameters:

key - 哈希表的键，类型为 String

fields - 哈希表中的字段，类型为 String... (可变参数)

Returns:

返回的 List 中包含每个字段对应的值，如果某个字段不存在，则对应位置为 null

hdel

public Long hdel(Object key,
                 Object... fields)

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

hdelRaw

public Long hdelRaw(String key,
                    String... fields)

hexists

public boolean hexists(Object key,
                       Object field)

查看哈希表 key 中，给定域 field 是否存在。

hgetAll

public Map hgetAll(Object key)

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

hvals

public List hvals(Object key)

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

hkeys

public Set<Object> hkeys(Object key)

返回哈希表 key 中的所有域。 底层实现此方法取名为 hfields 更为合适，在此仅为与底层保持一致

hkeysRawString

public Set<String> hkeysRawString(String key)

hlen

public Long hlen(Object key)

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

hincrBy

public Long hincrBy(Object key,
                    Object field,
                    long value)

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

hgetCounter

public Long hgetCounter(Object key,
                        Object field)

获取哈希表内记数器的值

hincrByFloat

public Double hincrByFloat(Object key,
                           Object field,
                           double value)

为哈希表 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 命令获取更多相关信息。

hgetFloatCounter

public Double hgetFloatCounter(Object key,
                               Object field)

lindex

public <T> T lindex(Object key,
                    long index)

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

llen

public Long llen(Object key)

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

lpop

public <T> T lpop(Object key)

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

lpush

public Long lpush(Object 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 存在但不是列表类型时，返回一个错误。

lpushx

public Long lpushx(Object key,
                   Object... values)

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

lset

public String lset(Object key,
                   long index,
                   Object value)

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

lrem

public Long lrem(Object key,
                 long count,
                 Object value)

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

lrange

public List lrange(Object key,
                   long start,
                   long end)

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

 例子：
 获取 list 中所有数据：cache.lrange(listKey, 0, -1);
 获取 list 中下标 1 到 3 的数据： cache.lrange(listKey, 1, 3);
 

ltrim

public String ltrim(Object key,
                    long start,
                    long end)

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

rpop

public <T> T rpop(Object key)

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

rpoplpush

public <T> T rpoplpush(Object srcKey,
                       Object dstKey)

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

rpush

public Long rpush(Object 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 存在但不是列表类型时，返回一个错误。

rpushx

public Long rpushx(Object key,
                   Object... values)

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

blpop

public List blpop(int timeout,
                  Object... keys)

BLPOP 是列表的阻塞式(blocking)弹出原语。 它是 LPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP 命令阻塞，直到等待超时或发现可弹出元素为止。 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。 参考：http://redisdoc.com/list/blpop.html 命令行：BLPOP key [key ...] timeout

brpop

public List brpop(int timeout,
                  Object... keys)

BRPOP 是列表的阻塞式(blocking)弹出原语。 它是 RPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BRPOP 命令阻塞，直到等待超时或发现可弹出元素为止。 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的尾部元素。 关于阻塞操作的更多信息，请查看 BLPOP 命令， BRPOP 除了弹出元素的位置和 BLPOP 不同之外，其他表现一致。 参考：http://redisdoc.com/list/brpop.html 命令行：BRPOP key [key ...] timeout

ping

public String ping()

使用客户端向 Redis 服务器发送一个 PING ，如果服务器运作正常的话，会返回一个 PONG 。 通常用于测试与服务器的连接是否仍然生效，或者用于测量延迟值。

sadd

public Long sadd(Object key,
                 Object... members)

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

scard

public Long scard(Object key)

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

spop

public <T> T spop(Object key)

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

smembers

public Set smembers(Object key)

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

sismember

public boolean sismember(Object key,
                         Object member)

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

sinter

public Set sinter(Object... keys)

返回多个集合的交集，多个集合由 keys 指定

srandmember

public <T> T srandmember(Object key)

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

srandmember

public List srandmember(Object key,
                        int count)

返回集合中的 count 个随机元素。 从 Redis 2.6 版本开始， SRANDMEMBER 命令接受可选的 count 参数： 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。 如果 count 大于等于集合基数，那么返回整个集合。 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。 该操作和 SPOP 相似，但 SPOP 将随机元素从集合中移除并返回，而 SRANDMEMBER 则仅仅返回随机元素，而不对集合进行任何改动。

srem

public Long srem(Object key,
                 Object... members)

移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。

sunion

public Set sunion(Object... keys)

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

sdiff

public Set sdiff(Object... keys)

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

zadd

public Long zadd(Object key,
                 double score,
                 Object member)

将一个或多个 member 元素及其 score 值加入到有序集 key 当中。 如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值， 并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。

zadd

public Long zadd(Object key,
                 Map<Object,Double> scoreMembers)

zcard

public Long zcard(Object key)

返回有序集 key 的基数。

zcount

public Long zcount(Object key,
                   double min,
                   double max)

返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。 关于参数 min 和 max 的详细使用方法，请参考 ZRANGEBYSCORE 命令。

zincrby

public Double zincrby(Object key,
                      double score,
                      Object member)

为有序集 key 的成员 member 的 score 值加上增量 increment 。

zrange

public Set zrange(Object key,
                  long start,
                  long end)

返回有序集 key 中，指定区间内的成员。 其中成员的位置按 score 值递增(从小到大)来排序。 具有相同 score 值的成员按字典序(lexicographical order )来排列。 如果你需要成员按 score 值递减(从大到小)来排列，请使用 ZREVRANGE 命令。

zrevrange

public Set zrevrange(Object key,
                     long start,
                     long end)

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

zrangeByScore

public Set zrangeByScore(Object key,
                         double min,
                         double max)

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。 有序集成员按 score 值递增(从小到大)次序排列。

zrank

public Long zrank(Object key,
                  Object member)

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

zrevrank

public Long zrevrank(Object key,
                     Object member)

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

zrem

public Long zrem(Object key,
                 Object... members)

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

zscore

public Double zscore(Object key,
                     Object member)

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

flushDB

public String flushDB()

删除当前 db 所有数据

flushAll

public String flushAll()

删除所有 db 的所有数据

subscribe

public void subscribe(redis.clients.jedis.JedisPubSub jedisPubSub,
                      String... channels)

subscribe channel [channel …] 订阅一个或多个频道
PS：
取消订阅在 jedisPubSub 中的 unsubscribe 方法。
重要：订阅后代码会阻塞监听发布的内容

subscribeThread

public redis.clients.jedis.JedisPubSub subscribeThread(redis.clients.jedis.JedisPubSub jedisPubSub,
                                                       String... channels)

subscribe channel [channel …] 订阅一个或多个频道
PS：
取消订阅在 jedisPubSub 中的 unsubscribe 方法。

psubscribe

public void psubscribe(redis.clients.jedis.JedisPubSub jedisPubSub,
                       String... patterns)

psubscribe pattern [pattern …] 订阅给定模式相匹配的所有频道
PS：
取消订阅在 jedisPubSub 中的 punsubscribe 方法。
重要：订阅后代码会阻塞监听发布的内容

psubscribeThread

public redis.clients.jedis.JedisPubSub psubscribeThread(redis.clients.jedis.JedisPubSub jedisPubSub,
                                                        String... patterns)

psubscribe pattern [pattern …] 订阅给定模式相匹配的所有频道
PS：
取消订阅在 jedisPubSub 中的 punsubscribe 方法。

publish

public Long publish(String channel,
                    String message)

publish channel message 给指定的频道发消息

eval

public Object eval(String script,
                   int keyCount,
                   String... params)

eval

public Object eval(String script,
                   List<String> keys,
                   List<String> args)

eval

public Object eval(String script)

evalsha

public Object evalsha(String sha1)

evalsha

public Object evalsha(String sha1,
                      List<String> keys,
                      List<String> args)

evalsha

public Object evalsha(String sha1,
                      int keyCount,
                      String... params)

scriptExists

public Boolean scriptExists(String sha1)

scriptExists

public List<Boolean> scriptExists(String... sha1)

scriptLoad

public String scriptLoad(String script)

keyToBytes

protected byte[] keyToBytes(Object key)

keyFromBytes

protected Object keyFromBytes(byte[] bytes)

keysToBytesArray

protected byte[][] keysToBytesArray(Object... keys)

fieldToBytes

protected byte[] fieldToBytes(Object field)

fieldFromBytes

protected Object fieldFromBytes(byte[] bytes)

fieldsToBytesArray

protected byte[][] fieldsToBytesArray(Object... fieldsArray)

fieldSetFromBytesSet

protected void fieldSetFromBytesSet(Set<byte[]> data,
                                    Set<Object> result)

valueToBytes

protected byte[] valueToBytes(Object value)

valueFromBytes

protected Object valueFromBytes(byte[] bytes)

valuesToBytesArray

protected byte[][] valuesToBytesArray(Object... valuesArray)

valueSetFromBytesSet

protected void valueSetFromBytesSet(Set<byte[]> data,
                                    Set<Object> result)

valueSetFromBytesSet

protected void valueSetFromBytesSet(List<byte[]> data,
                                    Set<Object> result)

valueListFromBytesList

protected List valueListFromBytesList(List<byte[]> data)

keyValueListFromBytesList

protected List keyValueListFromBytesList(List<byte[]> data)

getName

public String getName()

getSerializer

public ISerializer getSerializer()

getKeyNamingPolicy

public IKeyNamingPolicy getKeyNamingPolicy()

getJedis

public redis.clients.jedis.Jedis getJedis()

close

public void close(redis.clients.jedis.Jedis jedis)

getThreadLocalJedis

public redis.clients.jedis.Jedis getThreadLocalJedis()

setThreadLocalJedis

public void setThreadLocalJedis(redis.clients.jedis.Jedis jedis)

removeThreadLocalJedis

public void removeThreadLocalJedis()

lock

public String lock(String name,
                   int secondsToExpire,
                   int secondsToTimeout)

利用 set 方法实现锁

 例子：
 String lockId = Redis.use().lock("lockStock", 120, 5)
 if (lockId != null) {
     try {
        业务操作代码
     } finally {
         Redis.use().unlock("lockStock", lockId);
     }
 }
 

Parameters:

name - 锁的名称，通常与业务逻辑相关

secondsToExpire - 锁过期时间，单位秒

secondsToTimeout - 获取锁的超时时间，单位秒

Returns:

获取成功返回字符串，否则返回 false。释放锁时需要用到返回的字符串

unlock

public void unlock(String name,
                   String lockId)

释放锁

Parameters:

name - 锁的名称

lockId - 调用 lock(...) 方法成功获取锁时得到的返回值

withLock

public boolean withLock(String name,
                        int secondsToExpire,
                        int secondsToTimeout,
                        Func.F00 fun)

为业务封装分布式锁，免去锁的获取、释放 Redis.use().withLock("lockStock", 120, 5, () -> { // 业务操作代码 });

tx

public List<Object> tx(String watchKeys,
                       Func.F10<redis.clients.jedis.Transaction> tx)

redis 事务，返回值为非 null 时表示 redis 事务执行成功，否则执行失败 被监视的 watchKey 值发生变化时，事务将会执行失败

Parameters:

watchKeys - 被监视的 key，多个 key 使用逗号分隔，例如： "key1, key2"。无监视 key 传入 null 值或者使用 tx(F10 tx)

tx - lambda 提供 Transaction 对象，使用该对象对 redis 的操作产生的命令集合将成为原子操作

tx

public List<Object> tx(Func.F10<redis.clients.jedis.Transaction> tx)

scan

public void scan(Integer cursor,
                 String pattern,
                 Integer count,
                 Func.F11<List<String>,Boolean> keyList)

scan 命令查找符合给定模式 pattern 的 key

Parameters:

cursor - 游标值，值为 0 时表示一次新的查找

pattern - 用于匹配 key 的模式

count - 调整每次 scan 命令返回 key 的数量。注意该值只能大致调整数量，并不能精确指定数量， 返回值数量可以大于或者小于该值

keyList - 每次 scan 返回数据后被回调的函数，该函数接收每次 scan 返回的 key 值列表， 返回 true 继续调用 scan 命令，否则终止 scan

scan

public void scan(Integer cursor,
                 String pattern,
                 Func.F11<List<String>,Boolean> keyList)

scan

public void scan(Integer cursor,
                 Func.F11<List<String>,Boolean> keyList)

getBean

public <R> R getBean(String key,
                     Class<R> type)

setBean

public String setBean(String key,
                      long seconds,
                      Object input)

setBean

public String setBean(String key,
                      Object input)

setStr

public String setStr(String key,
                     String input)

set

public String set(String key,
                  long seconds,
                  String input)

getStr

public String getStr(String key)

setInt

public String setInt(String key,
                     int value)

setInt

public String setInt(String key,
                     long seconds,
                     int value)

getInt

public Integer getInt(String key)

setLong

public String setLong(String key,
                      long value)

setLong

public String setLong(String key,
                      long seconds,
                      long value)

getLong

public Long getLong(String key)

hsetList

public Long hsetList(String key,
                     String field,
                     List<?> list)

hsetList

public Long hsetList(String key,
                     String field,
                     List<?> list,
                     long seconds)

hgetList

public <R> List<R> hgetList(String key,
                            String field,
                            Class<R> elementType)

setIfAbsent

public Boolean setIfAbsent(Object key,
                           Object value)

Set key to hold the string value if key is absent.

Parameters:

key - must not be null.

value - must not be null.

Returns:

true if the key was set, false if the key was already present.

See Also:

Redis Documentation: SETNX

setRawIfAbsent

public Boolean setRawIfAbsent(String key,
                              String value)

setIfAbsent

public Boolean setIfAbsent(Object key,
                           Object value,
                           long timeout)

Set key to hold the string value and expiration timeout if key is absent.

Parameters:

key - must not be null.

value - must not be null.

timeout - must not be null.

Returns:

true if the key was set, false if the key was already present.

See Also:

Redis Documentation: SET

setRawIfAbsent

public Boolean setRawIfAbsent(String key,
                              String value,
                              long timeout)

setIfPresent

public Boolean setIfPresent(Object key,
                            Object value)

Set key to hold the string value if key is present.

Parameters:

key - must not be null.

value - must not be null.

Returns:

true if the key was set, false if the key was not present.

See Also:

Redis Documentation: SET

setRawIfPresent

public Boolean setRawIfPresent(String key,
                               String value)

setIfPresent

public Boolean setIfPresent(Object key,
                            Object value,
                            long timeout,
                            TimeUnit unit)

Set key to hold the string value and expiration timeout if key is present.

Parameters:

key - must not be null.

value - must not be null.

timeout - the key expiration timeout.

unit - must not be null.

Returns:

true if the key was set, false if the key was not present.

See Also:

Redis Documentation: SET

setRawIfPresent

public Boolean setRawIfPresent(String key,
                               String value,
                               long timeout,
                               TimeUnit unit)