Spring整合redis

环境配置

db.properties

redis_TIMEOUT = 100000
redis_REDIS_HOST = 127.0.0.1
redis_REDIS_PORT = 6379
redis_REDIS_PWD = 123456
redis_SSSION_TIMEOUT = 1800
redis_MAX_TOTAL = 500
redis_MAX_IDLE = 100

application-redis.xml

<?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:context="http://www.springframework.org/schema/context" 
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
	xmlns:jee="http://www.springframework.org/schema/jee" 
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
	
	<!-- redis 相关配置 --> 
	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
	    <property name="maxTotal" value="${redis_MAX_TOTAL}" />
	    <property name="maxIdle" value="${redis_MAX_IDLE}" />
	</bean>
    <bean id="jedisConnectionFactory"
      class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
	    <property name="hostName" value="${redis_REDIS_HOST}"/>
	    <property name="port" value="${redis_REDIS_PORT}"/>
	    <property name="password" value="${redis_REDIS_PWD}" />
	    <property name="timeout" value="${redis_TIMEOUT}"/>
	    <property name="usePool" value="true"/>
	    <property name="poolConfig" ref="jedisPoolConfig"/>
	</bean>
	<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
		<constructor-arg index="0" ref="jedisPoolConfig" />
		<constructor-arg index="1">
			<list>
				<bean name="master" class="redis.clients.jedis.JedisShardInfo">
					<constructor-arg index="0" value="${redis_REDIS_HOST}" />
					<constructor-arg index="1" value="${redis_REDIS_PORT}" type="int" />
					<property name="timeout" value="${redis_TIMEOUT}"/>
					<property name="password" value="${redis_REDIS_PWD}"/>
				</bean>
			</list>
		</constructor-arg>
	</bean>
</beans>

application-context.xml

<?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:context="http://www.springframework.org/schema/context" 
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
	xmlns:jee="http://www.springframework.org/schema/jee" 
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
	<!-- 扫描redis包 -->
	<context:component-scan base-package="com.shyb.redis"/>
	<!-- 加载其他配置文件 -->
	<import resource="application-dao.xml"/><!--dao中读取db.properties-->
	<import resource="application-redis.xml"/>
</beans>

redis包和java文件

包和结构

自己项目的包

CallBack.java

package com.shyb.redis;

import redis.clients.jedis.ShardedJedis;
//回调接口
public interface CallBack {
	Object doExecute(ShardedJedis shardedJedis);
}

RedisDataSourceImpl

package com.shyb.redis;

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

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

@Repository
public class RedisDataSourceImpl implements RedisDataSource {

	private static Logger logger = LoggerFactory.getLogger(RedisDataSourceImpl.class);

    @Autowired
    private ShardedJedisPool shardedJedisPool;

    public ShardedJedis getRedisClient() {
        try {
            ShardedJedis shardJedis = shardedJedisPool.getResource();
            return shardJedis;
        } catch (Exception e) {
        	logger.error("getRedisClent error", e);
        }
        return null;
    }

    public void returnResource(ShardedJedis shardedJedis) {
        shardedJedisPool.returnResource(shardedJedis);
    }

    public void returnResource(ShardedJedis shardedJedis, boolean broken) {
        if (broken) {
            shardedJedisPool.returnBrokenResource(shardedJedis);
        } else {
            shardedJedisPool.returnResource(shardedJedis);
        }
    }

}

RedisDataSource

package com.shyb.redis;

import redis.clients.jedis.ShardedJedis;

public interface RedisDataSource {
    public abstract ShardedJedis getRedisClient();
    public void returnResource(ShardedJedis shardedJedis);
    public void returnResource(ShardedJedis shardedJedis,boolean broken);
}

RedisClientTemplate

package com.shyb.redis;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

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

import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPipeline;
import redis.clients.jedis.SortingParams;
import redis.clients.jedis.Tuple;

/**
 * http://doc.redisfans.com/index.html查看api
 */
@SuppressWarnings("all")
@Repository
public class RedisClientTemplate {

	private static Logger log = LoggerFactory.getLogger(RedisClientTemplate.class);

	@Autowired
	private RedisDataSource redisDataSource;

	public void disconnect() {
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		shardedJedis.disconnect();
	}
	/**
	 * 获取ShardedJedis并执行的模板方法
	 * @param back 根据ShardedJedis执行具体的方法
	 * @return
	 */
	private Object executeRedis(CallBack back) {
		Object result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = back.doExecute(shardedJedis);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}
	/**
	 * 根据通配符找到符合条件的key
	 * @param pattern
	 * @return
	 */
	public Set<String> keys(String pattern) {
		return (Set<String>) executeRedis(new CallBack() {
			public Set<String> doExecute(ShardedJedis shardedJedis) {
				Jedis j =  shardedJedis.getShard(pattern);
				return j.keys(pattern);
			}
		});
	}

	/**
	 * 设置单个key
	 * @param key
	 * @param value
	 * @return
	 */
	public String set(String key,String value) {
		return (String) executeRedis(new CallBack() {
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.set(key, value);
			}
		});
	}

	/**
	 * 获取单个key
	 * 
	 * @param key
	 * @return
	 */
	public String get(String key) {
		return (String) executeRedis(new CallBack() {
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.get(key);
			}
		});
	}
	/**
	 * 判断key是否存在
	 * @param key
	 * @return
	 */
	public Boolean exists(String key) {
		return (Boolean) executeRedis(new CallBack() {
			@Override
			public Boolean doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.exists(key);
			}
		});
	}
	/**
	 * 查询key的类型
	 * 1.不存在 none 2.字符串string 3.列表list 4.集合set 5.有序集zset 6.哈希表hash
	 * @param key
	 * @return
	 */
	public String type(String key) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.type(key);
			}
		});
	}

	/**
	 * 在seconds秒后失效
	 * 
	 * @param key
	 * @param unixTime
	 * @return
	 */
	public Long expire(String key, int seconds) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.expire(key, seconds);
			}
		});
	}

	/**
	 * 在某个时间点失效
	 * @param key
	 * @param unixTime unix时间戳
	 * @return
	 */
	public Long expireAt(String key, long unixTime) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.expireAt(key, unixTime);
			}
		});
	}
	
	/**
	 * 查询key还有多少生效时间
	 * @param key
	 * @return key不存在返回-2 没有设置生效时间返回-1
	 */
	public Long ttl(String key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.ttl(key);
			}
		});
	}
	/**
	 * 二进制设置偏移值 如 a:01100001 变为b:01100010 需要调用setbit(key,7,0);setbit(key,6,1);  key的value是a
	 * @param key
	 * @param offset 偏移量
	 * @param value	true为1 false为0
	 * @return 返回值为原有位置的值 如：a变b  setbit(key,7,0)返回true setbit(key,6,1)返回false
	 */
	public boolean setbit(String key, long offset, boolean value) {
		return (boolean) executeRedis(new CallBack() {
			@Override
			public Object doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.setbit(key, offset, value);
			}
		});
	}
	/**
	 * 获取key对应的value的二进制所在偏移量的值
	 * @param key
	 * @param offset
	 * @return
	 */
	public boolean getbit(String key, long offset) {
		return (boolean) executeRedis(new CallBack() {
			@Override
			public Object doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.getbit(key, offset);
			}
		});
	}
	/**
	 * 将key对应的value从偏移量位置开始替换为value等长的字符串
	 * key不存在，会创建key value为""
	 * @param key
	 * @param offset
	 * @param value
	 * @return
	 */
	public long setrange(String key, long offset, String value) {
		return (long) executeRedis(new CallBack() {
			@Override
			public Object doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.setrange(key, offset, value);
			}
		});
	}
	/**
	 * 等价于substring,但包含头和尾  substring不包含尾
	 * @param key
	 * @param startOffset
	 * @param endOffset
	 * @return
	 */
	public String getrange(String key, long startOffset, long endOffset) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.getrange(key, startOffset, endOffset);
			}
		});
	}
	/**
	 * 设置并返回旧值  没有返回null
	 * set方法返回值为"OK"
	 * @param key
	 * @param value
	 * @return
	 */
	public String getSet(String key, String value) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.getSet(key, value);
			}
		});
	}
	/**
	 * 当key不存在时设置值，返回1
	 * 当key存在时不改动，返回0
	 * @param key
	 * @param value
	 * @return
	 */
	public Long setnx(String key, String value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.setnx(key, value);
			}
		});
	}
	/**
	 * 设置或替换值，并设置生存时间
	 * @param key
	 * @param seconds
	 * @param value
	 * @return
	 */
	public String setex(String key, int seconds, String value) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.setex(key, seconds, value);
			}
		});
	}
	/**
	 * 将key对应的数值减count并返回
	 * 如果key不存在，创建key，默认值为0
	 * @param key
	 * @return
	 */
	public Long decrBy(String key, long count) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.decrBy(key, count);
			}
		});
	}
	/**
	 * 将key对应的数值减1并返回
	 * 如果key不存在，创建key，默认值为0，再减一(即返回-1)
	 * @param key
	 * @return
	 */
	public Long decr(String key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.decr(key);
			}
		});
	}
	/**
	 * 将key对应的数值加count并返回
	 * 如果key不存在，创建key，默认值为0
	 * @param key
	 * @return
	 */
	public Long incrBy(String key, long count) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.incrBy(key, count);
			}
		});
	}
	/**
	 * 将key对应的数值加1并返回
	 * 如果key不存在，创建key，默认值为0，再加一(即返回1)
	 * @param key
	 * @return
	 */
	public Long incr(String key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.incr(key);
			}
		});
	}
	/**
	 * 追加字符串，相当于StringBuilder的append
	 * key不存在时等价于set方法
	 * @param key
	 * @param value
	 * @return 返回最终字符串的长度
	 */
	public Long append(String key, String value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.append(key, value);
			}
		});
	}
	/**
	 * 和getrange作用一样
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public String substr(String key, int start, int end) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.substr(key, start, end);
			}
		});
	}
	/**
	 * key不存在，创建新的hash表
	 * key存在。 field存在，value被覆盖。field不存在，添加新的
	 * @param key
	 * @param field
	 * @param value
	 * @return 值被覆盖返回0,创建新参数返回1
	 */
	public Long hset(String key, String field, String value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hset(key, field, value);
			}
		});
	}
	/**
	 * key或field不存在时返回null
	 * @param key
	 * @param field
	 * @return
	 */
	public String hget(String key, String field) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hget(key, field);
			}
		});
	}
	/**
	 * 如果key,field都存在，不执行操作，返回0
	 * 其他情况执行并返回1
	 * @param key
	 * @param field
	 * @param value
	 * @return
	 */
	public Long hsetnx(String key, String field, String value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hsetnx(key, field, value);
			}
		});
	}
	/**
	 * 将多个field和value值设置到key中，会覆盖旧值。返回"OK"
	 * @param key
	 * @param hash
	 * @return
	 */
	public String hmset(String key, Map<String, String> hash) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hmset(key, hash);
			}
		});
	}
	/**
	 * 根据fields返回1个或多个value,并存入list中。如果field不存在，list也会添加一个null
	 * @param key
	 * @param fields
	 * @return
	 */
	public List<String> hmget(String key, String... fields) {
		return (List<String>) executeRedis(new CallBack() {
			@Override
			public List<String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hmget(key, fields);
			}
		});
	}
	/**
	 * 给key下的field属性的值添加value增量，不存在则创建默认值0
	 * key下的field属性的值是字符串时，报错JedisDataException
	 * @param key
	 * @param field
	 * @param value
	 * @return
	 */
	public Long hincrBy(String key, String field, long value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hincrBy(key, field, value);
			}
		});
	}
	/**
	 * 判断是否存在key以及对应的field域
	 * @param key
	 * @param field
	 * @return
	 */
	public Boolean hexists(String key, String field) {
		return (Boolean) executeRedis(new CallBack() {
			@Override
			public Boolean doExecute(ShardedJedis shardedJedis) {
				return  shardedJedis.hexists(key, field);
			}
		});
	}
	/**
	 * 删除指定的key
	 * @param key
	 * @return
	 */
	public Long del(String key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.del(key);
			}
		});
	}
	/**
	 * 删除指定的key下的field
	 * @param key
	 * @param field
	 * @return
	 */
	public Long hdel(String key, String field) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hdel(key, field);
			}
		});
	}
	/**
	 * 获取key下的filed数量
	 * @param key
	 * @return
	 */
	public Long hlen(String key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hlen(key);
			}
		});
	}
	/**
	 * 获取key下所有的field
	 * @param key
	 * @return
	 */
	public Set<String> hkeys(String key) {
		return (Set<String>) executeRedis(new CallBack() {
			@Override
			public Set<String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hkeys(key);
			}
		});
	}
	/**
	 * 获取key下所有field对应的value
	 * @param key
	 * @return
	 */
	public List<String> hvals(String key) {
		return (List<String>) executeRedis(new CallBack() {
			@Override
			public List<String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hvals(key);
			}
		});
	}
	/**
	 * 获取key下的所有键值对
	 * @param key
	 * @return
	 */
	public Map<String, String> hgetAll(String key) {
		return (Map<String, String>) executeRedis(new CallBack() {
			@Override
			public Map<String, String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hgetAll(key);
			}
		});
	}


	// ================list ====== l表示 list,l表示left, r表示right====================
	/**
	 * 向列表key的右边添加string元素，key不是列表报错
	 * @param key
	 * @param string
	 * @return 新列表的长度
	 */
	public Long rpush(String key, String string) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.rpush(key, string);
			}
		});
	}
	/**
	 * 向列表key的左边添加string元素，key不是列表报错
	 * @param key
	 * @param string
	 * @return 新列表的长度
	 */
	public Long lpush(String key, String string) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.lpush(key, string);
			}
		});
	}
	/**
	 * 返回列表key的长度，key不存在返回0，key不是列表报错
	 * @param key
	 * @return
	 */
	public Long llen(String key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.llen(key);
			}
		});
	}
	/**
	 * 返回列表key的start到end位置的元素 含头含尾  end为-1标识最后一位
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public List<String> lrange(String key, long start, long end) {
		return (List<String>) executeRedis(new CallBack() {
			@Override
			public List<String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.lrange(key, start, end);
			}
		});
	}
	/**
	 * 清空不在start和end范围内的列表
	 * @param key
	 * @param start
	 * @param end
	 * @return  "OK"
	 */
	public String ltrim(String key, long start, long end) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.ltrim(key, start, end);
			}
		});
	}
	/**
	 * 根据key和下标获取列表对应位置的值
	 * @param key
	 * @param index
	 * @return
	 */
	public String lindex(String key, long index) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.lindex(key, index);
			}
		});
	}
	/**
	 * 修改列表key对应Index下标的值
	 * key不存在或Index越界报错，成功返回"OK"
	 * @param key
	 * @param index
	 * @param value
	 * @return
	 */
	public String lset(String key, long index, String value) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.lset(key, index, value);
			}
		});
	}
	/**
	 * 移除列表key的value元素
	 * count为要移除的数量  正数：从左开始 负数：从右开始
	 * @param key
	 * @param count
	 * @param value
	 * @return  实际移除数量
	 */
	public Long lrem(String key, long count, String value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.lrem(key, count, value);
			}
		});
	}
	/**
	 * 移除列表第一个(左)元素，没有返回null
	 * @param key
	 * @return
	 */
	public String lpop(String key) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.lpop(key);
			}
		});
	}
	/**
	 * 移除列表最后一个(右)元素，没有返回null
	 * @param key
	 * @return
	 */
	public String rpop(String key) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.rpop(key);
			}
		});
	}

	/**
	 * 向key对应的集合中添加member成员  已存在不添加，返回0.不存在添加，返回1
	 * @param key
	 * @param member
	 * @return
	 */
	public Long sadd(String key, String member) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.sadd(key, member);
			}
		});
	}
	/**
	 * 向key对应的集合中添加1或多个member,成功返回添加的个数
	 * @param key
	 * @param member
	 * @return
	 */
	public Long sadd(String key, String... member) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.sadd(key, member);
			}
		});
	}
	/**
	 * 获取key对应的集合中所有的元素
	 * @param key
	 * @return
	 */
	public Set<String> smembers(String key) {
		return (Set<String>) executeRedis(new CallBack() {
			@Override
			public Set<String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.smembers(key);
			}
		});
	}
	/**
	 * 移除key对应的集合中的member成员 
	 * @param key
	 * @param member
	 * @return 0 未移除 1移除1个
	 */
	public Long srem(String key, String member) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.srem(key, member);
			}
		});
	}
	/**
	 * 随机移除集合中的一个成员
	 * @param key
	 * @return
	 */
	public String spop(String key) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.spop(key);
			}
		});
	}
	/**
	 * 获取集合的基数(成员个数)
	 * @param key
	 * @return
	 */
	public Long scard(String key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.scard(key);
			}
		});
	}
	/**
	 * 判断member是不是key对应集合的成员
	 * @param key
	 * @param member
	 * @return
	 */
	public Boolean sismember(String key, String member) {
		return (Boolean) executeRedis(new CallBack() {
			@Override
			public Boolean doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.sismember(key, member);
			}
		});
	}
	/**
	 * 随机获取集合中的一个元素
	 * @param key
	 * @return
	 */
	public String srandmember(String key) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.srandmember(key);
			}
		});
	}
	/**
	 * 添加或修改key对应的有序集合的member成员的score值
	 * @param key
	 * @param score
	 * @param member
	 * @return  添加的个数
	 */
	public Long zadd(String key, double score, String member) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zadd(key, score, member);
			}
		});
	}
	/**
	 * 获取start和end区间的成员，按score递增顺序排
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public Set<String> zrange(String key, int start, int end) {
		return (Set<String>) executeRedis(new CallBack() {
			@Override
			public Set<String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrange(key, start, end);
			}
		});
	}
	/**
	 * 获取start和end区间的成员，按score递减顺序排
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public Set<String> zrevrange(String key, int start, int end) {
		return (Set<String>) executeRedis(new CallBack() {
			@Override
			public Set<String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrevrange(key, start, end);
			}
		});
	}
	/**
	 * 移除有序集合的member成员  
	 * @param key
	 * @param member
	 * @return  移除的数量 返回1或0
	 */
	public Long zrem(String key, String member) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrem(key, member);
			}
		});
	}
	/**
	 * 给key对应的member成员添加score分，score可以为负数
	 * @param key
	 * @param score
	 * @param member
	 * @return  member的新score值
	 */
	public Double zincrby(String key, double score, String member) {
		return (Double) executeRedis(new CallBack() {
			@Override
			public Double doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zincrby(key, score, member);
			}
		});
	}
	/**
	 * key中member成员的排名(score从小到大排 第一score值最小)  第一名返回0 第二返回1 ……
	 * @param key
	 * @param member
	 * @return
	 */
	public Long zrank(String key, String member) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrank(key, member);
			}
		});
	}
	/**
	 * key中member成员的排名(score从大到小排) score最大返回0 第二返回1 ……
	 * @param key
	 * @param member
	 * @return
	 */
	public Long zrevrank(String key, String member) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrevrank(key, member);
			}
		});
	}
	/**
	 * 获取key的start到end区间的成员和分数,并按照score从低到高排
	 * Tuple对象的element为成员，score为对应的分数
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public Set<Tuple> zrangeWithScores(String key, int start, int end) {
		return (Set<Tuple>) executeRedis(new CallBack() {
			@Override
			public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrangeWithScores(key, start, end);
			}
		});
	}
	/**
	 * 获取key的start到end区间的成员和分数,并按照score从高到低排
	 * Tuple对象的element为成员，score为对应的分数
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public Set<Tuple> zrevrangeWithScores(String key, int start, int end) {
		return (Set<Tuple>) executeRedis(new CallBack() {
			@Override
			public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrevrangeWithScores(key, start, end);
			}
		});
	}
	/**
	 * 获取有序集合的长度
	 * @param key
	 * @return  key不存在返回0
	 */
	public Long zcard(String key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zcard(key);
			}
		});
	}
	/**
	 * 获取有序集合key中member的score值，不存在返回null
	 * @param key
	 * @param member
	 * @return
	 */
	public Double zscore(String key, String member) {
		return (Double) executeRedis(new CallBack() {
			@Override
			public Double doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zscore(key, member);
			}
		});
	}
	/**
	 * 返回或保存key(列表，集合，有序集合)中经过排序的成员
	 * 默认按照数字排序从小到大
	 * @param key
	 * @return
	 */
	public List<String> sort(String key) {
		return (List<String>) executeRedis(new CallBack() {
			@Override
			public List<String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.sort(key);
			}
		});
	}
	/**
	 * 返回或保存key(列表，集合，有序集合)中经过排序的成员
	 * 默认按照数字排序从小到大
	 * @param key
	 * @param sortingParameters  排序参数
	 * @return
	 */
	public List<String> sort(String key, SortingParams sortingParameters) {
		return (List<String>) executeRedis(new CallBack() {
			@Override
			public List<String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.sort(key, sortingParameters);
			}
		});
	}
	/**
	 * 获取key对应有序集合中score在min到max之间的成员数量(包含min和max)
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 */
	public Long zcount(String key, double min, double max) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zcount(key, min, max);
			}
		});
	}
	/**
	 * 获取key对应有序集合分数在min和max之间的所有成员(包含min和max)
	 * 成员顺序按score从小到大排序
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 */
	public Set<String> zrangeByScore(String key, double min, double max) {
		return (Set<String>) executeRedis(new CallBack() {
			@Override
			public Set<String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrangeByScore(key, min, max);
			}
		});
	}
	/**
	 * 获取key对应有序集合分数在min和max之间的所有成员(包含min和max)
	 * 成员顺序按score从大到小排序
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 */
	public Set<String> zrevrangeByScore(String key, double max, double min) {
		return (Set<String>) executeRedis(new CallBack() {
			@Override
			public Set<String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrevrangeByScore(key, min, max);
			}
		});
	}
	/**
	 * 获取key对应有序集合分数在min和max之间的所有成员(包含min和max)
	 * 成员顺序按score从小到大排序
	 * @param key
	 * @param min
	 * @param max
	 * @param offset  从那个位置取     offset过大会影响速度
	 * @param count	取的个数    和数据库的limit一样
	 * @return
	 */
	public Set<String> zrangeByScore(String key, double min, double max, int offset, int count) {
		return (Set<String>) executeRedis(new CallBack() {
			@Override
			public Set<String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrangeByScore(key, min, max, offset, count);
			}
		});
	}
	/**
	 * 获取key对应有序集合分数在min和max之间的所有成员(包含min和max)
	 * 成员顺序按score从大到小排序
	 * @param key
	 * @param min
	 * @param max
	 * @param offset  从那个位置取     offset过大会影响速度
	 * @param count	取的个数    和数据库的limit一样
	 * @return
	 */
	public Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count) {
		return (Set<String>) executeRedis(new CallBack() {
			@Override
			public Set<String> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrevrangeByScore(key, min, max, offset, count);
			}
		});
	}
	/**
	 * 获取key对应有序集合分数在min和max之间的所有成员和score值(包含min和max)
	 * 成员顺序按score从小到大排序
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 */
	public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
		return (Set<Tuple>) executeRedis(new CallBack() {
			@Override
			public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrangeByScoreWithScores(key, min, max);
			}
		});
	}
	/**
	 * 获取key对应有序集合分数在min和max之间的所有成员和score值(包含min和max)
	* 成员顺序按score从大到小排序
	* @param key
	* @param min
	* @param max
	* @return
	*/
	public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min) {
		return (Set<Tuple>) executeRedis(new CallBack() {
			@Override
			public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrevrangeByScoreWithScores(key, min, max);
			}
		});
	}
	/**
	 * 获取key对应有序集合分数在min和max之间的所有成员带score值(包含min和max)
	 * 成员顺序按score从小到大排序
	 * @param key
	 * @param min
	 * @param max
	 * @param offset  从那个位置取     offset过大会影响速度
	 * @param count	取的个数    和数据库的limit一样
	 * @return
	 */
	public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count) {
		return (Set<Tuple>) executeRedis(new CallBack() {
			@Override
			public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrangeByScoreWithScores(key, min, max, offset, count);
			}
		});
	}
	/**
	 * 获取key对应有序集合分数在min和max之间的所有成员带score值(包含min和max)
	 * 成员顺序按score从大到小排序
	 * @param key
	 * @param min
	 * @param max
	 * @param offset  从那个位置取     offset过大会影响速度
	 * @param count	取的个数    和数据库的limit一样
	 * @return
	 */
	public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count) {
		return (Set<Tuple>) executeRedis(new CallBack() {
			@Override
			public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrevrangeByScoreWithScores(key, min, max, offset, count);
			}
		});
	}
	/**
	 * 移除key对应有序集合的顺序在start至end的成员  
	 * 集合按score从小到大排
	 * @param key
	 * @param start
	 * @param end
	 * @return   移除的数量
	 */
	public Long zremrangeByRank(String key, int start, int end) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zremrangeByRank(key, start, end);
			}
		});
	}
	/**
	 * 删除key对应有序集合的score在start至end的成员
	 * 集合按score从小到大排
	 * @param key
	 * @param start
	 * @param end
	 * @return 移除的数量
	 */
	public Long zremrangeByScore(String key, double start, double end) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zremrangeByScore(key, start, end);
			}
		});
	}
	/**
	 * 向key对应列表的pivot成员(where设置before或after)插入value
	 * @param key
	 * @param where  枚举类
	 * @param pivot
	 * @param value
	 * @return  key不存在或列表为空，返回0  成功返回列表长度，pivot不存在返回-1
	 */
	public Long linsert(String key, LIST_POSITION where, String pivot, String value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.linsert(key, where, pivot, value);
			}
		});
	}
	/**
	 * 存储key value都为byte数组
	 * @param key
	 * @param value
	 * @return
	 */
	public String set(byte[] key, byte[] value) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.set(key, value);
			}
		});
	}
	/**
	 * 根据byte数组获取值
	 * @param key
	 * @return
	 */
	public byte[] get(byte[] key) {
		return (byte[]) executeRedis(new CallBack() {
			@Override
			public byte[] doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.get(key);
			}
		});
	}
	/**
	 * byte数组是否存在
	 * @param key
	 * @return
	 */
	public Boolean exists(byte[] key) {
		return (Boolean) executeRedis(new CallBack() {
			@Override
			public Boolean doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.exists(key);
			}
		});
	}
	/**
	 * 获取key类型
	 * @param key
	 * @return
	 */
	public String type(byte[] key) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.type(key);
			}
		});
	}
	/**
	 * 设置key生效时间
	 * @param key
	 * @param seconds
	 * @return	成功返回1
	 */
	public Long expire(byte[] key, int seconds) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.expire(key, seconds);
			}
		});
	}
	/**
	 * 设置在unixTime时失效
	 * @param key
	 * @param unixTime
	 * @return
	 */
	public Long expireAt(byte[] key, long unixTime) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.expireAt(key, unixTime);
			}
		});
	}
	/**
	 * 查询剩余生效时间
	 * @param key
	 * @return
	 */
	public Long ttl(byte[] key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.ttl(key);
			}
		});
	}
	/**
	 * 设置并获取原来存在的值
	 * @param key
	 * @param value
	 * @return
	 */
	public byte[] getSet(byte[] key, byte[] value) {
		return (byte[]) executeRedis(new CallBack() {
			@Override
			public byte[] doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.getSet(key, value);
			}
		});
	}
	/**
	 * 不存在时设置
	 * @param key
	 * @param value
	 * @return
	 */
	public Long setnx(byte[] key, byte[] value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.setnx(key, value);
			}
		});
	}
	/**
	 * 修改值、生效时间
	 * @param key
	 * @param seconds
	 * @param value
	 * @return
	 */
	public String setex(byte[] key, int seconds, byte[] value) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.setex(key, seconds, value);
			}
		});
	}
	
	public Long decrBy(byte[] key, long integer) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.decrBy(key, integer);
			}
		});
	}

	public Long decr(byte[] key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.decr(key);
			}
		});
	}

	public Long incrBy(byte[] key, long integer) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.incrBy(key, integer);
			}
		});
	}

	public Long incr(byte[] key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.incr(key);
			}
		});
	}

	public Long append(byte[] key, byte[] value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.append(key, value);
			}
		});
	}

	public byte[] substr(byte[] key, int start, int end) {
		return (byte[]) executeRedis(new CallBack() {
			@Override
			public byte[] doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.substr(key, start, end);
			}
		});
	}

	public Long hset(byte[] key, byte[] field, byte[] value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hset(key, field, value);
			}
		});
	}

	public byte[] hget(byte[] key, byte[] field) {
		return (byte[]) executeRedis(new CallBack() {
			@Override
			public byte[] doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hget(key, field);
			}
		});
	}
	
	public Long hsetnx(byte[] key, byte[] field, byte[] value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hsetnx(key, field, value);
			}
		});
	}

	public String hmset(byte[] key, Map<byte[], byte[]> hash) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hmset(key, hash);
			}
		});
	}

	public List<byte[]> hmget(byte[] key, byte[]... fields) {
		return (List<byte[]>) executeRedis(new CallBack() {
			@Override
			public List<byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hmget(key, fields);
			}
		});
	}

	public Long hincrBy(byte[] key, byte[] field, long value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hincrBy(key, field, value);
			}
		});
	}

	public Boolean hexists(byte[] key, byte[] field) {
		return (Boolean) executeRedis(new CallBack() {
			@Override
			public Boolean doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hexists(key, field);
			}
		});
	}

	public Long hdel(byte[] key, byte[] field) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hdel(key, field);
			}
		});
	}
	
	public Long hlen(byte[] key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hlen(key);
			}
		});
	}
	
	public Set<byte[]> hkeys(byte[] key) {
		return (Set<byte[]>) executeRedis(new CallBack() {
			@Override
			public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hkeys(key);
			}
		});
	}

	public Collection<byte[]> hvals(byte[] key) {
		return (Collection<byte[]>) executeRedis(new CallBack() {
			@Override
			public Collection<byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hvals(key);
			}
		});
	}

	public Map<byte[], byte[]> hgetAll(byte[] key) {
		return (Map<byte[], byte[]>) executeRedis(new CallBack() {
			@Override
			public Map<byte[], byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.hgetAll(key);
			}
		});
	}
	
	public Long rpush(byte[] key, byte[] string) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.rpush(key, string);
			}
		});
	}

	public Long lpush(byte[] key, byte[] string) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.lpush(key, string);
			}
		});
	}

	public Long llen(byte[] key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.llen(key);
			}
		});
	}
	
	public List<byte[]> lrange(byte[] key, int start, int end) {
		return (List<byte[]>) executeRedis(new CallBack() {
			@Override
			public List<byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.lrange(key, start, end);
			}
		});
	}
	
	public String ltrim(byte[] key, int start, int end) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.ltrim(key, start, end);
			}
		});
	}

	public byte[] lindex(byte[] key, int index) {
		return (byte[]) executeRedis(new CallBack() {
			@Override
			public byte[] doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.lindex(key, index);
			}
		});
	}

	public String lset(byte[] key, int index, byte[] value) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.lset(key, index, value);
			}
		});
	}

	public Long lrem(byte[] key, int count, byte[] value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.lrem(key, count, value);
			}
		});
	}

	public byte[] lpop(byte[] key) {
		return (byte[]) executeRedis(new CallBack() {
			@Override
			public byte[] doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.lpop(key);
			}
		});
	}

	public byte[] rpop(byte[] key) {
		return (byte[]) executeRedis(new CallBack() {
			@Override
			public byte[] doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.rpop(key);
			}
		});
	}

	public Long sadd(byte[] key, byte[] member) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.sadd(key, member);
			}
		});
	}

	public Set<byte[]> smembers(byte[] key) {
		return (Set<byte[]>) executeRedis(new CallBack() {
			@Override
			public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.smembers(key);
			}
		});
	}

	public Long srem(byte[] key, byte[] member) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.srem(key, member);
			}
		});
	}

	public byte[] spop(byte[] key) {
		return (byte[]) executeRedis(new CallBack() {
			@Override
			public byte[] doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.spop(key);
			}
		});
	}

	public Long scard(byte[] key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.scard(key);
			}
		});
	}

	public Boolean sismember(byte[] key, byte[] member) {
		return (Boolean) executeRedis(new CallBack() {
			@Override
			public Boolean doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.sismember(key, member);
			}
		});
	}

	public byte[] srandmember(byte[] key) {
		return (byte[]) executeRedis(new CallBack() {
			@Override
			public byte[] doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.srandmember(key);
			}
		});
	}

	public Long zadd(byte[] key, double score, byte[] member) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zadd(key, score, member);
			}
		});
	}

	public Set<byte[]> zrange(byte[] key, int start, int end) {
		return (Set<byte[]>) executeRedis(new CallBack() {
			@Override
			public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrange(key, start, end);
			}
		});
	}
	
	public Long zrem(byte[] key, byte[] member) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrem(key, member);
			}
		});
	}

	public Double zincrby(byte[] key, double score, byte[] member) {
		return (Double) executeRedis(new CallBack() {
			@Override
			public Double doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zincrby(key, score, member);
			}
		});
	}
	
	public Long zrank(byte[] key, byte[] member) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrank(key, member);
			}
		});
	}

	public Long zrevrank(byte[] key, byte[] member) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrevrank(key, member);
			}
		});
	}

	public Set<byte[]> zrevrange(byte[] key, int start, int end) {
		return (Set<byte[]>) executeRedis(new CallBack() {
			@Override
			public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrevrange(key, start, end);
			}
		});
	}

	public Set<Tuple> zrangeWithScores(byte[] key, int start, int end) {
		return (Set<Tuple>) executeRedis(new CallBack() {
			@Override
			public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrangeWithScores(key, start, end);
			}
		});
	}

	public Set<Tuple> zrevrangeWithScores(byte[] key, int start, int end) {
		return (Set<Tuple>) executeRedis(new CallBack() {
			@Override
			public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrevrangeWithScores(key, start, end);
			}
		});
	}

	public Long zcard(byte[] key) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zcard(key);
			}
		});
	}

	public Double zscore(byte[] key, byte[] member) {
		return (Double) executeRedis(new CallBack() {
			@Override
			public Double doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zscore(key, member);
			}
		});
	}

	public List<byte[]> sort(byte[] key) {
		return (List<byte[]>) executeRedis(new CallBack() {
			@Override
			public List<byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.sort(key);
			}
		});
	}

	public List<byte[]> sort(byte[] key, SortingParams sortingParameters) {
		return (List<byte[]>) executeRedis(new CallBack() {
			@Override
			public List<byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.sort(key, sortingParameters);
			}
		});
	}

	public Long zcount(byte[] key, double min, double max) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zcount(key, min, max);
			}
		});
	}

	public Set<byte[]> zrangeByScore(byte[] key, double min, double max) {
		return (Set<byte[]>) executeRedis(new CallBack() {
			@Override
			public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrangeByScore(key, min, max);
			}
		});
	}

	public Set<byte[]> zrangeByScore(byte[] key, double min, double max, int offset, int count) {
		return (Set<byte[]>) executeRedis(new CallBack() {
			@Override
			public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrangeByScore(key, min, max, offset, count);
			}
		});
	}

	public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max) {
		return (Set<Tuple>) executeRedis(new CallBack() {
			@Override
			public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrangeByScoreWithScores(key, min, max);
			}
		});
	}

	public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) {
		return (Set<Tuple>) executeRedis(new CallBack() {
			@Override
			public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrangeByScoreWithScores(key, min, max, offset, count);
			}
		});
	}

	public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min) {
		return (Set<byte[]>) executeRedis(new CallBack() {
			@Override
			public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrevrangeByScore(key, max, min);
			}
		});
	}

	public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
		return (Set<byte[]>) executeRedis(new CallBack() {
			@Override
			public Set<byte[]> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrevrangeByScore(key, max, min, offset, count);
			}
		});
	}

	public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
		return (Set<Tuple>) executeRedis(new CallBack() {
			@Override
			public Set<Tuple> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zrevrangeByScoreWithScores(key, max, min);
			}
		});
	}

	public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
		Set<Tuple> result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {

			result = shardedJedis.zrevrangeByScoreWithScores(key, max, min, offset, count);

		} catch (Exception e) {

			log.error(e.getMessage(), e);
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	public Long zremrangeByRank(byte[] key, int start, int end) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zremrangeByRank(key, start, end);
			}
		});
	}

	public Long zremrangeByScore(byte[] key, double start, double end) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.zremrangeByScore(key, start, end);
			}
		});
	}

	public Long linsert(byte[] key, LIST_POSITION where, byte[] pivot, byte[] value) {
		return (Long) executeRedis(new CallBack() {
			@Override
			public Long doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.linsert(key, where, pivot, value);
			}
		});
	}

	public List<Object> pipelined(ShardedJedisPipeline shardedJedisPipeline) {
		return (List<Object>) executeRedis(new CallBack() {
			@Override
			public List<Object> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.pipelined(shardedJedisPipeline);
			}
		});
	}
	/**
	 * 根据key，使用hash算法找到对应的jedis对象
	 * @param key
	 * @return
	 */
	public Jedis getShard(byte[] key) {
		return (Jedis) executeRedis(new CallBack() {
			@Override
			public Jedis doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.getShard(key);
			}
		});
	}

	public Jedis getShard(String key) {
		return (Jedis) executeRedis(new CallBack() {
			@Override
			public Jedis doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.getShard(key);
			}
		});
	}

	public JedisShardInfo getShardInfo(byte[] key) {
		return (JedisShardInfo) executeRedis(new CallBack() {
			@Override
			public JedisShardInfo doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.getShardInfo(key);
			}
		});
	}

	public JedisShardInfo getShardInfo(String key) {
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		JedisShardInfo result = null;
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.getShardInfo(key);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	public String getKeyTag(String key) {
		return (String) executeRedis(new CallBack() {
			@Override
			public String doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.getKeyTag(key);
			}
		});
	}

	public Collection<JedisShardInfo> getAllShardInfo() {
		return (Collection<JedisShardInfo>) executeRedis(new CallBack() {
			@Override
			public Collection<JedisShardInfo> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.getAllShardInfo();
			}
		});
	}

	public Collection<Jedis> getAllShards() {
		return (Collection<Jedis>) executeRedis(new CallBack() {
			@Override
			public Collection<Jedis> doExecute(ShardedJedis shardedJedis) {
				return shardedJedis.getAllShards();
			}
		});
	}
}

测试