shardedJedisPool工具类

这里使用的是ShardedJedisPool，而不是RedisTemplate

1、配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"
    default-autowire="byName">
    
     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="${redis.pool.maxTotal}" />
        <property name="maxWaitMillis" value="${redis.pool.maxWaitMillis}" />
        <property name="maxIdle" value="${redis.pool.maxIdle}" />
        <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
    </bean>
    <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool"  scope="singleton">
        <constructor-arg index="0" ref="jedisPoolConfig" />
        <constructor-arg index="1">
            <list>
                <bean name="slave" class="redis.clients.jedis.JedisShardInfo">  
                    <constructor-arg index="0" value="${redis.slave.ip}" />  
                    <constructor-arg index="1" value="${redis.slave.port}" />  
                </bean>  
                <bean name="master" class="redis.clients.jedis.JedisShardInfo">   
                    <constructor-arg index="0" value="${redis.master.ip}" />   
                    <constructor-arg  index="1" value="${redis.master.port}"/>   
                </bean>
            </list>
        </constructor-arg>
    </bean>
    <bean id="jedisConnectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.master.ip}" />
        <property name="port" value="${redis.master.port}" />
        <property name="poolConfig" ref="jedisPoolConfig" />
    </bean>
    <!-- spring session 配置 -->
    <bean id="redisHttpSessionConfiguration" class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration">
        <property name="maxInactiveIntervalInSeconds" value="1800"/>
        <property name="redisNamespace" value="ianbase" />
    </bean>
    <!--spring session 监听器-->
    <!-- 让Spring Session不再执行config命令 -->
    <util:constant static-field="org.springframework.session.data.redis.config.ConfigureRedisAction.NO_OP"/>
</beans>

2、序列化工具

import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
/**
 * <p>
 * Title:对象序列化和反序列化。
 */  
public class SerializeUtil {  
  
    private static Logger LOG = LoggerFactory.getLogger(SerializeUtil.class);  
    /**  
     * 序列化
     *  
     * @param object  
     * @return byte[]
     */
    public static byte[] serialize(Object object) {  
        ObjectOutputStream oos = null;  
        ByteArrayOutputStream baos = null;
        if(object==null){
            return null;
        }
        try {  
            // 序列化  
            baos = new ByteArrayOutputStream();  
            oos = new ObjectOutputStream(baos);  
            oos.writeObject(object);  
            byte[] bytes = baos.toByteArray();  
            return bytes;  
        } catch (Exception e) {
            LOG.error("serialize error",e); 
        } finally {  
            try {  
                if (oos != null) {  
                    oos.close();  
                }  
                if (baos != null) {  
                    baos.close();  
                }  
            } catch (Exception e2) {
                LOG.error("serialize close error",e2); 
            }  
        }  
        return null;  
    }  
    /**  
     * 序列化
     *  
     * @param byte[]  
     * @return object
     */
    public static Object deserialize(byte[] bytes) { 
        if(bytes==null){
            return null;
        }
        ByteArrayInputStream bais = null;  
        try {  
            // 反序列化  
            bais = new ByteArrayInputStream(bytes);  
            ObjectInputStream ois = new ObjectInputStream(bais);  
            return ois.readObject();  
        } catch (Exception e) { 
            LOG.error("unserialize error",e); 
        }  
        return null;  
    }  
  
} 

3、RedisClient

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import SerializeUtil;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPipeline;
import redis.clients.jedis.ShardedJedisPool;

import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * redis操作工具类
 */
@SuppressWarnings("unchecked")
@Component
public class RedisClient {
    
    private static final Logger LOG = LoggerFactory.getLogger(ShardRedisClient.class);
    @Autowired
    private ShardedJedisPool    shardedJedisPool;
    
    /**
     * 字符集
     */
    private final Charset charset = Charset.forName("UTF-8");
    
    public String deserialize(byte[] bytes) {
        return (bytes == null ? null : new String(bytes, charset));
    }

    public byte[] serialize(String string) {
        return (string == null ? null : string.getBytes(charset));
    }

    /**
     * 设置单个值
     * 
     * @param key
     * @param value
     * @return
     */
    public boolean set(String key, String value) {
        boolean flag = false;
        ShardedJedis shardedJedis = shardedJedisPool.getResource();
        try {
            shardedJedis.set(key, value);
            flag=true;
        } catch (Exception e) {
            LOG.error("set error", e);
        } finally {
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }
        }
        return flag;
    }
    /**
     * 批量设置设置
     * 
     * @param key
     * @param value
     * @return
     */
    public boolean setList(String key, String value) {
        boolean flag = false;
        ShardedJedis shardedJedis = shardedJedisPool.getResource();
        try {
            ShardedJedisPipeline shardedJedisPipeline=shardedJedis.pipelined();
            shardedJedisPipeline.set(key, value);
            shardedJedisPipeline.sync();
            flag=true;
        } catch (Exception e) {
            LOG.error("set error", e);
        } finally {
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }
        }
        return flag;
    }
    /**
     * 设置单个值，并且设置过期时间
     * 
     * @param key
     * @param value
     * @param second
     * @return
     */
    public boolean set(String key, String value, int second) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            shardedJedis.setex(key, second, value);  
            return true;  
        } catch (Exception ex) {  
            LOG.error("set error.", ex);                
        } finally {
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }
            
        }  
        return false;  
    }
    /**
     * 删除所有匹配的key
     * 
     * @param prefixKey
     * @return
     */
    public boolean delKesByPrefix(String prefixKey) {
        ShardedJedis jedis = null;
        Set<String> setResult = new HashSet<String>();
        try {
            jedis  = shardedJedisPool.getResource();
            Iterator<Jedis> jedisIterator = jedis.getAllShards().iterator();
            while(jedisIterator.hasNext()){
                setResult = jedisIterator.next().keys(prefixKey+"*");
            }
            Iterator<String> it=setResult.iterator();
            while(it.hasNext()){
                String key=it.next();
                jedis.del(key);
            }
            return true; 
        } catch (Exception e) {
            LOG.error("getByPrefix error", e);
        }finally {
            if(jedis!=null){
                jedis.close();
            }              
        }
        return false;
    }
    /**
     * 获取单个值
     * 
     * @param key
     * @return
     */
    public String get(String key) {
        String result = null;
        ShardedJedis shardedJedis = shardedJedisPool.getResource();
        if (shardedJedis == null) {
            return result;
        }
        try {
            result = shardedJedis.get(key);
        } catch (Exception e) {
            LOG.error("redis get error", e);
        } finally {
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }
        }
        return result;
    }
    /**  
     * 删除HashSet对象  
     *  
     * @param key  
     *            键值  
     * @param field  
     *            属性  
     * @return 删除的记录数  
     */  
    public long del(String key) {  
        ShardedJedis shardedJedis = null;  
        long count = 0;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            count = shardedJedis.del(key);  
        } catch (Exception ex) {  
            LOG.error("hdel error.", ex);  
             
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return count;  
    }
    /**  
     * 设置一个key的过期时间（单位：秒）  
     *   
     * @param key  
     *            key值  
     * @param seconds  
     *            多少秒后过期  
     * @return 1：设置了过期时间, 0：没有设置过期时间/不能设置过期时间  
     */  
    public long expire(String key, int seconds) {  
        if (key == null || key.equals("")) {  
            return 0;  
        }    
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            return shardedJedis.expire(key, seconds);  
        } catch (Exception ex) {  
            LOG.error("EXPIRE error[key=" + key + " seconds=" + seconds + "]" + ex.getMessage(), ex);   
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }
        }  
        return 0;  
    } 
    /**  
     * 设置HashSet对象  
     *  
     * @param key  
     *            键值  
     * @param field  
     *            属性  
     * @param value  
     *            Json String or String value  
     * @return  
     */  
    public boolean hset( String key,String field, String value) {  
        if (value == null)  
            return false;  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            shardedJedis.hset(key, field, value);  
            return true;  
        } catch (Exception ex) {  
            LOG.error("hset error.", ex);  
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }
        }  
        return false;  
    }  
    /**  
     * 设置HashSet对象  
     *  
     * @param key  
     *            键值  
     * @param field  
     *            属性  
     * @param value  
     *            Json String or String value  
     * @return  
     */  
    public boolean hmset(String key, Map<String ,String> map ) {  
        if (map == null)  
            return false;  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            shardedJedis.hmset(key, map);  
            return true;  
        } catch (Exception ex) {  
            LOG.error("hmset error.", ex);  
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return false;  
    }
    /**  
     * 设置HashSet对象  
     *  
     * @param key  
     *            键值  
     * @param field  
     *            属性  
     * @param value  
     *            Json String or String value  
     * @return  
     */  
    public boolean hmsetObject(String key, Map<String ,Object> map ) {  
        if (map == null)  
            return false;  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            final Map<byte[], byte[]> hashes = new LinkedHashMap<byte[], byte[]>(map.size());

            for (Map.Entry<String, Object> entry : map.entrySet()) {
                hashes.put(serialize(entry.getKey()), SerializeUtil.serialize(entry.getValue()));
            }
            shardedJedis.hmset(serialize(key), hashes);  
            return true;  
        } catch (Exception ex) {  
            LOG.error("hmset error.", ex);  
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return false;  
    }
    
    /**  
     * 设置HashSet对象  
     *  
     * @param key  
     *            键值  
     * @param field  
     *            属性  
     * @param value  
     *            Json String or String value  
     * @return  
     */  
    public <T> boolean hmsetObjectClass(String key, Map<String ,T> map) {  
        if (map == null)  
            return false;  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            final Map<byte[], byte[]> hashes = new LinkedHashMap<byte[], byte[]>(map.size());

            for (Map.Entry<String, T> entry : map.entrySet()) {
                hashes.put(serialize(entry.getKey()), SerializeUtil.serialize(entry.getValue()));
            }
            shardedJedis.hmset(serialize(key), hashes);  
            return true;  
        } catch (Exception ex) {  
            LOG.error("hmset error.", ex);  
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return false;  
    }
    
    /**  
     * 设置HashSet对象 ，并且设置过期时间 
     *  
     * @param key  
     *            键值  
     * @param map  
     *              
     * @param seconds  
     *            过期时间，单位秒。               
     * @return  
     */  
    public boolean hmset(String key, Map<String ,String> map,int seconds ) { 
        if(this.hmset(key, map)){
            return this.expire(key, seconds)==1;
        }                  
        return false;  
    }
  
    /**  
     * 获得HashSet对象  
     *   
     * @param key  
     *            键值  
     * @param field  
     *            属性             
     * @return Json String or String value  
     */  
    public String hget(String key, String field) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            return shardedJedis.hget(key, field);  
        } catch (Exception ex) {  
            LOG.error("hget error.", ex);  
             
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return null;  
    }
    /**  
     * 获得HashSet对象  
     *   
     * @param key  
     *            键值  
     * @param field  
     *            属性             
     * @return Json String or String value  
     */  
    public Object hgetObject(String key, String field) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource(); 
            byte[] value=shardedJedis.hget(serialize(key), serialize(field));
            return SerializeUtil.deserialize(value);  
        } catch (Exception ex) {  
            LOG.error("hget error.", ex);  
             
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }
        }  
        return null;  
    }
    /**  
     * 获得HashSet对象  
     *  
     * @param key  
     *            键值  
     * @return Json String or String value  
     */  
    public Map<String,Object> hgetMap(String key) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            Map<byte[], byte[]> entries =shardedJedis.hgetAll(serialize(key));
            Map<String,Object> map = new LinkedHashMap<String,Object>(entries.size());

            for (Map.Entry<byte[], byte[]> entry : entries.entrySet()) {
                map.put(deserialize(entry.getKey()), SerializeUtil.deserialize(entry.getValue()));
            }
            return map;
        } catch (Exception ex) {  
            LOG.error("hgetAll error.", ex);  
             
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return null;  
    }
  
    /**
     * 获得缓存的Map,指定class
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> hgetMapClass(Class<T> t,String key) {
         ShardedJedis shardedJedis = null;  
         try {  
             shardedJedis = shardedJedisPool.getResource();  
             Map<byte[], byte[]> entries =shardedJedis.hgetAll(serialize(key));
             Map map = new LinkedHashMap<String,Object>(entries.size());

             for (Map.Entry<byte[], byte[]> entry : entries.entrySet()) {
                 map.put(deserialize(entry.getKey()), t.cast(SerializeUtil.deserialize(entry.getValue())));
             }
             return map;
         } catch (Exception ex) {  
             LOG.error("hgetAll error.", ex);
         } finally {  
             if(shardedJedis!=null){
                 shardedJedis.close(); 
             } 
         }
        return null;  
    }
    /**  
     * 删除HashSet对象  
     *  
     * @param key  
     *            键值  
     * @param field  
     *            属性值  
     * @return 删除的记录数  
     */  
    public long hdel(String key,String field) {  
        ShardedJedis shardedJedis = null;  
        long count = 0;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            count = shardedJedis.hdel(key,field);  
        } catch (Exception ex) {  
            LOG.error("hdel error.", ex);  
             
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return count;  
    }  
  
    /**  
     * 删除HashSet对象  
     *  
     * @param key  
     *            键值  
     * @param field  
     *            属性  
     * @return 删除的记录数  
     */  
    public long hdel(String key, String... field) {  
        ShardedJedis shardedJedis = null;  
        long count = 0;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            count = shardedJedis.hdel(key,field);  
        } catch (Exception ex) {  
            LOG.error("hdel error.", ex);  
             
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return count;  
    }  
  
    /**  
     * 判断key是否存在  
     *  
     * @param key  
     *            键值  
     * @param field  
     *            属性  
     * @return  
     */  
    public boolean hexists(String key, String field) {  
        ShardedJedis shardedJedis = null;  
        boolean isExist = false;  
        try {  
            shardedJedis = shardedJedisPool.getResource(); 
            isExist = shardedJedis.hexists(key,field);  
        } catch (Exception ex) {  
            LOG.error("hexists error.", ex);  
             
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return isExist;  
    }    
    
    /**  
     * 判断key是否存在  
     *  
     * @param key  
     *            键值  
     * @return  
     */  
    public boolean exists(String key) {  
        ShardedJedis shardedJedis = null;  
        boolean isExist = false;  
        try {  
            shardedJedis = shardedJedisPool.getResource(); 
            isExist = shardedJedis.exists(key); 
        } catch (Exception ex) {  
            LOG.error("hexists error.", ex);  
             
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return isExist;  
    }
  
    /**  
     * 返回 key 指定的哈希集中所有字段的value值  
     *  
     * @param key  
     * @return  
     */  
  
    public List<String> hvals(String key) {  
        ShardedJedis shardedJedis = null;  
        List<String> retList = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            retList = shardedJedis.hvals(key);  
        } catch (Exception ex) {  
            LOG.error("hvals error.", ex);  
             
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return retList;  
    }
    /**  
     * 返回 key 指定的哈希集中所有字段的value值  
     *  
     * @param key  
     * @return  
     */  
  
    public <T> List<T> hvalsObject(String key) {  
        ShardedJedis shardedJedis = null;  
        List<Object> retList = new ArrayList<Object>();  
        try {  
            shardedJedis = shardedJedisPool.getResource();
            Collection<byte[]> byteList=shardedJedis.hvals(serialize(key));
            Iterator<byte[]> it=byteList.iterator();
            while(it.hasNext()){
                retList.add(SerializeUtil.deserialize(it.next()));
            } 
        } catch (Exception ex) {  
            LOG.error("hvals error.", ex);  
             
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }
        }  
        return (List<T>)retList;  
    } 
  
    /**  
     * 返回 key 指定的哈希集中所有字段的field值  
     *  
     * @param key  
     * @return  
     */  
  
    public Set<String> hkeys(String key) {  
        ShardedJedis shardedJedis = null;  
        Set<String> retList = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            retList = shardedJedis.hkeys(key);  
        } catch (Exception ex) {  
            LOG.error("hkeys error.", ex);  
             
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return retList;  
    }  
  
    /**  
     * 返回 key 指定的哈希field值总数  
     *  
     * @param key  
     * @return  
     */  
    public long hlen(String key) {  
        ShardedJedis shardedJedis = null;  
        long retList = 0;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            retList = shardedJedis.hlen(key);  
        } catch (Exception ex) {  
            LOG.error("hkeys error.", ex);  
             
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return retList;  
    }  
  
    /**  
     * 设置排序集合  
     *  
     * @param key  
     * @param score  
     * @param value  
     * @return  
     */  
    public boolean setSortedSet(String key, long score, String value) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            shardedJedis.zadd(key, score, value);  
            return true;  
        } catch (Exception ex) {  
            LOG.error("setSortedSet error.", ex);  
             
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return false;  
    }
     
  
    /**  
     * 获得排序集合  
     *  
     * @param key  
     * @param startScore  
     * @param endScore  
     * @param orderByDesc  
     * @return  
     */  
    public Set<String> getSoredSet(String key, long startScore, long endScore, boolean orderByDesc) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            if (orderByDesc) {  
                return shardedJedis.zrevrangeByScore(key, endScore, startScore);  
            } else {  
                return shardedJedis.zrangeByScore(key, startScore, endScore);  
            }  
        } catch (Exception ex) {  
            LOG.error("getSoredSet error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return null;  
    }  
  
    /**  
     * 计算排序长度  
     *  
     * @param key  
     * @param startScore  
     * @param endScore  
     * @return  
     */  
    public long zcount(String key, long startScore, long endScore) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            Long count = shardedJedis.zcount(key, startScore, endScore);  
            return count == null ? 0L : count;  
        } catch (Exception ex) {  
            LOG.error("zcount error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }
        }  
        return 0L;  
    }  
  
    /**  
     * 删除排序集合  
     *  
     * @param key  
     * @param value  
     * @return  
     */  
    public boolean zrem(String key, String value) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            long count = shardedJedis.zrem(key, value);  
            return count > 0;  
        } catch (Exception ex) {  
            LOG.error("zrem error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return false;  
    }  
  
    /**  
     * 获得排序集合  
     *  
     * @param key  
     * @param startRange  
     * @param endRange  
     * @param orderByDesc  
     * @return  
     */  
    public Set<String> zrange(String key, int startRange, int endRange, boolean orderByDesc) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            if (orderByDesc) {  
                return shardedJedis.zrevrange(key, startRange, endRange);  
            } else {  
                return shardedJedis.zrange(key, startRange, endRange);  
            }  
        } catch (Exception ex) {  
            LOG.error("zrange error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return null;  
    }  
  
    /**  
     * 获得排序打分  
     *  
     * @param key  
     * @return  
     */  
    public Double zscore(String key, String member) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            return shardedJedis.zscore(key, member);  
        } catch (Exception ex) {  
            LOG.error("zscore error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            } 
        }  
        return null;  
    }
    /**  
     * 从list中删除value 默认count 1  
     *   
     * @param key  
     * @param values  
     *            值list  
     * @return  
     */  
    public int lrem(String key, List<String> values) {  
        return lrem(key, 1, values);  
    }  
  
    /**  
     * 从list中删除value  
     *   
     * @param key  
     * @param count  
     * @param values  
     *            值list  
     * @return  
     */  
    public int lrem(String key, long count, List<String> values) {  
        int result = 0;  
        if (values != null && values.size() > 0) {  
            for (String value : values) {  
                if (lrem(key, count, value)) {  
                    result++;  
                }  
            }  
        }  
        return result;  
    }  
  
    /**  
     * 从list中删除value  
     *   
     * @param key  
     * @param count  
     *            要删除个数  
     * @param value  
     * @return  
     */  
    public boolean lrem(String key, long count, String value) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            shardedJedis.lrem(key, count, value);  
            return true;  
        } catch (Exception ex) {  
            LOG.error("lrem error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }  
        }  
        return false;  
    }  
  
    /**  
     * 截取List  
     *   
     * @param key  
     * @param start  
     *            起始位置  
     * @param end  
     *            结束位置  
     * @return  
     */  
    public List<String> lrange(String key, long start, long end) {  
        if (key == null || key.equals("")) {  
            return null;  
        }  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            return shardedJedis.lrange(key, start, end);  
        } catch (Exception ex) {  
            LOG.error("lrange 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage(), ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }   
        }  
        return null;  
    }  
  
    /**  
     * 检查List长度  
     *   
     * @param key  
     * @return  
     */  
    public long llen(String key) {  
        if (key == null) {  
            return 0;  
        }  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            return shardedJedis.llen(key);  
        } catch (Exception ex) {  
            LOG.error("llen error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }  
        }  
        return 0;  
    }  
  
    /**  
     * 添加到List中（同时设置过期时间）  
     *   
     * @param key  
     *            key值  
     * @param seconds  
     *            过期时间 单位s  
     * @param value  
     * @return  
     */  
    public boolean lpush(String key, int seconds, String... value) {  
        boolean result = lpush(key, value);  
        if (result) {  
            long i = expire(key, seconds);  
            return i == 1;  
        }  
        return false;  
    }  
  
    /**  
     * 添加到List  
     *   
     * @param key  
     * @param value  
     * @return  
     */  
    public boolean lpush(String key, String... value) {  
        if (key == null || value == null) {  
            return false;  
        }  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            shardedJedis.lpush(key, value);  
            return true;  
        } catch (Exception ex) {  
            LOG.error("lpush error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }   
        }  
        return false;  
    }  
  
    /**  
     * 添加到List(只新增)  
     *   
     * @param key  
     * @param value  
     * @return  
     */  
    public boolean lpush(String key, List<String> list) {  
        if (key == null || list == null || list.size() == 0) {  
            return false;  
        }  
        for (String value : list) {  
            lpush(key, value);  
        }  
        return true;  
    }
    /**  
     * 截断一个List  
     *   
     * @param key  
     *            列表key  
     * @param start  
     *            开始位置 从0开始  
     * @param end  
     *            结束位置  
     * @return 状态码  
     */  
    public String ltrim(String key, long start, long end) {  
        if (key == null || key.equals("")) {  
            return "-";  
        }  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            return shardedJedis.ltrim(key, start, end);  
        } catch (Exception ex) {  
            LOG.error("ltrim 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage(), ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }  
        }  
        return "-";  
    }  
  
    /**  
     * 检查Set长度  
     *   
     * @param key  
     * @return  
     */  
    public long scard(String key) {  
        if (key == null) {  
            return 0;  
        }  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            return shardedJedis.scard(key);  
        } catch (Exception ex) {  
            LOG.error("scard error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }  
        }  
        return 0;  
    }  
  
    /**  
     * 添加到Set中（同时设置过期时间）  
     *   
     * @param key  
     *            key值  
     * @param seconds  
     *            过期时间 单位s  
     * @param value  
     * @return 成功true  
     */  
    public boolean sadd(String key, int seconds, String... value) {  
        boolean result = sadd(key, value);  
        if (result) {  
            long i = expire(key, seconds);  
            return i == 1;  
        }  
        return false;  
    }  
  
    /**  
     * 添加到Set中  
     *   
     * @param key  
     * @param value  
     * @return  
     */  
    public boolean sadd(String key, String... value) {  
        if (key == null || value == null) {  
            return false;  
        }  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            shardedJedis.sadd(key, value);  
            return true;  
        } catch (Exception ex) {  
            LOG.error("setList error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }  
        }  
        return false;  
    }
    /**  
     * 添加到Set中  
     *   
     * @param key  
     * @param value  
     * @return  
     */  
    public boolean saddObject(String key, Object... values) {  
        if (key == null || values == null) {  
            return false;  
        }
        int length=values.length;
        byte[][] array=new byte[length][];
        
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource(); 
            int i = 0;
            for(Object value : values){
                array[i++]=SerializeUtil.serialize(value);
            }            
            shardedJedis.sadd(serialize(key), array);  
            return true;  
        } catch (Exception ex) {  
            LOG.error("setList error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }  
        }  
        return false;  
    }
    
  
    /**  
     * @param key  
     * @param value  
     * @return 判断值是否包含在set中  
     */  
    public boolean sismember(String key, String value) {  
        if (key == null || value == null) {  
            return false;  
        }  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            return shardedJedis.sismember(key, value);  
        } catch (Exception ex) {  
            LOG.error("sismember error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }  
        }  
        return false;  
    }  
  
    /**  
     * 获取Set  
     *   
     * @param key  
     * @return  
     */  
    public Set<String> smembers(String key) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            return shardedJedis.smembers(key);  
        } catch (Exception ex) {  
            LOG.error("smembers error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }  
        }  
        return null;  
    }
    /**  
     * 获取Set  
     *   
     * @param key  
     * @return  
     */  
    public List<Object> smembersObjct(String key) {
        List<Object> list = new ArrayList<Object>();
        Set<byte[]> set = smembersByte(key);
        Iterator<byte[]> it = set.iterator();
        while (it.hasNext()) {
            list.add(SerializeUtil.deserialize(it.next()));
        }
        return list;

    }
    /**  
     * 获取Set  
     *   
     * @param key  
     * @return  
     */  
    public Set<byte[]> smembersByte(String key) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            return shardedJedis.smembers(key.getBytes(charset));  
        } catch (Exception ex) {  
            LOG.error("smembers error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }  
        }  
        return null;  
    }
  
    /**  
     * 从set中删除value  
     *   
     * @param key  
     * @return  
     */  
    public boolean srem(String key, String... value) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            shardedJedis.srem(key, value);  
            return true;  
        } catch (Exception ex) {  
            LOG.error("getList error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }  
        }  
        return false;  
    }  
  
    /**  
     * 获取List  
     *   
     * @param key  
     * @return  
     */  
    public List<String> lrange(String key) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
            return shardedJedis.lrange(key, 0, -1);  
        } catch (Exception ex) {  
            LOG.error("lrange error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }   
        }  
        return null;  
    }
    /**  
     * 获取List  
     *   
     * @param key  
     * @return  
     */  
    public List<Object> lrangeObject(String key) {
        List<Object> objList=new ArrayList<Object>();
        List<byte[]> list=lrangeByte( key) ;
        if(list !=null &&list.size()>0){
            for (int i=0;i<list.size();i++){
                objList.add(SerializeUtil.deserialize(list.get(i)));
            }
        }
        return objList;
    }
    /**  
     * 获取List  
     *   
     * @param key  
     * @return  
     */  
    public List<byte[]> lrangeByte(String key) {  
        ShardedJedis shardedJedis = null;  
        try {  
            shardedJedis = shardedJedisPool.getResource();  
             
            return shardedJedis.lrange(key.getBytes(charset), 0, -1);
            
            
        } catch (Exception ex) {  
            LOG.error("lrange error.", ex);  
              
        } finally {  
            if(shardedJedis!=null){
                shardedJedis.close(); 
            }   
        }  
        return null;  
    }
    
    public Object getValue(String key) {  
        Object ret = null;  
        ShardedJedis jedis = shardedJedisPool.getResource();  
        try {  
  
            // 去redis中取回序列化后的对象  
            byte[] obj = jedis.get(serialize(key));  
  
            // 取回的对象反序列化  
            if (obj != null) {  
                ret = SerializeUtil.deserialize(obj);  
            }    
        } catch (Exception e) {
            LOG.error("get error.", e); 
        } finally {
            if(jedis!=null){
                jedis.close(); 
            }  
        }  
        return ret;  
    }      
}