RedisClient (Nano ORM Jedis 1.4.5 API)

所有已知实现类:

AbstractRedisClient, RedisClientImpl, RedisClusterClientImpl
```
public interface RedisClient
```
针对Jedis池的使用而基础的封装，主要针对Sharding模式进行接口API的定义
如果Hosts配置为单节点时则无需特别注意，但是配置了多个节点时，则无法使用部分功能，这些功能主要因分布式而无法保证使用，但是部分操作可以进行遍历Sharding节点来进行操作，这也是可以满足操作的

从以下版本开始:

1.0

作者:

yanghe

嵌套类概要

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

static class RedisClient.Mark

嵌套类
限定符和类型	接口和说明
`static class`	`RedisClient.Mark`

方法概要

所有方法实例方法抽象方法
限定符和类型	方法和说明
`long`	`append(String key, Object value)` 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
`long`	`append(String key, Object value, String separator)` 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
`long`	`append(String key, String value)` 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
`long`	`append(String key, String value, String separator)` 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
`Map<String,String>`	`bpop(String[] keys, int timeout, RedisClient.Mark pop)`
`<T> Map<String,T>`	`bpop(String[] keys, int timeout, RedisClient.Mark pop, com.alibaba.fastjson.TypeReference<T> type)`
`Map<String,String>`	`bpop(String[] keys, RedisClient.Mark pop)`
`<T> Map<String,T>`	`bpop(String[] keys, RedisClient.Mark pop, com.alibaba.fastjson.TypeReference<T> type)`
`String`	`bpop(String key, int timeout, RedisClient.Mark pop)`
`<T> T`	`bpop(String key, int timeout, RedisClient.Mark pop, com.alibaba.fastjson.TypeReference<T> type)`
`String`	`bpop(String key, RedisClient.Mark pop)` BLPOP/BRPOP 是列表的阻塞式(blocking)弹出原语。
`<T> T`	`bpop(String key, RedisClient.Mark pop, com.alibaba.fastjson.TypeReference<T> type)`
`String`	`brpoplpush(String source, String destination)` BRPOPLPUSH 是 RPOPLPUSH 的阻塞版本，当给定列表 source 不为空时， BRPOPLPUSH 的表现和 RPOPLPUSH 一样。
`String`	`brpoplpush(String source, String destination, int timeout)`
`<T> T`	`brpoplpush(String source, String destination, int timeout, com.alibaba.fastjson.TypeReference<T> type)`
`<T> T`	`brpoplpush(String source, String destination, com.alibaba.fastjson.TypeReference<T> type)`
`long`	`del(List<String> keys)` 删除给定列表的所有key 。
`long`	`del(String... keys)` 删除给定的一个或多个 key 。
`boolean`	`exists(String key)` 检查给定 key 是否存在。
`long`	`expire(String key)` 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
`long`	`expire(String key, int seconds)` 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
`long`	`expireat(String key, long timestamp)` 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
`<T> Map<String,T>`	`get(List<String> keys, com.alibaba.fastjson.TypeReference<T> type)` 返回所有(一个或多个)给定 key 的值。
`Map<String,String>`	`get(String... keys)` 返回所有(一个或多个)给定 key 的值。
`String`	`get(String key)` 返回 key 所关联的字符串值。
`<T> Map<String,T>`	`get(String[] keys, com.alibaba.fastjson.TypeReference<T> type)` 返回所有(一个或多个)给定 key 的值。
`<T> T`	`get(String key, com.alibaba.fastjson.TypeReference<T> type)` 返回 key 所关联的字符串值，并且通过FastJson转换为泛型所对应的数据类型。
`String`	`getset(String key, String value)` 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
`long`	`hdel(String key, String... fields)` 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
`boolean`	`hexists(String key, String field)` 查看哈希表 key 中，给定域 field 是否存在。
`String`	`hget(String key, String field)` 返回哈希表 key 中给定域 field 的值。
`<T> T`	`hget(String key, String field, com.alibaba.fastjson.TypeReference<T> type)` 返回哈希表 key 中给定域 field 的值。
`Map<String,String>`	`hgetAll(String key)` 返回哈希表 key 中，所有的域和值。
`<T> Map<String,T>`	`hgetAll(String key, com.alibaba.fastjson.TypeReference<T> type)` 返回哈希表 key 中，所有的域和值。
`Set<String>`	`hkeys(String key)` 返回哈希表 key 中的所有域。
`<T> Set<T>`	`hkeys(String key, com.alibaba.fastjson.TypeReference<T> type)`
`long`	`hlen(String key)` 返回哈希表 key 中域的数量。
`Map<String,String>`	`hmget(String key, String... fields)` 返回哈希表 key 中，一个或多个给定域的值。
`<T> Map<String,T>`	`hmget(String key, String[] fields, com.alibaba.fastjson.TypeReference<T> type)` 返回哈希表 key 中，一个或多个给定域的值。
`boolean`	`hmset(String key, Map<String,Object> map)` 同时将多个 field-value (域-值)对设置到哈希表 key 中。
`boolean`	`hset(String key, String field, Object value)` 将哈希表 key 中的域 field 的值设为 value 。
`boolean`	`hset(String key, String field, String value)` 将哈希表 key 中的域 field 的值设为 value 。
`Map<String,Boolean>`	`hsetByNX(String key, Map<String,Object> map)` 同时将多个 field-value (域-值)对设置到哈希表 key 中，当且仅当域 field 不存在。
`boolean`	`hsetByNX(String key, String field, Object value)` 将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。
`boolean`	`hsetByNX(String key, String field, String value)` 将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。
`List<String>`	`hvals(String key)` 返回哈希表 key 中所有域的值。
`<T> List<T>`	`hvals(String key, com.alibaba.fastjson.TypeReference<T> type)`
`List<Map<String,String>>`	`info()`
`List<Map<String,String>>`	`info(String section)`
`Set<String>`	`keys(String pattern)` 查找所有符合给定模式 pattern 的 key 。
`String`	`lindex(String key, int index)` 返回列表 key 中，下标为 index 的元素。
`<T> T`	`lindex(String key, int index, com.alibaba.fastjson.TypeReference<T> type)`
`long`	`linsert(String key, String pivot, Object value, RedisClient.Mark position)`
`long`	`linsert(String key, String pivot, String value, RedisClient.Mark position)` LINSERT key BEFORE\|AFTER pivot value 将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。
`long`	`llen(String key)` LLEN key 返回列表 key 的长度。
`List<String>`	`lrange(String key)`
`List<String>`	`lrange(String key, int count)`
`List<String>`	`lrange(String key, int start, int end)` 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
`<T> List<T>`	`lrange(String key, int start, int end, com.alibaba.fastjson.TypeReference<T> type)` 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
`<T> List<T>`	`lrange(String key, int count, com.alibaba.fastjson.TypeReference<T> type)` 返回列表 key 中0到count之间的所有的元素。
`<T> List<T>`	`lrange(String key, com.alibaba.fastjson.TypeReference<T> type)`
`List<String>`	`lrangeltrim(String key, int count)`
`<T> List<T>`	`lrangeltrim(String key, int count, com.alibaba.fastjson.TypeReference<T> type)`
`long`	`lrem(String key, int count, Object value)`
`long`	`lrem(String key, int count, String value)` 根据参数 count 的值，移除列表中与参数 value 相等的元素。
`long`	`lrem(String key, Object value)`
`long`	`lrem(String key, String value)`
`boolean`	`lset(String key, int index, Object value)`
`boolean`	`lset(String key, int index, String value)` 将列表 key 下标为 index 的元素的值设置为 value 。
`boolean`	`ltrim(String key, int start, int end)` 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
`List<String>`	`pop(String key, int count)`
`<T> List<T>`	`pop(String key, int count, com.alibaba.fastjson.TypeReference<T> type)`
`String`	`pop(String key, RedisClient.Mark pop)` 移除并返回列表 key 的头/尾元素。
`<T> T`	`pop(String key, RedisClient.Mark pop, com.alibaba.fastjson.TypeReference<T> type)`
`boolean`	`push(String key, List<Object> values, RedisClient.Mark push)`
`Map<String,Boolean>`	`push(String key, Map<String,Object> scanMap, RedisClient.Mark push, RedisClient.Mark policy)` 根据策略(policy)存储列表(key-scanKey或者key-value)与散列(scanKey-value) 根据写入方式(push)存储列表数据
`boolean`	`push(String key, Object[] values, RedisClient.Mark push)`
`boolean`	`push(String key, Object value, RedisClient.Mark push)`
`boolean`	`push(String key, String[] values, RedisClient.Mark push)`
`boolean`	`push(String key, String scanKey, Object value, RedisClient.Mark push, RedisClient.Mark policy)` 根据策略(policy)存储列表(key-scanKey或者key-value)与散列(scanKey-value) 根据写入方式(push)存储列表数据
`boolean`	`push(String key, String value, RedisClient.Mark push)`
`boolean`	`push(String key, String scanKey, String value, RedisClient.Mark push, RedisClient.Mark policy)` 根据策略(policy)存储列表(key-scanKey或者key-value)与散列(scanKey-value) 根据写入方式(push)存储列表数据
`long`	`pushx(String key, Object[] values, RedisClient.Mark push)`
`long`	`pushx(String key, Object value, RedisClient.Mark push)`
`long`	`pushx(String key, String[] values, RedisClient.Mark push)`
`long`	`pushx(String key, String value, RedisClient.Mark push)`
`long`	`sadd(String key, Object... members)` 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
`long`	`sadd(String key, String... members)` 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
`Map<String,Long>`	`scard(Collection<String> keys)` 返回集合 key 的基数(集合中元素的数量)。
`Map<String,Long>`	`scard(String... keys)` 返回集合 key 的基数(集合中元素的数量)。
`long`	`scard(String key)` 返回集合 key 的基数(集合中元素的数量)。
`<T> Set<T>`	`sdiff(Collection<String> keys, com.alibaba.fastjson.TypeReference<T> type)` 返回一个集合的全部成员，该集合是所有给定集合之间的差集。
`Set<String>`	`sdiff(String... keys)` 返回一个集合的全部成员，该集合是所有给定集合之间的差集。
`<T> Set<T>`	`sdiff(String[] keys, com.alibaba.fastjson.TypeReference<T> type)` 返回一个集合的全部成员，该集合是所有给定集合之间的差集。
`long`	`sdiffstore(String destination, String... keys)` 这个命令的作用和 SDIFF 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。
`Map<String,Boolean>`	`set(Map<String,Object> map)` 同时设置一个或多个 key-value 对。
`boolean`	`set(String key, Object value)` 将对象 value 关联到 key 。
`boolean`	`set(String key, String value)` 将字符串值 value 关联到 key 。
`boolean`	`setByEX(String key, Object value)` 将字符串值 value 关联到 key, 使用默认的时间进行生命周期的设置。
`boolean`	`setByEX(String key, Object value, int seconds)` 将字符串值 value 关联到 key，并设置以秒为单位的生命周期。
`boolean`	`setByEX(String key, String value)` 将字符串值 value 关联到 key, 使用默认的时间进行生命周期的设置。
`boolean`	`setByEX(String key, String value, int seconds)` 将字符串值 value 关联到 key，并设置以秒为单位的生命周期。
`Map<String,Boolean>`	`setByNX(Map<String,Object> map)` 同时设置一个或多个 key-value 对, 当且仅当所有给定 key 都不存在.
`boolean`	`setByNX(String key, Object value)` 将对象 value 关联到 key, 当且仅当给定 key 不存在时.
`boolean`	`setByNX(String key, String value)` 将字符串值 value 关联到 key, 当且仅当给定 key 不存在时.
`<T> Set<T>`	`sinter(Collection<String> keys, com.alibaba.fastjson.TypeReference<T> type)` 返回一个集合的全部成员，该集合是所有给定集合的交集。
`Set<String>`	`sinter(String... keys)` 返回一个集合的全部成员，该集合是所有给定集合的交集。
`<T> Set<T>`	`sinter(String[] keys, com.alibaba.fastjson.TypeReference<T> type)` 返回一个集合的全部成员，该集合是所有给定集合的交集。
`long`	`sinterstore(String destination, String... keys)` 这个命令类似于 SINTER 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
`boolean`	`sismember(String key, Object member)` 判断 member 元素是否集合 key 的成员。
`boolean`	`sismember(String key, String member)` 判断 member 元素是否集合 key 的成员。
`Set<String>`	`smembers(String key)` 返回集合 key 中的所有成员。
`<T> Set<T>`	`smembers(String key, com.alibaba.fastjson.TypeReference<T> type)` 返回集合 key 中的所有成员。
`Map<Object,Boolean>`	`smove(String source, String destination, Object... members)` 将 member 元素从 source 集合移动到 destination 集合。
`boolean`	`smove(String source, String destination, Object member)` 将 member 元素从 source 集合移动到 destination 集合。
`Map<String,Boolean>`	`smove(String source, String destination, String... members)` 将 member 元素从 source 集合移动到 destination 集合。
`boolean`	`smove(String source, String destination, String member)` 将 member 元素从 source 集合移动到 destination 集合。
`String`	`spop(String key)` 移除并返回集合中的一个随机元素。
`Set<String>`	`spop(String key, int count)` 移除并返回集合中的{count}个随机元素。
`<T> Set<T>`	`spop(String key, int count, com.alibaba.fastjson.TypeReference<T> type)` 移除并返回集合中的{count}个随机元素。
`<T> T`	`spop(String key, com.alibaba.fastjson.TypeReference<T> type)` 移除并返回集合中的一个随机元素。
`String`	`srandmember(String key)` 返回集合中的一个随机元素
`List<String>`	`srandmember(String key, int count)` 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。
`<T> List<T>`	`srandmember(String key, int count, com.alibaba.fastjson.TypeReference<T> type)` 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。
`<T> T`	`srandmember(String key, com.alibaba.fastjson.TypeReference<T> type)` 返回集合中的一个随机元素
`long`	`srem(String key, Object... members)` 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
`long`	`srem(String key, String... members)` 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
`long`	`sreplace(String key, Collection<Object> oldMembers, Collection<Object> newMembers)`
`long`	`sreplace(String key, Object[] oldMembers, Object[] newMembers)`
`long`	`sreplace(String key, String[] oldMembers, String[] newMembers)` 替换原有的值
`long`	`strLen(String key)` 返回 key 所储存的字符串值的长度。
`Set<String>`	`sunion(String... keys)` 返回一个集合的全部成员，该集合是所有给定集合的并集。
`<T> Set<T>`	`sunion(String[] keys, com.alibaba.fastjson.TypeReference<T> type)` 返回一个集合的全部成员，该集合是所有给定集合的并集。
`long`	`sunionstore(String destination, String... keys)` 这个命令类似于 SUNION 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
`long`	`ttl(String key)` 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
`long`	`zadd(String key, double score, Object member)`
`long`	`zadd(String key, double score, String member)` 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
`long`	`zadd(String key, Map<Object,Double> values)`
`long`	`zcard(String key)`
`long`	`zcount(String key)`
`long`	`zcount(String key, double min, double max)`
`long`	`zcount(String key, String min, String max)`
`double`	`zincrby(String key, double increment, String member)` 为有序集 key 的成员 member 的 score 值加上增量 increment 。
`<T> double`	`zincrby(String key, double increment, T member)`
`long`	`zlexcount(String key, String min, String max)`
`Set<String>`	`zrange(String key)`
`Set<String>`	`zrange(String key, long end)`
`Set<String>`	`zrange(String key, long start, long end)` 返回有序集 key 中，指定区间内的成员。
`<T> Set<T>`	`zrange(String key, long start, long end, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Set<T>`	`zrange(String key, long end, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Set<T>`	`zrange(String key, com.alibaba.fastjson.TypeReference<T> type)`
`Set<String>`	`zrangeByLex(String key, String min, String max, int offset, int count)`
`<T> Set<T>`	`zrangeByLex(String key, String min, String max, int offset, int count, com.alibaba.fastjson.TypeReference<T> type)`
`Set<String>`	`zrangeByScore(String key, double min, double max)`
`Set<String>`	`zrangeByScore(String key, double min, double max, int offset, int count)`
`<T> Set<T>`	`zrangeByScore(String key, double min, double max, int offset, int count, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Set<T>`	`zrangeByScore(String key, double min, double max, com.alibaba.fastjson.TypeReference<T> type)`
`Set<String>`	`zrangeByScore(String key, String min, String max)`
`Set<String>`	`zrangeByScore(String key, String min, String max, int offset, int count)`
`<T> Set<T>`	`zrangeByScore(String key, String min, String max, int offset, int count, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Set<T>`	`zrangeByScore(String key, String min, String max, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Map<T,Double>`	`zrangeByScoreWithScores(String key, double min, double max, int offset, int count, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Map<T,Double>`	`zrangeByScoreWithScores(String key, double min, double max, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Map<T,Double>`	`zrangeByScoreWithScores(String key, String min, String max, int offset, int count, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Map<T,Double>`	`zrangeByScoreWithScores(String key, String min, String max, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Map<T,Double>`	`zrangeWithScores(String key, long start, long end, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Map<T,Double>`	`zrangeWithScores(String key, long end, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Map<T,Double>`	`zrangeWithScores(String key, com.alibaba.fastjson.TypeReference<T> type)`
`long`	`zrank(String key, String member)`
`<T> long`	`zrank(String key, T member)`
`long`	`zrem(String key, String... members)`
`<T> long`	`zrem(String key, T... members)`
`long`	`zremrangeByLex(String key, String min, String max)`
`long`	`zremrangeByRank(String key, long start, long end)` 移除有序集 key 中，指定排名(rank)区间内的所有成员。
`long`	`zremrangeByScore(String key, double min, double max)`
`long`	`zremrangeByScore(String key, String start, String end)`
`Set<String>`	`zrevrange(String key)`
`Set<String>`	`zrevrange(String key, long end)`
`Set<String>`	`zrevrange(String key, long start, long end)`
`<T> Set<T>`	`zrevrange(String key, long start, long end, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Set<T>`	`zrevrange(String key, long end, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Set<T>`	`zrevrange(String key, com.alibaba.fastjson.TypeReference<T> type)`
`Set<String>`	`zrevrangeByLex(String key, String max, String min)`
`Set<String>`	`zrevrangeByLex(String key, String max, String min, int offset, int count)`
`<T> Set<T>`	`zrevrangeByLex(String key, String max, String min, int offset, int count, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Set<T>`	`zrevrangeByLex(String key, String max, String min, com.alibaba.fastjson.TypeReference<T> type)`
`Set<String>`	`zrevrangeByScore(String key, double max, double min)`
`Set<String>`	`zrevrangeByScore(String key, double max, double min, int offset, int count)`
`<T> Set<T>`	`zrevrangeByScore(String key, double max, double min, int offset, int count, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Set<T>`	`zrevrangeByScore(String key, double max, double min, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Map<T,Double>`	`zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Map<T,Double>`	`zrevrangeByScoreWithScores(String key, double max, double min, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Map<T,Double>`	`zrevrangeWithScores(String key, long start, long end, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Map<T,Double>`	`zrevrangeWithScores(String key, long end, com.alibaba.fastjson.TypeReference<T> type)`
`<T> Map<T,Double>`	`zrevrangeWithScores(String key, com.alibaba.fastjson.TypeReference<T> type)`
`long`	`zrevrank(String key, String member)`
`<T> long`	`zrevrank(String key, T member)`
`double`	`zscore(String key, String member)`
`<T> double`	`zscore(String key, T member)`

- 方法详细资料
  - info
```
List<Map<String,String>> info()
```
    返回:
    
    Info list
    
    从以下版本开始:
    
    1.3.15
  - info
```
List<Map<String,String>> info(String section)
```
    参数:
    
    section - the section
    
    返回:
    
    Info list
    
    从以下版本开始:
    
    1.3.15
  - del
```
long del(String... keys)
```
    删除给定的一个或多个 key 。
    
    参数:
    
    keys - key动态数组
    
    返回:
    
    删除key的数量
  - del
```
long del(List<String> keys)
```
    删除给定列表的所有key 。
    
    参数:
    
    keys - key列表
    
    返回:
    
    删除key的数量
  - exists
```
boolean exists(String key)
```
    检查给定 key 是否存在。
    
    参数:
    
    key - 散列Key
    
    返回:
    
    如果存在则返回true，否则返回false
  - expire
```
long expire(String key,
            int seconds)
```
    为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
    
    参数:
    
    key - 散列Key
    
    seconds - 过期时间，单位：秒
    
    返回:
    
    设置成功返回 1 。当 key 不存在或者不能为 key 设置生存时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的生存时间)，返回 0 。
  - expire
```
long expire(String key)
```
    为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。使用RedisConfig中的过期时间进行设置
    
    参数:
    
    key - 散列key
    
    返回:
    
    设置成功返回 1 。当 key 不存在或者不能为 key 设置生存时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的生存时间)，返回 0 。
    
    另请参阅:
    
    RedisConfig.getExpireTime()
  - expireat
```
long expireat(String key,
              long timestamp)
```
    为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
    
    参数:
    
    key - 散列Key
    
    timestamp - 过期时间，时间戳，自动将毫秒制转换成秒制
    
    返回:
    
    如果生存时间设置成功，返回 1 。当 key 不存在或没办法设置生存时间，返回 0 。
  - ttl
```
long ttl(String key)
```
    以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
    
    参数:
    
    key - 元素Key
    
    返回:
    
    当 key 不存在时，返回 -2 。
    当 key 存在但没有设置剩余生存时间时，返回 -1 。
    否则，以秒为单位，返回 key 的剩余生存时间。
  - keys
```
Set<String> keys(String pattern)
```
    查找所有符合给定模式 pattern 的 key 。
    
    参数:
    
    pattern - 匹配规则
    
    返回:
    
    符合给定模式的 key 列表。
  - append
```
long append(String key,
            String value)
```
    如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
    如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
    使用默认分隔符进行分隔，默认分隔符：","
    
    参数:
    
    key - 散列Key
    
    value - 需要进行添加的内容
    
    返回:
    
    追加 value 之后， key 中字符串的长度。
  - append
```
long append(String key,
            String value,
            String separator)
```
    如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
    如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
    使用指定的分隔符进行分隔
    
    参数:
    
    key - 散列Key
    
    value - 需要添加的内容
    
    separator - 分隔符
    
    返回:
    
    追加 value 之后， key 中字符串的长度。
  - append
```
long append(String key,
            Object value,
            String separator)
```
    如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
    如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
    存入的value值自动转换为JSON字符串
    使用指定的分隔符进行分隔
    
    参数:
    
    key - 散列Key
    
    value - 需要添加的内容对象
    
    separator - 分隔符
    
    返回:
    
    追加 value 之后， key 中字符串的长度。
  - append
```
long append(String key,
            Object value)
```
    如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
    如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
    使用默认分隔符进行分隔，默认分隔符：","
    
    参数:
    
    key - 散列Key
    
    value - 需要添加的内容对象
    
    返回:
    
    追加 value 之后， key 中字符串的长度。
  - get
```
String get(String key)
```
    返回 key 所关联的字符串值。
    
    参数:
    
    key - 散列Key
    
    返回:
    
    当 key 不存在时，返回 null ，否则，返回 key 的值。如果 key 不是字符串类型，那么返回一个错误。
  - get
```
<T> T get(String key,
          com.alibaba.fastjson.TypeReference<T> type)
```
    返回 key 所关联的字符串值，并且通过FastJson转换为泛型所对应的数据类型。
    如果类型转换不匹配是则返回一个错误
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    key - 散列Key
    
    type - 对象类型转换
    
    返回:
    
    当 key 不存在时，返回 null ，否则，返回 key 的值。如果 key 不是字符串类型，那么返回一个错误。
  - get
```
Map<String,String> get(String... keys)
```
    返回所有(一个或多个)给定 key 的值。
    
    参数:
    
    keys - 散列Key动态数组
    
    返回:
    
    当 key 不存在时，返回 null ，否则，返回 key 的值。如果 key 不是字符串类型，那么返回一个错误。
  - get
```
<T> Map<String,T> get(String[] keys,
                      com.alibaba.fastjson.TypeReference<T> type)
```
    返回所有(一个或多个)给定 key 的值。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    keys - 散列Key的数组
    
    type - 需要转换的TypeReference泛型类型
    
    返回:
    
    当 key 不存在时，返回 null ，否则，返回 key 的值。如果 key 不是字符串类型，那么返回一个错误。
  - get
```
<T> Map<String,T> get(List<String> keys,
                      com.alibaba.fastjson.TypeReference<T> type)
```
    返回所有(一个或多个)给定 key 的值。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    keys - 散列Key的List集合
    
    type - 需要转换的TypeReference泛型类型
    
    返回:
    
    当 key 不存在时，返回 null ，否则，返回 key 的值。如果 key 不是字符串类型，那么返回一个错误。
  - getset
```
String getset(String key,
              String value)
```
    将给定 key 的值设为 value ，并返回 key 的旧值(old value)。当 key 存在但不是字符串类型时，返回一个错误。
    
    参数:
    
    key - 散列Key
    
    value - 散列值
    
    返回:
    
    返回给定 key 的旧值。当 key 没有旧值时，也即是， key 不存在时，返回 null 。
  - set
```
boolean set(String key,
            String value)
```
    将字符串值 value 关联到 key 。
    
    参数:
    
    key - 散列Key
    
    value - 散列值
    
    返回:
    
    在 Redis 2.6.12 版本以前， SET 命令总是返回 OK 。
    从 Redis 2.6.12 版本开始， SET 在设置操作成功完成时，才返回 OK 。
    如果设置了 NX 或者 XX ，但因为条件没达到而造成设置操作未执行，那么命令返回空批量回复（NULL Bulk Reply）。
  - set
```
boolean set(String key,
            Object value)
```
    将对象 value 关联到 key 。
    
    参数:
    
    key - 散列Key
    
    value - 散列值
    
    返回:
    
    在 Redis 2.6.12 版本以前， SET 命令总是返回 OK 。
    从 Redis 2.6.12 版本开始， SET 在设置操作成功完成时，才返回 OK 。
    如果设置了 NX 或者 XX ，但因为条件没达到而造成设置操作未执行，那么命令返回空批量回复（NULL Bulk Reply）。
  - set
```
Map<String,Boolean> set(Map<String,Object> map)
```
    同时设置一个或多个 key-value 对。
    
    参数:
    
    map - 散列Key-Value映射表
    
    返回:
    
    在 Redis 2.6.12 版本以前， SET 命令总是返回 OK 。
    从 Redis 2.6.12 版本开始， SET 在设置操作成功完成时，才返回 OK 。
    如果设置了 NX 或者 XX ，但因为条件没达到而造成设置操作未执行，那么命令返回空批量回复（NULL Bulk Reply）。
  - setByNX
```
boolean setByNX(String key,
                String value)
```
    将字符串值 value 关联到 key, 当且仅当给定 key 不存在时.
    
    参数:
    
    key - 散列Key
    
    value - 散列值
    
    返回:
    
    设置成功，返回 true 。设置失败，返回 false。
  - setByNX
```
boolean setByNX(String key,
                Object value)
```
    将对象 value 关联到 key, 当且仅当给定 key 不存在时.
    
    参数:
    
    key - 散列Key
    
    value - 散列值
    
    返回:
    
    设置成功，返回 true。设置失败，返回 false。
  - setByNX
```
Map<String,Boolean> setByNX(Map<String,Object> map)
```
    同时设置一个或多个 key-value 对, 当且仅当所有给定 key 都不存在. 即使只有一个给定 key 已存在， MSETNX 也会拒绝执行所有给定 key 的设置操作. 在Cluster模式下，存在一个给定的key时，剩下不存在的key也会被设置成功.
    
    参数:
    
    map - 散列Key-Value映射表
    
    返回:
    
    设置成功，返回 true。设置失败，返回 false。返回Key与结果对应的映射表
  - setByEX
```
boolean setByEX(String key,
                String value)
```
    将字符串值 value 关联到 key, 使用默认的时间进行生命周期的设置。
    
    参数:
    
    key - 散列Key
    
    value - 散列值
    
    返回:
    
    设置成功时返回 OK 。当 seconds 参数不合法时，返回一个错误。
  - setByEX
```
boolean setByEX(String key,
                Object value)
```
    将字符串值 value 关联到 key, 使用默认的时间进行生命周期的设置。
    
    参数:
    
    key - 散列Key
    
    value - 散列值
    
    返回:
    
    设置成功时返回 OK 。当 seconds 参数不合法时，返回一个错误。
  - setByEX
```
boolean setByEX(String key,
                String value,
                int seconds)
```
    将字符串值 value 关联到 key，并设置以秒为单位的生命周期。
    
    参数:
    
    key - 散列Key
    
    value - 散列值
    
    seconds - 时间(秒)
    
    返回:
    
    设置成功时返回 OK 。当 seconds 参数不合法时，返回一个错误。
  - setByEX
```
boolean setByEX(String key,
                Object value,
                int seconds)
```
    将字符串值 value 关联到 key，并设置以秒为单位的生命周期。
    
    参数:
    
    key - 散列Key
    
    value - 散列值
    
    seconds - 时间(秒)
    
    返回:
    
    设置成功时返回 OK 。当 seconds 参数不合法时，返回一个错误。
  - strLen
```
long strLen(String key)
```
    返回 key 所储存的字符串值的长度。当 key 储存的不是字符串值时，返回一个错误。
    
    参数:
    
    key - 散列Key
    
    返回:
    
    字符串值的长度。当 key 不存在时，返回 0 。
  - hdel
```
long hdel(String key,
          String... fields)
```
    删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
    
    参数:
    
    key - 哈希表Key
    
    fields - 哈希域动态数组
    
    返回:
    
    被成功移除的域的数量，不包括被忽略的域。
  - hexists
```
boolean hexists(String key,
                String field)
```
    查看哈希表 key 中，给定域 field 是否存在。
    
    参数:
    
    key - 哈希表Key
    
    field - 哈希域
    
    返回:
    
    如果哈希表含有给定域，返回 true 。如果哈希表不含有给定域，或 key 不存在，返回 false 。
  - hget
```
String hget(String key,
            String field)
```
    返回哈希表 key 中给定域 field 的值。
    
    参数:
    
    key - 哈希表Key
    
    field - 哈希域
    
    返回:
    
    给定域的值。当给定域不存在或是给定 key 不存在时，返回 null 。
  - hmget
```
Map<String,String> hmget(String key,
                         String... fields)
```
    返回哈希表 key 中，一个或多个给定域的值。
    如果给定的域不存在于哈希表，那么返回一个 nil 值。
    因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。
    
    参数:
    
    key - 哈希表Key
    
    fields - 哈希域
    
    返回:
    
    一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。
  - hget
```
<T> T hget(String key,
           String field,
           com.alibaba.fastjson.TypeReference<T> type)
```
    返回哈希表 key 中给定域 field 的值。并将值转换成泛型对象。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    key - 哈希表Key
    
    field - 哈希域
    
    type - TypeReference的泛型对象
    
    返回:
    
    给定域的值。当给定域不存在或是给定 key 不存在时，返回 null 。
  - hmget
```
<T> Map<String,T> hmget(String key,
                        String[] fields,
                        com.alibaba.fastjson.TypeReference<T> type)
```
    返回哈希表 key 中，一个或多个给定域的值。
    如果给定的域不存在于哈希表，那么返回一个 nil 值。
    因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    key - 哈希表Key
    
    fields - 哈希域数组
    
    type - TypeReference的泛型对象
    
    返回:
    
    给定域的值。当给定域不存在或是给定 key 不存在时，返回 null 。
  - hgetAll
```
Map<String,String> hgetAll(String key)
```
    返回哈希表 key 中，所有的域和值。
    在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。
    
    参数:
    
    key - 哈希表Key
    
    返回:
    
    以Map形式返回哈希表的域和域的值。若 key 不存在，返回空Map。
  - hgetAll
```
<T> Map<String,T> hgetAll(String key,
                          com.alibaba.fastjson.TypeReference<T> type)
```
    返回哈希表 key 中，所有的域和值。
    在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    key - 哈希表Key
    
    type - TypeReference的泛型对象
    
    返回:
    
    以Map形式返回哈希表的域和域的值。若 key 不存在，返回空Map。
  - hkeys
```
Set<String> hkeys(String key)
```
    返回哈希表 key 中的所有域。
    
    参数:
    
    key - 哈希表Key
    
    返回:
    
    一个包含哈希表中所有域的表。当 key 不存在时，返回一个空表。
  - hkeys
```
<T> Set<T> hkeys(String key,
                 com.alibaba.fastjson.TypeReference<T> type)
```
  - hlen
```
long hlen(String key)
```
    返回哈希表 key 中域的数量。
    
    参数:
    
    key - 哈希表Key
    
    返回:
    
    哈希表中域的数量。当 key 不存在时，返回 0 。
  - hset
```
boolean hset(String key,
             String field,
             String value)
```
    将哈希表 key 中的域 field 的值设为 value 。
    如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。
    如果域 field 已经存在于哈希表中，旧值将被覆盖。
    
    参数:
    
    key - 哈希表Key
    
    field - 哈希域
    
    value - 数据内容
    
    返回:
    
    如果 field 是哈希表中的一个新建域，并且值设置成功，返回 true 。如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 false 。
  - hset
```
boolean hset(String key,
             String field,
             Object value)
```
    将哈希表 key 中的域 field 的值设为 value 。
    如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。
    如果域 field 已经存在于哈希表中，旧值将被覆盖。
    
    参数:
    
    key - 哈希表Key
    
    field - 哈希域
    
    value - 数据对象内容
    
    返回:
    
    如果 field 是哈希表中的一个新建域，并且值设置成功，返回 true 。如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 false 。
  - hmset
```
boolean hmset(String key,
              Map<String,Object> map)
```
    同时将多个 field-value (域-值)对设置到哈希表 key 中。
    此命令会覆盖哈希表中已存在的域。
    如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。
    
    参数:
    
    key - 哈希表Key
    
    map - 数据对象映射表
    
    返回:
    
    Return OK or Exception if hash is empty
  - hsetByNX
```
boolean hsetByNX(String key,
                 String field,
                 String value)
```
    将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。
    若域 field 已经存在，该操作无效。
    如果 key 不存在，一个新哈希表被创建并执行 HSETNX 命令。
    
    参数:
    
    key - 哈希表Key
    
    field - 哈希域
    
    value - 数据内容
    
    返回:
    
    设置成功，返回 true 。如果给定域已经存在且没有操作被执行，返回 false 。
  - hsetByNX
```
boolean hsetByNX(String key,
                 String field,
                 Object value)
```
    将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。
    若域 field 已经存在，该操作无效。
    如果 key 不存在，一个新哈希表被创建并执行 HSETNX 命令。
    
    参数:
    
    key - the key
    
    field - the field
    
    value - the value
    
    返回:
    
    设置成功，返回 true 。如果给定域已经存在且没有操作被执行，返回 false 。
  - hsetByNX
```
Map<String,Boolean> hsetByNX(String key,
                             Map<String,Object> map)
```
    同时将多个 field-value (域-值)对设置到哈希表 key 中，当且仅当域 field 不存在。
    若域 field 已经存在，该操作无效。
    如果 key 不存在，一个新哈希表被创建并执行 HSETNX 命令。
    在Cluster模式下，即使存在一个给定的field，其他field也将写入成功.
    
    参数:
    
    key - the key
    
    map - the map
    
    返回:
    
    设置成功，返回 true 。如果给定域已经存在且没有操作被执行，返回 false 。
  - hvals
```
List<String> hvals(String key)
```
    返回哈希表 key 中所有域的值。
    
    参数:
    
    key - 哈希表Key
    
    返回:
    
    一个包含哈希表中所有值的表。当 key 不存在时，返回一个空表。
  - hvals
```
<T> List<T> hvals(String key,
                  com.alibaba.fastjson.TypeReference<T> type)
```
  - bpop
```
String bpop(String key,
            RedisClient.Mark pop)
```
    BLPOP/BRPOP 是列表的阻塞式(blocking)弹出原语。
    它是 LPOP/RPOP 命令的阻塞版本，当给定列表内没有任何元素可供弹出的时候，连接将被 BLPOP/BRPOP 命令阻塞，直到等待超时或发现可弹出元素为止。
    当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。
    
    非阻塞行为
    当 BLPOP/BRPOP 被调用时，如果给定 key 内至少有一个非空列表，那么弹出遇到的第一个非空列表的头元素，并和被弹出元素所属的列表的名字一起，组成结果返回给调用者。
    当存在多个给定 key 时， BLPOP/BRPOP 按给定 key 参数排列的先后顺序，依次检查各个列表。
    假设现在有 job 、 command 和 request 三个列表，其中 job 不存在， command 和 request 都持有非空列表。考虑以下命令：
    BLPOP job command request 0
    BLPOP 保证返回的元素来自 command ，因为它是按 "查找 job -> 查找 command -> 查找 request" 这样的顺序，第一个找到的非空列表。
    Timeout默认为0
    
    参数:
    
    key - 列表Key
    
    pop - 读取方式
    
    返回:
    
    如果列表为空，返回一个 null 。否则，返回被弹出元素的值。
    
    另请参阅:
    
    RedisClient.Mark.LPOP, RedisClient.Mark.RPOP
  - bpop
```
<T> T bpop(String key,
           RedisClient.Mark pop,
           com.alibaba.fastjson.TypeReference<T> type)
```
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    key - 列表Key
    
    pop - 读取方式
    
    type - TypeReference的泛型对象
    
    返回:
    
    如果列表为空，返回一个 null 。否则，返回被弹出元素的值。
    
    另请参阅:
    
    bpop(String, Mark)
  - bpop
```
String bpop(String key,
            int timeout,
            RedisClient.Mark pop)
```
    参数:
    
    key - 列表Key
    
    timeout - 超时时间(秒)
    
    pop - 读取方式
    
    返回:
    
    如果列表为空，返回一个 null 。否则，返回被弹出元素的值。
    
    另请参阅:
    
    bpop(String, Mark)
  - bpop
```
<T> T bpop(String key,
           int timeout,
           RedisClient.Mark pop,
           com.alibaba.fastjson.TypeReference<T> type)
```
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    key - 列表Key
    
    timeout - 超时时间(秒)
    
    pop - 读取方式
    
    type - TypeReference的泛型对象
    
    返回:
    
    如果列表为空，返回一个 null 。否则，返回被弹出元素的值。
  - bpop
```
Map<String,String> bpop(String[] keys,
                        RedisClient.Mark pop)
```
    参数:
    
    keys - 列表Key的数组
    
    pop - 读取方式
    
    返回:
    
    返回被弹出元素的非空值与列表Key的映射表
    
    另请参阅:
    
    bpop(String, Mark)
  - bpop
```
<T> Map<String,T> bpop(String[] keys,
                       RedisClient.Mark pop,
                       com.alibaba.fastjson.TypeReference<T> type)
```
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    keys - 列表Key的数组
    
    pop - 读取方式
    
    type - TypeReference的泛型对象
    
    返回:
    
    返回被弹出元素的非空值与列表Key的映射表
    
    另请参阅:
    
    bpop(String, Mark)
  - bpop
```
Map<String,String> bpop(String[] keys,
                        int timeout,
                        RedisClient.Mark pop)
```
    参数:
    
    keys - 列表Key的数组
    
    timeout - 超时时间(秒)
    
    pop - 读取方式
    
    返回:
    
    返回被弹出元素的非空值与列表Key的映射表
    
    另请参阅:
    
    bpop(String, Mark)
  - bpop
```
<T> Map<String,T> bpop(String[] keys,
                       int timeout,
                       RedisClient.Mark pop,
                       com.alibaba.fastjson.TypeReference<T> type)
```
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    keys - 列表Key的数组
    
    timeout - 超时时间(秒)
    
    pop - 读取方式
    
    type - TypeReference的泛型对象
    
    返回:
    
    返回被弹出元素的非空值与列表Key的映射表
    
    另请参阅:
    
    bpop(String, Mark)
  - brpoplpush
```
String brpoplpush(String source,
                  String destination)
```
    BRPOPLPUSH 是 RPOPLPUSH 的阻塞版本，当给定列表 source 不为空时， BRPOPLPUSH 的表现和 RPOPLPUSH 一样。
    当列表 source 为空时， BRPOPLPUSH 命令将阻塞连接，直到等待超时，或有另一个客户端对 source 执行 LPUSH 或 RPUSH 命令为止。
    超时参数 timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长(block indefinitely) 。
    Timeout默认为0
    
    参数:
    
    source - the source
    
    destination - the destination
    
    返回:
    
    String
  - brpoplpush
```
<T> T brpoplpush(String source,
                 String destination,
                 com.alibaba.fastjson.TypeReference<T> type)
```
  - brpoplpush
```
String brpoplpush(String source,
                  String destination,
                  int timeout)
```
  - brpoplpush
```
<T> T brpoplpush(String source,
                 String destination,
                 int timeout,
                 com.alibaba.fastjson.TypeReference<T> type)
```
  - lindex
```
String lindex(String key,
              int index)
```
    返回列表 key 中，下标为 index 的元素。
    下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
    你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
    如果 key 不是列表类型，返回一个错误。
    
    参数:
    
    key - the key
    
    index - the index
    
    返回:
    
    list对应index下标的数据
  - lindex
```
<T> T lindex(String key,
             int index,
             com.alibaba.fastjson.TypeReference<T> type)
```
  - linsert
```
long linsert(String key,
             String pivot,
             String value,
             RedisClient.Mark position)
```
    LINSERT key BEFORE|AFTER pivot value
    将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。
    当 pivot 不存在于列表 key 时，不执行任何操作。
    当 key 不存在时， key 被视为空列表，不执行任何操作。
    如果 key 不是列表类型，返回一个错误。
    
    参数:
    
    key - the key
    
    pivot - the pivot
    
    value - the value
    
    position - the position
    
    返回:
    
    long
  - linsert
```
long linsert(String key,
             String pivot,
             Object value,
             RedisClient.Mark position)
```
  - llen
```
long llen(String key)
```
    LLEN key
    返回列表 key 的长度。
    如果 key 不存在，则 key 被解释为一个空列表，返回 0 .
    如果 key 不是列表类型，返回一个错误。
    
    参数:
    
    key - the key
    
    返回:
    
    list长度
  - pop
```
String pop(String key,
           RedisClient.Mark pop)
```
    移除并返回列表 key 的头/尾元素。
    
    参数:
    
    key - the key
    
    pop - the pop
    
    返回:
    
    头或尾的元素
  - pop
```
List<String> pop(String key,
                 int count)
```
  - pop
```
<T> T pop(String key,
          RedisClient.Mark pop,
          com.alibaba.fastjson.TypeReference<T> type)
```
  - pop
```
<T> List<T> pop(String key,
                int count,
                com.alibaba.fastjson.TypeReference<T> type)
```
  - push
```
boolean push(String key,
             String[] values,
             RedisClient.Mark push)
```
  - push
```
boolean push(String key,
             String value,
             RedisClient.Mark push)
```
  - push
```
boolean push(String key,
             Object[] values,
             RedisClient.Mark push)
```
  - push
```
boolean push(String key,
             Object value,
             RedisClient.Mark push)
```
  - push
```
boolean push(String key,
             List<Object> values,
             RedisClient.Mark push)
```
  - push
```
boolean push(String key,
             String scanKey,
             String value,
             RedisClient.Mark push,
             RedisClient.Mark policy)
```
    根据策略(policy)存储列表(key-scanKey或者key-value)与散列(scanKey-value)
    根据写入方式(push)存储列表数据
    
    参数:
    
    key - 列表Key
    
    scanKey - 散列Key
    
    value - 元素值
    
    push - 写入方式(Mark.LPUSH / Mark.RPUSH)
    
    policy - 策略(Mark.KEY / Makr.VALUE)
    
    返回:
    
    如果写入成功则返回true，写入失败返回false
  - push
```
boolean push(String key,
             String scanKey,
             Object value,
             RedisClient.Mark push,
             RedisClient.Mark policy)
```
    根据策略(policy)存储列表(key-scanKey或者key-value)与散列(scanKey-value)
    根据写入方式(push)存储列表数据
    
    参数:
    
    key - 列表Key
    
    scanKey - 散列Key
    
    value - 元素值
    
    push - 写入方式(Mark.LPUSH / Mark.RPUSH)
    
    policy - 策略(Mark.KEY / Makr.VALUE)
    
    返回:
    
    如果写入成功则返回true，写入失败返回false
  - push
```
Map<String,Boolean> push(String key,
                         Map<String,Object> scanMap,
                         RedisClient.Mark push,
                         RedisClient.Mark policy)
```
    根据策略(policy)存储列表(key-scanKey或者key-value)与散列(scanKey-value) 根据写入方式(push)存储列表数据
    
    参数:
    
    key - 列表Key
    
    scanMap - 散列Key-Value集合
    
    push - 写入方式(Mark.LPUSH / Mark.RPUSH)
    
    policy - 策略(Mark.KEY / Makr.VALUE)
    
    返回:
    
    如果写入成功则返回true，写入失败返回false
  - pushx
```
long pushx(String key,
           String[] values,
           RedisClient.Mark push)
```
  - pushx
```
long pushx(String key,
           String value,
           RedisClient.Mark push)
```
  - pushx
```
long pushx(String key,
           Object[] values,
           RedisClient.Mark push)
```
  - pushx
```
long pushx(String key,
           Object value,
           RedisClient.Mark push)
```
  - lrange
```
List<String> lrange(String key,
                    int start,
                    int end)
```
    返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
    下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
    你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
    
    参数:
    
    key - 列表Key
    
    start - 起始位置
    
    end - 结束位置
    
    返回:
    
    元素集合
  - lrange
```
List<String> lrange(String key,
                    int count)
```
  - lrange
```
List<String> lrange(String key)
```
  - lrange
```
<T> List<T> lrange(String key,
                   int start,
                   int end,
                   com.alibaba.fastjson.TypeReference<T> type)
```
    返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
    下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
    你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    key - 列表Key
    
    start - 起始位置
    
    end - 结束位置
    
    type - 泛型对象
    
    返回:
    
    元素集合
  - lrange
```
<T> List<T> lrange(String key,
                   int count,
                   com.alibaba.fastjson.TypeReference<T> type)
```
    返回列表 key 中0到count之间的所有的元素。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    key - 列表Key
    
    count - 数量
    
    type - 泛型对象
    
    返回:
    
    元素集合
  - lrange
```
<T> List<T> lrange(String key,
                   com.alibaba.fastjson.TypeReference<T> type)
```
  - lrangeltrim
```
List<String> lrangeltrim(String key,
                         int count)
```
  - lrangeltrim
```
<T> List<T> lrangeltrim(String key,
                        int count,
                        com.alibaba.fastjson.TypeReference<T> type)
```
  - lrem
```
long lrem(String key,
          int count,
          String value)
```
    根据参数 count 的值，移除列表中与参数 value 相等的元素。
    count 的值可以是以下几种：
    count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
    count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
    count = 0 : 移除表中所有与 value 相等的值。
    
    参数:
    
    key - the key
    
    count - the count
    
    value - the value
    
    返回:
    
    delete size
  - lrem
```
long lrem(String key,
          String value)
```
  - lrem
```
long lrem(String key,
          int count,
          Object value)
```
  - lrem
```
long lrem(String key,
          Object value)
```
  - lset
```
boolean lset(String key,
             int index,
             String value)
```
    将列表 key 下标为 index 的元素的值设置为 value 。
    当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。
    
    参数:
    
    key - the key
    
    index - the index
    
    value - the value
    
    返回:
    
    set value successful
  - lset
```
boolean lset(String key,
             int index,
             Object value)
```
  - ltrim
```
boolean ltrim(String key,
              int start,
              int end)
```
    对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
    
    参数:
    
    key - the key
    
    start - the start
    
    end - the end
    
    返回:
    
    trim successful
  - sadd
```
long sadd(String key,
          String... members)
```
    将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
    假如 key 不存在，则创建一个只包含 member 元素作成员的集合。
    当 key 不是集合类型时，返回一个错误。
    
    参数:
    
    key - 集合Key
    
    members - 元素值动态数组
    
    返回:
    
    被添加到集合中的新元素的数量，不包括被忽略的元素。
  - sadd
```
long sadd(String key,
          Object... members)
```
    将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
    假如 key 不存在，则创建一个只包含 member 元素作成员的集合。
    当 key 不是集合类型时，返回一个错误。
    
    参数:
    
    key - 集合Key
    
    members - 元素对象动态数组
    
    返回:
    
    被添加到集合中的新元素的数量，不包括被忽略的元素。
  - sreplace
```
long sreplace(String key,
              String[] oldMembers,
              String[] newMembers)
```
    替换原有的值
    
    参数:
    
    key - 集合Key
    
    oldMembers - 旧的元素
    
    newMembers - 新的元素
    
    返回:
    
    replace size
  - sreplace
```
long sreplace(String key,
              Object[] oldMembers,
              Object[] newMembers)
```
  - sreplace
```
long sreplace(String key,
              Collection<Object> oldMembers,
              Collection<Object> newMembers)
```
  - scard
```
long scard(String key)
```
    返回集合 key 的基数(集合中元素的数量)。
    
    参数:
    
    key - 集合Key
    
    返回:
    
    集合的基数。当 key 不存在时，返回 0 。
  - scard
```
Map<String,Long> scard(String... keys)
```
    返回集合 key 的基数(集合中元素的数量)。
    
    参数:
    
    keys - 集合Key动态数组
    
    返回:
    
    集合的基数。当 key 不存在时，返回 0 。
  - scard
```
Map<String,Long> scard(Collection<String> keys)
```
    返回集合 key 的基数(集合中元素的数量)。
    
    参数:
    
    keys - 集合Key列表
    
    返回:
    
    集合的基数。当 key 不存在时，返回 0 。
  - sdiff
```
Set<String> sdiff(String... keys)
```
    返回一个集合的全部成员，该集合是所有给定集合之间的差集。不存在的 key 被视为空集。
    
    参数:
    
    keys - 集合Key动态数组
    
    返回:
    
    一个包含差集成员的列表。
  - sdiff
```
<T> Set<T> sdiff(String[] keys,
                 com.alibaba.fastjson.TypeReference<T> type)
```
    返回一个集合的全部成员，该集合是所有给定集合之间的差集。不存在的 key 被视为空集。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    keys - 集合Key动态数组
    
    type - 需要转换的TypeReference泛型类型
    
    返回:
    
    一个包含差集成员的列表。
  - sdiff
```
<T> Set<T> sdiff(Collection<String> keys,
                 com.alibaba.fastjson.TypeReference<T> type)
```
    返回一个集合的全部成员，该集合是所有给定集合之间的差集。不存在的 key 被视为空集。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    keys - 集合Key动态数组
    
    type - 需要转换的TypeReference泛型类型
    
    返回:
    
    一个包含差集成员的列表。
  - sdiffstore
```
long sdiffstore(String destination,
                String... keys)
```
    这个命令的作用和 SDIFF 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。
    如果 destination 集合已经存在，则将其覆盖。
    destination 可以是 key 本身。
    
    参数:
    
    destination - 目标集合Key
    
    keys - 集合Key动态数组
    
    返回:
    
    结果集中的元素数量。
  - sinter
```
Set<String> sinter(String... keys)
```
    返回一个集合的全部成员，该集合是所有给定集合的交集。
    不存在的 key 被视为空集。
    当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。
    
    参数:
    
    keys - 集合Key动态数组
    
    返回:
    
    交集成员的列表。
  - sinter
```
<T> Set<T> sinter(String[] keys,
                  com.alibaba.fastjson.TypeReference<T> type)
```
    返回一个集合的全部成员，该集合是所有给定集合的交集。
    不存在的 key 被视为空集。
    当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    keys - 集合Key数组
    
    type - 需要转换的TypeReference泛型类型
    
    返回:
    
    交集成员的列表。
  - sinter
```
<T> Set<T> sinter(Collection<String> keys,
                  com.alibaba.fastjson.TypeReference<T> type)
```
    返回一个集合的全部成员，该集合是所有给定集合的交集。
    不存在的 key 被视为空集。
    当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    keys - 集合Key列表
    
    type - 需要转换的TypeReference泛型类型
    
    返回:
    
    交集成员的列表。
  - sinterstore
```
long sinterstore(String destination,
                 String... keys)
```
    这个命令类似于 SINTER 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
    如果 destination 集合已经存在，则将其覆盖。
    destination 可以是 key 本身。
    
    参数:
    
    destination - 目标集合Key
    
    keys - 集合Key动态数组
    
    返回:
    
    结果集中的成员数量。
  - sismember
```
boolean sismember(String key,
                  String member)
```
    判断 member 元素是否集合 key 的成员。
    
    参数:
    
    key - 集合Key
    
    member - 元素值
    
    返回:
    
    如果 member 元素是集合的成员，返回 true 。如果 member 元素不是集合的成员，或 key 不存在，返回 false 。
  - sismember
```
boolean sismember(String key,
                  Object member)
```
    判断 member 元素是否集合 key 的成员。
    
    参数:
    
    key - 集合Key
    
    member - 元素对象
    
    返回:
    
    如果 member 元素是集合的成员，返回 true 。如果 member 元素不是集合的成员，或 key 不存在，返回 false 。
  - smembers
```
Set<String> smembers(String key)
```
    返回集合 key 中的所有成员。不存在的 key 被视为空集合。
    
    参数:
    
    key - 集合Key
    
    返回:
    
    集合中的所有成员。
  - smembers
```
<T> Set<T> smembers(String key,
                    com.alibaba.fastjson.TypeReference<T> type)
```
    返回集合 key 中的所有成员。不存在的 key 被视为空集合。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    key - 集合Key
    
    type - 需要转换的TypeReference泛型类型
    
    返回:
    
    集合中的所有成员。
  - smove
```
boolean smove(String source,
              String destination,
              String member)
```
    将 member 元素从 source 集合移动到 destination 集合。
    
    参数:
    
    source - 源集合Key
    
    destination - 目标集合Key
    
    member - 元素值
    
    返回:
    
    如果 member 元素被成功移除，返回 true 。
    如果 member 元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 false 。
  - smove
```
Map<String,Boolean> smove(String source,
                          String destination,
                          String... members)
```
    将 member 元素从 source 集合移动到 destination 集合。
    
    参数:
    
    source - 源集合Key
    
    destination - 目标集合Key
    
    members - 元素值动态数组
    
    返回:
    
    如果 member 元素被成功移除，返回 true 。
    如果 member 元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 false 。
  - smove
```
boolean smove(String source,
              String destination,
              Object member)
```
    将 member 元素从 source 集合移动到 destination 集合。
    
    参数:
    
    source - 源集合Key
    
    destination - 目标集合Key
    
    member - 元素对象
    
    返回:
    
    如果 member 元素被成功移除，返回 true 。
    如果 member 元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 false 。
  - smove
```
Map<Object,Boolean> smove(String source,
                          String destination,
                          Object... members)
```
    将 member 元素从 source 集合移动到 destination 集合。
    
    参数:
    
    source - 源集合Key
    
    destination - 目标集合Key
    
    members - 元素对象动态数组
    
    返回:
    
    如果 member 元素被成功移除，返回 true 。
    如果 member 元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 false 。
  - spop
```
String spop(String key)
```
    移除并返回集合中的一个随机元素。
    如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER 命令。
    
    参数:
    
    key - 集合Key
    
    返回:
    
    被移除的随机元素。当 key 不存在或 key 是空集时，返回 nil 。
  - spop
```
<T> T spop(String key,
           com.alibaba.fastjson.TypeReference<T> type)
```
    移除并返回集合中的一个随机元素。
    如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER 命令。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    key - 集合Key
    
    type - 需要转换的TypeReference泛型类型
    
    返回:
    
    被移除的随机元素。当 key 不存在或 key 是空集时，返回 nil 。
  - spop
```
Set<String> spop(String key,
                 int count)
```
    移除并返回集合中的{count}个随机元素。
    如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER 命令。
    
    参数:
    
    key - 集合Key
    
    count - 获取元素的数量
    
    返回:
    
    被移除的随机元素集合。当 key 不存在或 key 是空集时，返回 nil 。
  - spop
```
<T> Set<T> spop(String key,
                int count,
                com.alibaba.fastjson.TypeReference<T> type)
```
    移除并返回集合中的{count}个随机元素。
    如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER 命令。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    key - 集合Key
    
    count - 获取元素的数量
    
    type - 需要转换的TypeReference泛型类型
    
    返回:
    
    被移除的随机元素集合。当 key 不存在或 key 是空集时，返回 nil 。
  - srandmember
```
String srandmember(String key)
```
    返回集合中的一个随机元素
    
    参数:
    
    key - 集合Key
    
    返回:
    
    返回一个元素；如果集合为空，返回 null
  - srandmember
```
<T> T srandmember(String key,
                  com.alibaba.fastjson.TypeReference<T> type)
```
    返回集合中的一个随机元素
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    key - 集合Key
    
    type - 需要转换的TypeReference泛型类型
    
    返回:
    
    返回一个元素；如果集合为空，返回 null
  - srandmember
```
List<String> srandmember(String key,
                         int count)
```
    如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。
    如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。
    
    参数:
    
    key - 集合Key
    
    count - 获取元素的数量
    
    返回:
    
    返回一个List集合；如果集合为空，返回空集合。
  - srandmember
```
<T> List<T> srandmember(String key,
                        int count,
                        com.alibaba.fastjson.TypeReference<T> type)
```
    如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。
    如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    key - 集合Key
    
    count - 获取元素的数量
    
    type - 需要转换的TypeReference泛型类型
    
    返回:
    
    返回一个List集合；如果集合为空，返回空集合。
  - srem
```
long srem(String key,
          String... members)
```
    移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
    
    参数:
    
    key - 集合Key
    
    members - 元素值动态数组
    
    返回:
    
    rem member size
  - srem
```
long srem(String key,
          Object... members)
```
    移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
    
    参数:
    
    key - 集合Key
    
    members - 元素对象动态数组
    
    返回:
    
    rem member size
  - sunion
```
Set<String> sunion(String... keys)
```
    返回一个集合的全部成员，该集合是所有给定集合的并集。
    不存在的 key 被视为空集。
    
    参数:
    
    keys - 集合Key动态数组
    
    返回:
    
    并集成员的列表。
  - sunion
```
<T> Set<T> sunion(String[] keys,
                  com.alibaba.fastjson.TypeReference<T> type)
```
    返回一个集合的全部成员，该集合是所有给定集合的并集。
    不存在的 key 被视为空集。
    
    类型参数:
    
    T - TypeReference type
    
    参数:
    
    keys - 集合Key数组
    
    type - 需要转换的TypeReference泛型类型
    
    返回:
    
    并集成员的列表。
  - sunionstore
```
long sunionstore(String destination,
                 String... keys)
```
    这个命令类似于 SUNION 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
    如果 destination 已经存在，则将其覆盖。
    destination 可以是 key 本身。
    
    参数:
    
    destination - 目标集合Key
    
    keys - 集合Key动态数组
    
    返回:
    
    结果集中的元素数量。
  - zadd
```
long zadd(String key,
          double score,
          String member)
```
    将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
    如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
    score 值可以是整数值或双精度浮点数。
    如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。
    当 key 存在但不是有序集类型时，返回一个错误。
    
    参数:
    
    key - the key
    
    score - the score
    
    member - the member
    
    返回:
    
    被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。
  - zadd
```
long zadd(String key,
          double score,
          Object member)
```
  - zadd
```
long zadd(String key,
          Map<Object,Double> values)
```
  - zcard
```
long zcard(String key)
```
  - zcount
```
long zcount(String key,
            double min,
            double max)
```
  - zcount
```
long zcount(String key)
```
  - zcount
```
long zcount(String key,
            String min,
            String max)
```
  - zlexcount
```
long zlexcount(String key,
               String min,
               String max)
```
  - zincrby
```
double zincrby(String key,
               double increment,
               String member)
```
    为有序集 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 - the key
    
    increment - the increment
    
    member - the member
    
    返回:
    
    member 成员的新 score 值
  - zincrby
```
<T> double zincrby(String key,
                   double increment,
                   T member)
```
  - zrange
```
Set<String> zrange(String key,
                   long start,
                   long end)
```
    返回有序集 key 中，指定区间内的成员。
    其中成员的位置按 score 值递增(从小到大)来排序。
    具有相同 score 值的成员按字典序(lexicographical order )来排列。
    如果你需要成员按 score 值递减(从大到小)来排列，请使用 ZREVRANGE 命令。
    下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。
    你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。
    超出范围的下标并不会引起错误。
    比如说，当 start 的值比有序集的最大下标还要大，或是 start > stop 时， ZRANGE 命令只是简单地返回一个空列表。
    另一方面，假如 stop 参数的值比有序集的最大下标还要大，那么 Redis 将 stop 当作最大下标来处理。
    
    参数:
    
    key - the key
    
    start - the start
    
    end - the end
    
    返回:
    
    指定区间内，有序集成员的列表。
  - zrange
```
Set<String> zrange(String key,
                   long end)
```
  - zrange
```
Set<String> zrange(String key)
```
  - zrange
```
<T> Set<T> zrange(String key,
                  long start,
                  long end,
                  com.alibaba.fastjson.TypeReference<T> type)
```
  - zrange
```
<T> Set<T> zrange(String key,
                  long end,
                  com.alibaba.fastjson.TypeReference<T> type)
```
  - zrange
```
<T> Set<T> zrange(String key,
                  com.alibaba.fastjson.TypeReference<T> type)
```
  - zrangeByLex
```
Set<String> zrangeByLex(String key,
                        String min,
                        String max,
                        int offset,
                        int count)
```
  - zrangeByLex
```
<T> Set<T> zrangeByLex(String key,
                       String min,
                       String max,
                       int offset,
                       int count,
                       com.alibaba.fastjson.TypeReference<T> type)
```
  - zrangeWithScores
```
<T> Map<T,Double> zrangeWithScores(String key,
                                   long start,
                                   long end,
                                   com.alibaba.fastjson.TypeReference<T> type)
```
  - zrangeWithScores
```
<T> Map<T,Double> zrangeWithScores(String key,
                                   long end,
                                   com.alibaba.fastjson.TypeReference<T> type)
```
  - zrangeWithScores
```
<T> Map<T,Double> zrangeWithScores(String key,
                                   com.alibaba.fastjson.TypeReference<T> type)
```
  - zrangeByScore
```
Set<String> zrangeByScore(String key,
                          double min,
                          double max)
```
  - zrangeByScore
```
Set<String> zrangeByScore(String key,
                          double min,
                          double max,
                          int offset,
                          int count)
```
  - zrangeByScore
```
Set<String> zrangeByScore(String key,
                          String min,
                          String max)
```
  - zrangeByScore
```
Set<String> zrangeByScore(String key,
                          String min,
                          String max,
                          int offset,
                          int count)
```
  - zrangeByScore
```
<T> Set<T> zrangeByScore(String key,
                         double min,
                         double max,
                         com.alibaba.fastjson.TypeReference<T> type)
```
  - zrangeByScore
```
<T> Set<T> zrangeByScore(String key,
                         double min,
                         double max,
                         int offset,
                         int count,
                         com.alibaba.fastjson.TypeReference<T> type)
```
  - zrangeByScore
```
<T> Set<T> zrangeByScore(String key,
                         String min,
                         String max,
                         com.alibaba.fastjson.TypeReference<T> type)
```
  - zrangeByScore
```
<T> Set<T> zrangeByScore(String key,
                         String min,
                         String max,
                         int offset,
                         int count,
                         com.alibaba.fastjson.TypeReference<T> type)
```
  - zrangeByScoreWithScores
```
<T> Map<T,Double> zrangeByScoreWithScores(String key,
                                          double min,
                                          double max,
                                          com.alibaba.fastjson.TypeReference<T> type)
```
  - zrangeByScoreWithScores
```
<T> Map<T,Double> zrangeByScoreWithScores(String key,
                                          String min,
                                          String max,
                                          com.alibaba.fastjson.TypeReference<T> type)
```
  - zrangeByScoreWithScores
```
<T> Map<T,Double> zrangeByScoreWithScores(String key,
                                          double min,
                                          double max,
                                          int offset,
                                          int count,
                                          com.alibaba.fastjson.TypeReference<T> type)
```
  - zrangeByScoreWithScores
```
<T> Map<T,Double> zrangeByScoreWithScores(String key,
                                          String min,
                                          String max,
                                          int offset,
                                          int count,
                                          com.alibaba.fastjson.TypeReference<T> type)
```
  - zrank
```
long zrank(String key,
           String member)
```
  - zrank
```
<T> long zrank(String key,
               T member)
```
  - zrem
```
long zrem(String key,
          String... members)
```
  - zrem
```
<T> long zrem(String key,
              T... members)
```
  - zremrangeByLex
```
long zremrangeByLex(String key,
                    String min,
                    String max)
```
  - zremrangeByRank
```
long zremrangeByRank(String key,
                     long start,
                     long end)
```
    移除有序集 key 中，指定排名(rank)区间内的所有成员。
    区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内。
    下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。
    你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。
    
    参数:
    
    key - the key
    
    start - the start
    
    end - the end
    
    返回:
    
    被移除成员的数量。
  - zremrangeByScore
```
long zremrangeByScore(String key,
                      double min,
                      double max)
```
  - zremrangeByScore
```
long zremrangeByScore(String key,
                      String start,
                      String end)
```
  - zrevrange
```
Set<String> zrevrange(String key,
                      long start,
                      long end)
```
  - zrevrange
```
Set<String> zrevrange(String key,
                      long end)
```
  - zrevrange
```
Set<String> zrevrange(String key)
```
  - zrevrange
```
<T> Set<T> zrevrange(String key,
                     long start,
                     long end,
                     com.alibaba.fastjson.TypeReference<T> type)
```
  - zrevrange
```
<T> Set<T> zrevrange(String key,
                     long end,
                     com.alibaba.fastjson.TypeReference<T> type)
```
  - zrevrange
```
<T> Set<T> zrevrange(String key,
                     com.alibaba.fastjson.TypeReference<T> type)
```
  - zrevrangeByLex
```
Set<String> zrevrangeByLex(String key,
                           String max,
                           String min)
```
  - zrevrangeByLex
```
<T> Set<T> zrevrangeByLex(String key,
                          String max,
                          String min,
                          com.alibaba.fastjson.TypeReference<T> type)
```
  - zrevrangeByLex
```
Set<String> zrevrangeByLex(String key,
                           String max,
                           String min,
                           int offset,
                           int count)
```
  - zrevrangeByLex
```
<T> Set<T> zrevrangeByLex(String key,
                          String max,
                          String min,
                          int offset,
                          int count,
                          com.alibaba.fastjson.TypeReference<T> type)
```
  - zrevrangeWithScores
```
<T> Map<T,Double> zrevrangeWithScores(String key,
                                      long start,
                                      long end,
                                      com.alibaba.fastjson.TypeReference<T> type)
```
  - zrevrangeWithScores
```
<T> Map<T,Double> zrevrangeWithScores(String key,
                                      long end,
                                      com.alibaba.fastjson.TypeReference<T> type)
```
  - zrevrangeWithScores
```
<T> Map<T,Double> zrevrangeWithScores(String key,
                                      com.alibaba.fastjson.TypeReference<T> type)
```
  - zrevrangeByScore
```
Set<String> zrevrangeByScore(String key,
                             double max,
                             double min)
```
  - zrevrangeByScore
```
Set<String> zrevrangeByScore(String key,
                             double max,
                             double min,
                             int offset,
                             int count)
```
  - zrevrangeByScore
```
<T> Set<T> zrevrangeByScore(String key,
                            double max,
                            double min,
                            com.alibaba.fastjson.TypeReference<T> type)
```
  - zrevrangeByScore
```
<T> Set<T> zrevrangeByScore(String key,
                            double max,
                            double min,
                            int offset,
                            int count,
                            com.alibaba.fastjson.TypeReference<T> type)
```
  - zrevrangeByScoreWithScores
```
<T> Map<T,Double> zrevrangeByScoreWithScores(String key,
                                             double max,
                                             double min,
                                             com.alibaba.fastjson.TypeReference<T> type)
```
  - zrevrangeByScoreWithScores
```
<T> Map<T,Double> zrevrangeByScoreWithScores(String key,
                                             double max,
                                             double min,
                                             int offset,
                                             int count,
                                             com.alibaba.fastjson.TypeReference<T> type)
```
  - zrevrank
```
long zrevrank(String key,
              String member)
```
  - zrevrank
```
<T> long zrevrank(String key,
                  T member)
```
  - zscore
```
double zscore(String key,
              String member)
```
  - zscore
```
<T> double zscore(String key,
                  T member)
```

接口 RedisClient

嵌套类概要

方法概要

方法详细资料

info

info

del

del

exists

expire

expire

expireat

ttl

keys

append

append

append

append

get

get

get

get

get

getset

set

set

set

setByNX

setByNX

setByNX

setByEX

setByEX

setByEX

setByEX

strLen

hdel

hexists

hget

hmget

hget

hmget

hgetAll

hgetAll

hkeys

hkeys

hlen

hset

hset

hmset

hsetByNX

hsetByNX

hsetByNX

hvals

hvals

bpop

bpop

bpop

bpop

bpop

bpop

bpop

bpop

brpoplpush

brpoplpush

brpoplpush

brpoplpush

lindex

lindex

linsert

linsert

llen

pop

pop

pop

pop

push

push

push

push

push