Redis 相关类

spring 配置文件：spring.xml

<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="  
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd  
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">  
    
    <!-- Redis 资源连接池配置实例 -->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    	<property name="maxTotal" value="2048" />
    	<property name="maxIdle" value="200" />
    	<property name="numTestsPerEvictionRun" value="1024"/>    
		<property name="timeBetweenEvictionRunsMillis" value="30000" />    
		<property name="minEvictableIdleTimeMillis" value="-1" />    
		<property name="softMinEvictableIdleTimeMillis" value="10000" />    
		<property name="maxWaitMillis" value="1500"/>    
		<property name="testOnBorrow" value="true" />    
		<property name="testWhileIdle" value="true"/>    
		<property name="testOnReturn" value="false"/>    
		<property name="jmxEnabled" value="true"/>    
		<property name="blockWhenExhausted" value="false"/>
    </bean>
    
    <!-- Redis 资源连接池 实例 -->
    <bean id="shardedRedisPool" class="redis.clients.jedis.ShardedJedisPool">
    	<constructor-arg index="0" ref="jedisPoolConfig" />
    	<constructor-arg index="1">
    		<list>
    			<bean class="redis.clients.jedis.JedisShardInfo">
    				<constructor-arg name="host" value="127.0.0.1" />
    				<constructor-arg name="post" value="6379" />
    				<constructor-arg name="timeout" value="10000" />
    			</bean>
    		</list>
    	</constructor-arg>
    </bean>
    
    <bean id="redisDataResource" class="com.redis.RedisDataSourceImpl">
    	<property name="shardedJedisPool" ref="shardedRedisPool" />
    </bean>
    
    <bean id="redisClientTemplate" class="com.redis.RedisClientTemplate">
    	<property name="redisDataResource" ref="redisDataResource" />
    </bean>
    
</beans>

Redis 数据源Service接口  RedisDataSource.java

package com.redis;

import redis.clients.jedis.ShardedJedis;

/**
 * redis客户端实例接口：通过该实例操作redis数据源
 * @author Administrator
 *
 */
public interface RedisDataSource {

	/**
	 *   获取Redis客户端实例
	 * @return
	 */
	public abstract ShardedJedis getRedisClient();
	
	/**
	 *  将Redis客户端资源返回给Redis资源池
	 * @param shardedJedis
	 */
	public void returnResource (ShardedJedis shardedJedis);
	
	/**
	 * 出现异常后，将Redis客户端资源返回给Redis资源池
	 * @param shardedJedis
	 * @param broken
	 */
	public void returnResource (ShardedJedis shardedJedis, boolean broken);
}

Redis数据源Service接口实现类 RedisDataServiceImpl.java

package com.redis;

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

import lombok.Getter;
import lombok.Setter;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

/**
 * redis客户端实例接口实现类
 * @author Administrator
 *
 */
public class RedisDataSourceImpl implements RedisDataSource {
	private static final Logger logger = LoggerFactory.getLogger(RedisDataSourceImpl.class);
	
	@Autowired
	@Setter
	@Getter
	private ShardedJedisPool shardedJedisPool;

	@Override
	public ShardedJedis getRedisClient() {
		ShardedJedis sharedJedis = this.shardedJedisPool.getResource();
		return sharedJedis;
	}

	@Override
	public void returnResource(ShardedJedis shardedJedis) {
		this.shardedJedisPool.returnBrokenResource(shardedJedis);
	}

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

}

 Redis 客户端相关操作的工具类： RedisClientTemplate.java

package com.redis;

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

import org.springframework.beans.factory.annotation.Autowired;

import lombok.Getter;
import lombok.Setter;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;

/**
 * Redis客户端用于取值、存值操作的工具类
 * @author Administrator
 *
 */
public class RedisClientTemplate {

	@Autowired
	@Setter
	@Getter
	private RedisDataSource redisDataSource;

	/**
	 * Redis客户端断开连接
	 */
	public void disConnect() {
		ShardedJedis redisClient = this.redisDataSource.getRedisClient();
		redisClient.disconnect();
	}

	/**
	 * 在Redis里面设置单个值
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public String set(String key, String value) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.set(key, value);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 获取Redis中的某个值
	 * 
	 * @param key
	 * @return
	 */
	public String get(String key) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.get(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 判断Redis中是否存在某个key
	 * 
	 * @param key
	 * @return
	 */
	public boolean exists(String key) {
		boolean result = false;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.exists(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 获取key对应存储值value的类型
	 * 
	 * @param key
	 * @return
	 */
	public String type(String key) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.type(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 设置一个key多长时间后过期
	 * 
	 * @param key
	 * @param seconds
	 * @return
	 */
	public Long expire(String key, int seconds) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.expire(key, seconds);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 设置一个key在某一个时间点失效
	 * 
	 * @param key
	 * @param unixTime 时间戳
	 * @return
	 */
	public Long expireAt(String key, int unixTime) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			shardedJedis.expireAt(key, unixTime);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 以秒为单位，返回某个key的剩余生存时间
	 * 
	 * @param key
	 * @return
	 */
	public Long ttl(String key) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.ttl(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 当且仅当Redis中不存在key时，向Redis中添加key-value值
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public Long setnx(String key, String value) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.setnx(key, value);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 设置key-value，key的生命周期设置为seconds
	 * 
	 * @param key
	 * @param seconds
	 * @param value
	 * @return
	 */
	public String setex(String key, int seconds, String value) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.setex(key, seconds, value);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 将key所存储的值减去减量integer
	 * 
	 * @param key
	 * @param integer
	 * @return
	 */
	public Long decrBy(String key, long integer) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.decrBy(key, integer);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 将key对应的值减 1
	 * 
	 * @param key
	 * @return
	 */
	public Long decr(String key) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.decr(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 将key所存储的值加上增量integer
	 * 
	 * @param key
	 * @param integer
	 * @return
	 */
	public Long incrBy(String key, long integer) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.incrBy(key, integer);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 将key对应的值减 1
	 * 
	 * @param key
	 * @return
	 */
	public Long incr(String key) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.incr(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 如果已经存在字符串型的key，append命令将value追加到key对应值得末尾 如果key不存在，append命令就简单进行key-value设定
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public Long append(String key, String value) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.append(key, value);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 返回key对应的value值（String类型）得子串
	 * 
	 * @param key
	 * @param start 开始位置
	 * @param end   结束位置
	 * @return
	 */
	public String substr(String key, int start, int end) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.substr(key, start, end);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 将哈希表key中的域field的值设为value
	 * 
	 * @param key
	 * @param field
	 * @param value
	 * @return
	 */
	public Long hset(String key, String field, String value) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hset(key, field, value);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 返回哈希表key中给定域field的值
	 * 
	 * @param key
	 * @param field
	 * @return
	 */
	public String hget(String key, String field) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hget(key, field);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 同时将多个 field-value（域-值）对设置到哈希表key中
	 * 
	 * @param key
	 * @param hash
	 * @return
	 */
	public String hmset(String key, Map<String, String> hash) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hmset(key, hash);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 返回哈希表key中，一个或者多个field（域）对应的值
	 * 
	 * @param key
	 * @param fields
	 * @return
	 */
	public List<String> hmget(String key, String... fields) {
		List<String> result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hmget(key, fields);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 哈希表key 中域field对应的值增加增量value
	 * 
	 * @param key
	 * @param field
	 * @param value
	 * @return
	 */
	public Long hincrBy(String key, String field, long value) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hincrBy(key, field, value);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 判断哈希表key中field（域）对应的值是否存在
	 * 
	 * @param key
	 * @param field
	 * @return
	 */
	public Boolean hexists(String key, String field) {
		Boolean result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hexists(key, field);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 删除key
	 * 
	 * @param key
	 * @return
	 */
	public Long del(String key) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.del(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 删除哈希表key中一个或者多个field域
	 * 
	 * @param key
	 * @param field
	 * @return
	 */
	public Long hdel(String key, String... fields) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hdel(key, fields);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 返回哈希表key中field域的数量
	 * 
	 * @param key
	 * @return
	 */
	public Long hlen(String key) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hlen(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 返回哈希表key中的所有的field域
	 * 
	 * @param key
	 * @return
	 */
	public Set<String> hkeys(String key) {
		Set<String> result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hkeys(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 获取哈希表中key对应field域的值
	 * 
	 * @param key
	 * @return
	 */
	public List<String> hvals(String key) {
		List<String> result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hvals(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 返回哈希表中 key 对应的 field域和value值
	 * 
	 * @param key
	 * @return
	 */
	public Map<String, String> hgetAll(String key) {
		Map<String, String> result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hgetAll(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【List】在key对应的list值的末尾添加添加一个或多个 string
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public Long rpush(String key, String... strings) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.rpush(key, strings);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【list】在key对应的list值的表头添加一个或者多个value值
	 * 
	 * @param key
	 * @param strings
	 * @return
	 */
	public Long lpust(String key, String... strings) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.lpush(key, strings);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【list】返回key对应的List的长度
	 * 
	 * @param key
	 * @return
	 */
	public Long llen(String key) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.llen(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【List】返回key对应的指定区间的列表的元素，起始点start，终点end
	 * 
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public List<String> lrange(String key, long start, long end) {
		List<String> result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.lrange(key, start, end);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【list】只保留key对应集合的指定区间的元素，不在区间内的元素都删除掉
	 * 
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public String ltrim(String key, long start, long end) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.ltrim(key, start, end);
		} catch (Exception e) {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【list】返回key对应的集合中，下标为 index 的元素的值
	 * 
	 * @param key
	 * @param index
	 * @return
	 */
	public String lindex(String key, long index) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.lindex(key, index);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【list】将key对应的集合中，下标为 index 的值设为 value
	 * 
	 * @param key
	 * @param index
	 * @param value
	 * @return
	 */
	public String lset(String key, long index, String value) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.lset(key, index, value);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【list】移除并返回key对应集合的头元素
	 * 
	 * @param key
	 * @return
	 */
	public String lpop(String key) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.lpop(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【list】移除并返回key对应的集合的末尾的元素
	 * 
	 * @param key
	 * @return
	 */
	public String rpop(String key) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.rpop(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【Set】在key对应的set集合中添加一个或者多个元素
	 * 
	 * @param key
	 * @param strings
	 * @return
	 */
	public Long sadd(String key, String... members) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.sadd(key, members);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【Set】返回key对应的集合的所有元素
	 * 
	 * @param key
	 * @return
	 */
	public Set<String> smembers(String key) {
		Set<String> result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.smembers(key);
		} catch (Exception e) {
			broken = false;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【Set】返回key对用Set集合的元素基数（个数）
	 * 
	 * @param key
	 * @return
	 */
	public Long scard(String key) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.scard(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【zset有序集合】向key对应的有序集合zset中添加元素members，score用于排序； 如果该元素已经存在，则根据score更新该元素的位置
	 * 
	 * @param key
	 * @param score
	 * @param member
	 * @return
	 */
	public Long zadd(String key, double score, String member) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.zadd(key, score, member);
		} catch (Exception e) {
			this.redisDataSource.returnResource(shardedJedis, broken);
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【zset有序集合】返回key对应的有序集合中指定位置的元素集合
	 * 
	 * @param key
	 * @param start 开始位置
	 * @param end   结束位置
	 * @return
	 */
	public Set<String> zrange(String key, int start, int end) {
		Set<String> result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.zrange(key, start, end);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【zset有序集合】移除key对应的有序集合中的一个或者多个元素，不存在则忽略
	 * 
	 * @param key
	 * @param members
	 * @return
	 */
	public Long zrem(String key, String... members) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.zrem(key, members);
		} catch (Exception e) {
			broken = false;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【zset有序集合】将key对应的有序集合中的元素menber，其score值增加增量score;
	 * 如果该member值不存在，则向有序集合中添加member元素，其score值为 score
	 * 
	 * @param key
	 * @param score
	 * @param member
	 * @return
	 */
	public Double zincrby(String key, double score, String member) {
		Double result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.zincrby(key, score, member);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【zset有序集合】返回key对应的有序集合的member元素的的排名 其中有序集合中的所有元素时按着score值从小到大的顺序进行排列
	 * 
	 * @param key
	 * @param member
	 * @return
	 */
	public Long zrank(String key, String member) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.zrank(key, member);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【zset有序集合】返回key对应的有序集合基数（元素个数）
	 * 
	 * @param key
	 * @return
	 */
	public Long zcard(String key) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.zcard(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【zset有序集合】返回key对应的有序集合的元素的score值
	 * 
	 * @param key
	 * @param member
	 * @return
	 */
	public Double zscore(String key, String member) {
		Double result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.zscore(key, member);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【zset有序集合】返回key对应的有序集合其score在min,max之间的元素的个数： min ≤ score ≤ max
	 * 
	 * @param key
	 * @param min
	 * @param max
	 * @return
	 */
	public Long zcount(String key, double min, double max) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.zcount(key, min, max);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量存储 key-value 对
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public String set(byte[] key, byte[] value) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.set(key, value);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量获取key对应的值
	 * 
	 * @param key
	 * @return
	 */
	public byte[] get(byte[] key) {
		byte[] result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.get(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】判断多个key是否同时存在
	 * 
	 * @param key
	 * @return
	 */
	public Boolean exists(byte[] key) {
		Boolean result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.exists(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】设置key多长时间后过期
	 * 
	 * @param key
	 * @param seconds
	 * @return
	 */
	public Long expire(byte[] key, int seconds) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.expire(key, seconds);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 设置key在某一个时刻过期
	 * 
	 * @param key
	 * @param unixTime 时间戳
	 * @return
	 */
	public Long expireAt(byte[] key, int unixTime) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.expireAt(key, unixTime);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】以秒为单位，返回key对应的value的剩余时间
	 * 
	 * @param key
	 * @return
	 */
	public Long ttl(byte[] key) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.ttl(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】如果存在key，append命令将value值追加到key对应值的末尾 如果key不存在，则直接执行设置key-value操作
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public Long append(byte[] key, byte[] value) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.append(key, value);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量向key对应的哈希表中的添加 field-value
	 * 
	 * @param key
	 * @param field
	 * @param value
	 * @return
	 */
	public Long hset(byte[] key, byte[] field, byte[] value) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hset(key, field, value);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量获取key对用的哈希表，根据 field 获取 value
	 * 
	 * @param key
	 * @param field
	 * @return
	 */
	public byte[] hget(byte[] key, byte[] field) {
		byte[] result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hget(key, field);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量将key对应的哈希表中添加field-value
	 * 
	 * @param key
	 * @param hash
	 * @return
	 */
	public String hmset(byte[] key, Map<byte[], byte[]> hash) {
		String result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hmset(key, hash);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量获取key对应的哈希表，根据fields批量获取对应的value值
	 * 
	 * @param key
	 * @param fileds
	 * @return
	 */
	public List<byte[]> hmget(byte[] key, byte[]... fileds) {
		List<byte[]> result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hmget(key, fileds);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量判断key对应的哈希表中，field对应的value值是否存在
	 * 
	 * @param key
	 * @param field
	 * @return
	 */
	public Boolean hexists(byte[] key, byte[] field) {
		Boolean result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hexists(key, field);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量删除key对应哈希表中field对应的value值
	 * 
	 * @param key
	 * @param field
	 * @return
	 */
	public Long hdel(byte[] key, byte[] fields) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.hdel(key, fields);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量添加 key 对应的列表的表尾添加 value
	 * 
	 * @param key
	 * @param string
	 * @return
	 */
	public Long rpush(byte[] key, byte[] strings) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.rpush(key, strings);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量添加 key 对应的列表的表头添加 value
	 * 
	 * @param key
	 * @param string
	 * @return
	 */
	public Long lpush(byte[] key, byte[] strings) {
		Long result = null;
		ShardedJedis shardedJedis = this.redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.lpush(key, strings);
		} catch (Exception e) {
			broken = true;
		} finally {
			this.redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】返回批量key对应列表的长度
	 * 
	 * @param key
	 * @return
	 */
	public Long llen(byte[] key) {
		Long result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.llen(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量返回key对应列表的指定位置的值
	 * 
	 * @param key
	 * @param start 开始位置
	 * @param end   结束位置
	 * @return
	 */
	public List<byte[]> lrange(byte[] key, int start, int end) {
		List<byte[]> result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.lrange(key, start, end);
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量设置key对应的列表的index位置的值为value
	 * 
	 * @param key
	 * @param index
	 * @param value
	 * @return
	 */
	public String lset(byte[] key, int index, byte[] value) {
		String result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.lset(key, index, value);
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量移除key对应的列表的指定位置的value值
	 * 
	 * @param key
	 * @param count
	 * @param value
	 * @return
	 */
	public Long lrem(byte[] key, int count, byte[] value) {
		Long result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.lrem(key, count, value);
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量移除key对应的列表的头元素
	 * 
	 * @param key
	 * @return
	 */
	public byte[] lpop(byte[] key) {
		byte[] result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.lpop(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量移除key对应的列表的尾元素
	 * 
	 * @param key
	 * @return
	 */
	public byte[] rpop(byte[] key) {
		byte[] result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.rpop(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量增加key-value到set集合
	 * 
	 * @param key
	 * @param member
	 * @return
	 */
	public Long sadd(byte[] key, byte[] member) {
		Long result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.sadd(key, member);
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量获取key对应的Set集合
	 * 
	 * @param key
	 * @return
	 */
	public Set<byte[]> smembers(byte[] key) {
		Set<byte[]> result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.smembers(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】返回key对用Set集合的元素基数（个数）
	 * 
	 * @param key
	 * @return
	 */
	public Long scard(byte[] key) {
		Long result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.scard(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】批量添加key对应的有序集合value
	 * 
	 * @param key
	 * @param score
	 * @param member
	 * @return
	 */
	public Long zadd(byte[] key, double score, byte[] member) {
		Long result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.zadd(key, score, member);
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 【byte】返回key对用的有序集合的元素基数（个数）
	 * 
	 * @param key
	 * @return
	 */
	public Long zcard(byte[] key) {
		Long result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.zcard(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 根据key获取Redis客户端实例的信息
	 * 
	 * @param key
	 * @return
	 */
	public JedisShardInfo getShardInfo(String key) {
		JedisShardInfo result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.getShardInfo(key);
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 获取所有Redis客户端实例的信息
	 * 
	 * @return
	 */
	public Collection<JedisShardInfo> getAllShardInfo() {
		Collection<JedisShardInfo> result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.getAllShardInfo();
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}

	/**
	 * 获取所有Redis实例信息
	 * 
	 * @return
	 */
	public Collection<Jedis> getAllShards() {
		Collection<Jedis> result = null;
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		if (shardedJedis == null) {
			return result;
		}
		boolean broken = false;
		try {
			result = shardedJedis.getAllShards();
		} catch (Exception e) {
			broken = true;
		} finally {
			redisDataSource.returnResource(shardedJedis, broken);
		}
		return result;
	}
}