RedisClientImpl (Nano ORM Jedis 1.4.5 API)

java.lang.Object
- org.nanoframework.orm.jedis.AbstractRedisClient
- - org.nanoframework.orm.jedis.sharded.RedisClientImpl

所有已实现的接口:: RedisClient

public class RedisClientImpl
extends AbstractRedisClient

嵌套类概要
- 从接口继承的嵌套类/接口 org.nanoframework.orm.jedis.RedisClient
  RedisClient.Mark

字段概要
- 从类继承的字段 org.nanoframework.orm.jedis.AbstractRedisClient
  DEFAULT_SEPARATOR, INF0, INF1, OK, SUCCESS

构造器概要

构造器
构造器和说明

RedisClientImpl(RedisConfig config)

RedisClientImpl(String type)

构造器
构造器和说明
`RedisClientImpl(RedisConfig config)`
`RedisClientImpl(String type)`

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`long`	`append(String key, String value, String separator)` 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
`Map<String,String>`	`bpop(String[] keys, int timeout, RedisClient.Mark pop)`
`Map<String,String>`	`bpop(String[] keys, RedisClient.Mark pop)`
`String`	`bpop(String key, int timeout, RedisClient.Mark type)`
`String`	`brpoplpush(String source, String destination, int timeout)`
`long`	`del(String... keys)` 删除给定的一个或多个 key 。
`boolean`	`exists(String key)` 检查给定 key 是否存在。
`long`	`expire(String key, int seconds)` 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
`Map<String,String>`	`get(String... keys)` 返回所有(一个或多个)给定 key 的值。
`String`	`get(String key)` 返回 key 所关联的字符串值。
`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 的值。
`Map<String,String>`	`hgetAll(String key)` 返回哈希表 key 中，所有的域和值。
`Set<String>`	`hkeys(String key)` 返回哈希表 key 中的所有域。
`long`	`hlen(String key)` 返回哈希表 key 中域的数量。
`Map<String,String>`	`hmget(String key, String... fields)` 返回哈希表 key 中，一个或多个给定域的值。
`boolean`	`hmset(String key, Map<String,Object> map)` 同时将多个 field-value (域-值)对设置到哈希表 key 中。
`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, String value)` 将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。
`List<String>`	`hvals(String key)` 返回哈希表 key 中所有域的值。
`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 的元素。
`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, int start, int end)` 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
`List<String>`	`lrangeltrim(String key, int count)`
`long`	`lrem(String key, int count, String value)` 根据参数 count 的值，移除列表中与参数 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)`
`String`	`pop(String key, RedisClient.Mark pop)` 移除并返回列表 key 的头/尾元素。
`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, String[] values, 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, String[] values, RedisClient.Mark push)`
`long`	`sadd(String key, String... members)` 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
`Map<String,Long>`	`scard(String... keys)` 返回集合 key 的基数(集合中元素的数量)。
`long`	`scard(String key)` 返回集合 key 的基数(集合中元素的数量)。
`Set<String>`	`sdiff(String... keys)` 返回一个集合的全部成员，该集合是所有给定集合之间的差集。
`long`	`sdiffstore(String destination, String... keys)` 这个命令的作用和 SDIFF 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。
`Map<String,Boolean>`	`set(Map<String,Object> map)` 同时设置一个或多个 key-value 对。
`boolean`	`set(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, String value)` 将字符串值 value 关联到 key, 当且仅当给定 key 不存在时.
`Set<String>`	`sinter(String... keys)` 返回一个集合的全部成员，该集合是所有给定集合的交集。
`long`	`sinterstore(String destination, String... keys)` 这个命令类似于 SINTER 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
`boolean`	`sismember(String key, String member)` 判断 member 元素是否集合 key 的成员。
`Set<String>`	`smembers(String key)` 返回集合 key 中的所有成员。
`boolean`	`smove(String source, String destination, String member)` 将 member 元素从 source 集合移动到 destination 集合。
`String`	`spop(String key)` 移除并返回集合中的一个随机元素。
`Set<String>`	`spop(String key, int count)` 移除并返回集合中的{count}个随机元素。
`String`	`srandmember(String key)` 返回集合中的一个随机元素
`List<String>`	`srandmember(String key, int count)` 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。
`long`	`srem(String key, String... members)` 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
`long`	`sreplace(String key, String[] oldMembers, String[] newMembers)` 替换原有的值
`long`	`strLen(String key)` 返回 key 所储存的字符串值的长度。
`Set<String>`	`sunion(String... keys)` 返回一个集合的全部成员，该集合是所有给定集合的并集。
`long`	`sunionstore(String destination, String... keys)` 这个命令类似于 SUNION 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。
`long`	`ttl(String key)` 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
`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, double min, double max)`
`long`	`zcount(String key, String min, String max)`
`double`	`zincrby(String key, double increment, String member)` 为有序集 key 的成员 member 的 score 值加上增量 increment 。
`long`	`zlexcount(String key, String min, String max)`
`Set<String>`	`zrange(String key, long start, long end)` 返回有序集 key 中，指定区间内的成员。
`Set<String>`	`zrangeByLex(String key, String min, String max, int offset, int count)`
`Set<String>`	`zrangeByScore(String key, String min, String max)`
`Set<String>`	`zrangeByScore(String key, String min, String max, int offset, int count)`
`<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)`
`long`	`zrank(String key, String member)`
`long`	`zrem(String key, String... members)`
`long`	`zremrangeByLex(String key, String min, String max)`
`long`	`zremrangeByRank(String key, long start, long end)` 移除有序集 key 中，指定排名(rank)区间内的所有成员。
`long`	`zremrangeByScore(String key, String start, String end)`
`Set<String>`	`zrevrange(String key, long start, long end)`
`Set<String>`	`zrevrangeByLex(String key, String max, String min)`
`Set<String>`	`zrevrangeByLex(String key, String max, String min, int offset, int count)`
`Set<String>`	`zrevrangeByScore(String key, double max, double min)`
`Set<String>`	`zrevrangeByScore(String key, double max, double min, int offset, int count)`
`<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)`
`long`	`zrevrank(String key, String member)`
`double`	`zscore(String key, String member)`

从类继承的方法 org.nanoframework.orm.jedis.AbstractRedisClient
append, append, append, bpop, bpop, bpop, bpop, bpop, brpoplpush, brpoplpush, brpoplpush, del, expire, expireat, get, get, get, hget, hgetAll, hkeys, hmget, hset, hsetByNX, hvals, lindex, linsert, lrange, lrange, lrange, lrange, lrange, lrangeltrim, lrem, lrem, lrem, lset, pop, pop, push, push, push, push, push, pushx, pushx, pushx, sadd, scard, sdiff, sdiff, set, setByEX, setByEX, setByEX, setByNX, sinter, sinter, sismember, smembers, smove, smove, smove, spop, spop, srandmember, srandmember, srem, sreplace, sreplace, sunion, zadd, zcount, zincrby, zrange, zrange, zrange, zrange, zrange, zrangeByLex, zrangeByScore, zrangeByScore, zrangeByScore, zrangeByScore, zrangeByScore, zrangeByScore, zrangeByScoreWithScores, zrangeByScoreWithScores, zrangeWithScores, zrangeWithScores, zrank, zrem, zremrangeByScore, zrevrange, zrevrange, zrevrange, zrevrange, zrevrange, zrevrangeByLex, zrevrangeByLex, zrevrangeByScore, zrevrangeByScore, zrevrangeWithScores, zrevrangeWithScores, zrevrank, zscore

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

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

类 RedisClientImpl

嵌套类概要

从接口继承的嵌套类/接口 org.nanoframework.orm.jedis.RedisClient

字段概要

从类继承的字段 org.nanoframework.orm.jedis.AbstractRedisClient

构造器概要

方法概要

从类继承的方法 org.nanoframework.orm.jedis.AbstractRedisClient

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

构造器详细资料

RedisClientImpl

RedisClientImpl

方法详细资料

info

info

del

exists

expire

ttl

keys

append

get

get

getset

set

set

setByNX

setByNX

setByEX

strLen

hdel

hexists

hget

hmget

hgetAll

hkeys

hlen

hset

hmset

hsetByNX

hsetByNX

hvals

bpop

bpop

bpop

brpoplpush

lindex

linsert

llen

pop

pop

push

push

push

pushx

lrange

lrangeltrim

lrem

lset

ltrim

sadd

sreplace

scard

scard

sdiff

sdiffstore

sinter

sinterstore

sismember

smembers

smove

spop

spop

srandmember

srandmember

srem

sunion

sunionstore

zadd

zadd