重大改版
 鱼翔空 2015-09-27 nosql|   0 812 
文章评分 90 次,平均分 5.0
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);
	}
	
}


 

除特别注明外,本站所有文章均为我要编程原创,转载请注明出处来自http://5ycode.com/article/109.html

关于
该用户很懒!
切换注册

登录

忘记密码 ?

切换登录

注册

扫一扫二维码分享