spring和redis的整合-超出昨天的本身系列（7）
添加时间:2013-7-29 点击量:
超出昨天的本身系列（7）
扯淡：
比来一向在慢慢多进修各个组件，本身搭建出一些设法。是一个浏览的过程，慢慢意识到常识是可以融汇贯通，触类旁通的，不过前提如同是研究的斗劲深，有了本身的见地。自认为进修才能不咋地，速度慢不说，还轻易放弃，大多半时辰都是回头捡起来补的那种景象。
所以，我想：自我把守的才能是否决意了一小我进修的高度，也限制了见识的高度呢？
跟着年数的增长，越来越感觉进修常识的那种急迫性，专业方面的，自我教养方面的，都须要急迫的获得满足。我知道很多人其实已经放弃看书了，根蒂根基刷刷微博，看看消息，就满足本身的浏览了。但有时辰，静下心来的时辰，很本身的内心上什么也没有，懊悔本身没种棵树，或掘口井什么的。
不知道你们是否有如许的感触感染？
主题：（以下例子都应用maven构建）
redis的常识：官网
1，哄骗spring-data-redis整合
项目应用的pom.xml：
<project xmlns=http://maven.apache.org/POM/4.0.0 xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance
xsi:schemaLocation=http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd>
<modelVersion>4.0.0</modelVersion>
<groupId>com.x.redis</groupId>
<artifactId>Spring_redis</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>Spring_redis</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>3.1.2.RELEASE</version>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.1.0</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.8.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.1</version>
</dependency>
<!-- 将现有的jakarta commons logging的调用转换成lsf4j的调用。 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.6.1</version>
</dependency>
<!-- Hack：确保commons-logging的jar包不被引入，不然将和jcl-over-slf4j冲突 -->
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
<scope>provided</scope>
</dependency>
<!-- slf4j的实现：logback，用来庖代log4j。更快、更强！ -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>0.9.24</version>
<scope>runtime</scope>
</dependency>
</dependencies>
</project>
View Code
除了log项目组，只有一个spring core 和 spring-data-redis了
项目文件目次布局：
applicationContext.xml：
1，context:property-placeholder 标签用来导入properties文件。从而调换￥{redis.maxIdle}如许的变量。
2，context:component-scan 是为了在com.x.redis.dao报下的类可以或许实用spring的注解注入的体式格式。
3，事实上我们只须要把JedisPoolConfig配数来就好了，接下来就是spring的封装了。所以直接看UserDAOImpl的实现就熟悉打听了。
<？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:p=http://www.springframework.org/schema/p
xmlns:context=http://www.springframework.org/schema/context
xmlns:jee=http://www.springframework.org/schema/jee 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/context http://www.springframework.org/schema/context/spring-context.xsd>
<context:property-placeholder location=classpath:redis.properties />
<context:component-scan base-package=com.x.redis.dao>
</context:component-scan>
<bean id=poolConfig class=redis.clients.jedis.JedisPoolConfig>
<property name=maxIdle value=￥{redis.maxIdle} />
<property name=maxActive value=￥{redis.maxActive} />
<property name=maxWait value=￥{redis.maxWait} />
<property name=testOnBorrow value=￥{redis.testOnBorrow} />
</bean>
<bean id=connectionFactory class=org.springframework.data.redis.connection.jedis.JedisConnectionFactory
p:host-name=￥{redis.host} p:port=￥{redis.port} p:password=￥{redis.pass} p:pool-config-ref=poolConfig/>
<bean id=redisTemplate class=org.springframework.data.redis.core.StringRedisTemplate>
<property name=connectionFactory ref=connectionFactory />
</bean>
<bean id=userDAO class=com.x.redis.dao.impl.UserDAOImpl />
</beans>
redis.properties：
＃ Redis settings
＃redis.host=192.168.20.101
＃redis.port=6380
＃redis.pass=foobared
redis.host=127.0.0.1
redis.port=6379
redis.pass=
redis.maxIdle=300
redis.maxActive=600
redis.maxWait=1000
redis.testOnBorrow=true
View Code
UserDAOImpl：
1，spring对dao层的封装很多用了类似于下面代码的模板体式格式。
2，RedisTemplate就是spring对redis的一个封装罢了。
public class UserDAOImpl implements UserDAO {
＠Autowired
protected RedisTemplate<Serializable， Serializable> redisTemplate;
public void saveUser（final User user） {
redisTemplate.execute（new RedisCallback<Object>（） {
＠Override
public Object doInRedis（RedisConnection connection） throws DataAccessException {
connection.set（redisTemplate.getStringSerializer（）.serialize（user.uid. + user.getId（）），
redisTemplate.getStringSerializer（）.serialize（user.getName（）））;
return null;
}
}）;
}
＠Override
public User getUser（final long id） {
return redisTemplate.execute（new RedisCallback<User>（） {
＠Override
public User doInRedis（RedisConnection connection） throws DataAccessException {
byte[] key = redisTemplate.getStringSerializer（）.serialize（user.uid. + id）;
if （connection.exists（key）） {
byte[] value = connection.get（key）;
String name = redisTemplate.getStringSerializer（）.deserialize（value）;
User user = new User（）;
user.setName（name）;
user.setId（id）;
return user;
}
return null;
}
}）;
}
}
其他：
User：
public class User {
private long id;
private String name;
public long getId（） {
return id;
}
public void setId（long id） {
this.id = id;
}
public String getName（） {
return name;
}
public void setName（String name） {
this.name = name;
}
}
View Code
测试代码：
public static void main（String[] args） {
ApplicationContext ac = new ClassPathXmlApplicationContext（classpath:/applicationContext.xml）;
UserDAO userDAO = （UserDAO）ac.getBean（userDAO）;
User user1 = new User（）;
user1.setId（1）;
user1.setName（obama）;
userDAO.saveUser（user1）;
User user2 = userDAO.getUser（1）;
System.out.println（user2.getName（））;
}
2，晦气用spring-data-redis整合
小我感觉如许整合灵活度更大，可以或许加倍了然的完成任务。
pom.xml:
<project xmlns=http://maven.apache.org/POM/4.0.0 xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance
xsi:schemaLocation=http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd>
<modelVersion>4.0.0</modelVersion>
<groupId>com.d.work</groupId>
<artifactId>Redis_Templete</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>Redis_Templete</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.1.0</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>3.1.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>3.1.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>3.1.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.1</version>
</dependency>
<!-- 将现有的jakarta commons logging的调用转换成lsf4j的调用。 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.6.1</version>
</dependency>
<!-- Hack：确保commons-logging的jar包不被引入，不然将和jcl-over-slf4j冲突 -->
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
<scope>provided</scope>
</dependency>
<!-- slf4j的实现：logback，用来庖代log4j。更快、更强！ -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>0.9.24</version>
<scope>runtime</scope>
</dependency>
</dependencies>
</project>
View Code
目次布局：
data-source.xml
1，context:property-placeholder 和 context:component-scan 前面申明过啦。
2，设备了一个ShardedJedisPool，在jdeis里 还有个JedisPool。这两个的差别:
一个是分片情势，可以连接有主备的redis办事端，一个是单个的。具体后续进修
3，因为不应用spring-data-redis的封装，所以本身要本身封装一个
<？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:p=http://www.springframework.org/schema/p
xmlns:context=http://www.springframework.org/schema/context
xmlns:jee=http://www.springframework.org/schema/jee 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/context http://www.springframework.org/schema/context/spring-context.xsd>
<context:property-placeholder location=classpath:redis.properties />
<context:component-scan base-package=com.d.work.main>
</context:component-scan>
<context:component-scan base-package=com.d.work.redis>
</context:component-scan>
<bean id=jedisPoolConfig class=redis.clients.jedis.JedisPoolConfig>
<property name=maxActive value=50 />
<property name=maxIdle value=8 />
<property name=maxWait value=1000 />
<property name=testOnBorrow value=true/>
<property name=testOnReturn value=true/>
<!-- <property name=testWhileIdle value=true/> -->
</bean>
<bean id=shardedJedisPool class=redis.clients.jedis.ShardedJedisPool scope=singleton>
<constructor-arg index=0 ref=jedisPoolConfig />
<constructor-arg index=1>
<list>
<bean class=redis.clients.jedis.JedisShardInfo>
<constructor-arg name=host value=￥{redis.host} />
<constructor-arg name=port value=￥{redis.port} />
<constructor-arg name=timeout value=￥{redis.timeout} />
<constructor-arg name=weight value=1 />
</bean>
</list>
</constructor-arg>
</bean>
</beans>
RedisDataSource:定义三个办法
public interface RedisDataSource {
public abstract ShardedJedis getRedisClient（）;
public void returnResource（ShardedJedis shardedJedis）;
public void returnResource（ShardedJedis shardedJedis，boolean broken）;
}
实现redisDataSource:
1， 注入设备好的ShardedJedisPool，这三个办法的感化：
getRedisClient（） ： 取得redis的客户端，可以履行号令了。
returnResource（ShardedJedis shardedJedis） ： 将资料返还给pool
returnResource（ShardedJedis shardedJedis， boolean broken） : 呈现异常后，将资料返还给pool （其实不须要第二个办法）
＠Repository（redisDataSource）
public class RedisDataSourceImpl implements RedisDataSource {
private static final Logger log = LoggerFactory.getLogger（RedisDataSourceImpl.class）;
＠Autowired
private ShardedJedisPool shardedJedisPool;
public ShardedJedis getRedisClient（） {
try {
ShardedJedis shardJedis = shardedJedisPool.getResource（）;
return shardJedis;
} catch （Exception e） {
log.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）;
}
}
}
第二层的封装：RedisClientTemplate，例子实现了放值和取值。最后代码供给了全部号令的实现。
代码就是映射性质的又一次调用jedis的办法罢了，用了个broken来做标示符，决意返还资料的体式格式。
这一层的目标首要也是让再上层的调用不须要关怀pool中链接的取得和返还题目了。
＠Repository（redisClientTemplate）
public class RedisClientTemplate {
private static final Logger log = LoggerFactory.getLogger（RedisClientTemplate.class）;
＠Autowired
private RedisDataSource redisDataSource;
public void disconnect（） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
shardedJedis.disconnect（）;
}
/
设置单个值
＠param key
＠param value
＠return
/
public String set（String key， String value） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.set（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
/
获取单个值
＠param key
＠return
/
public String get（String key） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.get（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
}
测试代码：
public static void main（String[] args） {
ApplicationContext ac = new ClassPathXmlApplicationContext（classpath:/data-source.xml）;
RedisClientTemplate redisClient = （RedisClientTemplate）ac.getBean（redisClientTemplate）;
redisClient.set（a， abc）;
System.out.println（redisClient.get（a））;
}
附上RedisClientTemplate全部实现：
＠Repository（redisClientTemplate）
public class RedisClientTemplate {
private static final Logger log = LoggerFactory.getLogger（RedisClientTemplate.class）;
＠Autowired
private RedisDataSource redisDataSource;
public void disconnect（） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
shardedJedis.disconnect（）;
}
/
设置单个值
＠param key
＠param value
＠return
/
public String set（String key， String value） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.set（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
/
获取单个值
＠param key
＠return
/
public String get（String key） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.get（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Boolean exists（String key） {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.exists（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String type（String key） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.type（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
/
在某段时候后实现
＠param key
＠param unixTime
＠return
/
public Long expire（String key， int seconds） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.expire（key， seconds）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
/
在某个时候点失效
＠param key
＠param unixTime
＠return
/
public Long expireAt（String key， long unixTime） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.expireAt（key， unixTime）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long ttl（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.ttl（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public boolean setbit（String key， long offset， boolean value） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
boolean result = false;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setbit（key， offset， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public boolean getbit（String key， long offset） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
boolean result = false;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getbit（key， offset）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public long setrange（String key， long offset， String value） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
long result = 0;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setrange（key， offset， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String getrange（String key， long startOffset， long endOffset） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
String result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getrange（key， startOffset， endOffset）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String getSet（String key， String value） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getSet（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long setnx（String key， String value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setnx（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String setex（String key， int seconds， String value） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setex（key， seconds， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long decrBy（String key， long integer） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.decrBy（key， integer）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long decr（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.decr（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long incrBy（String key， long integer） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.incrBy（key， integer）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long incr（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.incr（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long append（String key， String value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.append（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String substr（String key， int start， int end） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.substr（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hset（String key， String field， String value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hset（key， field， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String hget（String key， String field） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hget（key， field）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hsetnx（String key， String field， String value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hsetnx（key， field， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String hmset（String key， Map<String， String> hash） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hmset（key， hash）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<String> hmget（String key， String... fields） {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hmget（key， fields）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hincrBy（String key， String field， long value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hincrBy（key， field， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Boolean hexists（String key， String field） {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hexists（key， field）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long del（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.del（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hdel（String key， String field） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hdel（key， field）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hlen（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hlen（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> hkeys（String key） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hkeys（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<String> hvals（String key） {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hvals（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Map<String， String> hgetAll（String key） {
Map<String， String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hgetAll（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
// ================list ====== l默示 list或 left， r默示right====================
public Long rpush（String key， String string） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.rpush（key， string）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long lpush（String key， String string） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lpush（key， string）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long llen（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.llen（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<String> lrange（String key， long start， long end） {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lrange（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String ltrim（String key， long start， long end） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.ltrim（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String lindex（String key， long index） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lindex（key， index）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String lset（String key， long index， String 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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long lrem（String key， long count， String 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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String lpop（String key） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lpop（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String rpop（String key） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.rpop（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
//return 1 add a not exist value ，
//return 0 add a exist value
public Long sadd（String key， String 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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> smembers（String key） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.smembers（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long srem（String key， String member） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Long result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.srem（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String spop（String key） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
String result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.spop（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long scard（String key） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Long result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.scard（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Boolean sismember（String key， String member） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Boolean result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sismember（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String srandmember（String key） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
String result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.srandmember（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zadd（String key， double score， String 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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> zrange（String key， int start， int end） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrange（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zrem（String key， String member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrem（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Double zincrby（String key， double score， String member） {
Double result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zincrby（key， score， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zrank（String key， String member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrank（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zrevrank（String key， String member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrank（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> zrevrange（String key， int start， int end） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrange（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrangeWithScores（String key， int start， int end） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeWithScores（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrevrangeWithScores（String key， int start， int end） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeWithScores（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zcard（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zcard（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Double zscore（String key， String member） {
Double result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zscore（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<String> sort（String key） {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sort（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<String> sort（String key， SortingParams sortingParameters） {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sort（key， sortingParameters）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zcount（String key， double min， double max） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zcount（key， min， max）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> zrangeByScore（String key， double min， double max） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScore（key， min， max）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> zrevrangeByScore（String key， double max， double min） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeByScore（key， max， min）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> zrangeByScore（String key， double min， double max， int offset， int count） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScore（key， min， max， offset， count）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> zrevrangeByScore（String key， double max， double min， int offset， int count） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeByScore（key， max， min， offset， count）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrangeByScoreWithScores（String key， double min， double max） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScoreWithScores（key， min， max）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrevrangeByScoreWithScores（String key， double max， double min） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeByScoreWithScores（key， max， min）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrangeByScoreWithScores（String key， double min， double max， int offset， int count） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScoreWithScores（key， min， max， offset， count）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrevrangeByScoreWithScores（String 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（String key， int start， int end） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zremrangeByRank（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zremrangeByScore（String key， double start， double end） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zremrangeByScore（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long l（String key， LIST_POSITION where， String pivot， String value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.l（key， where， pivot， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String set（byte[] key， byte[] value） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.set（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] get（byte[] key） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.get（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Boolean exists（byte[] key） {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.exists（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String type（byte[] key） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.type（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long expire（byte[] key， int seconds） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.expire（key， seconds）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long expireAt（byte[] key， long unixTime） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.expireAt（key， unixTime）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long ttl（byte[] key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.ttl（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] getSet（byte[] key， byte[] value） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getSet（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long setnx（byte[] key， byte[] value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setnx（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String setex（byte[] key， int seconds， byte[] value） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setex（key， seconds， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long decrBy（byte[] key， long integer） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.decrBy（key， integer）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long decr（byte[] key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.decr（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long incrBy（byte[] key， long integer） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.incrBy（key， integer）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long incr（byte[] key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.incr（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long append（byte[] key， byte[] value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.append（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] substr（byte[] key， int start， int end） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.substr（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hset（byte[] key， byte[] field， byte[] value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hset（key， field， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] hget（byte[] key， byte[] field） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hget（key， field）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hsetnx（byte[] key， byte[] field， byte[] value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hsetnx（key， field， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String hmset（byte[] key， Map<byte[]， byte[]> hash） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hmset（key， hash）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<byte[]> hmget（byte[] key， byte[]... fields） {
List<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hmget（key， fields）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hincrBy（byte[] key， byte[] field， long value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hincrBy（key， field， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Boolean hexists（byte[] key， byte[] field） {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hexists（key， field）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hdel（byte[] key， byte[] field） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hdel（key， field）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hlen（byte[] key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hlen（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> hkeys（byte[] key） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hkeys（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Collection<byte[]> hvals（byte[] key） {
Collection<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hvals（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Map<byte[]， byte[]> hgetAll（byte[] key） {
Map<byte[]， byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hgetAll（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long rpush（byte[] key， byte[] string） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.rpush（key， string）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long lpush（byte[] key， byte[] string） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lpush（key， string）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String ltrim（byte[] key， int start， int end） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.ltrim（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] lindex（byte[] key， int index） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lindex（key， index）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long srem（byte[] key， byte[] member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.srem（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] spop（byte[] key） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.spop（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Boolean sismember（byte[] key， byte[] member） {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sismember（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] srandmember（byte[] key） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.srandmember（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> zrange（byte[] key， int start， int end） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrange（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zrem（byte[] key， byte[] member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrem（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Double zincrby（byte[] key， double score， byte[] member） {
Double result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zincrby（key， score， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zrank（byte[] key， byte[] member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrank（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zrevrank（byte[] key， byte[] member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrank（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> zrevrange（byte[] key， int start， int end） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrange（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrangeWithScores（byte[] key， int start， int end） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeWithScores（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrevrangeWithScores（byte[] key， int start， int end） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeWithScores（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Double zscore（byte[] key， byte[] member） {
Double result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zscore（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<byte[]> sort（byte[] key） {
List<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sort（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<byte[]> sort（byte[] key， SortingParams sortingParameters） {
List<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sort（key， sortingParameters）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zcount（byte[] key， double min， double max） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zcount（key， min， max）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> zrangeByScore（byte[] key， double min， double max） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScore（key， min， max）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> zrangeByScore（byte[] key， double min， double max， int offset， int count） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScore（key， min， max， offset， count）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrangeByScoreWithScores（byte[] key， double min， double max） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScoreWithScores（key， min， max）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrangeByScoreWithScores（byte[] key， double min， double max， int offset， int count） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScoreWithScores（key， min， max， offset， count）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> zrevrangeByScore（byte[] key， double max， double min） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeByScore（key， max， min）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> zrevrangeByScore（byte[] key， double max， double min， int offset， int count） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeByScore（key， max， min， offset， count）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrevrangeByScoreWithScores（byte[] key， double max， double min） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeByScoreWithScores（key， max， min）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zremrangeByRank（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zremrangeByScore（byte[] key， double start， double end） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zremrangeByScore（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long l（byte[] key， LIST_POSITION where， byte[] pivot， byte[] value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.l（key， where， pivot， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<Object> pipelined（ShardedJedisPipeline shardedJedisPipeline） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
List<Object> result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.pipelined（shardedJedisPipeline）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Jedis getShard（byte[] key） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Jedis result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getShard（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Jedis getShard（String key） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Jedis result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getShard（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public JedisShardInfo getShardInfo（byte[] 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 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） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
String result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getKeyTag（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Collection<JedisShardInfo> getAllShardInfo（） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Collection<JedisShardInfo> result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getAllShardInfo（）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Collection<Jedis> getAllShards（） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Collection<Jedis> result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getAllShards（）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
}
View Code
-----------------------------------
感激一路有你~
原来，再大的房子，再大的床，没有相爱的人陪伴，都只是冰冷的物质。而如果身边有爱人陪伴，即使房子小，床小，也觉得无关紧要，因为这些物质上面有了爱的温度，成了家的元素。—— 何珞《婚房》#书摘#
超出昨天的本身系列（7）
扯淡：
比来一向在慢慢多进修各个组件，本身搭建出一些设法。是一个浏览的过程，慢慢意识到常识是可以融汇贯通，触类旁通的，不过前提如同是研究的斗劲深，有了本身的见地。自认为进修才能不咋地，速度慢不说，还轻易放弃，大多半时辰都是回头捡起来补的那种景象。
所以，我想：自我把守的才能是否决意了一小我进修的高度，也限制了见识的高度呢？
跟着年数的增长，越来越感觉进修常识的那种急迫性，专业方面的，自我教养方面的，都须要急迫的获得满足。我知道很多人其实已经放弃看书了，根蒂根基刷刷微博，看看消息，就满足本身的浏览了。但有时辰，静下心来的时辰，很本身的内心上什么也没有，懊悔本身没种棵树，或掘口井什么的。
不知道你们是否有如许的感触感染？
主题：（以下例子都应用maven构建）
redis的常识：官网
1，哄骗spring-data-redis整合
项目应用的pom.xml：
<project xmlns=http://maven.apache.org/POM/4.0.0 xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance
xsi:schemaLocation=http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd>
<modelVersion>4.0.0</modelVersion>
<groupId>com.x.redis</groupId>
<artifactId>Spring_redis</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>Spring_redis</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>3.1.2.RELEASE</version>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.1.0</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.8.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.1</version>
</dependency>
<!-- 将现有的jakarta commons logging的调用转换成lsf4j的调用。 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.6.1</version>
</dependency>
<!-- Hack：确保commons-logging的jar包不被引入，不然将和jcl-over-slf4j冲突 -->
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
<scope>provided</scope>
</dependency>
<!-- slf4j的实现：logback，用来庖代log4j。更快、更强！ -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>0.9.24</version>
<scope>runtime</scope>
</dependency>
</dependencies>
</project>
View Code
除了log项目组，只有一个spring core 和 spring-data-redis了
项目文件目次布局：
applicationContext.xml：
1，context:property-placeholder 标签用来导入properties文件。从而调换￥{redis.maxIdle}如许的变量。
2，context:component-scan 是为了在com.x.redis.dao报下的类可以或许实用spring的注解注入的体式格式。
3，事实上我们只须要把JedisPoolConfig配数来就好了，接下来就是spring的封装了。所以直接看UserDAOImpl的实现就熟悉打听了。
<？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:p=http://www.springframework.org/schema/p
xmlns:context=http://www.springframework.org/schema/context
xmlns:jee=http://www.springframework.org/schema/jee 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/context http://www.springframework.org/schema/context/spring-context.xsd>
<context:property-placeholder location=classpath:redis.properties />
<context:component-scan base-package=com.x.redis.dao>
</context:component-scan>
<bean id=poolConfig class=redis.clients.jedis.JedisPoolConfig>
<property name=maxIdle value=￥{redis.maxIdle} />
<property name=maxActive value=￥{redis.maxActive} />
<property name=maxWait value=￥{redis.maxWait} />
<property name=testOnBorrow value=￥{redis.testOnBorrow} />
</bean>
<bean id=connectionFactory class=org.springframework.data.redis.connection.jedis.JedisConnectionFactory
p:host-name=￥{redis.host} p:port=￥{redis.port} p:password=￥{redis.pass} p:pool-config-ref=poolConfig/>
<bean id=redisTemplate class=org.springframework.data.redis.core.StringRedisTemplate>
<property name=connectionFactory ref=connectionFactory />
</bean>
<bean id=userDAO class=com.x.redis.dao.impl.UserDAOImpl />
</beans>
redis.properties：
＃ Redis settings
＃redis.host=192.168.20.101
＃redis.port=6380
＃redis.pass=foobared
redis.host=127.0.0.1
redis.port=6379
redis.pass=
redis.maxIdle=300
redis.maxActive=600
redis.maxWait=1000
redis.testOnBorrow=true
View Code
UserDAOImpl：
1，spring对dao层的封装很多用了类似于下面代码的模板体式格式。
2，RedisTemplate就是spring对redis的一个封装罢了。
public class UserDAOImpl implements UserDAO {
＠Autowired
protected RedisTemplate<Serializable， Serializable> redisTemplate;
public void saveUser（final User user） {
redisTemplate.execute（new RedisCallback<Object>（） {
＠Override
public Object doInRedis（RedisConnection connection） throws DataAccessException {
connection.set（redisTemplate.getStringSerializer（）.serialize（user.uid. + user.getId（）），
redisTemplate.getStringSerializer（）.serialize（user.getName（）））;
return null;
}
}）;
}
＠Override
public User getUser（final long id） {
return redisTemplate.execute（new RedisCallback<User>（） {
＠Override
public User doInRedis（RedisConnection connection） throws DataAccessException {
byte[] key = redisTemplate.getStringSerializer（）.serialize（user.uid. + id）;
if （connection.exists（key）） {
byte[] value = connection.get（key）;
String name = redisTemplate.getStringSerializer（）.deserialize（value）;
User user = new User（）;
user.setName（name）;
user.setId（id）;
return user;
}
return null;
}
}）;
}
}
其他：
User：
public class User {
private long id;
private String name;
public long getId（） {
return id;
}
public void setId（long id） {
this.id = id;
}
public String getName（） {
return name;
}
public void setName（String name） {
this.name = name;
}
}
View Code
测试代码：
public static void main（String[] args） {
ApplicationContext ac = new ClassPathXmlApplicationContext（classpath:/applicationContext.xml）;
UserDAO userDAO = （UserDAO）ac.getBean（userDAO）;
User user1 = new User（）;
user1.setId（1）;
user1.setName（obama）;
userDAO.saveUser（user1）;
User user2 = userDAO.getUser（1）;
System.out.println（user2.getName（））;
}
2，晦气用spring-data-redis整合
小我感觉如许整合灵活度更大，可以或许加倍了然的完成任务。
pom.xml:
<project xmlns=http://maven.apache.org/POM/4.0.0 xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance
xsi:schemaLocation=http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd>
<modelVersion>4.0.0</modelVersion>
<groupId>com.d.work</groupId>
<artifactId>Redis_Templete</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>Redis_Templete</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.1.0</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>3.1.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>3.1.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>3.1.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.1</version>
</dependency>
<!-- 将现有的jakarta commons logging的调用转换成lsf4j的调用。 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>1.6.1</version>
</dependency>
<!-- Hack：确保commons-logging的jar包不被引入，不然将和jcl-over-slf4j冲突 -->
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
<scope>provided</scope>
</dependency>
<!-- slf4j的实现：logback，用来庖代log4j。更快、更强！ -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>0.9.24</version>
<scope>runtime</scope>
</dependency>
</dependencies>
</project>
View Code
目次布局：
data-source.xml
1，context:property-placeholder 和 context:component-scan 前面申明过啦。
2，设备了一个ShardedJedisPool，在jdeis里 还有个JedisPool。这两个的差别:
一个是分片情势，可以连接有主备的redis办事端，一个是单个的。具体后续进修
3，因为不应用spring-data-redis的封装，所以本身要本身封装一个
<？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:p=http://www.springframework.org/schema/p
xmlns:context=http://www.springframework.org/schema/context
xmlns:jee=http://www.springframework.org/schema/jee 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/context http://www.springframework.org/schema/context/spring-context.xsd>
<context:property-placeholder location=classpath:redis.properties />
<context:component-scan base-package=com.d.work.main>
</context:component-scan>
<context:component-scan base-package=com.d.work.redis>
</context:component-scan>
<bean id=jedisPoolConfig class=redis.clients.jedis.JedisPoolConfig>
<property name=maxActive value=50 />
<property name=maxIdle value=8 />
<property name=maxWait value=1000 />
<property name=testOnBorrow value=true/>
<property name=testOnReturn value=true/>
<!-- <property name=testWhileIdle value=true/> -->
</bean>
<bean id=shardedJedisPool class=redis.clients.jedis.ShardedJedisPool scope=singleton>
<constructor-arg index=0 ref=jedisPoolConfig />
<constructor-arg index=1>
<list>
<bean class=redis.clients.jedis.JedisShardInfo>
<constructor-arg name=host value=￥{redis.host} />
<constructor-arg name=port value=￥{redis.port} />
<constructor-arg name=timeout value=￥{redis.timeout} />
<constructor-arg name=weight value=1 />
</bean>
</list>
</constructor-arg>
</bean>
</beans>
RedisDataSource:定义三个办法
public interface RedisDataSource {
public abstract ShardedJedis getRedisClient（）;
public void returnResource（ShardedJedis shardedJedis）;
public void returnResource（ShardedJedis shardedJedis，boolean broken）;
}
实现redisDataSource:
1， 注入设备好的ShardedJedisPool，这三个办法的感化：
getRedisClient（） ： 取得redis的客户端，可以履行号令了。
returnResource（ShardedJedis shardedJedis） ： 将资料返还给pool
returnResource（ShardedJedis shardedJedis， boolean broken） : 呈现异常后，将资料返还给pool （其实不须要第二个办法）
＠Repository（redisDataSource）
public class RedisDataSourceImpl implements RedisDataSource {
private static final Logger log = LoggerFactory.getLogger（RedisDataSourceImpl.class）;
＠Autowired
private ShardedJedisPool shardedJedisPool;
public ShardedJedis getRedisClient（） {
try {
ShardedJedis shardJedis = shardedJedisPool.getResource（）;
return shardJedis;
} catch （Exception e） {
log.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）;
}
}
}
第二层的封装：RedisClientTemplate，例子实现了放值和取值。最后代码供给了全部号令的实现。
代码就是映射性质的又一次调用jedis的办法罢了，用了个broken来做标示符，决意返还资料的体式格式。
这一层的目标首要也是让再上层的调用不须要关怀pool中链接的取得和返还题目了。
＠Repository（redisClientTemplate）
public class RedisClientTemplate {
private static final Logger log = LoggerFactory.getLogger（RedisClientTemplate.class）;
＠Autowired
private RedisDataSource redisDataSource;
public void disconnect（） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
shardedJedis.disconnect（）;
}
/
设置单个值
＠param key
＠param value
＠return
/
public String set（String key， String value） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.set（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
/
获取单个值
＠param key
＠return
/
public String get（String key） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.get（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
}
测试代码：
public static void main（String[] args） {
ApplicationContext ac = new ClassPathXmlApplicationContext（classpath:/data-source.xml）;
RedisClientTemplate redisClient = （RedisClientTemplate）ac.getBean（redisClientTemplate）;
redisClient.set（a， abc）;
System.out.println（redisClient.get（a））;
}
附上RedisClientTemplate全部实现：
＠Repository（redisClientTemplate）
public class RedisClientTemplate {
private static final Logger log = LoggerFactory.getLogger（RedisClientTemplate.class）;
＠Autowired
private RedisDataSource redisDataSource;
public void disconnect（） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
shardedJedis.disconnect（）;
}
/
设置单个值
＠param key
＠param value
＠return
/
public String set（String key， String value） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.set（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
/
获取单个值
＠param key
＠return
/
public String get（String key） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.get（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Boolean exists（String key） {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.exists（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String type（String key） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.type（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
/
在某段时候后实现
＠param key
＠param unixTime
＠return
/
public Long expire（String key， int seconds） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.expire（key， seconds）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
/
在某个时候点失效
＠param key
＠param unixTime
＠return
/
public Long expireAt（String key， long unixTime） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.expireAt（key， unixTime）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long ttl（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.ttl（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public boolean setbit（String key， long offset， boolean value） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
boolean result = false;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setbit（key， offset， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public boolean getbit（String key， long offset） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
boolean result = false;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getbit（key， offset）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public long setrange（String key， long offset， String value） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
long result = 0;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setrange（key， offset， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String getrange（String key， long startOffset， long endOffset） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
String result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getrange（key， startOffset， endOffset）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String getSet（String key， String value） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getSet（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long setnx（String key， String value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setnx（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String setex（String key， int seconds， String value） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setex（key， seconds， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long decrBy（String key， long integer） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.decrBy（key， integer）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long decr（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.decr（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long incrBy（String key， long integer） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.incrBy（key， integer）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long incr（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.incr（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long append（String key， String value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.append（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String substr（String key， int start， int end） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.substr（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hset（String key， String field， String value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hset（key， field， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String hget（String key， String field） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hget（key， field）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hsetnx（String key， String field， String value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hsetnx（key， field， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String hmset（String key， Map<String， String> hash） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hmset（key， hash）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<String> hmget（String key， String... fields） {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hmget（key， fields）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hincrBy（String key， String field， long value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hincrBy（key， field， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Boolean hexists（String key， String field） {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hexists（key， field）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long del（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.del（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hdel（String key， String field） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hdel（key， field）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hlen（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hlen（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> hkeys（String key） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hkeys（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<String> hvals（String key） {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hvals（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Map<String， String> hgetAll（String key） {
Map<String， String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hgetAll（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
// ================list ====== l默示 list或 left， r默示right====================
public Long rpush（String key， String string） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.rpush（key， string）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long lpush（String key， String string） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lpush（key， string）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long llen（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.llen（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<String> lrange（String key， long start， long end） {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lrange（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String ltrim（String key， long start， long end） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.ltrim（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String lindex（String key， long index） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lindex（key， index）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String lset（String key， long index， String 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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long lrem（String key， long count， String 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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String lpop（String key） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lpop（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String rpop（String key） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.rpop（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
//return 1 add a not exist value ，
//return 0 add a exist value
public Long sadd（String key， String 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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> smembers（String key） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.smembers（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long srem（String key， String member） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Long result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.srem（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String spop（String key） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
String result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.spop（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long scard（String key） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Long result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.scard（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Boolean sismember（String key， String member） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Boolean result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sismember（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String srandmember（String key） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
String result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.srandmember（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zadd（String key， double score， String 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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> zrange（String key， int start， int end） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrange（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zrem（String key， String member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrem（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Double zincrby（String key， double score， String member） {
Double result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zincrby（key， score， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zrank（String key， String member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrank（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zrevrank（String key， String member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrank（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> zrevrange（String key， int start， int end） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrange（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrangeWithScores（String key， int start， int end） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeWithScores（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrevrangeWithScores（String key， int start， int end） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeWithScores（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zcard（String key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zcard（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Double zscore（String key， String member） {
Double result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zscore（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<String> sort（String key） {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sort（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<String> sort（String key， SortingParams sortingParameters） {
List<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sort（key， sortingParameters）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zcount（String key， double min， double max） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zcount（key， min， max）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> zrangeByScore（String key， double min， double max） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScore（key， min， max）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> zrevrangeByScore（String key， double max， double min） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeByScore（key， max， min）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> zrangeByScore（String key， double min， double max， int offset， int count） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScore（key， min， max， offset， count）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<String> zrevrangeByScore（String key， double max， double min， int offset， int count） {
Set<String> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeByScore（key， max， min， offset， count）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrangeByScoreWithScores（String key， double min， double max） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScoreWithScores（key， min， max）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrevrangeByScoreWithScores（String key， double max， double min） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeByScoreWithScores（key， max， min）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrangeByScoreWithScores（String key， double min， double max， int offset， int count） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScoreWithScores（key， min， max， offset， count）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrevrangeByScoreWithScores（String 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（String key， int start， int end） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zremrangeByRank（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zremrangeByScore（String key， double start， double end） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zremrangeByScore（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long l（String key， LIST_POSITION where， String pivot， String value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.l（key， where， pivot， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String set（byte[] key， byte[] value） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.set（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] get（byte[] key） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.get（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Boolean exists（byte[] key） {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.exists（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String type（byte[] key） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.type（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long expire（byte[] key， int seconds） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.expire（key， seconds）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long expireAt（byte[] key， long unixTime） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.expireAt（key， unixTime）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long ttl（byte[] key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.ttl（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] getSet（byte[] key， byte[] value） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getSet（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long setnx（byte[] key， byte[] value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setnx（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String setex（byte[] key， int seconds， byte[] value） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.setex（key， seconds， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long decrBy（byte[] key， long integer） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.decrBy（key， integer）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long decr（byte[] key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.decr（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long incrBy（byte[] key， long integer） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.incrBy（key， integer）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long incr（byte[] key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.incr（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long append（byte[] key， byte[] value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.append（key， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] substr（byte[] key， int start， int end） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.substr（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hset（byte[] key， byte[] field， byte[] value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hset（key， field， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] hget（byte[] key， byte[] field） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hget（key， field）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hsetnx（byte[] key， byte[] field， byte[] value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hsetnx（key， field， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String hmset（byte[] key， Map<byte[]， byte[]> hash） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hmset（key， hash）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<byte[]> hmget（byte[] key， byte[]... fields） {
List<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hmget（key， fields）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hincrBy（byte[] key， byte[] field， long value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hincrBy（key， field， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Boolean hexists（byte[] key， byte[] field） {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hexists（key， field）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hdel（byte[] key， byte[] field） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hdel（key， field）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long hlen（byte[] key） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hlen（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> hkeys（byte[] key） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hkeys（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Collection<byte[]> hvals（byte[] key） {
Collection<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hvals（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Map<byte[]， byte[]> hgetAll（byte[] key） {
Map<byte[]， byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.hgetAll（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long rpush（byte[] key， byte[] string） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.rpush（key， string）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long lpush（byte[] key， byte[] string） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lpush（key， string）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public String ltrim（byte[] key， int start， int end） {
String result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.ltrim（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] lindex（byte[] key， int index） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.lindex（key， index）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long srem（byte[] key， byte[] member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.srem（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] spop（byte[] key） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.spop（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Boolean sismember（byte[] key， byte[] member） {
Boolean result = false;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sismember（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public byte[] srandmember（byte[] key） {
byte[] result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.srandmember（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> zrange（byte[] key， int start， int end） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrange（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zrem（byte[] key， byte[] member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrem（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Double zincrby（byte[] key， double score， byte[] member） {
Double result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zincrby（key， score， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zrank（byte[] key， byte[] member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrank（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zrevrank（byte[] key， byte[] member） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrank（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> zrevrange（byte[] key， int start， int end） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrange（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrangeWithScores（byte[] key， int start， int end） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeWithScores（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrevrangeWithScores（byte[] key， int start， int end） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeWithScores（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Double zscore（byte[] key， byte[] member） {
Double result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zscore（key， member）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<byte[]> sort（byte[] key） {
List<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sort（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<byte[]> sort（byte[] key， SortingParams sortingParameters） {
List<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.sort（key， sortingParameters）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zcount（byte[] key， double min， double max） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zcount（key， min， max）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> zrangeByScore（byte[] key， double min， double max） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScore（key， min， max）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> zrangeByScore（byte[] key， double min， double max， int offset， int count） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScore（key， min， max， offset， count）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrangeByScoreWithScores（byte[] key， double min， double max） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScoreWithScores（key， min， max）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrangeByScoreWithScores（byte[] key， double min， double max， int offset， int count） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrangeByScoreWithScores（key， min， max， offset， count）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> zrevrangeByScore（byte[] key， double max， double min） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeByScore（key， max， min）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<byte[]> zrevrangeByScore（byte[] key， double max， double min， int offset， int count） {
Set<byte[]> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeByScore（key， max， min， offset， count）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Set<Tuple> zrevrangeByScoreWithScores（byte[] key， double max， double min） {
Set<Tuple> result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zrevrangeByScoreWithScores（key， max， min）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
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） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zremrangeByRank（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long zremrangeByScore（byte[] key， double start， double end） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.zremrangeByScore（key， start， end）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Long l（byte[] key， LIST_POSITION where， byte[] pivot， byte[] value） {
Long result = null;
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.l（key， where， pivot， value）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public List<Object> pipelined（ShardedJedisPipeline shardedJedisPipeline） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
List<Object> result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.pipelined（shardedJedisPipeline）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Jedis getShard（byte[] key） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Jedis result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getShard（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Jedis getShard（String key） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Jedis result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getShard（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public JedisShardInfo getShardInfo（byte[] 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 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） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
String result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getKeyTag（key）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Collection<JedisShardInfo> getAllShardInfo（） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Collection<JedisShardInfo> result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getAllShardInfo（）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
public Collection<Jedis> getAllShards（） {
ShardedJedis shardedJedis = redisDataSource.getRedisClient（）;
Collection<Jedis> result = null;
if （shardedJedis == null） {
return result;
}
boolean broken = false;
try {
result = shardedJedis.getAllShards（）;
} catch （Exception e） {
log.error（e.getMessage（）， e）;
broken = true;
} finally {
redisDataSource.returnResource（shardedJedis， broken）;
}
return result;
}
}
View Code
-----------------------------------
感激一路有你~
原来，再大的房子，再大的床，没有相爱的人陪伴，都只是冰冷的物质。而如果身边有爱人陪伴，即使房子小，床小，也觉得无关紧要，因为这些物质上面有了爱的温度，成了家的元素。—— 何珞《婚房》#书摘#
