redis 工具类

package cn.zto.util;  
  
import java.util.List;  
import java.util.Map;  
import java.util.Set;  
  
import org.junit.Test;  
  
  
import redis.clients.jedis.Jedis;  
import redis.clients.jedis.JedisPool;  
import redis.clients.jedis.JedisPoolConfig;  
import redis.clients.jedis.BinaryClient.LIST_POSITION;  
  
/** 
 * <p>redis通用工具类</p> 
 * @author bigSea 
 * 
 */  
public class RedisUtil {  
      
    private JedisPool pool = null;  
      
    /** 
     * <p>传入ip和端口号构建redis 连接池</p> 
     * @param ip ip 
     * @param prot 端口 
     */  
    public RedisUtil(String ip, int prot) {  
        if (pool == null) {  
            JedisPoolConfig config = new JedisPoolConfig();  
            // 控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；  
            // 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。  
            config.setMaxActive(500);  
            // 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。  
            config.setMaxIdle(5);  
            // 表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；  
            config.setMaxWait(1000 * 100);  
            // 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；  
            config.setTestOnBorrow(true);  
            // pool = new JedisPool(config, "192.168.0.121", 6379, 100000);  
            pool = new JedisPool(config, ip, prot, 100000);  
        }  
    }  
  
    /** 
     * <p>通过配置对象 ip 端口 构建连接池</p> 
     * @param config 配置对象 
     * @param ip ip 
     * @param prot 端口 
     */  
    public RedisUtil(JedisPoolConfig config ,String ip, int prot){  
        if (pool == null) {  
            pool = new JedisPool(config,ip,prot,10000);  
        }  
    }  
      
    /** 
     * <p>通过配置对象 ip 端口 超时时间 构建连接池</p> 
     * @param config 配置对象 
     * @param ip ip 
     * @param prot 端口 
     * @param timeout 超时时间 
     */  
    public RedisUtil(JedisPoolConfig config ,String ip, int prot ,int timeout){  
        if (pool == null) {  
            pool = new JedisPool(config,ip,prot,timeout);  
        }  
    }  
      
    /** 
     * <p>通过连接池对象 构建一个连接池</p> 
     * @param pool 连接池对象 
     */  
    public RedisUtil(JedisPool pool){  
        if (this.pool == null) {  
            this.pool = pool;  
        }  
    }  
      
    /** 
     * <p>通过key获取储存在redis中的value</p> 
     * <p>并释放连接</p> 
     * @param key 
     * @return 成功返回value 失败返回null 
     */  
    public String get(String key){  
        Jedis jedis = null;  
        String value = null;  
        try {  
            jedis = pool.getResource();  
            value = jedis.get(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return value;  
    }  
      
    /** 
     * <p>向redis存入key和value,并释放连接资源</p> 
     * <p>如果key已经存在 则覆盖</p> 
     * @param key 
     * @param value 
     * @return 成功 返回OK 失败返回 0 
     */  
    public String set(String key,String value){  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.set(key, value);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
            return "0";  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  
      
      
    /** 
     * <p>删除指定的key,也可以传入一个包含key的数组</p> 
     * @param keys 一个key  也可以使 string 数组 
     * @return 返回删除成功的个数  
     */  
    public Long del(String...keys){  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.del(keys);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
            return 0L;  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  
      
    /** 
     * <p>通过key向指定的value值追加值</p> 
     * @param key  
     * @param str  
     * @return 成功返回 添加后value的长度 失败 返回 添加的 value 的长度  异常返回0L 
     */  
    public Long append(String key ,String str){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.append(key, str);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
            return 0L;  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>判断key是否存在</p> 
     * @param key 
     * @return true OR false 
     */  
    public Boolean exists(String key){  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.exists(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
            return false;  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  
      
    /** 
     * <p>设置key value,如果key已经存在则返回0,nx==> not exist</p> 
     * @param key 
     * @param value 
     * @return 成功返回1 如果存在 和 发生异常 返回 0 
     */  
    public Long setnx(String key ,String value){  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.setnx(key, value);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
            return 0L;  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  
      
    /** 
     * <p>设置key value并制定这个键值的有效期</p> 
     * @param key 
     * @param value 
     * @param seconds 单位:秒 
     * @return 成功返回OK 失败和异常返回null 
     */  
    public String setex(String key,String value,int seconds){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.setex(key, seconds, value);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
      
    /** 
     * <p>通过key 和offset 从指定的位置开始将原先value替换</p> 
     * <p>下标从0开始,offset表示从offset下标开始替换</p> 
     * <p>如果替换的字符串长度过小则会这样</p> 
     * <p>example:</p> 
     * <p>value : bigsea@zto.cn</p> 
     * <p>str : abc </p> 
     * <P>从下标7开始替换  则结果为</p> 
     * <p>RES : bigsea.abc.cn</p> 
     * @param key 
     * @param str 
     * @param offset 下标位置 
     * @return 返回替换后  value 的长度 
     */  
    public Long setrange(String key,String str,int offset){  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.setrange(key, offset, str);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
            return 0L;  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  
      
      
      
    /** 
     * <p>通过批量的key获取批量的value</p> 
     * @param keys string数组 也可以是一个key 
     * @return 成功返回value的集合, 失败返回null的集合 ,异常返回空 
     */  
    public List<String> mget(String...keys){  
        Jedis jedis = null;  
        List<String> values = null;  
        try {  
            jedis = pool.getResource();  
            values = jedis.mget(keys);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return values;  
    }  
      
    /** 
     * <p>批量的设置key:value,可以一个</p> 
     * <p>example:</p> 
     * <p>  obj.mset(new String[]{"key2","value1","key2","value2"})</p> 
     * @param keysvalues 
     * @return 成功返回OK 失败 异常 返回 null 
     *  
     */  
    public String mset(String...keysvalues){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.mset(keysvalues);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>批量的设置key:value,可以一个,如果key已经存在则会失败,操作会回滚</p> 
     * <p>example:</p> 
     * <p>  obj.msetnx(new String[]{"key2","value1","key2","value2"})</p> 
     * @param keysvalues  
     * @return 成功返回1 失败返回0  
     */  
    public Long msetnx(String...keysvalues){  
        Jedis jedis = null;  
        Long res = 0L;  
        try {  
            jedis = pool.getResource();  
            res =jedis.msetnx(keysvalues);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>设置key的值,并返回一个旧值</p> 
     * @param key 
     * @param value 
     * @return 旧值 如果key不存在 则返回null 
     */  
    public String getset(String key,String value){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.getSet(key, value);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过下标 和key 获取指定下标位置的 value</p> 
     * @param key 
     * @param startOffset 开始位置 从0 开始 负数表示从右边开始截取 
     * @param endOffset  
     * @return 如果没有返回null  
     */  
    public String getrange(String key, int startOffset ,int endOffset){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.getrange(key, startOffset, endOffset);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key 对value进行加值+1操作,当value不是int类型时会返回错误,当key不存在是则value为1</p> 
     * @param key 
     * @return 加值后的结果 
     */  
    public Long incr(String key){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.incr(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key给指定的value加值,如果key不存在,则这是value为该值</p> 
     * @param key 
     * @param integer 
     * @return 
     */  
    public Long incrBy(String key,Long integer){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.incrBy(key, integer);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>对key的值做减减操作,如果key不存在,则设置key为-1</p> 
     * @param key 
     * @return 
     */  
    public Long decr(String key) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.decr(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>减去指定的值</p> 
     * @param key 
     * @param integer 
     * @return 
     */  
    public Long decrBy(String key,Long integer){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.decrBy(key, integer);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key获取value值的长度</p> 
     * @param key 
     * @return 失败返回null  
     */  
    public Long serlen(String key){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.strlen(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key给field设置指定的值,如果key不存在,则先创建</p> 
     * @param key 
     * @param field 字段 
     * @param value 
     * @return 如果存在返回0 异常返回null 
     */  
    public Long hset(String key,String field,String value) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hset(key, field, value);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key给field设置指定的值,如果key不存在则先创建,如果field已经存在,返回0</p> 
     * @param key 
     * @param field 
     * @param value 
     * @return 
     */  
    public Long hsetnx(String key,String field,String value){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hsetnx(key, field, value);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key同时设置 hash的多个field</p> 
     * @param key 
     * @param hash 
     * @return 返回OK 异常返回null 
     */  
    public String hmset(String key,Map<String, String> hash){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hmset(key, hash);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key 和 field 获取指定的 value</p> 
     * @param key 
     * @param field 
     * @return 没有返回null 
     */  
    public String hget(String key, String field){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hget(key, field);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key 和 fields 获取指定的value 如果没有对应的value则返回null</p> 
     * @param key 
     * @param fields 可以使 一个String 也可以是 String数组 
     * @return  
     */  
    public List<String> hmget(String key,String...fields){  
        Jedis jedis = null;  
        List<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hmget(key, fields);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key给指定的field的value加上给定的值</p> 
     * @param key 
     * @param field 
     * @param value  
     * @return 
     */  
    public Long hincrby(String key ,String field ,Long value){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hincrBy(key, field, value);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key和field判断是否有指定的value存在</p> 
     * @param key 
     * @param field 
     * @return 
     */  
    public Boolean hexists(String key , String field){  
        Jedis jedis = null;  
        Boolean res = false;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hexists(key, field);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key返回field的数量</p> 
     * @param key 
     * @return 
     */  
    public Long hlen(String key){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hlen(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
          
    }  
      
    /** 
     * <p>通过key 删除指定的 field </p> 
     * @param key 
     * @param fields 可以是 一个 field 也可以是 一个数组 
     * @return 
     */  
    public Long hdel(String key ,String...fields){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hdel(key, fields);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key返回所有的field</p> 
     * @param key 
     * @return 
     */  
    public Set<String> hkeys(String key){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hkeys(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key返回所有和key有关的value</p> 
     * @param key 
     * @return 
     */  
    public List<String> hvals(String key){  
        Jedis jedis = null;  
        List<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hvals(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key获取所有的field和value</p> 
     * @param key 
     * @return 
     */  
    public Map<String, String> hgetall(String key){  
        Jedis jedis = null;  
        Map<String, String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hgetAll(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key向list头部添加字符串</p> 
     * @param key 
     * @param strs 可以使一个string 也可以使string数组 
     * @return 返回list的value个数 
     */  
    public Long lpush(String key ,String...strs){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lpush(key, strs);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key向list尾部添加字符串</p> 
     * @param key 
     * @param strs 可以使一个string 也可以使string数组 
     * @return 返回list的value个数 
     */  
    public Long rpush(String key ,String...strs){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.rpush(key, strs);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key在list指定的位置之前或者之后 添加字符串元素</p> 
     * @param key  
     * @param where LIST_POSITION枚举类型 
     * @param pivot list里面的value 
     * @param value 添加的value 
     * @return 
     */  
    public Long linsert(String key, LIST_POSITION where,  
            String pivot, String value){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.linsert(key, where, pivot, value);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key设置list指定下标位置的value</p> 
     * <p>如果下标超过list里面value的个数则报错</p> 
     * @param key  
     * @param index 从0开始 
     * @param value 
     * @return 成功返回OK 
     */  
    public String lset(String key ,Long index, String value){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lset(key, index, value);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key从对应的list中删除指定的count个 和 value相同的元素</p> 
     * @param key  
     * @param count 当count为0时删除全部 
     * @param value  
     * @return 返回被删除的个数 
     */  
    public Long lrem(String key,long count,String value){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lrem(key, count, value);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key保留list中从strat下标开始到end下标结束的value值</p> 
     * @param key 
     * @param start 
     * @param end 
     * @return 成功返回OK 
     */  
    public String ltrim(String key ,long start ,long end){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.ltrim(key, start, end);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key从list的头部删除一个value,并返回该value</p> 
     * @param key 
     * @return  
     */  
    public String lpop(String key){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lpop(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key从list尾部删除一个value,并返回该元素</p> 
     * @param key 
     * @return 
     */  
    public String rpop(String key){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.rpop(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key从一个list的尾部删除一个value并添加到另一个list的头部,并返回该value</p> 
     * <p>如果第一个list为空或者不存在则返回null</p> 
     * @param srckey 
     * @param dstkey 
     * @return 
     */  
    public String rpoplpush(String srckey, String dstkey){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.rpoplpush(srckey, dstkey);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key获取list中指定下标位置的value</p> 
     * @param key 
     * @param index 
     * @return 如果没有返回null 
     */  
    public String lindex(String key,long index){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lindex(key, index);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key返回list的长度</p> 
     * @param key 
     * @return 
     */  
    public Long llen(String key){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.llen(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key获取list指定下标位置的value</p> 
     * <p>如果start 为 0 end 为 -1 则返回全部的list中的value</p> 
     * @param key  
     * @param start 
     * @param end 
     * @return 
     */  
    public List<String> lrange(String key,long start,long end){  
        Jedis jedis = null;  
        List<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lrange(key, start, end);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key向指定的set中添加value</p> 
     * @param key 
     * @param members 可以是一个String 也可以是一个String数组 
     * @return 添加成功的个数 
     */  
    public Long sadd(String key,String...members){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sadd(key, members);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key删除set中对应的value值</p> 
     * @param key 
     * @param members 可以是一个String 也可以是一个String数组 
     * @return 删除的个数 
     */  
    public Long srem(String key,String...members){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.srem(key, members);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key随机删除一个set中的value并返回该值</p> 
     * @param key 
     * @return 
     */  
    public String spop(String key){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.spop(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key获取set中的差集</p> 
     * <p>以第一个set为标准</p> 
     * @param keys 可以使一个string 则返回set中所有的value 也可以是string数组 
     * @return  
     */  
    public Set<String> sdiff(String...keys){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sdiff(keys);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key获取set中的差集并存入到另一个key中</p> 
     * <p>以第一个set为标准</p> 
     * @param dstkey 差集存入的key 
     * @param keys 可以使一个string 则返回set中所有的value 也可以是string数组 
     * @return  
     */  
    public Long sdiffstore(String dstkey,String... keys){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sdiffstore(dstkey, keys);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key获取指定set中的交集</p> 
     * @param keys 可以使一个string 也可以是一个string数组 
     * @return 
     */  
    public Set<String> sinter(String...keys){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sinter(keys);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key获取指定set中的交集 并将结果存入新的set中</p> 
     * @param dstkey 
     * @param keys 可以使一个string 也可以是一个string数组 
     * @return 
     */  
    public Long sinterstore(String dstkey,String...keys){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sinterstore(dstkey, keys);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key返回所有set的并集</p> 
     * @param keys 可以使一个string 也可以是一个string数组 
     * @return 
     */  
    public Set<String> sunion(String... keys){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sunion(keys);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key返回所有set的并集,并存入到新的set中</p> 
     * @param dstkey  
     * @param keys 可以使一个string 也可以是一个string数组 
     * @return 
     */  
    public Long sunionstore(String dstkey,String...keys){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sunionstore(dstkey, keys);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key将set中的value移除并添加到第二个set中</p> 
     * @param srckey 需要移除的 
     * @param dstkey 添加的 
     * @param member set中的value 
     * @return 
     */  
    public Long smove(String srckey, String dstkey, String member){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.smove(srckey, dstkey, member);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key获取set中value的个数</p> 
     * @param key 
     * @return 
     */  
    public Long scard(String key){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.scard(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key判断value是否是set中的元素</p> 
     * @param key 
     * @param member 
     * @return 
     */  
    public Boolean sismember(String key,String member){  
        Jedis jedis = null;  
        Boolean res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sismember(key, member);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key获取set中随机的value,不删除元素</p> 
     * @param key 
     * @return 
     */  
    public String srandmember(String key){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.srandmember(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key获取set中所有的value</p> 
     * @param key 
     * @return 
     */  
    public Set<String> smembers(String key){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.smembers(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key向zset中添加value,score,其中score就是用来排序的</p> 
     * <p>如果该value已经存在则根据score更新元素</p> 
     * @param key 
     * @param scoreMembers  
     * @return 
     */  
    public Long zadd(String key,Map<Double, String> scoreMembers){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zadd(key, scoreMembers);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key向zset中添加value,score,其中score就是用来排序的</p> 
     * <p>如果该value已经存在则根据score更新元素</p> 
     * @param key 
     * @param score 
     * @param member 
     * @return 
     */  
    public Long zadd(String key,double score,String member){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zadd(key, score, member);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key删除在zset中指定的value</p> 
     * @param key 
     * @param members 可以使一个string 也可以是一个string数组 
     * @return 
     */  
    public Long zrem(String key,String...members){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrem(key, members);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key增加该zset中value的score的值</p> 
     * @param key 
     * @param score  
     * @param member  
     * @return 
     */  
    public Double zincrby(String key ,double score ,String member){  
        Jedis jedis = null;  
        Double res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zincrby(key, score, member);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key返回zset中value的排名</p> 
     * <p>下标从小到大排序</p> 
     * @param key 
     * @param member 
     * @return 
     */  
    public Long zrank(String key,String member){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrank(key, member);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key返回zset中value的排名</p> 
     * <p>下标从大到小排序</p> 
     * @param key 
     * @param member 
     * @return 
     */  
    public Long zrevrank(String key,String member){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrevrank(key, member);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key将获取score从start到end中zset的value</p> 
     * <p>socre从大到小排序</p> 
     * <p>当start为0 end为-1时返回全部</p> 
     * @param key 
     * @param start 
     * @param end 
     * @return 
     */  
    public Set<String> zrevrange(String key ,long start ,long end){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrevrange(key, start, end);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key返回指定score内zset中的value</p> 
     * @param key  
     * @param max  
     * @param min  
     * @return 
     */  
    public Set<String> zrangebyscore(String key,String max,String min){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrevrangeByScore(key, max, min);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key返回指定score内zset中的value</p> 
     * @param key  
     * @param max   
     * @param min  
     * @return 
     */  
    public Set<String> zrangeByScore(String key ,double max,double min){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrevrangeByScore(key,max,min);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>返回指定区间内zset中value的数量</p> 
     * @param key 
     * @param min 
     * @param max 
     * @return 
     */  
    public Long zcount(String key,String min,String max){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zcount(key, min, max);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key返回zset中的value个数</p> 
     * @param key 
     * @return 
     */  
    public Long zcard(String key){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zcard(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key获取zset中value的score值</p> 
     * @param key 
     * @param member 
     * @return 
     */  
    public Double zscore(String key,String member){  
        Jedis jedis = null;  
        Double res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zscore(key, member);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key删除给定区间内的元素</p> 
     * @param key  
     * @param start  
     * @param end 
     * @return 
     */  
    public Long zremrangeByRank(String key ,long start, long end){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zremrangeByRank(key, start, end);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key删除指定score内的元素</p> 
     * @param key 
     * @param start 
     * @param end 
     * @return 
     */  
    public Long zremrangeByScore(String key,double start,double end){  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zremrangeByScore(key, start, end);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
    /** 
     * <p>返回满足pattern表达式的所有key</p> 
     * <p>keys(*)</p> 
     * <p>返回所有的key</p> 
     * @param pattern 
     * @return 
     */  
    public Set<String> keys(String pattern){  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.keys(pattern);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * <p>通过key判断值得类型</p> 
     * @param key 
     * @return 
     */  
    public String type(String key){  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.type(key);  
        } catch (Exception e) {  
            pool.returnBrokenResource(jedis);  
            e.printStackTrace();  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  
      
    /** 
     * 返还到连接池 
     *  
     * @param pool 
     * @param redis 
     */  
    public static void returnResource(JedisPool pool, Jedis jedis) {  
        if (jedis != null) {  
            pool.returnResource(jedis);  
        }  
    }  
} 

1. package cn.zto.util;  
2.   
3. import java.util.List;  
4. import java.util.Map;  
5. import java.util.Set;  
6.   
7. import org.junit.Test;  
8.   
9.   
10. import redis.clients.jedis.Jedis;  
11. import redis.clients.jedis.JedisPool;  
12. import redis.clients.jedis.JedisPoolConfig;  
13. import redis.clients.jedis.BinaryClient.LIST_POSITION;  
14.   
15. /** 
16.  * <p>redis通用工具类</p> 
17.  * @author bigSea 
18.  * 
19.  */  
20. public class RedisUtil {  
21.       
22.     private JedisPool pool = null;  
23.       
24.     /** 
25.      * <p>传入ip和端口号构建redis 连接池</p> 
26.      * @param ip ip 
27.      * @param prot 端口 
28.      */  
29.     public RedisUtil(String ip, int prot) {  
30.         if (pool == null) {  
31.             JedisPoolConfig config = new JedisPoolConfig();  
32.             // 控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；  
33.             // 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。  
34.             config.setMaxActive(500);  
35.             // 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。  
36.             config.setMaxIdle(5);  
37.             // 表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；  
38.             config.setMaxWait(1000 * 100);  
39.             // 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；  
40.             config.setTestOnBorrow(true);  
41.             // pool = new JedisPool(config, "192.168.0.121", 6379, 100000);  
42.             pool = new JedisPool(config, ip, prot, 100000);  
43.         }  
44.     }  
45.   
46.     /** 
47.      * <p>通过配置对象 ip 端口 构建连接池</p> 
48.      * @param config 配置对象 
49.      * @param ip ip 
50.      * @param prot 端口 
51.      */  
52.     public RedisUtil(JedisPoolConfig config ,String ip, int prot){  
53.         if (pool == null) {  
54.             pool = new JedisPool(config,ip,prot,10000);  
55.         }  
56.     }  
57.       
58.     /** 
59.      * <p>通过配置对象 ip 端口 超时时间 构建连接池</p> 
60.      * @param config 配置对象 
61.      * @param ip ip 
62.      * @param prot 端口 
63.      * @param timeout 超时时间 
64.      */  
65.     public RedisUtil(JedisPoolConfig config ,String ip, int prot ,int timeout){  
66.         if (pool == null) {  
67.             pool = new JedisPool(config,ip,prot,timeout);  
68.         }  
69.     }  
70.       
71.     /** 
72.      * <p>通过连接池对象 构建一个连接池</p> 
73.      * @param pool 连接池对象 
74.      */  
75.     public RedisUtil(JedisPool pool){  
76.         if (this.pool == null) {  
77.             this.pool = pool;  
78.         }  
79.     }  
80.       
81.     /** 
82.      * <p>通过key获取储存在redis中的value</p> 
83.      * <p>并释放连接</p> 
84.      * @param key 
85.      * @return 成功返回value 失败返回null 
86.      */  
87.     public String get(String key){  
88.         Jedis jedis = null;  
89.         String value = null;  
90.         try {  
91.             jedis = pool.getResource();  
92.             value = jedis.get(key);  
93.         } catch (Exception e) {  
94.             pool.returnBrokenResource(jedis);  
95.             e.printStackTrace();  
96.         } finally {  
97.             returnResource(pool, jedis);  
98.         }  
99.         return value;  
100.     }  
101.       
102.     /** 
103.      * <p>向redis存入key和value,并释放连接资源</p> 
104.      * <p>如果key已经存在 则覆盖</p> 
105.      * @param key 
106.      * @param value 
107.      * @return 成功 返回OK 失败返回 0 
108.      */  
109.     public String set(String key,String value){  
110.         Jedis jedis = null;  
111.         try {  
112.             jedis = pool.getResource();  
113.             return jedis.set(key, value);  
114.         } catch (Exception e) {  
115.             pool.returnBrokenResource(jedis);  
116.             e.printStackTrace();  
117.             return "0";  
118.         } finally {  
119.             returnResource(pool, jedis);  
120.         }  
121.     }  
122.       
123.       
124.     /** 
125.      * <p>删除指定的key,也可以传入一个包含key的数组</p> 
126.      * @param keys 一个key  也可以使 string 数组 
127.      * @return 返回删除成功的个数  
128.      */  
129.     public Long del(String...keys){  
130.         Jedis jedis = null;  
131.         try {  
132.             jedis = pool.getResource();  
133.             return jedis.del(keys);  
134.         } catch (Exception e) {  
135.             pool.returnBrokenResource(jedis);  
136.             e.printStackTrace();  
137.             return 0L;  
138.         } finally {  
139.             returnResource(pool, jedis);  
140.         }  
141.     }  
142.       
143.     /** 
144.      * <p>通过key向指定的value值追加值</p> 
145.      * @param key  
146.      * @param str  
147.      * @return 成功返回 添加后value的长度 失败 返回 添加的 value 的长度  异常返回0L 
148.      */  
149.     public Long append(String key ,String str){  
150.         Jedis jedis = null;  
151.         Long res = null;  
152.         try {  
153.             jedis = pool.getResource();  
154.             res = jedis.append(key, str);  
155.         } catch (Exception e) {  
156.             pool.returnBrokenResource(jedis);  
157.             e.printStackTrace();  
158.             return 0L;  
159.         } finally {  
160.             returnResource(pool, jedis);  
161.         }  
162.         return res;  
163.     }  
164.       
165.     /** 
166.      * <p>判断key是否存在</p> 
167.      * @param key 
168.      * @return true OR false 
169.      */  
170.     public Boolean exists(String key){  
171.         Jedis jedis = null;  
172.         try {  
173.             jedis = pool.getResource();  
174.             return jedis.exists(key);  
175.         } catch (Exception e) {  
176.             pool.returnBrokenResource(jedis);  
177.             e.printStackTrace();  
178.             return false;  
179.         } finally {  
180.             returnResource(pool, jedis);  
181.         }  
182.     }  
183.       
184.     /** 
185.      * <p>设置key value,如果key已经存在则返回0,nx==> not exist</p> 
186.      * @param key 
187.      * @param value 
188.      * @return 成功返回1 如果存在 和 发生异常 返回 0 
189.      */  
190.     public Long setnx(String key ,String value){  
191.         Jedis jedis = null;  
192.         try {  
193.             jedis = pool.getResource();  
194.             return jedis.setnx(key, value);  
195.         } catch (Exception e) {  
196.             pool.returnBrokenResource(jedis);  
197.             e.printStackTrace();  
198.             return 0L;  
199.         } finally {  
200.             returnResource(pool, jedis);  
201.         }  
202.     }  
203.       
204.     /** 
205.      * <p>设置key value并制定这个键值的有效期</p> 
206.      * @param key 
207.      * @param value 
208.      * @param seconds 单位:秒 
209.      * @return 成功返回OK 失败和异常返回null 
210.      */  
211.     public String setex(String key,String value,int seconds){  
212.         Jedis jedis = null;  
213.         String res = null;  
214.         try {  
215.             jedis = pool.getResource();  
216.             res = jedis.setex(key, seconds, value);  
217.         } catch (Exception e) {  
218.             pool.returnBrokenResource(jedis);  
219.             e.printStackTrace();  
220.         } finally {  
221.             returnResource(pool, jedis);  
222.         }  
223.         return res;  
224.     }  
225.       
226.       
227.     /** 
228.      * <p>通过key 和offset 从指定的位置开始将原先value替换</p> 
229.      * <p>下标从0开始,offset表示从offset下标开始替换</p> 
230.      * <p>如果替换的字符串长度过小则会这样</p> 
231.      * <p>example:</p> 
232.      * <p>value : bigsea@zto.cn</p> 
233.      * <p>str : abc </p> 
234.      * <P>从下标7开始替换  则结果为</p> 
235.      * <p>RES : bigsea.abc.cn</p> 
236.      * @param key 
237.      * @param str 
238.      * @param offset 下标位置 
239.      * @return 返回替换后  value 的长度 
240.      */  
241.     public Long setrange(String key,String str,int offset){  
242.         Jedis jedis = null;  
243.         try {  
244.             jedis = pool.getResource();  
245.             return jedis.setrange(key, offset, str);  
246.         } catch (Exception e) {  
247.             pool.returnBrokenResource(jedis);  
248.             e.printStackTrace();  
249.             return 0L;  
250.         } finally {  
251.             returnResource(pool, jedis);  
252.         }  
253.     }  
254.       
255.       
256.       
257.     /** 
258.      * <p>通过批量的key获取批量的value</p> 
259.      * @param keys string数组 也可以是一个key 
260.      * @return 成功返回value的集合, 失败返回null的集合 ,异常返回空 
261.      */  
262.     public List<String> mget(String...keys){  
263.         Jedis jedis = null;  
264.         List<String> values = null;  
265.         try {  
266.             jedis = pool.getResource();  
267.             values = jedis.mget(keys);  
268.         } catch (Exception e) {  
269.             pool.returnBrokenResource(jedis);  
270.             e.printStackTrace();  
271.         } finally {  
272.             returnResource(pool, jedis);  
273.         }  
274.         return values;  
275.     }  
276.       
277.     /** 
278.      * <p>批量的设置key:value,可以一个</p> 
279.      * <p>example:</p> 
280.      * <p>  obj.mset(new String[]{"key2","value1","key2","value2"})</p> 
281.      * @param keysvalues 
282.      * @return 成功返回OK 失败 异常 返回 null 
283.      *  
284.      */  
285.     public String mset(String...keysvalues){  
286.         Jedis jedis = null;  
287.         String res = null;  
288.         try {  
289.             jedis = pool.getResource();  
290.             res = jedis.mset(keysvalues);  
291.         } catch (Exception e) {  
292.             pool.returnBrokenResource(jedis);  
293.             e.printStackTrace();  
294.         } finally {  
295.             returnResource(pool, jedis);  
296.         }  
297.         return res;  
298.     }  
299.       
300.     /** 
301.      * <p>批量的设置key:value,可以一个,如果key已经存在则会失败,操作会回滚</p> 
302.      * <p>example:</p> 
303.      * <p>  obj.msetnx(new String[]{"key2","value1","key2","value2"})</p> 
304.      * @param keysvalues  
305.      * @return 成功返回1 失败返回0  
306.      */  
307.     public Long msetnx(String...keysvalues){  
308.         Jedis jedis = null;  
309.         Long res = 0L;  
310.         try {  
311.             jedis = pool.getResource();  
312.             res =jedis.msetnx(keysvalues);  
313.         } catch (Exception e) {  
314.             pool.returnBrokenResource(jedis);  
315.             e.printStackTrace();  
316.         } finally {  
317.             returnResource(pool, jedis);  
318.         }  
319.         return res;  
320.     }  
321.       
322.     /** 
323.      * <p>设置key的值,并返回一个旧值</p> 
324.      * @param key 
325.      * @param value 
326.      * @return 旧值 如果key不存在 则返回null 
327.      */  
328.     public String getset(String key,String value){  
329.         Jedis jedis = null;  
330.         String res = null;  
331.         try {  
332.             jedis = pool.getResource();  
333.             res = jedis.getSet(key, value);  
334.         } catch (Exception e) {  
335.             pool.returnBrokenResource(jedis);  
336.             e.printStackTrace();  
337.         } finally {  
338.             returnResource(pool, jedis);  
339.         }  
340.         return res;  
341.     }  
342.       
343.     /** 
344.      * <p>通过下标 和key 获取指定下标位置的 value</p> 
345.      * @param key 
346.      * @param startOffset 开始位置 从0 开始 负数表示从右边开始截取 
347.      * @param endOffset  
348.      * @return 如果没有返回null  
349.      */  
350.     public String getrange(String key, int startOffset ,int endOffset){  
351.         Jedis jedis = null;  
352.         String res = null;  
353.         try {  
354.             jedis = pool.getResource();  
355.             res = jedis.getrange(key, startOffset, endOffset);  
356.         } catch (Exception e) {  
357.             pool.returnBrokenResource(jedis);  
358.             e.printStackTrace();  
359.         } finally {  
360.             returnResource(pool, jedis);  
361.         }  
362.         return res;  
363.     }  
364.       
365.     /** 
366.      * <p>通过key 对value进行加值+1操作,当value不是int类型时会返回错误,当key不存在是则value为1</p> 
367.      * @param key 
368.      * @return 加值后的结果 
369.      */  
370.     public Long incr(String key){  
371.         Jedis jedis = null;  
372.         Long res = null;  
373.         try {  
374.             jedis = pool.getResource();  
375.             res = jedis.incr(key);  
376.         } catch (Exception e) {  
377.             pool.returnBrokenResource(jedis);  
378.             e.printStackTrace();  
379.         } finally {  
380.             returnResource(pool, jedis);  
381.         }  
382.         return res;  
383.     }  
384.       
385.     /** 
386.      * <p>通过key给指定的value加值,如果key不存在,则这是value为该值</p> 
387.      * @param key 
388.      * @param integer 
389.      * @return 
390.      */  
391.     public Long incrBy(String key,Long integer){  
392.         Jedis jedis = null;  
393.         Long res = null;  
394.         try {  
395.             jedis = pool.getResource();  
396.             res = jedis.incrBy(key, integer);  
397.         } catch (Exception e) {  
398.             pool.returnBrokenResource(jedis);  
399.             e.printStackTrace();  
400.         } finally {  
401.             returnResource(pool, jedis);  
402.         }  
403.         return res;  
404.     }  
405.       
406.     /** 
407.      * <p>对key的值做减减操作,如果key不存在,则设置key为-1</p> 
408.      * @param key 
409.      * @return 
410.      */  
411.     public Long decr(String key) {  
412.         Jedis jedis = null;  
413.         Long res = null;  
414.         try {  
415.             jedis = pool.getResource();  
416.             res = jedis.decr(key);  
417.         } catch (Exception e) {  
418.             pool.returnBrokenResource(jedis);  
419.             e.printStackTrace();  
420.         } finally {  
421.             returnResource(pool, jedis);  
422.         }  
423.         return res;  
424.     }  
425.       
426.     /** 
427.      * <p>减去指定的值</p> 
428.      * @param key 
429.      * @param integer 
430.      * @return 
431.      */  
432.     public Long decrBy(String key,Long integer){  
433.         Jedis jedis = null;  
434.         Long res = null;  
435.         try {  
436.             jedis = pool.getResource();  
437.             res = jedis.decrBy(key, integer);  
438.         } catch (Exception e) {  
439.             pool.returnBrokenResource(jedis);  
440.             e.printStackTrace();  
441.         } finally {  
442.             returnResource(pool, jedis);  
443.         }  
444.         return res;  
445.     }  
446.       
447.     /** 
448.      * <p>通过key获取value值的长度</p> 
449.      * @param key 
450.      * @return 失败返回null  
451.      */  
452.     public Long serlen(String key){  
453.         Jedis jedis = null;  
454.         Long res = null;  
455.         try {  
456.             jedis = pool.getResource();  
457.             res = jedis.strlen(key);  
458.         } catch (Exception e) {  
459.             pool.returnBrokenResource(jedis);  
460.             e.printStackTrace();  
461.         } finally {  
462.             returnResource(pool, jedis);  
463.         }  
464.         return res;  
465.     }  
466.       
467.     /** 
468.      * <p>通过key给field设置指定的值,如果key不存在,则先创建</p> 
469.      * @param key 
470.      * @param field 字段 
471.      * @param value 
472.      * @return 如果存在返回0 异常返回null 
473.      */  
474.     public Long hset(String key,String field,String value) {  
475.         Jedis jedis = null;  
476.         Long res = null;  
477.         try {  
478.             jedis = pool.getResource();  
479.             res = jedis.hset(key, field, value);  
480.         } catch (Exception e) {  
481.             pool.returnBrokenResource(jedis);  
482.             e.printStackTrace();  
483.         } finally {  
484.             returnResource(pool, jedis);  
485.         }  
486.         return res;  
487.     }  
488.       
489.     /** 
490.      * <p>通过key给field设置指定的值,如果key不存在则先创建,如果field已经存在,返回0</p> 
491.      * @param key 
492.      * @param field 
493.      * @param value 
494.      * @return 
495.      */  
496.     public Long hsetnx(String key,String field,String value){  
497.         Jedis jedis = null;  
498.         Long res = null;  
499.         try {  
500.             jedis = pool.getResource();  
501.             res = jedis.hsetnx(key, field, value);  
502.         } catch (Exception e) {  
503.             pool.returnBrokenResource(jedis);  
504.             e.printStackTrace();  
505.         } finally {  
506.             returnResource(pool, jedis);  
507.         }  
508.         return res;  
509.     }  
510.       
511.     /** 
512.      * <p>通过key同时设置 hash的多个field</p> 
513.      * @param key 
514.      * @param hash 
515.      * @return 返回OK 异常返回null 
516.      */  
517.     public String hmset(String key,Map<String, String> hash){  
518.         Jedis jedis = null;  
519.         String res = null;  
520.         try {  
521.             jedis = pool.getResource();  
522.             res = jedis.hmset(key, hash);  
523.         } catch (Exception e) {  
524.             pool.returnBrokenResource(jedis);  
525.             e.printStackTrace();  
526.         } finally {  
527.             returnResource(pool, jedis);  
528.         }  
529.         return res;  
530.     }  
531.       
532.     /** 
533.      * <p>通过key 和 field 获取指定的 value</p> 
534.      * @param key 
535.      * @param field 
536.      * @return 没有返回null 
537.      */  
538.     public String hget(String key, String field){  
539.         Jedis jedis = null;  
540.         String res = null;  
541.         try {  
542.             jedis = pool.getResource();  
543.             res = jedis.hget(key, field);  
544.         } catch (Exception e) {  
545.             pool.returnBrokenResource(jedis);  
546.             e.printStackTrace();  
547.         } finally {  
548.             returnResource(pool, jedis);  
549.         }  
550.         return res;  
551.     }  
552.       
553.     /** 
554.      * <p>通过key 和 fields 获取指定的value 如果没有对应的value则返回null</p> 
555.      * @param key 
556.      * @param fields 可以使 一个String 也可以是 String数组 
557.      * @return  
558.      */  
559.     public List<String> hmget(String key,String...fields){  
560.         Jedis jedis = null;  
561.         List<String> res = null;  
562.         try {  
563.             jedis = pool.getResource();  
564.             res = jedis.hmget(key, fields);  
565.         } catch (Exception e) {  
566.             pool.returnBrokenResource(jedis);  
567.             e.printStackTrace();  
568.         } finally {  
569.             returnResource(pool, jedis);  
570.         }  
571.         return res;  
572.     }  
573.       
574.     /** 
575.      * <p>通过key给指定的field的value加上给定的值</p> 
576.      * @param key 
577.      * @param field 
578.      * @param value  
579.      * @return 
580.      */  
581.     public Long hincrby(String key ,String field ,Long value){  
582.         Jedis jedis = null;  
583.         Long res = null;  
584.         try {  
585.             jedis = pool.getResource();  
586.             res = jedis.hincrBy(key, field, value);  
587.         } catch (Exception e) {  
588.             pool.returnBrokenResource(jedis);  
589.             e.printStackTrace();  
590.         } finally {  
591.             returnResource(pool, jedis);  
592.         }  
593.         return res;  
594.     }  
595.       
596.     /** 
597.      * <p>通过key和field判断是否有指定的value存在</p> 
598.      * @param key 
599.      * @param field 
600.      * @return 
601.      */  
602.     public Boolean hexists(String key , String field){  
603.         Jedis jedis = null;  
604.         Boolean res = false;  
605.         try {  
606.             jedis = pool.getResource();  
607.             res = jedis.hexists(key, field);  
608.         } catch (Exception e) {  
609.             pool.returnBrokenResource(jedis);  
610.             e.printStackTrace();  
611.         } finally {  
612.             returnResource(pool, jedis);  
613.         }  
614.         return res;  
615.     }  
616.       
617.     /** 
618.      * <p>通过key返回field的数量</p> 
619.      * @param key 
620.      * @return 
621.      */  
622.     public Long hlen(String key){  
623.         Jedis jedis = null;  
624.         Long res = null;  
625.         try {  
626.             jedis = pool.getResource();  
627.             res = jedis.hlen(key);  
628.         } catch (Exception e) {  
629.             pool.returnBrokenResource(jedis);  
630.             e.printStackTrace();  
631.         } finally {  
632.             returnResource(pool, jedis);  
633.         }  
634.         return res;  
635.           
636.     }  
637.       
638.     /** 
639.      * <p>通过key 删除指定的 field </p> 
640.      * @param key 
641.      * @param fields 可以是 一个 field 也可以是 一个数组 
642.      * @return 
643.      */  
644.     public Long hdel(String key ,String...fields){  
645.         Jedis jedis = null;  
646.         Long res = null;  
647.         try {  
648.             jedis = pool.getResource();  
649.             res = jedis.hdel(key, fields);  
650.         } catch (Exception e) {  
651.             pool.returnBrokenResource(jedis);  
652.             e.printStackTrace();  
653.         } finally {  
654.             returnResource(pool, jedis);  
655.         }  
656.         return res;  
657.     }  
658.       
659.     /** 
660.      * <p>通过key返回所有的field</p> 
661.      * @param key 
662.      * @return 
663.      */  
664.     public Set<String> hkeys(String key){  
665.         Jedis jedis = null;  
666.         Set<String> res = null;  
667.         try {  
668.             jedis = pool.getResource();  
669.             res = jedis.hkeys(key);  
670.         } catch (Exception e) {  
671.             pool.returnBrokenResource(jedis);  
672.             e.printStackTrace();  
673.         } finally {  
674.             returnResource(pool, jedis);  
675.         }  
676.         return res;  
677.     }  
678.       
679.     /** 
680.      * <p>通过key返回所有和key有关的value</p> 
681.      * @param key 
682.      * @return 
683.      */  
684.     public List<String> hvals(String key){  
685.         Jedis jedis = null;  
686.         List<String> res = null;  
687.         try {  
688.             jedis = pool.getResource();  
689.             res = jedis.hvals(key);  
690.         } catch (Exception e) {  
691.             pool.returnBrokenResource(jedis);  
692.             e.printStackTrace();  
693.         } finally {  
694.             returnResource(pool, jedis);  
695.         }  
696.         return res;  
697.     }  
698.       
699.     /** 
700.      * <p>通过key获取所有的field和value</p> 
701.      * @param key 
702.      * @return 
703.      */  
704.     public Map<String, String> hgetall(String key){  
705.         Jedis jedis = null;  
706.         Map<String, String> res = null;  
707.         try {  
708.             jedis = pool.getResource();  
709.             res = jedis.hgetAll(key);  
710.         } catch (Exception e) {  
711.             pool.returnBrokenResource(jedis);  
712.             e.printStackTrace();  
713.         } finally {  
714.             returnResource(pool, jedis);  
715.         }  
716.         return res;  
717.     }  
718.       
719.     /** 
720.      * <p>通过key向list头部添加字符串</p> 
721.      * @param key 
722.      * @param strs 可以使一个string 也可以使string数组 
723.      * @return 返回list的value个数 
724.      */  
725.     public Long lpush(String key ,String...strs){  
726.         Jedis jedis = null;  
727.         Long res = null;  
728.         try {  
729.             jedis = pool.getResource();  
730.             res = jedis.lpush(key, strs);  
731.         } catch (Exception e) {  
732.             pool.returnBrokenResource(jedis);  
733.             e.printStackTrace();  
734.         } finally {  
735.             returnResource(pool, jedis);  
736.         }  
737.         return res;  
738.     }  
739.       
740.     /** 
741.      * <p>通过key向list尾部添加字符串</p> 
742.      * @param key 
743.      * @param strs 可以使一个string 也可以使string数组 
744.      * @return 返回list的value个数 
745.      */  
746.     public Long rpush(String key ,String...strs){  
747.         Jedis jedis = null;  
748.         Long res = null;  
749.         try {  
750.             jedis = pool.getResource();  
751.             res = jedis.rpush(key, strs);  
752.         } catch (Exception e) {  
753.             pool.returnBrokenResource(jedis);  
754.             e.printStackTrace();  
755.         } finally {  
756.             returnResource(pool, jedis);  
757.         }  
758.         return res;  
759.     }  
760.       
761.     /** 
762.      * <p>通过key在list指定的位置之前或者之后 添加字符串元素</p> 
763.      * @param key  
764.      * @param where LIST_POSITION枚举类型 
765.      * @param pivot list里面的value 
766.      * @param value 添加的value 
767.      * @return 
768.      */  
769.     public Long linsert(String key, LIST_POSITION where,  
770.             String pivot, String value){  
771.         Jedis jedis = null;  
772.         Long res = null;  
773.         try {  
774.             jedis = pool.getResource();  
775.             res = jedis.linsert(key, where, pivot, value);  
776.         } catch (Exception e) {  
777.             pool.returnBrokenResource(jedis);  
778.             e.printStackTrace();  
779.         } finally {  
780.             returnResource(pool, jedis);  
781.         }  
782.         return res;  
783.     }  
784.       
785.     /** 
786.      * <p>通过key设置list指定下标位置的value</p> 
787.      * <p>如果下标超过list里面value的个数则报错</p> 
788.      * @param key  
789.      * @param index 从0开始 
790.      * @param value 
791.      * @return 成功返回OK 
792.      */  
793.     public String lset(String key ,Long index, String value){  
794.         Jedis jedis = null;  
795.         String res = null;  
796.         try {  
797.             jedis = pool.getResource();  
798.             res = jedis.lset(key, index, value);  
799.         } catch (Exception e) {  
800.             pool.returnBrokenResource(jedis);  
801.             e.printStackTrace();  
802.         } finally {  
803.             returnResource(pool, jedis);  
804.         }  
805.         return res;  
806.     }  
807.       
808.     /** 
809.      * <p>通过key从对应的list中删除指定的count个 和 value相同的元素</p> 
810.      * @param key  
811.      * @param count 当count为0时删除全部 
812.      * @param value  
813.      * @return 返回被删除的个数 
814.      */  
815.     public Long lrem(String key,long count,String value){  
816.         Jedis jedis = null;  
817.         Long res = null;  
818.         try {  
819.             jedis = pool.getResource();  
820.             res = jedis.lrem(key, count, value);  
821.         } catch (Exception e) {  
822.             pool.returnBrokenResource(jedis);  
823.             e.printStackTrace();  
824.         } finally {  
825.             returnResource(pool, jedis);  
826.         }  
827.         return res;  
828.     }  
829.       
830.     /** 
831.      * <p>通过key保留list中从strat下标开始到end下标结束的value值</p> 
832.      * @param key 
833.      * @param start 
834.      * @param end 
835.      * @return 成功返回OK 
836.      */  
837.     public String ltrim(String key ,long start ,long end){  
838.         Jedis jedis = null;  
839.         String res = null;  
840.         try {  
841.             jedis = pool.getResource();  
842.             res = jedis.ltrim(key, start, end);  
843.         } catch (Exception e) {  
844.             pool.returnBrokenResource(jedis);  
845.             e.printStackTrace();  
846.         } finally {  
847.             returnResource(pool, jedis);  
848.         }  
849.         return res;  
850.     }  
851.       
852.     /** 
853.      * <p>通过key从list的头部删除一个value,并返回该value</p> 
854.      * @param key 
855.      * @return  
856.      */  
857.     public String lpop(String key){  
858.         Jedis jedis = null;  
859.         String res = null;  
860.         try {  
861.             jedis = pool.getResource();  
862.             res = jedis.lpop(key);  
863.         } catch (Exception e) {  
864.             pool.returnBrokenResource(jedis);  
865.             e.printStackTrace();  
866.         } finally {  
867.             returnResource(pool, jedis);  
868.         }  
869.         return res;  
870.     }  
871.       
872.     /** 
873.      * <p>通过key从list尾部删除一个value,并返回该元素</p> 
874.      * @param key 
875.      * @return 
876.      */  
877.     public String rpop(String key){  
878.         Jedis jedis = null;  
879.         String res = null;  
880.         try {  
881.             jedis = pool.getResource();  
882.             res = jedis.rpop(key);  
883.         } catch (Exception e) {  
884.             pool.returnBrokenResource(jedis);  
885.             e.printStackTrace();  
886.         } finally {  
887.             returnResource(pool, jedis);  
888.         }  
889.         return res;  
890.     }  
891.       
892.     /** 
893.      * <p>通过key从一个list的尾部删除一个value并添加到另一个list的头部,并返回该value</p> 
894.      * <p>如果第一个list为空或者不存在则返回null</p> 
895.      * @param srckey 
896.      * @param dstkey 
897.      * @return 
898.      */  
899.     public String rpoplpush(String srckey, String dstkey){  
900.         Jedis jedis = null;  
901.         String res = null;  
902.         try {  
903.             jedis = pool.getResource();  
904.             res = jedis.rpoplpush(srckey, dstkey);  
905.         } catch (Exception e) {  
906.             pool.returnBrokenResource(jedis);  
907.             e.printStackTrace();  
908.         } finally {  
909.             returnResource(pool, jedis);  
910.         }  
911.         return res;  
912.     }  
913.       
914.     /** 
915.      * <p>通过key获取list中指定下标位置的value</p> 
916.      * @param key 
917.      * @param index 
918.      * @return 如果没有返回null 
919.      */  
920.     public String lindex(String key,long index){  
921.         Jedis jedis = null;  
922.         String res = null;  
923.         try {  
924.             jedis = pool.getResource();  
925.             res = jedis.lindex(key, index);  
926.         } catch (Exception e) {  
927.             pool.returnBrokenResource(jedis);  
928.             e.printStackTrace();  
929.         } finally {  
930.             returnResource(pool, jedis);  
931.         }  
932.         return res;  
933.     }  
934.       
935.     /** 
936.      * <p>通过key返回list的长度</p> 
937.      * @param key 
938.      * @return 
939.      */  
940.     public Long llen(String key){  
941.         Jedis jedis = null;  
942.         Long res = null;  
943.         try {  
944.             jedis = pool.getResource();  
945.             res = jedis.llen(key);  
946.         } catch (Exception e) {  
947.             pool.returnBrokenResource(jedis);  
948.             e.printStackTrace();  
949.         } finally {  
950.             returnResource(pool, jedis);  
951.         }  
952.         return res;  
953.     }  
954.       
955.     /** 
956.      * <p>通过key获取list指定下标位置的value</p> 
957.      * <p>如果start 为 0 end 为 -1 则返回全部的list中的value</p> 
958.      * @param key  
959.      * @param start 
960.      * @param end 
961.      * @return 
962.      */  
963.     public List<String> lrange(String key,long start,long end){  
964.         Jedis jedis = null;  
965.         List<String> res = null;  
966.         try {  
967.             jedis = pool.getResource();  
968.             res = jedis.lrange(key, start, end);  
969.         } catch (Exception e) {  
970.             pool.returnBrokenResource(jedis);  
971.             e.printStackTrace();  
972.         } finally {  
973.             returnResource(pool, jedis);  
974.         }  
975.         return res;  
976.     }  
977.       
978.     /** 
979.      * <p>通过key向指定的set中添加value</p> 
980.      * @param key 
981.      * @param members 可以是一个String 也可以是一个String数组 
982.      * @return 添加成功的个数 
983.      */  
984.     public Long sadd(String key,String...members){  
985.         Jedis jedis = null;  
986.         Long res = null;  
987.         try {  
988.             jedis = pool.getResource();  
989.             res = jedis.sadd(key, members);  
990.         } catch (Exception e) {  
991.             pool.returnBrokenResource(jedis);  
992.             e.printStackTrace();  
993.         } finally {  
994.             returnResource(pool, jedis);  
995.         }  
996.         return res;  
997.     }  
998.       
999.     /** 
1000.      * <p>通过key删除set中对应的value值</p> 
1001.      * @param key 
1002.      * @param members 可以是一个String 也可以是一个String数组 
1003.      * @return 删除的个数 
1004.      */  
1005.     public Long srem(String key,String...members){  
1006.         Jedis jedis = null;  
1007.         Long res = null;  
1008.         try {  
1009.             jedis = pool.getResource();  
1010.             res = jedis.srem(key, members);  
1011.         } catch (Exception e) {  
1012.             pool.returnBrokenResource(jedis);  
1013.             e.printStackTrace();  
1014.         } finally {  
1015.             returnResource(pool, jedis);  
1016.         }  
1017.         return res;  
1018.     }  
1019.       
1020.     /** 
1021.      * <p>通过key随机删除一个set中的value并返回该值</p> 
1022.      * @param key 
1023.      * @return 
1024.      */  
1025.     public String spop(String key){  
1026.         Jedis jedis = null;  
1027.         String res = null;  
1028.         try {  
1029.             jedis = pool.getResource();  
1030.             res = jedis.spop(key);  
1031.         } catch (Exception e) {  
1032.             pool.returnBrokenResource(jedis);  
1033.             e.printStackTrace();  
1034.         } finally {  
1035.             returnResource(pool, jedis);  
1036.         }  
1037.         return res;  
1038.     }  
1039.       
1040.     /** 
1041.      * <p>通过key获取set中的差集</p> 
1042.      * <p>以第一个set为标准</p> 
1043.      * @param keys 可以使一个string 则返回set中所有的value 也可以是string数组 
1044.      * @return  
1045.      */  
1046.     public Set<String> sdiff(String...keys){  
1047.         Jedis jedis = null;  
1048.         Set<String> res = null;  
1049.         try {  
1050.             jedis = pool.getResource();  
1051.             res = jedis.sdiff(keys);  
1052.         } catch (Exception e) {  
1053.             pool.returnBrokenResource(jedis);  
1054.             e.printStackTrace();  
1055.         } finally {  
1056.             returnResource(pool, jedis);  
1057.         }  
1058.         return res;  
1059.     }  
1060.       
1061.     /** 
1062.      * <p>通过key获取set中的差集并存入到另一个key中</p> 
1063.      * <p>以第一个set为标准</p> 
1064.      * @param dstkey 差集存入的key 
1065.      * @param keys 可以使一个string 则返回set中所有的value 也可以是string数组 
1066.      * @return  
1067.      */  
1068.     public Long sdiffstore(String dstkey,String... keys){  
1069.         Jedis jedis = null;  
1070.         Long res = null;  
1071.         try {  
1072.             jedis = pool.getResource();  
1073.             res = jedis.sdiffstore(dstkey, keys);  
1074.         } catch (Exception e) {  
1075.             pool.returnBrokenResource(jedis);  
1076.             e.printStackTrace();  
1077.         } finally {  
1078.             returnResource(pool, jedis);  
1079.         }  
1080.         return res;  
1081.     }  
1082.       
1083.     /** 
1084.      * <p>通过key获取指定set中的交集</p> 
1085.      * @param keys 可以使一个string 也可以是一个string数组 
1086.      * @return 
1087.      */  
1088.     public Set<String> sinter(String...keys){  
1089.         Jedis jedis = null;  
1090.         Set<String> res = null;  
1091.         try {  
1092.             jedis = pool.getResource();  
1093.             res = jedis.sinter(keys);  
1094.         } catch (Exception e) {  
1095.             pool.returnBrokenResource(jedis);  
1096.             e.printStackTrace();  
1097.         } finally {  
1098.             returnResource(pool, jedis);  
1099.         }  
1100.         return res;  
1101.     }  
1102.       
1103.     /** 
1104.      * <p>通过key获取指定set中的交集 并将结果存入新的set中</p> 
1105.      * @param dstkey 
1106.      * @param keys 可以使一个string 也可以是一个string数组 
1107.      * @return 
1108.      */  
1109.     public Long sinterstore(String dstkey,String...keys){  
1110.         Jedis jedis = null;  
1111.         Long res = null;  
1112.         try {  
1113.             jedis = pool.getResource();  
1114.             res = jedis.sinterstore(dstkey, keys);  
1115.         } catch (Exception e) {  
1116.             pool.returnBrokenResource(jedis);  
1117.             e.printStackTrace();  
1118.         } finally {  
1119.             returnResource(pool, jedis);  
1120.         }  
1121.         return res;  
1122.     }  
1123.       
1124.     /** 
1125.      * <p>通过key返回所有set的并集</p> 
1126.      * @param keys 可以使一个string 也可以是一个string数组 
1127.      * @return 
1128.      */  
1129.     public Set<String> sunion(String... keys){  
1130.         Jedis jedis = null;  
1131.         Set<String> res = null;  
1132.         try {  
1133.             jedis = pool.getResource();  
1134.             res = jedis.sunion(keys);  
1135.         } catch (Exception e) {  
1136.             pool.returnBrokenResource(jedis);  
1137.             e.printStackTrace();  
1138.         } finally {  
1139.             returnResource(pool, jedis);  
1140.         }  
1141.         return res;  
1142.     }  
1143.       
1144.     /** 
1145.      * <p>通过key返回所有set的并集,并存入到新的set中</p> 
1146.      * @param dstkey  
1147.      * @param keys 可以使一个string 也可以是一个string数组 
1148.      * @return 
1149.      */  
1150.     public Long sunionstore(String dstkey,String...keys){  
1151.         Jedis jedis = null;  
1152.         Long res = null;  
1153.         try {  
1154.             jedis = pool.getResource();  
1155.             res = jedis.sunionstore(dstkey, keys);  
1156.         } catch (Exception e) {  
1157.             pool.returnBrokenResource(jedis);  
1158.             e.printStackTrace();  
1159.         } finally {  
1160.             returnResource(pool, jedis);  
1161.         }  
1162.         return res;  
1163.     }  
1164.       
1165.     /** 
1166.      * <p>通过key将set中的value移除并添加到第二个set中</p> 
1167.      * @param srckey 需要移除的 
1168.      * @param dstkey 添加的 
1169.      * @param member set中的value 
1170.      * @return 
1171.      */  
1172.     public Long smove(String srckey, String dstkey, String member){  
1173.         Jedis jedis = null;  
1174.         Long res = null;  
1175.         try {  
1176.             jedis = pool.getResource();  
1177.             res = jedis.smove(srckey, dstkey, member);  
1178.         } catch (Exception e) {  
1179.             pool.returnBrokenResource(jedis);  
1180.             e.printStackTrace();  
1181.         } finally {  
1182.             returnResource(pool, jedis);  
1183.         }  
1184.         return res;  
1185.     }  
1186.       
1187.     /** 
1188.      * <p>通过key获取set中value的个数</p> 
1189.      * @param key 
1190.      * @return 
1191.      */  
1192.     public Long scard(String key){  
1193.         Jedis jedis = null;  
1194.         Long res = null;  
1195.         try {  
1196.             jedis = pool.getResource();  
1197.             res = jedis.scard(key);  
1198.         } catch (Exception e) {  
1199.             pool.returnBrokenResource(jedis);  
1200.             e.printStackTrace();  
1201.         } finally {  
1202.             returnResource(pool, jedis);  
1203.         }  
1204.         return res;  
1205.     }  
1206.       
1207.     /** 
1208.      * <p>通过key判断value是否是set中的元素</p> 
1209.      * @param key 
1210.      * @param member 
1211.      * @return 
1212.      */  
1213.     public Boolean sismember(String key,String member){  
1214.         Jedis jedis = null;  
1215.         Boolean res = null;  
1216.         try {  
1217.             jedis = pool.getResource();  
1218.             res = jedis.sismember(key, member);  
1219.         } catch (Exception e) {  
1220.             pool.returnBrokenResource(jedis);  
1221.             e.printStackTrace();  
1222.         } finally {  
1223.             returnResource(pool, jedis);  
1224.         }  
1225.         return res;  
1226.     }  
1227.       
1228.     /** 
1229.      * <p>通过key获取set中随机的value,不删除元素</p> 
1230.      * @param key 
1231.      * @return 
1232.      */  
1233.     public String srandmember(String key){  
1234.         Jedis jedis = null;  
1235.         String res = null;  
1236.         try {  
1237.             jedis = pool.getResource();  
1238.             res = jedis.srandmember(key);  
1239.         } catch (Exception e) {  
1240.             pool.returnBrokenResource(jedis);  
1241.             e.printStackTrace();  
1242.         } finally {  
1243.             returnResource(pool, jedis);  
1244.         }  
1245.         return res;  
1246.     }  
1247.       
1248.     /** 
1249.      * <p>通过key获取set中所有的value</p> 
1250.      * @param key 
1251.      * @return 
1252.      */  
1253.     public Set<String> smembers(String key){  
1254.         Jedis jedis = null;  
1255.         Set<String> res = null;  
1256.         try {  
1257.             jedis = pool.getResource();  
1258.             res = jedis.smembers(key);  
1259.         } catch (Exception e) {  
1260.             pool.returnBrokenResource(jedis);  
1261.             e.printStackTrace();  
1262.         } finally {  
1263.             returnResource(pool, jedis);  
1264.         }  
1265.         return res;  
1266.     }  
1267.       
1268.     /** 
1269.      * <p>通过key向zset中添加value,score,其中score就是用来排序的</p> 
1270.      * <p>如果该value已经存在则根据score更新元素</p> 
1271.      * @param key 
1272.      * @param scoreMembers  
1273.      * @return 
1274.      */  
1275.     public Long zadd(String key,Map<Double, String> scoreMembers){  
1276.         Jedis jedis = null;  
1277.         Long res = null;  
1278.         try {  
1279.             jedis = pool.getResource();  
1280.             res = jedis.zadd(key, scoreMembers);  
1281.         } catch (Exception e) {  
1282.             pool.returnBrokenResource(jedis);  
1283.             e.printStackTrace();  
1284.         } finally {  
1285.             returnResource(pool, jedis);  
1286.         }  
1287.         return res;  
1288.     }  
1289.       
1290.     /** 
1291.      * <p>通过key向zset中添加value,score,其中score就是用来排序的</p> 
1292.      * <p>如果该value已经存在则根据score更新元素</p> 
1293.      * @param key 
1294.      * @param score 
1295.      * @param member 
1296.      * @return 
1297.      */  
1298.     public Long zadd(String key,double score,String member){  
1299.         Jedis jedis = null;  
1300.         Long res = null;  
1301.         try {  
1302.             jedis = pool.getResource();  
1303.             res = jedis.zadd(key, score, member);  
1304.         } catch (Exception e) {  
1305.             pool.returnBrokenResource(jedis);  
1306.             e.printStackTrace();  
1307.         } finally {  
1308.             returnResource(pool, jedis);  
1309.         }  
1310.         return res;  
1311.     }  
1312.       
1313.     /** 
1314.      * <p>通过key删除在zset中指定的value</p> 
1315.      * @param key 
1316.      * @param members 可以使一个string 也可以是一个string数组 
1317.      * @return 
1318.      */  
1319.     public Long zrem(String key,String...members){  
1320.         Jedis jedis = null;  
1321.         Long res = null;  
1322.         try {  
1323.             jedis = pool.getResource();  
1324.             res = jedis.zrem(key, members);  
1325.         } catch (Exception e) {  
1326.             pool.returnBrokenResource(jedis);  
1327.             e.printStackTrace();  
1328.         } finally {  
1329.             returnResource(pool, jedis);  
1330.         }  
1331.         return res;  
1332.     }  
1333.       
1334.     /** 
1335.      * <p>通过key增加该zset中value的score的值</p> 
1336.      * @param key 
1337.      * @param score  
1338.      * @param member  
1339.      * @return 
1340.      */  
1341.     public Double zincrby(String key ,double score ,String member){  
1342.         Jedis jedis = null;  
1343.         Double res = null;  
1344.         try {  
1345.             jedis = pool.getResource();  
1346.             res = jedis.zincrby(key, score, member);  
1347.         } catch (Exception e) {  
1348.             pool.returnBrokenResource(jedis);  
1349.             e.printStackTrace();  
1350.         } finally {  
1351.             returnResource(pool, jedis);  
1352.         }  
1353.         return res;  
1354.     }  
1355.       
1356.     /** 
1357.      * <p>通过key返回zset中value的排名</p> 
1358.      * <p>下标从小到大排序</p> 
1359.      * @param key 
1360.      * @param member 
1361.      * @return 
1362.      */  
1363.     public Long zrank(String key,String member){  
1364.         Jedis jedis = null;  
1365.         Long res = null;  
1366.         try {  
1367.             jedis = pool.getResource();  
1368.             res = jedis.zrank(key, member);  
1369.         } catch (Exception e) {  
1370.             pool.returnBrokenResource(jedis);  
1371.             e.printStackTrace();  
1372.         } finally {  
1373.             returnResource(pool, jedis);  
1374.         }  
1375.         return res;  
1376.     }  
1377.       
1378.     /** 
1379.      * <p>通过key返回zset中value的排名</p> 
1380.      * <p>下标从大到小排序</p> 
1381.      * @param key 
1382.      * @param member 
1383.      * @return 
1384.      */  
1385.     public Long zrevrank(String key,String member){  
1386.         Jedis jedis = null;  
1387.         Long res = null;  
1388.         try {  
1389.             jedis = pool.getResource();  
1390.             res = jedis.zrevrank(key, member);  
1391.         } catch (Exception e) {  
1392.             pool.returnBrokenResource(jedis);  
1393.             e.printStackTrace();  
1394.         } finally {  
1395.             returnResource(pool, jedis);  
1396.         }  
1397.         return res;  
1398.     }  
1399.       
1400.     /** 
1401.      * <p>通过key将获取score从start到end中zset的value</p> 
1402.      * <p>socre从大到小排序</p> 
1403.      * <p>当start为0 end为-1时返回全部</p> 
1404.      * @param key 
1405.      * @param start 
1406.      * @param end 
1407.      * @return 
1408.      */  
1409.     public Set<String> zrevrange(String key ,long start ,long end){  
1410.         Jedis jedis = null;  
1411.         Set<String> res = null;  
1412.         try {  
1413.             jedis = pool.getResource();  
1414.             res = jedis.zrevrange(key, start, end);  
1415.         } catch (Exception e) {  
1416.             pool.returnBrokenResource(jedis);  
1417.             e.printStackTrace();  
1418.         } finally {  
1419.             returnResource(pool, jedis);  
1420.         }  
1421.         return res;  
1422.     }  
1423.       
1424.     /** 
1425.      * <p>通过key返回指定score内zset中的value</p> 
1426.      * @param key  
1427.      * @param max  
1428.      * @param min  
1429.      * @return 
1430.      */  
1431.     public Set<String> zrangebyscore(String key,String max,String min){  
1432.         Jedis jedis = null;  
1433.         Set<String> res = null;  
1434.         try {  
1435.             jedis = pool.getResource();  
1436.             res = jedis.zrevrangeByScore(key, max, min);  
1437.         } catch (Exception e) {  
1438.             pool.returnBrokenResource(jedis);  
1439.             e.printStackTrace();  
1440.         } finally {  
1441.             returnResource(pool, jedis);  
1442.         }  
1443.         return res;  
1444.     }  
1445.       
1446.     /** 
1447.      * <p>通过key返回指定score内zset中的value</p> 
1448.      * @param key  
1449.      * @param max   
1450.      * @param min  
1451.      * @return 
1452.      */  
1453.     public Set<String> zrangeByScore(String key ,double max,double min){  
1454.         Jedis jedis = null;  
1455.         Set<String> res = null;  
1456.         try {  
1457.             jedis = pool.getResource();  
1458.             res = jedis.zrevrangeByScore(key,max,min);  
1459.         } catch (Exception e) {  
1460.             pool.returnBrokenResource(jedis);  
1461.             e.printStackTrace();  
1462.         } finally {  
1463.             returnResource(pool, jedis);  
1464.         }  
1465.         return res;  
1466.     }  
1467.       
1468.     /** 
1469.      * <p>返回指定区间内zset中value的数量</p> 
1470.      * @param key 
1471.      * @param min 
1472.      * @param max 
1473.      * @return 
1474.      */  
1475.     public Long zcount(String key,String min,String max){  
1476.         Jedis jedis = null;  
1477.         Long res = null;  
1478.         try {  
1479.             jedis = pool.getResource();  
1480.             res = jedis.zcount(key, min, max);  
1481.         } catch (Exception e) {  
1482.             pool.returnBrokenResource(jedis);  
1483.             e.printStackTrace();  
1484.         } finally {  
1485.             returnResource(pool, jedis);  
1486.         }  
1487.         return res;  
1488.     }  
1489.       
1490.     /** 
1491.      * <p>通过key返回zset中的value个数</p> 
1492.      * @param key 
1493.      * @return 
1494.      */  
1495.     public Long zcard(String key){  
1496.         Jedis jedis = null;  
1497.         Long res = null;  
1498.         try {  
1499.             jedis = pool.getResource();  
1500.             res = jedis.zcard(key);  
1501.         } catch (Exception e) {  
1502.             pool.returnBrokenResource(jedis);  
1503.             e.printStackTrace();  
1504.         } finally {  
1505.             returnResource(pool, jedis);  
1506.         }  
1507.         return res;  
1508.     }  
1509.       
1510.     /** 
1511.      * <p>通过key获取zset中value的score值</p> 
1512.      * @param key 
1513.      * @param member 
1514.      * @return 
1515.      */  
1516.     public Double zscore(String key,String member){  
1517.         Jedis jedis = null;  
1518.         Double res = null;  
1519.         try {  
1520.             jedis = pool.getResource();  
1521.             res = jedis.zscore(key, member);  
1522.         } catch (Exception e) {  
1523.             pool.returnBrokenResource(jedis);  
1524.             e.printStackTrace();  
1525.         } finally {  
1526.             returnResource(pool, jedis);  
1527.         }  
1528.         return res;  
1529.     }  
1530.       
1531.     /** 
1532.      * <p>通过key删除给定区间内的元素</p> 
1533.      * @param key  
1534.      * @param start  
1535.      * @param end 
1536.      * @return 
1537.      */  
1538.     public Long zremrangeByRank(String key ,long start, long end){  
1539.         Jedis jedis = null;  
1540.         Long res = null;  
1541.         try {  
1542.             jedis = pool.getResource();  
1543.             res = jedis.zremrangeByRank(key, start, end);  
1544.         } catch (Exception e) {  
1545.             pool.returnBrokenResource(jedis);  
1546.             e.printStackTrace();  
1547.         } finally {  
1548.             returnResource(pool, jedis);  
1549.         }  
1550.         return res;  
1551.     }  
1552.       
1553.     /** 
1554.      * <p>通过key删除指定score内的元素</p> 
1555.      * @param key 
1556.      * @param start 
1557.      * @param end 
1558.      * @return 
1559.      */  
1560.     public Long zremrangeByScore(String key,double start,double end){  
1561.         Jedis jedis = null;  
1562.         Long res = null;  
1563.         try {  
1564.             jedis = pool.getResource();  
1565.             res = jedis.zremrangeByScore(key, start, end);  
1566.         } catch (Exception e) {  
1567.             pool.returnBrokenResource(jedis);  
1568.             e.printStackTrace();  
1569.         } finally {  
1570.             returnResource(pool, jedis);  
1571.         }  
1572.         return res;  
1573.     }  
1574.     /** 
1575.      * <p>返回满足pattern表达式的所有key</p> 
1576.      * <p>keys(*)</p> 
1577.      * <p>返回所有的key</p> 
1578.      * @param pattern 
1579.      * @return 
1580.      */  
1581.     public Set<String> keys(String pattern){  
1582.         Jedis jedis = null;  
1583.         Set<String> res = null;  
1584.         try {  
1585.             jedis = pool.getResource();  
1586.             res = jedis.keys(pattern);  
1587.         } catch (Exception e) {  
1588.             pool.returnBrokenResource(jedis);  
1589.             e.printStackTrace();  
1590.         } finally {  
1591.             returnResource(pool, jedis);  
1592.         }  
1593.         return res;  
1594.     }  
1595.       
1596.     /** 
1597.      * <p>通过key判断值得类型</p> 
1598.      * @param key 
1599.      * @return 
1600.      */  
1601.     public String type(String key){  
1602.         Jedis jedis = null;  
1603.         String res = null;  
1604.         try {  
1605.             jedis = pool.getResource();  
1606.             res = jedis.type(key);  
1607.         } catch (Exception e) {  
1608.             pool.returnBrokenResource(jedis);  
1609.             e.printStackTrace();  
1610.         } finally {  
1611.             returnResource(pool, jedis);  
1612.         }  
1613.         return res;  
1614.     }  
1615.       
1616.     /** 
1617.      * 返还到连接池 
1618.      *  
1619.      * @param pool 
1620.      * @param redis 
1621.      */  
1622.     public static void returnResource(JedisPool pool, Jedis jedis) {  
1623.         if (jedis != null) {  
1624.             pool.returnResource(jedis);  
1625.         }  
1626.     }  
1627. }