package com.yxkong.common.utils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.apache.log4j.Logger;
import org.junit.Test;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.BitOP;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisPubSub;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.SortingParams;
import redis.clients.jedis.Transaction;
import redis.clients.jedis.Tuple;
import redis.clients.jedis.ZParams;
import redis.clients.jedis.ZParams.Aggregate;
/**
* Redis 工具类
* @author yxkong
*/
public class RedisUtil {
protected static Logger logger = Logger.getLogger(RedisUtil.class);
private static JedisPool jedisPool = null;
public final static int EXRP_HOUR = 60*60; //一小时
public final static int EXRP_DAY = 60*60*24; //一天
public final static int EXRP_MONTH = 60*60*24*30; //一个月
public final static String ASC="asc"; //正序
public final static String DESC="desc"; //倒序
static{
try {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(50);
config.setMaxIdle(5);
config.setMaxWaitMillis(1000*10);
config.setTestOnBorrow(true);
jedisPool = new JedisPool(config, "192.168.1.37", 6379, 1000*5);
} catch (Exception e) {
logger.error("create JedisPool error : "+e);
}
}
/**
* @return Jedis
*/
public synchronized Jedis getJedis() {
Jedis jedis = null;
try {
if (jedisPool != null) {
jedis = jedisPool.getResource();
}
} catch (Exception e) {
logger.error("Get jedis error : "+e);
}
return jedis;
}
/* ######################## key键命令 start ###############################*/
/**
* 删除一个或多个key
* @param keys
* @since >=1.0.0
* @return
*/
public Long del(String... keys){
return getJedis().del(keys);
}
/**
* 序列化给定 key ，并返回被序列化的值
* @param key
* @since >=2.6.0
* @return
*/
public byte[] dump(String key){
return getJedis().dump(key);
}
/**
* 判断key是否存在
* @param key
* @since >=1.0.0
* @return
*/
public Boolean exists(String key){
return getJedis().exists(key);
}
/**
* 给key设置生存时间
* @param key
* @param seconds 生存时间（秒）
* @since >=1.0.0
*/
public Long expire(String key,int seconds){
return getJedis().expire(key, seconds);
}
/**
* 给key设置生存时间
* @param key
* @param unixTime unix时间戳，已秒为单位
* @since >=1.2.0
* @return
*/
public Long expireAt(String key,long unixTime){
return getJedis().expireAt(key, unixTime);
}
/**
* 根据表达式匹配所有的key
* @param pattern
* <p> ‘*’表示所有，‘?’表示单个<p>
<p> ‘*’ 匹配数据库中所有 key 。<p>
<p> h?llo 匹配 hello ， hallo 和 hxllo 等。<p>
<p> h*llo 匹配 hllo 和 heeeeello 等。<p>
<p> h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。<p>
<p> 特殊符号用 \ 隔开<p>
@since >=1.0.0
* @return 返回找到的key的set集合
*/
public Set<String> keys(String pattern){
return getJedis().keys(pattern);
}
/**
* 将 key 原子性地从当前实例传送到目标实例的指定数据库上，一旦传送成功， key 保证会出现在目标实例上，而当前实例上的 key 会被删除。
* @param host 目标redis ip
* @param port 目标redis 端口
* @param key 要移动的key
* @param destinationDb 目标数据库（默认0-15）
* @param timeout 超时时间
* @since >=2.6.0
* @return 迁移成功时返回 OK ，否则返回相应的错误
*/
public String migrate(String host,int port,String key,int destinationDb,int timeout){
return getJedis().migrate(host, port, key, destinationDb, timeout);
}
/**
* 将当前数据库的 key 移动到给定的数据库 db 当中<br>
* 如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。
* @param key
* @param destinationDb 默认0-15
* @since >=1.0.0
* @return
*/
public Long move(String key,int destinationDb){
return getJedis().move(key, destinationDb);
}
/**
* 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。
* @param key
* @since 2.2.0
* @return 当生存时间移除成功时，返回 1 .如果 key 不存在或 key 没有设置生存时间，返回 0
*/
public Long persist(String key){
return getJedis().persist(key);
}
/**
* 这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令那样，以秒为单位
* @param key
* @param milliseconds 毫秒时间
* @since 2.6.0
* @return
*/
public Long pexpire(String key,long milliseconds){
return getJedis().pexpire(key, milliseconds);
}
/**
* 这个命令和 EXPIREAT 命令类似，但它以毫秒为单位设置 key 的过期 unix 时间戳，而不是像 EXPIREAT 那样，以秒为单位
* @param key
* @param milliseconds
* @since >=2.6.0
* @return
*/
public Long pexpireAt(String key,long millisecondsTimestamp){
return getJedis().pexpireAt(key, millisecondsTimestamp);
}
/**
* 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
* @param key
* @since >=1.0.0
* @return 当 key 不存在时，返回 -2 。<br> 当 key 存在但没有设置剩余生存时间时，返回 -1 。<br>否则，以秒为单位，返回 key 的剩余生存时间。
*/
public Long ttl(String key){
return getJedis().ttl(key);
}
/**
* 这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间，而不是像 TTL 命令那样，以秒为单位。
* @param key
* @since >=2.6.0
* @return 当 key 不存在时，返回 -2 。<br> 当 key 存在但没有设置剩余生存时间时，返回 -1 。<br> 否则，以毫秒为单位，返回 key 的剩余生存时间。
*/
public Long pttl(String key){
return getJedis().pttl(key);
}
/**
* 从当前数据库中随机返回(不删除)一个 key 。
* @since >=1.0.0
* @return 当数据库不为空时，返回一个 key 。<br>当数据库为空时，返回 nil 。
*/
public String randomKey(){
return getJedis().randomKey();
}
/**
* 将 key 改名为 newkey 。<br>
* 当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。当 newkey 已经存在时， RENAME 命令将覆盖旧值。
* @param oldkey
* @param newKey
* @since >=1.0.0
* @return 改名成功时提示 OK ，失败时候返回一个错误。
*/
public String rename(String oldkey,String newkey){
return getJedis().rename(oldkey, newkey);
}
/**
* 当且仅当 newkey不存在时修改成功
* @param oldkey
* @param newkey
* @since >=1.0.0
* @return 修改成功时，返回 1 。 <br>如果 newkey 已经存在，返回 0 。
*/
public Long renameEnx(String oldkey,String newkey){
return getJedis().renamenx(oldkey, newkey);
}
/**
* 反序列化给定的序列化值，并将它和给定的 key 关联，
* @param key
* @param ttl 以毫秒为单位为key设置生存时间，为0表示不设置时间
* @param serializedValue
* @since >=2.6.0
* @return
*/
public String restore(String key,int ttl,byte[] serializedValue){
return getJedis().restore(key, ttl, serializedValue);
}
/**
* 正倒序排序集合
* @param key asc 正序排， desc 倒序排
* @param sortType
* @since >=1.0.0
* @return
*/
public List<String> sort(String key,String sortType){
SortingParams sp=new SortingParams();
if(sortType==null||ASC.equals(sortType)){
sp.desc();
return getJedis().sort(key, sp.asc());
}else{
return getJedis().sort(key, sp.desc());
}
}
/**
* 集合排序
* x = [1, 2, 3]
y = [a, b, c]
k1 = z
k2 = y
k3 = x
w1 = 9
w2 = 8
w3 = 7
* <p>SortingParams sp=new SortingParams();</p>
* <p>正序排:
sort(x) or sort(x, sp.asc())
-> [1, 2, 3]</p>
<p>倒序排
sort(x, sp.desc())
-> [3, 2, 1]</p>
<p>
sort(y)
-> [c, a, b]</p>
<p>以第一个字母正序排
sort(y, sp.alpha())
-> [a, b, c]</p>
<p> 以第一个字母倒序排
sort(y, sp.alpha().desc())
-> [c, a, b]</p>
<p>limit 分页取，类似于mysql</p>
<p>从索引 0开始，正序取两个
Limit (e.g. for Pagination):
sort(x, sp.limit(0, 2))
-> [1, 2]</p>
<p>以首字母倒序排，从索引1开始取两个
sort(y, sp.alpha().desc().limit(1, 2))
-> [b, a]</p>
<p>使用外部key排序</p>
<p> 以w1,w2,w3的顺序的排序方式排序
sort(x, sb.by(w*))
-> [3, 2, 1]</p>
<p>以w1,w2,w3的倒序的排序方式排序
sort(x, sb.by(w*).desc())
-> [1, 2, 3]</p>
Getting external keys:
sort(x, sp.by(w*).get(k*))
-> [x, y, z]
sort(x, sp.by(w*).get(#).get(k*))
-> [3, x, 2, y, 1, z]
* @param key
* @param sortingParams
* @since >=1.0.0
* @return
*/
public List<String> sort(String key,SortingParams sortingParams){
return getJedis().sort(key, sortingParams);
}
/**
* 返回 key 所储存的值的类型。
* @param key
* @since 1.0.0
* @return none (key不存在)<br>string (字符串)<br>list (列表)<br>set (集合)<br>zset (有序集)<br>hash (哈希表)
*/
public String type(String key){
return getJedis().type(key);
}
/**
* 用于迭代当前数据库中的数据库键。
* @param cursor 自己填写从0开始,值不确定
* @since >=2.8.0
* @return ScanResult getStringCursor() 获取返回的游标，如果为0代表结束<br>
* getResult() 返回迭代出的key的集合，默认10条
*/
public ScanResult<String> scan(String cursor){
return getJedis().scan(cursor);
}
/**
* 命令用于迭代当前数据库中的数据库键。
* @param cursor 自己填写从0开始,值不确定
* @param scanParams
* count 返回多少条记录
* match 先迭代，后过滤，可能为空，但返回的游标不为0
* @since >=2.8.0
* @return ScanResult getStringCursor() 获取返回的游标，如果为0代表结束<br>
* getResult() 返回迭代出的key的集合，默认10条
*/
public ScanResult<String> scan(String cursor, ScanParams scanParams){
return getJedis().scan(cursor, scanParams);
}
/* ######################## key键命令 end ###############################*/
/* ######################## String（字符串）start ###############################*/
/**
* 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。<br>
* 如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
* @param key
* @param value
* @return 追加 value 之后， key 中字符串的长度。
*/
public Long append(String key ,String value){
return getJedis().append(key, value);
}
/**
* 计算给定字符串中，被设置为 1 的比特位的数量。<br>
* 存在的 key 被当成是空字符串来处理，因此对一个不存在的 key 进行 BITCOUNT 操作，结果为 0 。
* @param key
* @return 被设置为 1 的位的数量。
*/
public Long bitcount(String key){
return getJedis().bitcount(key);
}
/**
* 计算给定字符串中，被设置为 1 的比特位的数量。
* 存在的 key 被当成是空字符串来处理，因此对一个不存在的 key 进行 BITCOUNT 操作，结果为 0 。
* @param key
* @param start
* @param end start 和 end 参数的设置和 GETRANGE 命令类似，都可以使用负数值： 比如 -1 表示最后一个字节， -2 表示倒数第二个字节，以此类推。
* @return 被设置为 1 的位的数量。
*/
public Long bitcount(String key,long start,long end){
return getJedis().bitcount(key, start, end);
}
/**
* 对一个或多个保存二进制位的字符串 key 进行位元操作，并将结果保存到 destkey 上。
* @param op AND 、 OR 、 NOT 、 XOR 这四种操作中的任意一种
* @param destKey
* @param srcKeys
* @return
*/
public Long bitop(BitOP op,String destKey,String... srcKeys){
return getJedis().bitop(op, destKey, srcKeys);
}
/**
* 将 key 中储存的数字值减一。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
* @param key
* @return 执行 DECR 命令之后 key 的值
*/
public Long decr(String key){
return getJedis().decr(key);
}
/**
* 将 key 所储存的值减去减量 decrement 。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECRBY 操作。
* @param key
* @param decrement
* @return 减去 decrement 之后， key 的值。
*/
public Long decrBy(String key,Long decrement){
return getJedis().decrBy(key, decrement);
}
/**
* 返回 key 所关联的字符串值,如果 key 不存在那么返回特殊值 nil
* 假如 key 储存的值不是字符串类型，返回一个错误，因为 GET 只能用于处理字符串值。
* @param key
* @return 当 key 不存在时，返回 nil ，否则，返回 key 的值。
如果 key 不是字符串类型，那么返回一个错误。
*/
public String get(String key){
return getJedis().get(key);
}
/**
* 对 key 所储存的字符串值，获取指定偏移量上的位(bit)。当 offset 比字符串值的长度大，或者 key 不存在时，返回 0
* @param key
* @param offset
* @return
*/
public Boolean getBit(String key,long offset){
return getJedis().getbit(key, offset);
}
/**
* 截取key对应的字符串，指定开始和结束位置，包含开始和结束位置
* @param key
* @param startOffset
* @param endOffset
* @return 截取得出的字符串。
*/
public String getRange(String key,Long startOffset,Long endOffset){
return getJedis().getrange(key, startOffset, endOffset);
}
/**
* 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。当 key 存在但不是字符串类型时，返回一个错误。
* @param key
* @param value
* @return 返回给定 key 的旧值。当 key 没有旧值时，也即是， key 不存在时，返回 nil 。
*/
public String getSet(String key,String value){
return getJedis().getSet(key, value);
}
/**
* 将 key 中储存的数字值增一。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
* 本操作的值限制在 64 位(bit)有符号数字表示之内。
* @param key
* @return 执行 INCR 命令之后 key 的值。
*/
public Long incr(String key){
return getJedis().incr(key);
}
/**
* 将 key 所储存的值加上增量 increment 。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
* 本操作的值限制在 64 位(bit)有符号数字表示之内。
* @param key
* @param increment
* @return 加上 increment 之后， key 的值。
*/
public Long incrBy(String key,Long increment){
return getJedis().incrBy(key, increment);
}
/**
* 为 key 中所储存的值加上浮点数增量 increment。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
* 本操作的值限制在 64 位(bit)有符号数字表示之内。
* 当以下任意一个条件发生时，返回一个错误：
key 的值不是字符串类型(因为 Redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型）
key 当前的值或者给定的增量 increment 不能解释(parse)为双精度浮点数(double precision floating point number）
除此之外，无论加法计算所得的浮点数的实际精度有多长， INCRBYFLOAT 的计算结果也最多只能表示小数点的后十七位。
* @param key
* @param increment
* @return 执行命令之后 key 的值。
*/
public Double incrByFloat(String key,double increment){
return getJedis().incrByFloat(key, increment);
}
/**
* 返回指定keys的列表数据
* @param keys
* @return 一个包含所有给定 key 的值的列表。
*/
public List<String> mget(String... keys){
return getJedis().mget(keys);
}
/**
* 同时设置一个或多个 key-value 对。
* 如果某个给定 key 已经存在，那么 MSET 会用新值覆盖原来的旧值，如果这不是你所希望的效果，请考虑使用 MSETNX 命令：它只会在所有给定 key 都不存在的情况下进行设置操作。
MSET 是一个原子性(atomic)操作，所有给定 key 都会在同一时间内被设置，某些给定 key 被更新而另一些给定 key 没有改变的情况，不可能发生。
* @param keysvalues
* @return 总是返回 OK (因为 MSET 不可能失败)
*/
public String mset(String ...keysvalues){
return getJedis().mset(keysvalues);
}
/**
* 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。
* 即使只有一个给定 key 已存在， MSETNX 也会拒绝执行所有给定 key 的设置操作。
* MSETNX 是原子性的
* @param keysvalues
* @return 当所有 key 都成功设置，返回 1 。
如果所有给定 key 都设置失败(至少有一个 key 已经存在)，那么返回 0 。
*/
public Long msetnx(String ...keysvalues ){
return getJedis().msetnx(keysvalues);
}
/**
* 将字符串值 value 关联到 key。如果 key 已经持有其他值， SET 就覆写旧值，无视类型。
* @param key
* @param value
* @return
* 在 Redis 2.6.12 版本以前， SET 命令总是返回 OK 。
从 Redis 2.6.12 版本开始， SET 在设置操作成功完成时，才返回 OK 。
如果设置了 NX 或者 XX ，但因为条件没达到而造成设置操作未执行，那么命令返回空批量回复（NULL Bulk Reply）。
*/
public String set(String key,String value){
return getJedis().set(key, value);
}
/**
* 将字符串值 value 关联到 key ,
* @param key
* @param value
* @param nxxx NX ：只在键不存在时，才对键进行设置操作。
* XX ：只在键已经存在时，才对键进行设置操作
* @return
*/
public String set(String key,String value,String nxxx){
return getJedis().set(key, value, nxxx);
}
/**
* 将字符串值 value 关联到 key
* @param key
* @param value
* @param nxxx NX ：只在键不存在时，才对键进行设置操作。
* XX ：只在键已经存在时，才对键进行设置操作
* @param expx EX second ：设置键的过期时间为 second 秒
* PX millisecond ：设置键的过期时间为 millisecond 毫秒
* @param time
* @return
*/
public String set(String key,String value,String nxxx,String expx,int time){
return getJedis().set(key, value, nxxx, expx, time);
}
/**
* 对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)。位的设置或清除取决于 value 参数，可以是 0 也可以是 1
* 当 key 不存在时，自动生成一个新的字符串值。
* @param key
* @param offset
* @param value
* @return 指定偏移量原来储存的位
*/
public Boolean setbit(String key,long offset ,String value){
return getJedis().setbit(key, offset, value);
}
/**
* 对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)。位的设置或清除取决于 value 参数，可以是 0 也可以是 1
* 当 key 不存在时，自动生成一个新的字符串值。
* @param key
* @param offset
* @param value
* @return 指定偏移量原来储存的位
*/
public Boolean setbit(String key,long offset ,Boolean value){
return getJedis().setbit(key, offset, value);
}
/**
* 将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)。
* 如果 key 已经存在， SETEX 命令将覆写旧值。
* @param key
* @param seconds
* @param value
* @return 设置成功时返回 OK 。
当 seconds 参数不合法时，返回一个错误。
*/
public String setex(String key,int seconds,String value){
return getJedis().setex(key, seconds, value);
}
/**
* 这个命令和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，而不是像 SETEX 命令那样，以秒为单位。
* @param key
* @param milliseconds
* @param value
* @return
*/
public String psetex(String key,long milliseconds ,String value){
return getJedis().psetex(key, milliseconds, value);
}
/**
* 将 key 的值设为 value ，当且仅当 key 不存在.若给定的 key 已经存在，则 SETNX 不做任何动作
* @param key
* @param value
* @return
* 设置成功，返回 1 。设置失败，返回 0 。
*/
public Long setnx(String key,String value){
return getJedis().setnx(key, value);
}
/**
* 给key对应的字符串的第offset位开始替换为 value值
* @param key
* @param offset
* @param value
* @return 被 SETRANGE 修改之后，字符串的长度。
*/
public Long setrange(String key, long offset,String value){
return getJedis().setrange(key, offset, value);
}
/**
* 返回 key 所储存的字符串值的长度,当 key 储存的不是字符串值时，返回一个错误。
* @param key
* @return 字符串值的长度。当 key 不存在时，返回 0 。
*/
public Long strlen(String key){
return getJedis().strlen(key);
}
/* ######################## String（字符串）end ###############################*/
/* ######################## Hash（哈希表）start ###############################*/
/**
* 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
* @param key
* @param fields
* @return 被成功移除的域的数量，不包括被忽略的域。
*/
public Long hdel(String key,String... fields){
return getJedis().hdel(key, fields);
}
/**
* 查看哈希表 key 中，给定域 field 是否存在。
* @param key
* @param field
* @return 如果哈希表含有给定域，返回 1 。如果哈希表不含有给定域，或 key 不存在，返回 0 。
*/
public Boolean hexists(String key,String field){
return getJedis().hexists(key, field);
}
/**
* 返回哈希表 key 中给定域 field 的值。
* @param key
* @param field
* @return 给定域的值。当给定域不存在或是给定 key 不存在时，返回 nil 。
*/
public String hget(String key,String field){
return getJedis().hget(key, field);
}
/**
* 返回哈希表 key 中，所有的域和值。在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。
* @param key
* @return 以列表形式返回哈希表的域和域的值。若 key 不存在，返回空列表。
*/
public Map<String,String> hgetAll(String key){
return getJedis().hgetAll(key);
}
/**
* 为哈希表 key 中的域 field 的值加上增量 increment ,增量也可以为负数，相当于对给定域进行减法操作。
* 如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。如果域 field 不存在，那么在执行命令前，域的值被初始化为 0 。
* 对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。本操作的值被限制在 64 位(bit)有符号数字表示之内。
* @param key
* @param field
* @param increment
* @return
*/
public Long hincrBy(String key,String field,long increment){
return getJedis().hincrBy(key, field, increment);
}
/**
* 为哈希表 key 中的域 field 加上浮点数增量 increment 。如果哈希表中没有域 field ，那么 HINCRBYFLOAT 会先将域 field 的值设为 0 ，然后再执行加法操作。
如果键 key 不存在，那么 HINCRBYFLOAT 会先创建一个哈希表，再创建域 field ，最后再执行加法操作。
当以下任意一个条件发生时，返回一个错误：
域 field 的值不是字符串类型(因为 redis 中的数字和浮点数都以字符串的形式保存，所以它们都属于字符串类型）
域 field 当前的值或给定的增量 increment 不能解释(parse)为双精度浮点数(double precision floating point number)
* @param key
* @param field
* @param increment
* @return 执行加法操作之后 field 域的值
*/
public Double hincrByFloat(String key,String field,double increment ){
return getJedis().hincrByFloat(key, field, increment);
}
/**
* 返回哈希表 key 中的所有域。
* @param key
* @return 一个包含哈希表中所有域的表。 当 key 不存在时，返回一个空表。
*/
public Set<String> hkeys(String key){
return getJedis().hkeys(key);
}
/**
* 返回哈希表 key 中域的数量。
* @param key
* @return 哈希表中域的数量。当 key 不存在时，返回 0
*/
public Long hlen(String key){
return getJedis().hlen(key);
}
/**
* 返回哈希表 key 中，一个或多个给定域的值。如果给定的域不存在于哈希表，那么返回一个 nil 值。
* 因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表
* @param key
* @param fields
* @return 一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。
*/
public List<String> hmget(String key,String...fields){
return getJedis().hmget(key, fields);
}
/**
* 同时将多个 field-value (域-值)对设置到哈希表 key 中,此命令会覆盖哈希表中已存在的域
* @param key
* @param map
* @return 如果命令执行成功，返回 OK 。当 key 不是哈希表(hash)类型时，返回一个错误。
*/
public String hmset(String key,Map<String,String> map ){
return getJedis().hmset(key, map);
}
/**
* 将哈希表 key 中的域 field 的值设为 value 。如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。如果域 field 已经存在于哈希表中，旧值将被覆盖。
* @param key
* @param field
* @param value
* @return 如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1 。如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 0 。
*/
public Long hset(String key,String field,String value){
return getJedis().hset(key, field, value);
}
/**
* 当且仅当域 field 不存在时， 将哈希表 key 中的域 field 的值设置为 value。
* 若域 field 已经存在，该操作无效。
* @param key
* @param field
* @param value
* @return 设置成功，返回 1 。 如果给定域已经存在且没有操作被执行，返回 0 。
*/
public Long hsetnx(String key,String field,String value){
return getJedis().hsetnx(key, field, value);
}
/**
* 返回哈希表 key 中所有域的值。
* @param key
* @return 一个包含哈希表中所有值的表。当 key 不存在时，返回一个空表。
*/
public List<String> hvals(String key){
return getJedis().hvals(key);
}
/**
* 命令用于迭代哈希键中的键值对
* @param key 自己填写从0开始,值不确定
* @param cursor
* @since >=2.8.0
* @return ScanResult getStringCursor() 获取返回的游标，如果为0代表结束<br>
* getResult() 返回迭代出的key的集合，默认10条
*/
public ScanResult<Entry<String,String>> hscan(String key,String cursor){
return getJedis().hscan(key, cursor);
}
/**
* 命令用于迭代哈希键中的键值对
* @param cursor 自己填写从0开始,值不确定
* @param scanParams
* count 返回多少条记录
* match 先迭代，后过滤，可能为空，但返回的游标不为0
* @since >=2.8.0
* @return ScanResult getStringCursor() 获取返回的游标，如果为0代表结束<br>
* getResult() 返回迭代出的key的集合，默认10条
*/
public ScanResult<Entry<String,String>> hscan(String key,String cursor,ScanParams params) {
return getJedis().hscan(key, cursor, params);
}
/* ######################## Hash（哈希表）end ###############################*/
/* ######################## List（列表）start ###############################*/
/**
* 获取keys对应的列表 第一个不为空的头元素
* 非阻塞行为
* 当 BLPOP 被调用时，如果给定 key 内至少有一个非空列表，那么弹出遇到的第一个非空列表的头元素，并和被弹出元素所属的列表的名字一起，组成结果返回给调用者。
* 阻塞行为
* 如果所有给定 key 都不存在或包含空列表，那么 BLPOP 命令将阻塞连接，直到等待超时，或有另一个客户端对给定 key 的任意一个执行 LPUSH 或 RPUSH 命令为止。
* @param keys
* @return
* 如果列表为空，返回一个 nil 。
否则，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。
*/
public List<String> blpop(String...keys){
return getJedis().blpop(keys);
}
/**
* 获取keys对应的列表 第一个不为空的头元素
* 非阻塞行为
* 当 BLPOP 被调用时，如果给定 key 内至少有一个非空列表，那么弹出遇到的第一个非空列表的头元素，并和被弹出元素所属的列表的名字一起，组成结果返回给调用者。
* 阻塞行为
* 如果所有给定 key 都不存在或包含空列表，那么 BLPOP 命令将阻塞连接，直到等待超时，或有另一个客户端对给定 key 的任意一个执行 LPUSH 或 RPUSH 命令为止。
* @param timeout 超时时间
* @param keys
* @return
* 如果列表为空，返回一个 nil 。
否则，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。
*/
public List<String> blpop(int timeout,String...keys){
return getJedis().blpop(timeout, keys);
}
/**
* 获取keys对应的列表 第一个不为空的尾元素
* 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的尾部元素。
* @param keys
* @return 假如在指定时间内没有任何元素被弹出，则返回一个 nil 和等待时长。
反之，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。
*/
public List<String> brpop(String... keys){
return getJedis().brpop(keys);
}
/**
* 获取keys对应的列表 第一个不为空的尾元素
* 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的尾部元素。
* @param timeout 超时时间
* @param keys
* @return 假如在指定时间内没有任何元素被弹出，则返回一个 nil 和等待时长。
反之，返回一个含有两个元素的列表，第一个元素是被弹出元素所属的 key ，第二个元素是被弹出元素的值。
*/
public List<String> brpop(int timeout,String... keys){
return getJedis().brpop(timeout, keys);
}
/**
* 非阻塞
* 将srckey对应列表的尾元素弹出返回客户端，并将该元素放入到dstkey对应列表的头部
* 如果 srckey 和 dstkey 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转(rotation)操作。
* @param srckey
* @param dstkey
* @return
*/
public String rpoplpush(String srckey,String dstkey){
return getJedis().rpoplpush(srckey, dstkey);
}
/**
* srckey 不为空时和rpoplpush效果一样
* srckey为空时，将阻塞连接，直到超时或有另一个客户端对 source 执行 LPUSH 或 RPUSH 命令为止。
* @param source
* @param destination
* @param timeout 接受一个以秒为单位的数字作为值。超时参数设为 0 表示阻塞时间可以无限期延长
* @return
*/
public String brpoplpush(String srckey,String dstkey,int timeout){
return getJedis().brpoplpush(srckey, dstkey, timeout);
}
/**
* 返回key对应的列表对应index索引的值
* @param key
* @param index 以 0 表示列表的第一个元素 以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素
* @return 列表中下标为 index 的元素。
*/
public String lindex(String key,long index){
return getJedis().lindex(key, index);
}
/**
*根据where 将value值插入到key对应的列表pivot位置之前或之后
* @param key
* @param where BEFORE|AFTER 之前or之后
* @param pivot 要插入值的位置
* @param value
* @return 如果命令执行成功，返回插入操作完成之后，列表的长度。
如果没有找到 pivot ，返回 -1 。如果 key 不存在或为空列表，返回 0 。
*/
public Long linsert(String key,LIST_POSITION where,String pivot,String value){
return getJedis().linsert(key, where, pivot, value);
}
/**
* 返回key对应的列表的长度，如果key不是列表类型，返回一个错误
* @param key
* @return 列表长度
*/
public Long llen(String key){
return getJedis().llen(key);
}
/**
* 移除并返回key对应列表的头元素
* @param key
* @return 列表的头元素 当 key 不存在时，返回 nil
*/
public String lpop(String key){
return getJedis().lpop(key);
}
/**
* 将一个或多个值插入到key对应的列表的表头，key不存在生成一个空列表并放入
* @param key
* @param values
* @return 返回列表长度
*/
public Long lpush(String key,String...values){
return getJedis().lpush(key, values);
}
/**
* 当key存在并是一个列表时，将values插入表头
* @param key
* @param values
* @return 返回列表长度
*/
public Long lpushx(String key,String... values){
return getJedis().lpushx(key, values);
}
/**
* 返回列表指定区间的元素，包含startIndex和stopIndex
* @param key
* @param startIndex
* @param stopIndex
* @return
*/
public List<String> lrange(String key,long startIndex,long stopIndex){
return getJedis().lrange(key, startIndex, stopIndex);
}
/**
* 根据参数 count 的值，移除列表中与参数 value 相等的元素。
* @param key
* @param count
* count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
* count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值
* count = 0 : 移除表中所有与 value 相等的值
* @param value
* @return 被移除元素的数量。因为不存在的 key 被视作空表(empty list)，所以当 key 不存在时， LREM 命令总是返回 0 。
*/
public Long lrem(String key,Long count,String value){
return getJedis().lrem(key, count, value);
}
/**
* 将key对应得列表下标为index的元素的值设置为value
* 当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。
* @param key
* @param index
* @param value
* @return 操作成功返回 ok ，否则返回错误信息
*/
public String lset(String key,Long index,String value){
return getJedis().lset(key, index, value);
}
/**
* 对key对应的列表进行修剪，只保留[startIndex,stopIndex]区间内的值
* @param key
* @param startIndex
* @param stopIndex
* @return 命令执行成功时，返回 ok
*/
public String ltrim(String key,long startIndex,long stopIndex){
return getJedis().ltrim(key, startIndex, stopIndex);
}
/**
* 移除并返回列表的尾元素
* @param key
* @return 列表的尾元素。当 key 不存在时，返回 nil 。
*/
public String rpop(String key){
return getJedis().rpop(key);
}
/**
* 将一个或多个值插入到表尾，如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。
* @param key
* @param values
* @return 执行 RPUSH 操作后，表的长度。
*/
public Long rpush(String key,String...values){
return getJedis().rpush(key, values);
}
/**
* 将一个或多个值插入到表尾，当 key 不存在时， LPUSHX 命令什么也不做。
* @param key
* @param values
* @return RPUSHX 命令执行之后，表的长度
*/
public Long rpushx(String key,String...values){
return getJedis().rpushx(ASC, values);
}
/* ######################## List（列表）end ###############################*/
/* ######################## Set（集合）start ###############################*/
/**
* 将一个或多个value元素加入到集合中，已存在的元素将被忽略，key不存在创建新的集合
* @param key
* @param values
* @return 被添加到集合中的新元素的数量，不包括被忽略的元素
*/
public Long sadd(String key,String...values){
return getJedis().sadd(ASC, values);
}
/**
* 返回集合的size
* @param key
* @return 集合的size，key不存在返回0
*/
public Long scard(String key){
return getJedis().scard(key);
}
/**
* 返回 第一个集合不在后面集合中的值
* @param keys
* @return 一个包含差集成员的列表
*/
public Set<String> sdiff(String...keys){
return getJedis().sdiff(keys);
}
/**
* 将keys的差集保存到dstkey集合中
* @param dstkey
* @param keys
* @return 结果集中的元素数量。
*/
public Long sdiffstore(String dstkey,String... keys){
return getJedis().sdiffstore(dstkey, keys);
}
/**
* 返回keys集合的交集
* @param keys
* @return 交集成员的列表
*/
public Set<String> sinter(String...keys){
return getJedis().sinter(keys);
}
/**
* 将keys集合的交集保存到dstkey中，并返回长度
* @param dstkey
* @param keys
* @return
*/
public Long sinterstore(String dstkey,String... keys){
return getJedis().sinterstore(dstkey, keys);
}
/**
* 判断member是否是key对应的集合的成员
* @param key
* @param member
* @return
*/
public Boolean sismember(String key,String member){
return getJedis().sismember(key, member);
}
/**
* 返回key对应的集合，key不存在返回空集合
* @param key
* @return
*/
public Set<String> smembers(String key){
return getJedis().smembers(key);
}
/**
* 将member从srckey对应的集合移动到dstkey对应的集合，原子操作
* 当dstkey已经有member时，只会将srckey的member删掉
* @param srckey
* @param dstkey
* @param member
* @return 如果 member 元素被成功移除，返回 1 。如果 member 元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 0 。
*/
public Long smove(String srckey,String dstkey,String member){
return getJedis().smove(srckey, dstkey, member);
}
/**
* 移除并返回集合中的一个随机元素
* @param key
* @return
*/
public String spop(String key){
return getJedis().spop(key);
}
/**
* 随机返回并移除count个元素
* @param key
* @param count
* @return
*/
public Set<String> spop(String key,long count){
return getJedis().spop(key, count);
}
/**
* 随机返回集合的一个元素
* @param key
* @return
*/
public String srandmember(String key){
return getJedis().srandmember(key);
}
/**
* 随机返回集合的count个元素
* @param key
* @param count
* 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。
* 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值
* @return
*/
public List<String> srandmember(String key,int count){
return getJedis().srandmember(key, count);
}
/**
* 移除集合中的一个或多个member元素，不存在的member元素会忽略
* @param key
* @param members
* @return 被成功移除的元素的数量，不包括被忽略的元素。
*/
public Long srem(String key,String...members){
return getJedis().srem(key, members);
}
/**
* 返回所有集合的并集，不存在的key被视为空集
* @param keys
* @return 并集成员的列表
*/
public Set<String> sunion(String...keys){
return getJedis().sunion(keys);
}
/**
* 将keys所有集合的并集存储到dstkey对应的集合，如果dstkey存在则覆盖
* @param dstkey
* @param keys
* @return 结果集中的元素数量
*/
public Long sunionstore(String dstkey,String...keys){
return getJedis().sunionstore(dstkey, keys);
}
/**
* 命令用于迭代集合键中的元素
* @param key 自己填写从0开始,值不确定
* @param cursor
* @return ScanResult getStringCursor() 获取返回的游标，如果为0代表结束<br>
* getResult() 返回迭代出的key的集合，默认10条
*/
public ScanResult<String> sscan(String key,String cursor){
return getJedis().sscan(key, cursor);
}
/**
* 命令用于迭代集合键中的元素
* @param cursor 自己填写从0开始,值不确定
* @param scanParams
* count 返回多少条记录
* match 先迭代，后过滤，可能为空，但返回的游标不为0
* @return ScanResult getStringCursor() 获取返回的游标，如果为0代表结束<br>
* getResult() 返回迭代出的key的集合，默认10条
*/
public ScanResult<String> sscan(String key,String cursor,ScanParams params) {
return getJedis().sscan(key, cursor, params);
}
/* ######################## Set（集合）end ###############################*/
/* ######################## SortedSet（有序集合）start ###############################*/
/**
* 将一个member元素及其score值加入到有序集合中，按score排序
* @param key
* @param score
* @param member
* @return 被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员
*/
public Long zadd(String key,double score,String member){
return getJedis().zadd(key, score, member);
}
/**
* 将一个或多个member元素及其score值加入到有序集合中，按score排序
* @param key
* @param scoreMembers
* @return 被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员
*/
public Long zadd(String key,Map<String,Double> scoreMembers){
return getJedis().zadd(key, scoreMembers);
}
/**
* 返回有序集合的size
* @param key
* @return 当 key 存在且是有序集类型时，返回有序集的基数，当 key 不存在时，返回 0
*/
public Long zcard(String key){
return getJedis().zcard(key);
}
/**
* 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量
* @param key
* @param min
* @param max
* @return 返回符合条件的有序集合的size
*/
public Long zcount(String key,Double min,Double max){
return getJedis().zcount(key, min, max);
}
/**
* 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量
* @param key
* @param min (1 变成开区间的
* @param max (5 变成开区间
* @return 返回符合条件的有序集合的size
*/
public Long zcount(String key,String min,String max){
return getJedis().zcount(key, min, max);
}
/**
* 为key对应的有序集合的member的socore增加increment
* 当 key 不存在，或 member 不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。
* @param key
* @param increment 值可以是整数值或双精度浮点数
* @param member
* @return member 成员的新 score 值
*/
public Double zincrby(String key,Double increment ,String member){
return getJedis().zincrby(key, increment , member);
}
/**
* 返回有序集合指定区间内的成员
* 集合按score值从小到大排序，第一个成员对应的下标是0
* @param key
* @param startIndex
* @param endIndex
* @return 指定区间内的有序集成员的列表
*/
public Set<String> zrange(String key,Long startIndex,Long endIndex){
return getJedis().zrange(key, startIndex, endIndex);
}
/**
* 返回有序集合指定区间内的成员和其对应的score
* @param key
* @param startIndex
* @param endIndex
* @return 指定区间内，带有 score 值的有序集成员的列表
*/
public Set<Tuple> zrangeWithScores(String key,Long startIndex,Long endIndex){
return getJedis().zrangeWithScores(key, startIndex, endIndex);
}
/**
* 返回key对应的有序集合中所有score值介于min和max之间（包含等于min或max）的成员。
* @param key
* @param min
* @param max
* @return 返回 max>=score>=min的值
*/
public Set<String> zrangeByScore(String key,double min,double max){
return getJedis().zrangeByScore(key, min, max);
}
/**
* 返回key对应的有序集合中所有score值介于min和max之间（包含等于min或max）的成员
* offset count参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )，注意当 offset 很大时，定位 offset 的操作可能需要遍历整个有序集
* @param key
* @param min 默认是闭区间 表示score>=min
* @param max 默认是闭区间 表示score<=max
* @param offset 开始索引
* @param count 返回的数量
* @return 返回 max>=score>=min的值
*/
public Set<String> zrangeByScore(String key,double min,double max,int offset,int count){
return getJedis().zrangeByScore(key, min, max, offset, count);
}
/**
* 返回key对应的有序集合中所有score值介于min和max之间（可以是min,max开区间）的成员。
* @param key
* @param min 可以是开区间 (1 表示score>1
* @param max 可以是开区间 (5 表示score<5
* @return 返回 max>=score>=min或 max>score>min的值
*/
public Set<String> zrangeByScore(String key,String min,String max){
return getJedis().zrangeByScore(key, min, max);
}
/**
* 返回key对应的有序集合中所有score值介于min和max之间（可以是min,max开区间）的成员
* offset count参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )，注意当 offset 很大时，定位 offset 的操作可能需要遍历整个有序集
* @param key
* @param min 可以是开区间 (1 表示score>1
* @param max 可以是开区间 (5 表示score<5
* @param offset 开始索引
* @param count 返回的数量
* @return 返回 max>=score>=min或 max>score>min的值
*/
public Set<String> zrangeByScore(String key,String min,String max,int offset,int count){
return getJedis().zrangeByScore(key, min, max, offset, count);
}
/**
* 返回key对应的有序集合中所有score值介于min和max之间（包含等于min或max）的成员。
* @param key
* @param min
* @param max
* @return 返回 max>=score>=min的值
*/
public Set<Tuple> zrangeByScoreWithScores(String key,double min,double max){
return getJedis().zrangeByScoreWithScores(key, min, max);
}
/**
* 返回key对应的有序集合中所有score值介于min和max之间（包含等于min或max）的成员
* offset count参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )，注意当 offset 很大时，定位 offset 的操作可能需要遍历整个有序集
* @param key
* @param min
* @param max
* @param offset 开始索引
* @param count 返回的数量
* @return
*/
public Set<Tuple> zrangeByScoreWithScores(String key,double min,double max,int offset,int count){
return getJedis().zrangeByScoreWithScores(key, min, max, offset, count);
}
/**
* 返回key对应的有序集合中所有score值介于min和max之间（可以是min,max开区间）的成员。
* @param key
* @param min 可以是开区间 (1 表示score>1
* @param max 可以是开区间 (5 表示score<5
* @return 返回 max>=score>=min或 max>score>min的值
*/
public Set<Tuple> zrangeByScoreWithScores(String key,String min,String max){
return getJedis().zrangeByScoreWithScores(key, min, max);
}
/**
* 返回key对应的有序集合中所有score值介于min和max之间（可以是min,max开区间）的成员
* offset count参数指定返回结果的数量及区间(就像SQL中的 SELECT LIMIT offset, count )，注意当 offset 很大时，定位 offset 的操作可能需要遍历整个有序集
* @param key
* @param min 可以是开区间 (1 表示score>1
* @param max 可以是开区间 (5 表示score<5
* @param offset 开始索引
* @param count 返回的数量
* @return 返回 max>=score>=min或 max>score>min的值
*/
public Set<Tuple> zrangeByScoreWithScores(String key,String min,String max,int offset,int count){
return getJedis().zrangeByScoreWithScores(key, min, max, offset, count);
}
/**
* 返回有序集合中成员member的下标，有序集合按score值从小到大排
* @param key
* @param member
* @return 如果 member 是有序集 key 的成员，返回 member 的排名，如果 member 不是有序集 key 的成员，返回 nil
*/
public Long zrank(String key,String member){
return getJedis().zrank(key, member);
}
/**
* 移除有序集合中对应的members的成员，不存在的成员被忽略
* @param key
* @param members
* @return 被成功移除的成员的数量，不包括被忽略的成员
*/
public Long zrem(String key,String...members){
return getJedis().zrem(key, members);
}
/**
* 移除有序集合中，指定排名（rank）区间内的所有成员
* @param key
* @param startIndex 开始下标
* @param endIndex 结束下标
* @return 被移除成员的数量
*/
public Long zremrangeByRank(String key,Long startIndex,Long endIndex){
return getJedis().zremrangeByRank(key, startIndex, endIndex);
}
/**
* 移除有序集合中所有score值介于min和max（包括等于min或max）区间的值
* @param key
* @param min
* @param max
* @return 被移除的成员
*/
public Long zremrangeByScore(String key,double min,double max){
return getJedis().zremrangeByScore(key, min, max);
}
/**
* 移除有序集合中所有score值介于min和max区间的值,min,max加上(表示不包含
* @param key
* @param min (1 score>1
* @param max 5 score<=5
* @return 被移除的成员
*/
public Long zremrangeByScore(String key,String min,String max){
return getJedis().zremrangeByScore(key, min, max);
}
/**
* 对于一个所有成员的分值都相同的有序集合键 key 来说， 这个命令会返回该集合中， 成员介于 min 和 max 范围内的元素数量
* @param key
* @param min 必须包含(或者[ (表示开区间 [表示闭区间 (1 index>1
* @param max 必须包含(或者[ (表示开区间 [表示闭区间
* 特殊值 + 和 - 在 min 参数以及 max 参数中具有特殊的意义， 其中 + 表示正无限， 而 - 表示负无限
* @since >=2.8.9
* @return
*/
public Long zremrangeByLex(String key,String min,String max){
return getJedis().zremrangeByLex(key, min, max);
}
/**
* 返回有序集合中指定区间的成员,成员按score递减排序
* @param key
* @param startIndex 0
* @param endIndex -1表示无穷大
* @return 指定区间内的有序集成员的列表
*/
public Set<String> zrevrange(String key,long startIndex,long endIndex){
return getJedis().zrevrange(key, startIndex, endIndex);
}
/**
* 返回有序集合中指定区间的成员,成员按score递减排序
* @param key
* @param startIndex
* @param endIndex -1表示无穷大
* @return 指定区间内，带有 score 值的有序集成员的列表
*/
public Set<Tuple> zrevrangeWithScores(String key,long startIndex,long endIndex){
return getJedis().zrevrangeWithScores(key, startIndex, endIndex);
}
/**
* 返回有序集中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。
* @param key
* @param min
* @param max
* @return 指定区间内的有序集成员的列表
*/
public Set<String> zrevrangeByScores(String key,double min,double max){
return getJedis().zrevrangeByScore(key, max, min);
}
/**
* 返回有序集中， score 值介于 max 和 min 之间的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。
* @param key
* @param min (1 score>1
* @param max 5 score<=5
* @return 指定区间内的有序集成员的列表
*/
public Set<String> zrevrangeByScores(String key,String min,String max){
return getJedis().zrevrangeByScore(key, max, min);
}
/**
* 返回有序集中， score 值介于 max 和 min 之间(默认包括等于 max 或 min )的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。
* @param key
* @param min
* @param max
* @param offset 开始索引
* @param count 返回数量
* @return 指定区间内的有序集成员的列表
*/
public Set<String> zrevrangeByScores(String key,double min,double max,int offset,int count){
return getJedis().zrevrangeByScore(key, max, min,offset,count);
}
/**
* 返回有序集中， score 值介于 max 和 min 之间的所有的成员。有序集成员按 score 值递减(从大到小)的次序排列。
* @param key
* @param min (1 score>1
* @param max 5 score<=5
* @param offset 开始索引
* @param count 返回数量
* @return 指定区间内的有序集成员的列表
*/
public Set<String> zrevrangeByScores(String key,String min,String max,int offset,int count){
return getJedis().zrevrangeByScore(key, max, min,offset,count);
}
public Set<Tuple> zrevrangeByScoreWithScores(String key,double min,double max){
return getJedis().zrevrangeByScoreWithScores(key, max, min);
}
public Set<Tuple> zrevrangeByScoreWithScores(String key,String min,String max){
return getJedis().zrevrangeByScoreWithScores(key, max, min);
}
public Set<Tuple> zrevrangeByScoreWithScores(String key,double min,double max,int offset,int count){
return getJedis().zrevrangeByScoreWithScores(key, max, min,offset,count);
}
public Set<Tuple> zrevrangeByScoreWithScores(String key,String min,String max,int offset,int count){
return getJedis().zrevrangeByScoreWithScores(key, max, min,offset,count);
}
/**
* 返回集合成员member的排名，按score从大到小的排序
* @param key
* @param member
* @return 如果 member 是有序集 key 的成员，返回 member 的排名,如果 member 不是有序集 key 的成员，返回空
*/
public Long zrevrank(String key,String member){
return getJedis().zrevrank(key, member);
}
/**
* 返回有序集合中成员member的score值，member或者key不存在返回空
* @param key
* @param member
* @return
*/
public Double zscore(String key,String member){
return getJedis().zscore(key, member);
}
/**
* 将一个或多个有序集合的并集存储到dstkey,dstkey存在则覆盖
* 默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。
* @param dstkey
* @param keys
* @return 保存到 dstkey 的结果集的基数
*/
public Long zunionstore(String dstkey,String... keys){
return getJedis().zunionstore(dstkey, keys);
}
/**
* 将一个或多个有序集合的并集存储到dstkey,dstkey存在则覆盖
* 默认情况下，结果集中某个成员的 score 值是所有给定集下该成员 score 值之 和 。
* @param dstkey
* @param params
* weightsByDouble 你可以为 每个 给定有序集 分别 指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子。如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1
* aggregate 指定并集的结果集的聚合方式
* 默认参数 SUM 可以将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值
* MIN 可以将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值
* MAX 将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值
* @param keys
* @return 保存到 dstkey 的结果集的基数
*/
public Long zunionstore(String dstkey,ZParams params,String... keys){
return getJedis().zunionstore(dstkey, params, keys);
}
/**
* 将一个或多个有序集合的交集存储到dstkey，dstkey存在则覆盖
* 默认情况下：结果集中某个成员的 score 值是所有给定集下该成员 score 值之和
* @param dstkey
* @param keys
* @return 保存到 dstkey 的结果集的基数
*/
public Long zinterstore(String dstkey,String...keys){
return getJedis().zinterstore(dstkey, keys);
}
/**
* 将一个或多个有序集合的交集存储到dstkey，dstkey存在则覆盖,
* 默认情况下：结果集中某个成员的 score 值是所有给定集下该成员 score 值之和
* @param dstkey
* @param params
* weightsByDouble 你可以为 每个 给定有序集 分别 指定一个乘法因子(multiplication factor)，每个给定有序集的所有成员的 score 值在传递给聚合函数(aggregation function)之前都要先乘以该有序集的因子。如果没有指定 WEIGHTS 选项，乘法因子默认设置为 1
* aggregate 指定并集的结果集的聚合方式
* 默认参数 SUM 可以将所有集合中某个成员的 score 值之 和 作为结果集中该成员的 score 值
* MIN 可以将所有集合中某个成员的 最小 score 值作为结果集中该成员的 score 值
* MAX 将所有集合中某个成员的 最大 score 值作为结果集中该成员的 score 值
* @param keys
* @since >=2.0.0
* @return 保存到 dstkey 的结果集的基数
*/
public Long zinterstore(String dstkey,ZParams params,String... keys){
return getJedis().zinterstore(dstkey, params, keys);
}
/**
* 当有序集合的所有成员都具有相同的分值时， 有序集合的元素会根据成员的字典序（lexicographical ordering）来进行排序， 而这个命令则可以返回给定的有序集合键 key 中， 值介于 min 和 max 之间的成员
* @param key
* @param min 必须包含(或者[ (表示开区间 [表示闭区间 (1 index>1
* @param max 必须包含(或者[ (表示开区间 [表示闭区间<br>
* 特殊值 + 和 - 在 min 参数以及 max 参数中具有特殊的意义， 其中 + 表示正无限， 而 - 表示负无限
* @since >=2.8.9
* @return 包含了有序集合在指定范围内的成员的列表
*/
public Set<String> zrangeByLex(String key,String min,String max){
return getJedis().zrangeByLex(key, min, max);
}
/**
* 当有序集合的所有成员都具有相同的分值时， 有序集合的元素会根据成员的字典序（lexicographical ordering）来进行排序， 而这个命令则可以返回给定的有序集合键 key 中， 值介于 min 和 max 之间的成员
* @param key
* @param min 必须包含(或者[ (表示开区间 [表示闭区间 (1 index>1
* @param max 必须包含(或者[ (表示开区间 [表示闭区间<br>
* 特殊值 + 和 - 在 min 参数以及 max 参数中具有特殊的意义， 其中 + 表示正无限， 而 - 表示负无限
* @param offset 开始索引
* @param count 返回数量
* @since >=2.8.9
* @return 包含了有序集合在指定范围内的成员的列表
*/
public Set<String> zrangeByLex(String key,String min,String max,int offset,int count){
return getJedis().zrangeByLex(key, min, max, offset, count);
}
/**
* 命令用于迭代有序集合中的元素（包括元素成员和元素分值）
* @param key 自己填写从0开始,值不确定
* @param cursor
* @since >=2.8.0
* @return ScanResult getStringCursor() 获取返回的游标，如果为0代表结束<br>
* getResult() 返回迭代出的key的集合，默认10条
*/
public ScanResult<Tuple> zscan(String key,String cursor){
return getJedis().zscan(key, cursor);
}
/**
* 命令用于迭代有序集合中的元素（包括元素成员和元素分值）
* @param cursor 自己填写从0开始,值不确定
* @param scanParams
* count 返回多少条记录
* match 先迭代，后过滤，可能为空，但返回的游标不为0
* @since >=2.8.0
* @return ScanResult getStringCursor() 获取返回的游标，如果为0代表结束<br>
* getResult() 返回迭代出的key的集合，默认10条
*/
public ScanResult<Tuple> zscan(String key,String cursor,ScanParams params) {
return getJedis().zscan(key, cursor, params);
}
/* ######################## SortedSet（有序集合）end ###############################*/
/* ######################## 发布订阅 start ###############################*/
/**
* 订阅一个或多个符合给定模式的频道
* @param jedisPubSub
* @since >=2.0.0
* @param patterns
*/
public void psubscribe(JedisPubSub jedisPubSub,String...patterns){
getJedis().psubscribe(jedisPubSub, patterns);
}
/**
* 将信息 message 发送到指定的频道 channel
* @param channel
* @param message
* @since >= 2.0.0
* @return
*/
public Long pubLish(String channel,String message){
return getJedis().publish(channel, message);
}
/**
* 订阅给定的一个或多个频道的信息。
* @param jedisPubSub
* @param channels
* @since >=2.0.0
*/
public void subscribe(JedisPubSub jedisPubSub,String... channels){
getJedis().subscribe(jedisPubSub, channels);
}
// /** 内省命令
// * 列出当前的活跃频道
// * @param pattern
// * @since >=2.8.0
// * @return 由活跃频道组成的列表
// */
// public List<String> pubsubChannels(String pattern){
// return getJedis().pubsubChannels(pattern);
// }
// /** 内省命令
// * 返回给定频道的订阅者数量， 订阅模式的客户端不计算在内
// * @param channels
// * @since >=2.8.0
// * @return
// */
// public Map<String,String> pubsubNumSub(String... channels){
// return getJedis().pubsubNumSub(channels);
// }
// /** 内省命令
// * 返回订阅模式的数量 是客户端订阅的所有模式的数量总和
// * @since >=2.8.0
// * @return
// */
// public Long pubsubNumPat(){
// return getJedis().pubsubNumPat();
// }
/* ######################## 发布订阅 end ###############################*/
/* ######################## Transaction（事务） start ###############################*/
/**
* 标记一个事务块的开始
* @since >=1.2.0
* @return
*/
public Transaction multi(){
return getJedis().multi();
}
/**
* 监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断
* @param keys
* @since >=2.2.0
* @return 总是返回 OK
*/
public String watch(String...keys){
return getJedis().watch(keys);
}
/**
* 取消 WATCH 命令对所有 key 的监视
* @since >=2.2.0
* @return
*/
public String unwatch(){
return getJedis().unwatch();
}
/* ######################## Transaction（事务） end ###############################*/
/**
* 发布测试
*/
@Test
public void testPub(){
pubLish("news.sport", "北马已经结束了，xx获取了第一名");
pubLish("news.money", "今天股票又跌了6%，大家快来抄底");
pubLish("news.mobile", "小鱼牌手机就要上市了");
}
/**
* 订阅测试
* 先运行 testSub(),再运行testPub()
*/
@Test
public void testSub(){
psubscribe(new TestRedisListener(), "news.*");
}
@Test
public void testscan(){
ScanParams scanParams=new ScanParams();
scanParams.count(15);
scanParams.match("*00*");
ScanResult<String> scan = scan("0",scanParams);
List<String> result = scan.getResult();
logger.info(scan.getStringCursor());
for(String str:result){
logger.info(str);
}
}
/**
* 有序集合测试
*/
@Test
public void testSortSet(){
zadd("yxjh001", 1.5, "小鱼");
zadd("yxjh001", 2, "yxkong");
zadd("yxjh001", 2.5, "鱼翔空");
Map<String,Double> scoreMembers=new HashMap<String, Double>();
scoreMembers.put("小鱼", 1.0);
scoreMembers.put("5ycode", 1.5);
scoreMembers.put("yxkong", 1.0);
zadd("yxjh002", scoreMembers);
logger.info("yxjh001 size:"+zcard("yxjh001")+" 对应score范围 "+zcount("yxjh001", 1.0, 2.0));
logger.info("yxjh002 size:"+zcard("yxjh002")+" 对应score范围 "+zcount("yxjh002", "(1", "(2"));
zincrby("yxjh002", 0.2, "yxkong");
logger.info("yxjh002 size:"+zcard("yxjh002")+" 对应score范围 "+zcount("yxjh002", "(1", "(2"));
logger.info(zrange("yxjh002", 0L, 1L));
logger.info(zrangeByScore("yxjh002", 1, 2));
logger.info(zrangeByScore("yxjh002", "(1", "1.5"));
Set<Tuple> zrangeWithScores = zrangeWithScores("yxjh002", 0L, 1L);
for (Tuple t:zrangeWithScores) {
logger.info("member:"+t.getElement()+" score:"+t.getScore());
}
logger.info(zrevrank("yxjh002", "yxkong"));
logger.info(zrevrank("yxjh002", "yxkong1"));
for(Tuple t:zrangeWithScores("yxjh001", 0L, -1L)){
logger.info("yxjh002:"+t.getElement()+" "+t.getScore());
}
for(Tuple t:zrangeWithScores("yxjh002", 0L, -1L)){
logger.info("yxjh002:"+t.getElement()+" "+t.getScore());
}
logger.info(zunionstore("yxjh003", "yxjh001","yxjh002"));
for(Tuple t:zrangeWithScores("yxjh003", 0L, -1L)){
logger.info("yxjh003:"+t.getElement()+" "+t.getScore());
}
logger.info(zinterstore("yxjh004", "yxjh001","yxjh002"));
for(Tuple t:zrangeWithScores("yxjh004", 0L, -1L)){
logger.info("yxjh004:"+t.getElement()+" "+t.getScore());
}
ZParams params=new ZParams();
params.aggregate(Aggregate.MAX);
logger.info(zinterstore("yxjh005",params, "yxjh001","yxjh002"));
for(Tuple t:zrangeWithScores("yxjh005", 0L, -1L)){
logger.info("yxjh005:"+t.getElement()+" "+t.getScore());
}
}
@Test
public void test(){
Map<String,String> map=new HashMap<String, String>();
String key="user001";
map.put("name", "小鱼");
map.put("sex", "man");
map.put("age", "27");
hmset(key, map);
logger.info(hkeys(key));
logger.info(hvals(key));
logger.info(hgetAll(key));
lpush("userducc", "小鱼","27","男");
// lpushx("useryxk", "鱼翔空","26","男");
logger.info("userducc 长度："+llen("userducc"));
logger.info("useryxk 长度："+llen("useryxk"));
logger.info(lpop("userducc"));
logger.info(rpop("userducc"));
logger.info("userducc 长度："+llen("userducc"));
}
}
package com.yxkong.common.utils;
import org.apache.log4j.Logger;
import redis.clients.jedis.JedisPubSub;
public class TestRedisListener extends JedisPubSub {
protected static Logger logger = Logger.getLogger(TestRedisListener.class);
/**
* 取得订阅消息后的处理
*/
@Override
public void onMessage(String channel, String message) {
// super.onMessage(channel, message);
logger.error("onMessage:"+channel+" "+message);
}
/**
* 初始化订阅的时候处理
*/
@Override
public void onSubscribe(String channel, int subscribedChannels) {
super.onSubscribe(channel, subscribedChannels);
}
/**
* 取消订阅的时候处理
*/
@Override
public void onUnsubscribe(String channel, int subscribedChannels) {
super.onUnsubscribe(channel, subscribedChannels);
}
/**
* 初始化按表达式方式订阅的时候处理
*/
@Override
public void onPSubscribe(String pattern, int subscribedChannels) {
super.onPSubscribe(pattern, subscribedChannels);
}
/**
* 取消按表达式的方式订阅的时候处理
*/
@Override
public void onPUnsubscribe(String pattern, int subscribedChannels) {
super.onPUnsubscribe(pattern, subscribedChannels);
}
/**
* 取得按表达式的方式订阅的消息后的处理
*/
@Override
public void onPMessage(String pattern, String channel, String message) {
// super.onPMessage(pattern, channel, message);
logger.error("onPMessage:"+channel+" "+message);
}
}
文章评论