超越昨天的自己系列（7）

扯淡：

　　 最近一直在慢慢多学习各个组件，自己搭建出一些想法。是一个涉猎的过程，慢慢意识到知识是可以融汇贯通，举一反三的，不过前提好像是研究的比较深，有了自己的见解。自认为学习能力不咋地，速度慢不说，还容易放弃，大多数时候都是回头捡起来补的那种情况。

　　所以，我想：自我监督的能力是否决定了一个人学习的高度，也限制了见识的高度呢？

　　随着年纪的增长，越来越觉得学习知识的那种迫切性，专业方面的，自我修养方面的，都需要急切的得到满足。我知道很多人其实已经放弃看书了，基本刷刷微博，看看新闻，就满足自己的阅读欲望了。但有时候，静下心来的时候，很自己的心田上什么也没有，后悔自己没种棵树，或掘口井什么的。

　　不知道你们是否有这样的感觉？


主题：(以下例子都使用maven构建)

　　redis的知识：官网

　　1，利用spring-data-redis整合

　　项目使用的pom.xml：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.   <modelVersion>4.0.0</modelVersion>
  4.  
  5.   <groupId>com.x.redis</groupId>
  6.   <artifactId>Spring_redis</artifactId>
  7.   <version>1.0-SNAPSHOT</version>
  8.   <packaging>jar</packaging>
  9.  
  10.   <name>Spring_redis</name>
  11.   <url>http://maven.apache.org</url>
  12.  
  13.   <properties>
  14.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  15.   </properties>
  16.  
  17.   <dependencies>
  18.      <dependency>
  19.         <groupId>org.springframework.data</groupId>
  20.         <artifactId>spring-data-redis</artifactId>
  21.         <version>1.0.2.RELEASE</version>
  22.     </dependency>
  23.     <dependency>
  24.         <groupId>org.springframework</groupId>
  25.         <artifactId>spring-core</artifactId>
  26.         <version>3.1.2.RELEASE</version>
  27.     </dependency>  
  28.  
  29.     <dependency>
  30.         <groupId>redis.clients</groupId>
  31.         <artifactId>jedis</artifactId>
  32.         <version>2.1.0</version>
  33.     </dependency>  
  34.  
  35.      <dependency>
  36.         <groupId>junit</groupId>
  37.         <artifactId>junit</artifactId>
  38.         <version>4.8.2</version>
  39.         <scope>test</scope>
  40.     </dependency>
  41.                 <dependency>
  42.                 <groupId>org.slf4j</groupId>
  43.                 <artifactId>slf4j-api</artifactId>
  44.                 <version>1.6.1</version>
  45.             </dependency>
  46.             <!-- 将现有的jakarta commons logging的调用转换成lsf4j的调用。 -->
  47.             <dependency>
  48.                 <groupId>org.slf4j</groupId>
  49.                 <artifactId>jcl-over-slf4j</artifactId>
  50.                 <version>1.6.1</version>
  51.             </dependency>
  52.             <!-- Hack：确保commons-logging的jar包不被引入，否则将和jcl-over-slf4j冲突 -->
  53.             <dependency>
  54.                 <groupId>commons-logging</groupId>
  55.                 <artifactId>commons-logging</artifactId>
  56.                 <version>1.1.1</version>
  57.                 <scope>provided</scope>
  58.             </dependency>
  59.             <!-- slf4j的实现：logback，用来取代log4j。更快、更强！ -->
  60.             <dependency>
  61.                 <groupId>ch.qos.logback</groupId>
  62.                 <artifactId>logback-classic</artifactId>
  63.                 <version>0.9.24</version>
  64.                 <scope>runtime</scope>
  65.             </dependency>
  66.   </dependencies>
  67. </project>

　　除了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的实现就明白了。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  4.     xmlns:context="http://www.springframework.org/schema/context"
  5.     xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
  6.     xmlns:aop="http://www.springframework.org/schema/aop"
  7.     xsi:schemaLocation="
  8.             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  9.             http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">  
  10.  
  11.     <context:property-placeholder location="classpath:redis.properties" />
  12.     <context:component-scan base-package="com.x.redis.dao">
  13.     </context:component-scan>
  14.     <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
  15.         <property name="maxIdle" value="${redis.maxIdle}" />
  16.         <property name="maxActive" value="${redis.maxActive}" />
  17.         <property name="maxWait" value="${redis.maxWait}" />
  18.         <property name="testOnBorrow" value="${redis.testOnBorrow}" />
  19.     </bean>  
  20.  
  21.     <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
  22.         p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"  p:pool-config-ref="poolConfig"/>  
  23.  
  24.     <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
  25.         <property name="connectionFactory"   ref="connectionFactory" />
  26.     </bean>         
  27.  
  28.     <bean id="userDAO" class="com.x.redis.dao.impl.UserDAOImpl" />
  29. </beans>

　　redis.properties：

  1. # Redis settings
  2. #redis.host=192.168.20.101
  3. #redis.port=6380
  4. #redis.pass=foobared
  5. redis.host=127.0.0.1
  6. redis.port=6379
  7. redis.pass=
  8.  
  9. redis.maxIdle=300
  10. redis.maxActive=600
  11. redis.maxWait=1000
  12. redis.testOnBorrow=true

　　UserDAOImpl：

　　1，spring对dao层的封装很多用了类似于下面代码的模板方式。

　　2，RedisTemplate就是spring对redis的一个封装而已。

  1. public class UserDAOImpl implements UserDAO {
  2.  
  3.     @Autowired
  4.     protected RedisTemplate<Serializable, Serializable> redisTemplate;
  5.  
  6.     public void saveUser(final User user) {
  7.         redisTemplate.execute(new RedisCallback<Object>() {
  8.  
  9.             @Override
  10.             public Object doInRedis(RedisConnection connection) throws DataAccessException {
  11.                 connection.set(redisTemplate.getStringSerializer().serialize("user.uid." + user.getId()),
  12.                                redisTemplate.getStringSerializer().serialize(user.getName()));
  13.                 return null;
  14.             }
  15.         });
  16.     }
  17.  
  18.     @Override
  19.     public User getUser(final long id) {
  20.         return redisTemplate.execute(new RedisCallback<User>() {
  21.             @Override
  22.             public User doInRedis(RedisConnection connection) throws DataAccessException {
  23.                 byte[] key = redisTemplate.getStringSerializer().serialize("user.uid." + id);
  24.                 if (connection.exists(key)) {
  25.                     byte[] value = connection.get(key);
  26.                     String name = redisTemplate.getStringSerializer().deserialize(value);
  27.                     User user = new User();
  28.                     user.setName(name);
  29.                     user.setId(id);
  30.                     return user;
  31.                 }
  32.                 return null;
  33.             }
  34.         });
  35.     }
  36.  
  37. }

　　其他：

　　User：

  1. public class User {
  2.  
  3.     private long id;
  4.     private String name;
  5.  
  6.     public long getId() {
  7.         return id;
  8.     }
  9.  
  10.     public void setId(long id) {
  11.         this.id = id;
  12.     }
  13.  
  14.     public String getName() {
  15.         return name;
  16.     }
  17.  
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  21. }

　　测试代码：

  1.     public static void main(String[] args) {
  2.         ApplicationContext ac =  new ClassPathXmlApplicationContext("classpath:/applicationContext.xml");
  3.         UserDAO userDAO = (UserDAO)ac.getBean("userDAO");
  4.         User user1 = new User();
  5.         user1.setId(1);
  6.         user1.setName("obama");
  7.         userDAO.saveUser(user1);
  8.         User user2 = userDAO.getUser(1);
  9.         System.out.println(user2.getName());
  10.     }

　　2，不利用spring-data-redis整合

　　个人觉得这样整合灵活度更大，能够更加明了的完成任务。

　　pom.xml:

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.   <modelVersion>4.0.0</modelVersion>
  4.  
  5.   <groupId>com.d.work</groupId>
  6.   <artifactId>Redis_Templete</artifactId>
  7.   <version>1.0-SNAPSHOT</version>
  8.   <packaging>jar</packaging>
  9.  
  10.   <name>Redis_Templete</name>
  11.   <url>http://maven.apache.org</url>
  12.  
  13.   <properties>
  14.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  15.   </properties>
  16.  
  17.   <dependencies>
  18.     <dependency>
  19.       <groupId>junit</groupId>
  20.       <artifactId>junit</artifactId>
  21.       <version>3.8.1</version>
  22.       <scope>test</scope>
  23.     </dependency>
  24.     <dependency>
  25.         <groupId>redis.clients</groupId>
  26.         <artifactId>jedis</artifactId>
  27.         <version>2.1.0</version>
  28.     </dependency>
  29.         <dependency>
  30.         <groupId>org.springframework</groupId>
  31.         <artifactId>spring-core</artifactId>
  32.         <version>3.1.2.RELEASE</version>
  33.     </dependency>
  34.         <dependency>
  35.         <groupId>org.springframework</groupId>
  36.         <artifactId>spring-beans</artifactId>
  37.         <version>3.1.2.RELEASE</version>
  38.     </dependency>
  39.         <dependency>
  40.         <groupId>org.springframework</groupId>
  41.         <artifactId>spring-context</artifactId>
  42.         <version>3.1.2.RELEASE</version>
  43.     </dependency>
  44.     <dependency>
  45.                 <groupId>org.slf4j</groupId>
  46.                 <artifactId>slf4j-api</artifactId>
  47.                 <version>1.6.1</version>
  48.             </dependency>
  49.             <!-- 将现有的jakarta commons logging的调用转换成lsf4j的调用。 -->
  50.             <dependency>
  51.                 <groupId>org.slf4j</groupId>
  52.                 <artifactId>jcl-over-slf4j</artifactId>
  53.                 <version>1.6.1</version>
  54.             </dependency>
  55.             <!-- Hack：确保commons-logging的jar包不被引入，否则将和jcl-over-slf4j冲突 -->
  56.             <dependency>
  57.                 <groupId>commons-logging</groupId>
  58.                 <artifactId>commons-logging</artifactId>
  59.                 <version>1.1.1</version>
  60.                 <scope>provided</scope>
  61.             </dependency>
  62.             <!-- slf4j的实现：logback，用来取代log4j。更快、更强！ -->
  63.             <dependency>
  64.                 <groupId>ch.qos.logback</groupId>
  65.                 <artifactId>logback-classic</artifactId>
  66.                 <version>0.9.24</version>
  67.                 <scope>runtime</scope>
  68.             </dependency>
  69.   </dependencies>
  70. </project>

　　目录结构：

　　

　　data-source.xml

　　1，context:property-placeholder 和 context:component-scan 前面解释过啦。

　　2，配置了一个ShardedJedisPool，在jdeis里 还有个JedisPool。这两个的区别:

　　　　一个是分片形式，可以连接有主备的redis服务端，一个是单个的。详细后续学习
 
　　3，因为不使用spring-data-redis的封装，所以自己要自己封装一个
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  4.     xmlns:context="http://www.springframework.org/schema/context"
  5.     xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
  6.     xmlns:aop="http://www.springframework.org/schema/aop"
  7.     xsi:schemaLocation="
  8.             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  9.             http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">  
  10.  
  11.     <context:property-placeholder location="classpath:redis.properties" />
  12.     <context:component-scan base-package="com.d.work.main">
  13.     </context:component-scan>
  14.         <context:component-scan base-package="com.d.work.redis">
  15.     </context:component-scan>
  16.     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
  17.         <property name="maxActive" value="50" />
  18.         <property name="maxIdle" value="8" />
  19.         <property name="maxWait" value="1000" />
  20.         <property name="testOnBorrow" value="true"/>
  21.         <property name="testOnReturn" value="true"/>
  22.         <!-- <property name="testWhileIdle" value="true"/> -->
  23.     </bean>
  24.  
  25.     <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool"  scope="singleton">
  26.         <constructor-arg index="0" ref="jedisPoolConfig" />
  27.         <constructor-arg index="1">
  28.             <list>
  29.                 <bean class="redis.clients.jedis.JedisShardInfo">
  30.                     <constructor-arg name="host" value="${redis.host}" />
  31.                     <constructor-arg name="port" value="${redis.port}" />
  32.                     <constructor-arg name="timeout" value="${redis.timeout}" />
  33.                     <constructor-arg name="weight" value="1" />
  34.                 </bean>
  35.             </list>
  36.         </constructor-arg>
  37.     </bean>
  38. </beans>

RedisDataSource:定义三个方法

  1. public interface RedisDataSource {
  2.     public abstract ShardedJedis getRedisClient();
  3.     public void returnResource(ShardedJedis shardedJedis);
  4.     public void returnResource(ShardedJedis shardedJedis,boolean broken);
  5. }

实现redisDataSource:

1, 注入配置好的ShardedJedisPool，这三个方法的作用：

  1. getRedisClient() ： 取得redis的客户端，可以执行命令了。
  1. returnResource(ShardedJedis shardedJedis) ： 将资源返还给pool
  1. returnResource(ShardedJedis shardedJedis, boolean broken) : 出现异常后，将资源返还给pool （其实不需要第二个方法）
  1. @Repository("redisDataSource")
  2. public class RedisDataSourceImpl implements RedisDataSource {
  3.  
  4.     private static final Logger log = LoggerFactory.getLogger(RedisDataSourceImpl.class);
  5.  
  6.     @Autowired
  7.     private ShardedJedisPool    shardedJedisPool;
  8.  
  9.     public ShardedJedis getRedisClient() {
  10.         try {
  11.             ShardedJedis shardJedis = shardedJedisPool.getResource();
  12.             return shardJedis;
  13.         } catch (Exception e) {
  14.             log.error("getRedisClent error", e);
  15.         }
  16.         return null;
  17.     }
  18.  
  19.     public void returnResource(ShardedJedis shardedJedis) {
  20.         shardedJedisPool.returnResource(shardedJedis);
  21.     }
  22.  
  23.     public void returnResource(ShardedJedis shardedJedis, boolean broken) {
  24.         if (broken) {
  25.             shardedJedisPool.returnBrokenResource(shardedJedis);
  26.         } else {
  27.             shardedJedisPool.returnResource(shardedJedis);
  28.         }
  29.     }
  30. }

第二层的封装：RedisClientTemplate，例子实现了放值和取值。最后代码提供了全部命令的实现。

　　代码就是映射性质的又一次调用jedis的方法而已，用了个broken来做标示符，决定返还资源的方式。

　　这一层的目的主要也是让再上层的调用不需要关心pool中链接的取得和返还问题了。

  1. @Repository("redisClientTemplate")
  2. public class RedisClientTemplate {
  3.  
  4.     private static final Logger log = LoggerFactory.getLogger(RedisClientTemplate.class);
  5.  
  6.     @Autowired
  7.     private RedisDataSource     redisDataSource;
  8.  
  9.     public void disconnect() {
  10.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  11.         shardedJedis.disconnect();
  12.     }
  13.  
  14.     /**
  15.      * 设置单个值
  16.      *
  17.      * @param key
  18.      * @param value
  19.      * @return
  20.      */
  21.     public String set(String key, String value) {
  22.         String result = null;
  23.  
  24.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  25.         if (shardedJedis == null) {
  26.             return result;
  27.         }
  28.         boolean broken = false;
  29.         try {
  30.             result = shardedJedis.set(key, value);
  31.         } catch (Exception e) {
  32.             log.error(e.getMessage(), e);
  33.             broken = true;
  34.         } finally {
  35.             redisDataSource.returnResource(shardedJedis, broken);
  36.         }
  37.         return result;
  38.     }
  39.  
  40.     /**
  41.      * 获取单个值
  42.      *
  43.      * @param key
  44.      * @return
  45.      */
  46.     public String get(String key) {
  47.         String result = null;
  48.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  49.         if (shardedJedis == null) {
  50.             return result;
  51.         }
  52.  
  53.         boolean broken = false;
  54.         try {
  55.             result = shardedJedis.get(key);
  56.  
  57.         } catch (Exception e) {
  58.             log.error(e.getMessage(), e);
  59.             broken = true;
  60.         } finally {
  61.             redisDataSource.returnResource(shardedJedis, broken);
  62.         }
  63.         return result;
  64.     }
  65. }

测试代码：

  1.     public static void main(String[] args) {
  2.         ApplicationContext ac =  new ClassPathXmlApplicationContext("classpath:/data-source.xml");
  3.         RedisClientTemplate redisClient = (RedisClientTemplate)ac.getBean("redisClientTemplate");
  4.         redisClient.set("a", "abc");
  5.         System.out.println(redisClient.get("a"));
  6.     }

附上RedisClientTemplate全部实现：

  1. @Repository("redisClientTemplate")
  2. public class RedisClientTemplate {
  3.  
  4.     private static final Logger log = LoggerFactory.getLogger(RedisClientTemplate.class);
  5.  
  6.     @Autowired
  7.     private RedisDataSource     redisDataSource;
  8.  
  9.     public void disconnect() {
  10.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  11.         shardedJedis.disconnect();
  12.     }
  13.  
  14.     /**
  15.      * 设置单个值
  16.      *
  17.      * @param key
  18.      * @param value
  19.      * @return
  20.      */
  21.     public String set(String key, String value) {
  22.         String result = null;
  23.  
  24.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  25.         if (shardedJedis == null) {
  26.             return result;
  27.         }
  28.         boolean broken = false;
  29.         try {
  30.             result = shardedJedis.set(key, value);
  31.         } catch (Exception e) {
  32.             log.error(e.getMessage(), e);
  33.             broken = true;
  34.         } finally {
  35.             redisDataSource.returnResource(shardedJedis, broken);
  36.         }
  37.         return result;
  38.     }
  39.  
  40.     /**
  41.      * 获取单个值
  42.      *
  43.      * @param key
  44.      * @return
  45.      */
  46.     public String get(String key) {
  47.         String result = null;
  48.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  49.         if (shardedJedis == null) {
  50.             return result;
  51.         }
  52.  
  53.         boolean broken = false;
  54.         try {
  55.             result = shardedJedis.get(key);
  56.  
  57.         } catch (Exception e) {
  58.             log.error(e.getMessage(), e);
  59.             broken = true;
  60.         } finally {
  61.             redisDataSource.returnResource(shardedJedis, broken);
  62.         }
  63.         return result;
  64.     }
  65.  
  66.     public Boolean exists(String key) {
  67.         Boolean result = false;
  68.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  69.         if (shardedJedis == null) {
  70.             return result;
  71.         }
  72.         boolean broken = false;
  73.         try {
  74.             result = shardedJedis.exists(key);
  75.         } catch (Exception e) {
  76.             log.error(e.getMessage(), e);
  77.             broken = true;
  78.         } finally {
  79.             redisDataSource.returnResource(shardedJedis, broken);
  80.         }
  81.         return result;
  82.     }
  83.  
  84.     public String type(String key) {
  85.         String result = null;
  86.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  87.         if (shardedJedis == null) {
  88.             return result;
  89.         }
  90.         boolean broken = false;
  91.         try {
  92.             result = shardedJedis.type(key);
  93.  
  94.         } catch (Exception e) {
  95.             log.error(e.getMessage(), e);
  96.             broken = true;
  97.         } finally {
  98.             redisDataSource.returnResource(shardedJedis, broken);
  99.         }
  100.         return result;
  101.     }
  102.  
  103.     /**
  104.      * 在某段时间后实现
  105.      *
  106.      * @param key
  107.      * @param unixTime
  108.      * @return
  109.      */
  110.     public Long expire(String key, int seconds) {
  111.         Long result = null;
  112.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  113.         if (shardedJedis == null) {
  114.             return result;
  115.         }
  116.         boolean broken = false;
  117.         try {
  118.             result = shardedJedis.expire(key, seconds);
  119.  
  120.         } catch (Exception e) {
  121.             log.error(e.getMessage(), e);
  122.             broken = true;
  123.         } finally {
  124.             redisDataSource.returnResource(shardedJedis, broken);
  125.         }
  126.         return result;
  127.     }
  128.  
  129.     /**
  130.      * 在某个时间点失效
  131.      *
  132.      * @param key
  133.      * @param unixTime
  134.      * @return
  135.      */
  136.     public Long expireAt(String key, long unixTime) {
  137.         Long result = null;
  138.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  139.         if (shardedJedis == null) {
  140.             return result;
  141.         }
  142.         boolean broken = false;
  143.         try {
  144.             result = shardedJedis.expireAt(key, unixTime);
  145.  
  146.         } catch (Exception e) {
  147.             log.error(e.getMessage(), e);
  148.             broken = true;
  149.         } finally {
  150.             redisDataSource.returnResource(shardedJedis, broken);
  151.         }
  152.         return result;
  153.     }
  154.  
  155.     public Long ttl(String key) {
  156.         Long result = null;
  157.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  158.         if (shardedJedis == null) {
  159.             return result;
  160.         }
  161.         boolean broken = false;
  162.         try {
  163.             result = shardedJedis.ttl(key);
  164.  
  165.         } catch (Exception e) {
  166.             log.error(e.getMessage(), e);
  167.             broken = true;
  168.         } finally {
  169.             redisDataSource.returnResource(shardedJedis, broken);
  170.         }
  171.         return result;
  172.     }
  173.  
  174.     public boolean setbit(String key, long offset, boolean value) {
  175.  
  176.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  177.         boolean result = false;
  178.         if (shardedJedis == null) {
  179.             return result;
  180.         }
  181.         boolean broken = false;
  182.         try {
  183.             result = shardedJedis.setbit(key, offset, value);
  184.         } catch (Exception e) {
  185.             log.error(e.getMessage(), e);
  186.             broken = true;
  187.         } finally {
  188.             redisDataSource.returnResource(shardedJedis, broken);
  189.         }
  190.         return result;
  191.     }
  192.  
  193.     public boolean getbit(String key, long offset) {
  194.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  195.         boolean result = false;
  196.         if (shardedJedis == null) {
  197.             return result;
  198.         }
  199.         boolean broken = false;
  200.  
  201.         try {
  202.             result = shardedJedis.getbit(key, offset);
  203.         } catch (Exception e) {
  204.             log.error(e.getMessage(), e);
  205.             broken = true;
  206.         } finally {
  207.             redisDataSource.returnResource(shardedJedis, broken);
  208.         }
  209.         return result;
  210.     }
  211.  
  212.     public long setrange(String key, long offset, String value) {
  213.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  214.         long result = 0;
  215.         if (shardedJedis == null) {
  216.             return result;
  217.         }
  218.         boolean broken = false;
  219.         try {
  220.             result = shardedJedis.setrange(key, offset, value);
  221.         } catch (Exception e) {
  222.             log.error(e.getMessage(), e);
  223.             broken = true;
  224.         } finally {
  225.             redisDataSource.returnResource(shardedJedis, broken);
  226.         }
  227.         return result;
  228.     }
  229.  
  230.     public String getrange(String key, long startOffset, long endOffset) {
  231.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  232.         String result = null;
  233.         if (shardedJedis == null) {
  234.             return result;
  235.         }
  236.         boolean broken = false;
  237.         try {
  238.             result = shardedJedis.getrange(key, startOffset, endOffset);
  239.  
  240.         } catch (Exception e) {
  241.             log.error(e.getMessage(), e);
  242.             broken = true;
  243.         } finally {
  244.             redisDataSource.returnResource(shardedJedis, broken);
  245.         }
  246.         return result;
  247.     }
  248.  
  249.     public String getSet(String key, String value) {
  250.         String result = null;
  251.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  252.         if (shardedJedis == null) {
  253.             return result;
  254.         }
  255.         boolean broken = false;
  256.         try {
  257.             result = shardedJedis.getSet(key, value);
  258.         } catch (Exception e) {
  259.             log.error(e.getMessage(), e);
  260.             broken = true;
  261.         } finally {
  262.             redisDataSource.returnResource(shardedJedis, broken);
  263.         }
  264.         return result;
  265.     }
  266.  
  267.     public Long setnx(String key, String value) {
  268.         Long result = null;
  269.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  270.         if (shardedJedis == null) {
  271.             return result;
  272.         }
  273.         boolean broken = false;
  274.         try {
  275.             result = shardedJedis.setnx(key, value);
  276.         } catch (Exception e) {
  277.             log.error(e.getMessage(), e);
  278.             broken = true;
  279.         } finally {
  280.             redisDataSource.returnResource(shardedJedis, broken);
  281.         }
  282.         return result;
  283.     }
  284.  
  285.     public String setex(String key, int seconds, String value) {
  286.         String result = null;
  287.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  288.         if (shardedJedis == null) {
  289.             return result;
  290.         }
  291.         boolean broken = false;
  292.         try {
  293.             result = shardedJedis.setex(key, seconds, value);
  294.  
  295.         } catch (Exception e) {
  296.             log.error(e.getMessage(), e);
  297.             broken = true;
  298.         } finally {
  299.             redisDataSource.returnResource(shardedJedis, broken);
  300.         }
  301.         return result;
  302.     }
  303.  
  304.     public Long decrBy(String key, long integer) {
  305.         Long result = null;
  306.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  307.         if (shardedJedis == null) {
  308.             return result;
  309.         }
  310.         boolean broken = false;
  311.         try {
  312.             result = shardedJedis.decrBy(key, integer);
  313.  
  314.         } catch (Exception e) {
  315.             log.error(e.getMessage(), e);
  316.             broken = true;
  317.         } finally {
  318.             redisDataSource.returnResource(shardedJedis, broken);
  319.         }
  320.         return result;
  321.     }
  322.  
  323.     public Long decr(String key) {
  324.         Long result = null;
  325.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  326.         if (shardedJedis == null) {
  327.             return result;
  328.         }
  329.         boolean broken = false;
  330.         try {
  331.             result = shardedJedis.decr(key);
  332.  
  333.         } catch (Exception e) {
  334.             log.error(e.getMessage(), e);
  335.             broken = true;
  336.         } finally {
  337.             redisDataSource.returnResource(shardedJedis, broken);
  338.         }
  339.         return result;
  340.     }
  341.  
  342.     public Long incrBy(String key, long integer) {
  343.         Long result = null;
  344.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  345.         if (shardedJedis == null) {
  346.             return result;
  347.         }
  348.         boolean broken = false;
  349.         try {
  350.             result = shardedJedis.incrBy(key, integer);
  351.  
  352.         } catch (Exception e) {
  353.             log.error(e.getMessage(), e);
  354.             broken = true;
  355.         } finally {
  356.             redisDataSource.returnResource(shardedJedis, broken);
  357.         }
  358.         return result;
  359.     }
  360.  
  361.     public Long incr(String key) {
  362.         Long result = null;
  363.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  364.         if (shardedJedis == null) {
  365.             return result;
  366.         }
  367.         boolean broken = false;
  368.         try {
  369.             result = shardedJedis.incr(key);
  370.  
  371.         } catch (Exception e) {
  372.             log.error(e.getMessage(), e);
  373.             broken = true;
  374.         } finally {
  375.             redisDataSource.returnResource(shardedJedis, broken);
  376.         }
  377.         return result;
  378.     }
  379.  
  380.     public Long append(String key, String value) {
  381.         Long result = null;
  382.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  383.         if (shardedJedis == null) {
  384.             return result;
  385.         }
  386.         boolean broken = false;
  387.         try {
  388.             result = shardedJedis.append(key, value);
  389.  
  390.         } catch (Exception e) {
  391.             log.error(e.getMessage(), e);
  392.             broken = true;
  393.         } finally {
  394.             redisDataSource.returnResource(shardedJedis, broken);
  395.         }
  396.         return result;
  397.     }
  398.  
  399.     public String substr(String key, int start, int end) {
  400.         String result = null;
  401.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  402.         if (shardedJedis == null) {
  403.             return result;
  404.         }
  405.         boolean broken = false;
  406.         try {
  407.             result = shardedJedis.substr(key, start, end);
  408.  
  409.         } catch (Exception e) {
  410.             log.error(e.getMessage(), e);
  411.             broken = true;
  412.         } finally {
  413.             redisDataSource.returnResource(shardedJedis, broken);
  414.         }
  415.         return result;
  416.     }
  417.  
  418.     public Long hset(String key, String field, String value) {
  419.         Long result = null;
  420.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  421.         if (shardedJedis == null) {
  422.             return result;
  423.         }
  424.         boolean broken = false;
  425.         try {
  426.             result = shardedJedis.hset(key, field, value);
  427.  
  428.         } catch (Exception e) {
  429.             log.error(e.getMessage(), e);
  430.             broken = true;
  431.         } finally {
  432.             redisDataSource.returnResource(shardedJedis, broken);
  433.         }
  434.         return result;
  435.     }
  436.  
  437.     public String hget(String key, String field) {
  438.         String result = null;
  439.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  440.         if (shardedJedis == null) {
  441.             return result;
  442.         }
  443.         boolean broken = false;
  444.         try {
  445.             result = shardedJedis.hget(key, field);
  446.  
  447.         } catch (Exception e) {
  448.             log.error(e.getMessage(), e);
  449.             broken = true;
  450.         } finally {
  451.             redisDataSource.returnResource(shardedJedis, broken);
  452.         }
  453.         return result;
  454.     }
  455.  
  456.     public Long hsetnx(String key, String field, String value) {
  457.         Long result = null;
  458.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  459.         if (shardedJedis == null) {
  460.             return result;
  461.         }
  462.         boolean broken = false;
  463.         try {
  464.             result = shardedJedis.hsetnx(key, field, value);
  465.  
  466.         } catch (Exception e) {
  467.             log.error(e.getMessage(), e);
  468.             broken = true;
  469.         } finally {
  470.             redisDataSource.returnResource(shardedJedis, broken);
  471.         }
  472.         return result;
  473.     }
  474.  
  475.     public String hmset(String key, Map<String, String> hash) {
  476.         String result = null;
  477.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  478.         if (shardedJedis == null) {
  479.             return result;
  480.         }
  481.         boolean broken = false;
  482.         try {
  483.             result = shardedJedis.hmset(key, hash);
  484.  
  485.         } catch (Exception e) {
  486.             log.error(e.getMessage(), e);
  487.             broken = true;
  488.         } finally {
  489.             redisDataSource.returnResource(shardedJedis, broken);
  490.         }
  491.         return result;
  492.     }
  493.  
  494.     public List<String> hmget(String key, String... fields) {
  495.         List<String> result = null;
  496.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  497.         if (shardedJedis == null) {
  498.             return result;
  499.         }
  500.         boolean broken = false;
  501.         try {
  502.             result = shardedJedis.hmget(key, fields);
  503.  
  504.         } catch (Exception e) {
  505.             log.error(e.getMessage(), e);
  506.             broken = true;
  507.         } finally {
  508.             redisDataSource.returnResource(shardedJedis, broken);
  509.         }
  510.         return result;
  511.     }
  512.  
  513.     public Long hincrBy(String key, String field, long value) {
  514.         Long result = null;
  515.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  516.         if (shardedJedis == null) {
  517.             return result;
  518.         }
  519.         boolean broken = false;
  520.         try {
  521.             result = shardedJedis.hincrBy(key, field, value);
  522.  
  523.         } catch (Exception e) {
  524.             log.error(e.getMessage(), e);
  525.             broken = true;
  526.         } finally {
  527.             redisDataSource.returnResource(shardedJedis, broken);
  528.         }
  529.         return result;
  530.     }
  531.  
  532.     public Boolean hexists(String key, String field) {
  533.         Boolean result = false;
  534.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  535.         if (shardedJedis == null) {
  536.             return result;
  537.         }
  538.         boolean broken = false;
  539.         try {
  540.             result = shardedJedis.hexists(key, field);
  541.  
  542.         } catch (Exception e) {
  543.             log.error(e.getMessage(), e);
  544.             broken = true;
  545.         } finally {
  546.             redisDataSource.returnResource(shardedJedis, broken);
  547.         }
  548.         return result;
  549.     }
  550.  
  551.     public Long del(String key) {
  552.         Long result = null;
  553.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  554.         if (shardedJedis == null) {
  555.             return result;
  556.         }
  557.         boolean broken = false;
  558.         try {
  559.             result = shardedJedis.del(key);
  560.  
  561.         } catch (Exception e) {
  562.             log.error(e.getMessage(), e);
  563.             broken = true;
  564.         } finally {
  565.             redisDataSource.returnResource(shardedJedis, broken);
  566.         }
  567.         return result;
  568.     }
  569.  
  570.     public Long hdel(String key, String field) {
  571.         Long result = null;
  572.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  573.         if (shardedJedis == null) {
  574.             return result;
  575.         }
  576.         boolean broken = false;
  577.         try {
  578.             result = shardedJedis.hdel(key, field);
  579.  
  580.         } catch (Exception e) {
  581.             log.error(e.getMessage(), e);
  582.             broken = true;
  583.         } finally {
  584.             redisDataSource.returnResource(shardedJedis, broken);
  585.         }
  586.         return result;
  587.     }
  588.  
  589.     public Long hlen(String key) {
  590.         Long result = null;
  591.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  592.         if (shardedJedis == null) {
  593.             return result;
  594.         }
  595.         boolean broken = false;
  596.         try {
  597.             result = shardedJedis.hlen(key);
  598.  
  599.         } catch (Exception e) {
  600.             log.error(e.getMessage(), e);
  601.             broken = true;
  602.         } finally {
  603.             redisDataSource.returnResource(shardedJedis, broken);
  604.         }
  605.         return result;
  606.     }
  607.  
  608.     public Set<String> hkeys(String key) {
  609.         Set<String> result = null;
  610.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  611.         if (shardedJedis == null) {
  612.             return result;
  613.         }
  614.         boolean broken = false;
  615.         try {
  616.             result = shardedJedis.hkeys(key);
  617.  
  618.         } catch (Exception e) {
  619.             log.error(e.getMessage(), e);
  620.             broken = true;
  621.         } finally {
  622.             redisDataSource.returnResource(shardedJedis, broken);
  623.         }
  624.         return result;
  625.     }
  626.  
  627.     public List<String> hvals(String key) {
  628.         List<String> result = null;
  629.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  630.         if (shardedJedis == null) {
  631.             return result;
  632.         }
  633.         boolean broken = false;
  634.         try {
  635.             result = shardedJedis.hvals(key);
  636.  
  637.         } catch (Exception e) {
  638.             log.error(e.getMessage(), e);
  639.             broken = true;
  640.         } finally {
  641.             redisDataSource.returnResource(shardedJedis, broken);
  642.         }
  643.         return result;
  644.     }
  645.  
  646.     public Map<String, String> hgetAll(String key) {
  647.         Map<String, String> result = null;
  648.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  649.         if (shardedJedis == null) {
  650.             return result;
  651.         }
  652.         boolean broken = false;
  653.         try {
  654.             result = shardedJedis.hgetAll(key);
  655.  
  656.         } catch (Exception e) {
  657.             log.error(e.getMessage(), e);
  658.             broken = true;
  659.         } finally {
  660.             redisDataSource.returnResource(shardedJedis, broken);
  661.         }
  662.         return result;
  663.     }
  664.  
  665.     // ================list ====== l表示 list或 left, r表示right====================
  666.     public Long rpush(String key, String string) {
  667.         Long result = null;
  668.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  669.         if (shardedJedis == null) {
  670.             return result;
  671.         }
  672.         boolean broken = false;
  673.         try {
  674.             result = shardedJedis.rpush(key, string);
  675.  
  676.         } catch (Exception e) {
  677.             log.error(e.getMessage(), e);
  678.             broken = true;
  679.         } finally {
  680.             redisDataSource.returnResource(shardedJedis, broken);
  681.         }
  682.         return result;
  683.     }
  684.  
  685.     public Long lpush(String key, String string) {
  686.         Long result = null;
  687.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  688.         if (shardedJedis == null) {
  689.             return result;
  690.         }
  691.         boolean broken = false;
  692.         try {
  693.             result = shardedJedis.lpush(key, string);
  694.  
  695.         } catch (Exception e) {
  696.             log.error(e.getMessage(), e);
  697.             broken = true;
  698.         } finally {
  699.             redisDataSource.returnResource(shardedJedis, broken);
  700.         }
  701.         return result;
  702.     }
  703.  
  704.     public Long llen(String key) {
  705.         Long result = null;
  706.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  707.         if (shardedJedis == null) {
  708.             return result;
  709.         }
  710.         boolean broken = false;
  711.         try {
  712.             result = shardedJedis.llen(key);
  713.  
  714.         } catch (Exception e) {
  715.             log.error(e.getMessage(), e);
  716.             broken = true;
  717.         } finally {
  718.             redisDataSource.returnResource(shardedJedis, broken);
  719.         }
  720.         return result;
  721.     }
  722.  
  723.     public List<String> lrange(String key, long start, long end) {
  724.         List<String> result = null;
  725.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  726.         if (shardedJedis == null) {
  727.             return result;
  728.         }
  729.         boolean broken = false;
  730.         try {
  731.             result = shardedJedis.lrange(key, start, end);
  732.  
  733.         } catch (Exception e) {
  734.             log.error(e.getMessage(), e);
  735.             broken = true;
  736.         } finally {
  737.             redisDataSource.returnResource(shardedJedis, broken);
  738.         }
  739.         return result;
  740.     }
  741.  
  742.     public String ltrim(String key, long start, long end) {
  743.         String result = null;
  744.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  745.         if (shardedJedis == null) {
  746.             return result;
  747.         }
  748.         boolean broken = false;
  749.         try {
  750.             result = shardedJedis.ltrim(key, start, end);
  751.  
  752.         } catch (Exception e) {
  753.             log.error(e.getMessage(), e);
  754.             broken = true;
  755.         } finally {
  756.             redisDataSource.returnResource(shardedJedis, broken);
  757.         }
  758.         return result;
  759.     }
  760.  
  761.     public String lindex(String key, long index) {
  762.         String result = null;
  763.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  764.         if (shardedJedis == null) {
  765.             return result;
  766.         }
  767.         boolean broken = false;
  768.         try {
  769.             result = shardedJedis.lindex(key, index);
  770.  
  771.         } catch (Exception e) {
  772.             log.error(e.getMessage(), e);
  773.             broken = true;
  774.         } finally {
  775.             redisDataSource.returnResource(shardedJedis, broken);
  776.         }
  777.         return result;
  778.     }
  779.  
  780.     public String lset(String key, long index, String value) {
  781.         String result = null;
  782.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  783.         if (shardedJedis == null) {
  784.             return result;
  785.         }
  786.         boolean broken = false;
  787.         try {
  788.             result = shardedJedis.lset(key, index, value);
  789.  
  790.         } catch (Exception e) {
  791.             log.error(e.getMessage(), e);
  792.             broken = true;
  793.         } finally {
  794.             redisDataSource.returnResource(shardedJedis, broken);
  795.         }
  796.         return result;
  797.     }
  798.  
  799.     public Long lrem(String key, long count, String value) {
  800.         Long result = null;
  801.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  802.         if (shardedJedis == null) {
  803.             return result;
  804.         }
  805.         boolean broken = false;
  806.         try {
  807.             result = shardedJedis.lrem(key, count, value);
  808.  
  809.         } catch (Exception e) {
  810.             log.error(e.getMessage(), e);
  811.             broken = true;
  812.         } finally {
  813.             redisDataSource.returnResource(shardedJedis, broken);
  814.         }
  815.         return result;
  816.     }
  817.  
  818.     public String lpop(String key) {
  819.         String result = null;
  820.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  821.         if (shardedJedis == null) {
  822.             return result;
  823.         }
  824.         boolean broken = false;
  825.         try {
  826.             result = shardedJedis.lpop(key);
  827.  
  828.         } catch (Exception e) {
  829.             log.error(e.getMessage(), e);
  830.             broken = true;
  831.         } finally {
  832.             redisDataSource.returnResource(shardedJedis, broken);
  833.         }
  834.         return result;
  835.     }
  836.  
  837.     public String rpop(String key) {
  838.         String result = null;
  839.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  840.         if (shardedJedis == null) {
  841.             return result;
  842.         }
  843.         boolean broken = false;
  844.         try {
  845.             result = shardedJedis.rpop(key);
  846.  
  847.         } catch (Exception e) {
  848.             log.error(e.getMessage(), e);
  849.             broken = true;
  850.         } finally {
  851.             redisDataSource.returnResource(shardedJedis, broken);
  852.         }
  853.         return result;
  854.     }
  855.  
  856.     //return 1 add a not exist value ,
  857.     //return 0 add a exist value
  858.     public Long sadd(String key, String member) {
  859.         Long result = null;
  860.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  861.         if (shardedJedis == null) {
  862.             return result;
  863.         }
  864.         boolean broken = false;
  865.         try {
  866.             result = shardedJedis.sadd(key, member);
  867.  
  868.         } catch (Exception e) {
  869.             log.error(e.getMessage(), e);
  870.             broken = true;
  871.         } finally {
  872.             redisDataSource.returnResource(shardedJedis, broken);
  873.         }
  874.         return result;
  875.     }
  876.  
  877.     public Set<String> smembers(String key) {
  878.         Set<String> result = null;
  879.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  880.         if (shardedJedis == null) {
  881.             return result;
  882.         }
  883.         boolean broken = false;
  884.         try {
  885.             result = shardedJedis.smembers(key);
  886.  
  887.         } catch (Exception e) {
  888.             log.error(e.getMessage(), e);
  889.             broken = true;
  890.         } finally {
  891.             redisDataSource.returnResource(shardedJedis, broken);
  892.         }
  893.         return result;
  894.     }
  895.  
  896.     public Long srem(String key, String member) {
  897.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  898.  
  899.         Long result = null;
  900.         if (shardedJedis == null) {
  901.             return result;
  902.         }
  903.         boolean broken = false;
  904.         try {
  905.             result = shardedJedis.srem(key, member);
  906.         } catch (Exception e) {
  907.             log.error(e.getMessage(), e);
  908.             broken = true;
  909.         } finally {
  910.             redisDataSource.returnResource(shardedJedis, broken);
  911.         }
  912.         return result;
  913.     }
  914.  
  915.     public String spop(String key) {
  916.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  917.         String result = null;
  918.         if (shardedJedis == null) {
  919.             return result;
  920.         }
  921.         boolean broken = false;
  922.         try {
  923.             result = shardedJedis.spop(key);
  924.         } catch (Exception e) {
  925.             log.error(e.getMessage(), e);
  926.             broken = true;
  927.         } finally {
  928.             redisDataSource.returnResource(shardedJedis, broken);
  929.         }
  930.         return result;
  931.     }
  932.  
  933.     public Long scard(String key) {
  934.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  935.         Long result = null;
  936.         if (shardedJedis == null) {
  937.             return result;
  938.         }
  939.         boolean broken = false;
  940.         try {
  941.             result = shardedJedis.scard(key);
  942.  
  943.         } catch (Exception e) {
  944.             log.error(e.getMessage(), e);
  945.             broken = true;
  946.         } finally {
  947.             redisDataSource.returnResource(shardedJedis, broken);
  948.         }
  949.         return result;
  950.     }
  951.  
  952.     public Boolean sismember(String key, String member) {
  953.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  954.         Boolean result = null;
  955.         if (shardedJedis == null) {
  956.             return result;
  957.         }
  958.         boolean broken = false;
  959.         try {
  960.             result = shardedJedis.sismember(key, member);
  961.         } catch (Exception e) {
  962.             log.error(e.getMessage(), e);
  963.             broken = true;
  964.         } finally {
  965.             redisDataSource.returnResource(shardedJedis, broken);
  966.         }
  967.         return result;
  968.     }
  969.  
  970.     public String srandmember(String key) {
  971.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  972.         String result = null;
  973.         if (shardedJedis == null) {
  974.             return result;
  975.         }
  976.         boolean broken = false;
  977.         try {
  978.             result = shardedJedis.srandmember(key);
  979.         } catch (Exception e) {
  980.             log.error(e.getMessage(), e);
  981.             broken = true;
  982.         } finally {
  983.             redisDataSource.returnResource(shardedJedis, broken);
  984.         }
  985.         return result;
  986.     }
  987.  
  988.     public Long zadd(String key, double score, String member) {
  989.         Long result = null;
  990.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  991.         if (shardedJedis == null) {
  992.             return result;
  993.         }
  994.         boolean broken = false;
  995.         try {
  996.             result = shardedJedis.zadd(key, score, member);
  997.         } catch (Exception e) {
  998.             log.error(e.getMessage(), e);
  999.             broken = true;
  1000.         } finally {
  1001.             redisDataSource.returnResource(shardedJedis, broken);
  1002.         }
  1003.         return result;
  1004.     }
  1005.  
  1006.     public Set<String> zrange(String key, int start, int end) {
  1007.         Set<String> result = null;
  1008.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1009.         if (shardedJedis == null) {
  1010.             return result;
  1011.         }
  1012.         boolean broken = false;
  1013.         try {
  1014.             result = shardedJedis.zrange(key, start, end);
  1015.         } catch (Exception e) {
  1016.             log.error(e.getMessage(), e);
  1017.             broken = true;
  1018.         } finally {
  1019.             redisDataSource.returnResource(shardedJedis, broken);
  1020.         }
  1021.         return result;
  1022.     }
  1023.  
  1024.     public Long zrem(String key, String member) {
  1025.         Long result = null;
  1026.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1027.         if (shardedJedis == null) {
  1028.             return result;
  1029.         }
  1030.         boolean broken = false;
  1031.         try {
  1032.             result = shardedJedis.zrem(key, member);
  1033.         } catch (Exception e) {
  1034.             log.error(e.getMessage(), e);
  1035.             broken = true;
  1036.         } finally {
  1037.             redisDataSource.returnResource(shardedJedis, broken);
  1038.         }
  1039.         return result;
  1040.     }
  1041.  
  1042.     public Double zincrby(String key, double score, String member) {
  1043.         Double result = null;
  1044.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1045.         if (shardedJedis == null) {
  1046.             return result;
  1047.         }
  1048.         boolean broken = false;
  1049.         try {
  1050.  
  1051.             result = shardedJedis.zincrby(key, score, member);
  1052.  
  1053.         } catch (Exception e) {
  1054.             log.error(e.getMessage(), e);
  1055.             broken = true;
  1056.         } finally {
  1057.             redisDataSource.returnResource(shardedJedis, broken);
  1058.         }
  1059.         return result;
  1060.     }
  1061.  
  1062.     public Long zrank(String key, String member) {
  1063.         Long result = null;
  1064.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1065.         if (shardedJedis == null) {
  1066.             return result;
  1067.         }
  1068.         boolean broken = false;
  1069.         try {
  1070.  
  1071.             result = shardedJedis.zrank(key, member);
  1072.  
  1073.         } catch (Exception e) {
  1074.             log.error(e.getMessage(), e);
  1075.             broken = true;
  1076.         } finally {
  1077.             redisDataSource.returnResource(shardedJedis, broken);
  1078.         }
  1079.         return result;
  1080.     }
  1081.  
  1082.     public Long zrevrank(String key, String member) {
  1083.         Long result = null;
  1084.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1085.         if (shardedJedis == null) {
  1086.             return result;
  1087.         }
  1088.         boolean broken = false;
  1089.         try {
  1090.  
  1091.             result = shardedJedis.zrevrank(key, member);
  1092.  
  1093.         } catch (Exception e) {
  1094.             log.error(e.getMessage(), e);
  1095.             broken = true;
  1096.         } finally {
  1097.             redisDataSource.returnResource(shardedJedis, broken);
  1098.         }
  1099.         return result;
  1100.     }
  1101.  
  1102.     public Set<String> zrevrange(String key, int start, int end) {
  1103.         Set<String> result = null;
  1104.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1105.         if (shardedJedis == null) {
  1106.             return result;
  1107.         }
  1108.         boolean broken = false;
  1109.         try {
  1110.  
  1111.             result = shardedJedis.zrevrange(key, start, end);
  1112.  
  1113.         } catch (Exception e) {
  1114.             log.error(e.getMessage(), e);
  1115.             broken = true;
  1116.         } finally {
  1117.             redisDataSource.returnResource(shardedJedis, broken);
  1118.         }
  1119.         return result;
  1120.     }
  1121.  
  1122.     public Set<Tuple> zrangeWithScores(String key, int start, int end) {
  1123.         Set<Tuple> result = null;
  1124.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1125.         if (shardedJedis == null) {
  1126.             return result;
  1127.         }
  1128.         boolean broken = false;
  1129.         try {
  1130.  
  1131.             result = shardedJedis.zrangeWithScores(key, start, end);
  1132.  
  1133.         } catch (Exception e) {
  1134.             log.error(e.getMessage(), e);
  1135.             broken = true;
  1136.         } finally {
  1137.             redisDataSource.returnResource(shardedJedis, broken);
  1138.         }
  1139.         return result;
  1140.     }
  1141.  
  1142.     public Set<Tuple> zrevrangeWithScores(String key, int start, int end) {
  1143.         Set<Tuple> result = null;
  1144.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1145.         if (shardedJedis == null) {
  1146.             return result;
  1147.         }
  1148.         boolean broken = false;
  1149.         try {
  1150.  
  1151.             result = shardedJedis.zrevrangeWithScores(key, start, end);
  1152.  
  1153.         } catch (Exception e) {
  1154.             log.error(e.getMessage(), e);
  1155.             broken = true;
  1156.         } finally {
  1157.             redisDataSource.returnResource(shardedJedis, broken);
  1158.         }
  1159.         return result;
  1160.     }
  1161.  
  1162.     public Long zcard(String key) {
  1163.         Long result = null;
  1164.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1165.         if (shardedJedis == null) {
  1166.             return result;
  1167.         }
  1168.         boolean broken = false;
  1169.         try {
  1170.  
  1171.             result = shardedJedis.zcard(key);
  1172.  
  1173.         } catch (Exception e) {
  1174.             log.error(e.getMessage(), e);
  1175.             broken = true;
  1176.         } finally {
  1177.             redisDataSource.returnResource(shardedJedis, broken);
  1178.         }
  1179.         return result;
  1180.     }
  1181.  
  1182.     public Double zscore(String key, String member) {
  1183.         Double result = null;
  1184.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1185.         if (shardedJedis == null) {
  1186.             return result;
  1187.         }
  1188.         boolean broken = false;
  1189.         try {
  1190.  
  1191.             result = shardedJedis.zscore(key, member);
  1192.  
  1193.         } catch (Exception e) {
  1194.             log.error(e.getMessage(), e);
  1195.             broken = true;
  1196.         } finally {
  1197.             redisDataSource.returnResource(shardedJedis, broken);
  1198.         }
  1199.         return result;
  1200.     }
  1201.  
  1202.     public List<String> sort(String key) {
  1203.         List<String> result = null;
  1204.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1205.         if (shardedJedis == null) {
  1206.             return result;
  1207.         }
  1208.         boolean broken = false;
  1209.         try {
  1210.  
  1211.             result = shardedJedis.sort(key);
  1212.  
  1213.         } catch (Exception e) {
  1214.             log.error(e.getMessage(), e);
  1215.             broken = true;
  1216.         } finally {
  1217.             redisDataSource.returnResource(shardedJedis, broken);
  1218.         }
  1219.         return result;
  1220.     }
  1221.  
  1222.     public List<String> sort(String key, SortingParams sortingParameters) {
  1223.         List<String> result = null;
  1224.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1225.         if (shardedJedis == null) {
  1226.             return result;
  1227.         }
  1228.         boolean broken = false;
  1229.         try {
  1230.  
  1231.             result = shardedJedis.sort(key, sortingParameters);
  1232.  
  1233.         } catch (Exception e) {
  1234.             log.error(e.getMessage(), e);
  1235.             broken = true;
  1236.         } finally {
  1237.             redisDataSource.returnResource(shardedJedis, broken);
  1238.         }
  1239.         return result;
  1240.     }
  1241.  
  1242.     public Long zcount(String key, double min, double max) {
  1243.         Long result = null;
  1244.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1245.         if (shardedJedis == null) {
  1246.             return result;
  1247.         }
  1248.         boolean broken = false;
  1249.         try {
  1250.  
  1251.             result = shardedJedis.zcount(key, min, max);
  1252.  
  1253.         } catch (Exception e) {
  1254.             log.error(e.getMessage(), e);
  1255.             broken = true;
  1256.         } finally {
  1257.             redisDataSource.returnResource(shardedJedis, broken);
  1258.         }
  1259.         return result;
  1260.     }
  1261.  
  1262.     public Set<String> zrangeByScore(String key, double min, double max) {
  1263.         Set<String> result = null;
  1264.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1265.         if (shardedJedis == null) {
  1266.             return result;
  1267.         }
  1268.         boolean broken = false;
  1269.         try {
  1270.  
  1271.             result = shardedJedis.zrangeByScore(key, min, max);
  1272.  
  1273.         } catch (Exception e) {
  1274.             log.error(e.getMessage(), e);
  1275.             broken = true;
  1276.         } finally {
  1277.             redisDataSource.returnResource(shardedJedis, broken);
  1278.         }
  1279.         return result;
  1280.     }
  1281.  
  1282.     public Set<String> zrevrangeByScore(String key, double max, double min) {
  1283.         Set<String> result = null;
  1284.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1285.         if (shardedJedis == null) {
  1286.             return result;
  1287.         }
  1288.         boolean broken = false;
  1289.         try {
  1290.  
  1291.             result = shardedJedis.zrevrangeByScore(key, max, min);
  1292.  
  1293.         } catch (Exception e) {
  1294.             log.error(e.getMessage(), e);
  1295.             broken = true;
  1296.         } finally {
  1297.             redisDataSource.returnResource(shardedJedis, broken);
  1298.         }
  1299.         return result;
  1300.     }
  1301.  
  1302.     public Set<String> zrangeByScore(String key, double min, double max, int offset, int count) {
  1303.         Set<String> result = null;
  1304.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1305.         if (shardedJedis == null) {
  1306.             return result;
  1307.         }
  1308.         boolean broken = false;
  1309.         try {
  1310.  
  1311.             result = shardedJedis.zrangeByScore(key, min, max, offset, count);
  1312.  
  1313.         } catch (Exception e) {
  1314.             log.error(e.getMessage(), e);
  1315.             broken = true;
  1316.         } finally {
  1317.             redisDataSource.returnResource(shardedJedis, broken);
  1318.         }
  1319.         return result;
  1320.     }
  1321.  
  1322.     public Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count) {
  1323.         Set<String> result = null;
  1324.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1325.         if (shardedJedis == null) {
  1326.             return result;
  1327.         }
  1328.         boolean broken = false;
  1329.         try {
  1330.  
  1331.             result = shardedJedis.zrevrangeByScore(key, max, min, offset, count);
  1332.  
  1333.         } catch (Exception e) {
  1334.             log.error(e.getMessage(), e);
  1335.             broken = true;
  1336.         } finally {
  1337.             redisDataSource.returnResource(shardedJedis, broken);
  1338.         }
  1339.         return result;
  1340.     }
  1341.  
  1342.     public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
  1343.         Set<Tuple> result = null;
  1344.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1345.         if (shardedJedis == null) {
  1346.             return result;
  1347.         }
  1348.         boolean broken = false;
  1349.         try {
  1350.  
  1351.             result = shardedJedis.zrangeByScoreWithScores(key, min, max);
  1352.  
  1353.         } catch (Exception e) {
  1354.             log.error(e.getMessage(), e);
  1355.             broken = true;
  1356.         } finally {
  1357.             redisDataSource.returnResource(shardedJedis, broken);
  1358.         }
  1359.         return result;
  1360.     }
  1361.  
  1362.     public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min) {
  1363.         Set<Tuple> result = null;
  1364.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1365.         if (shardedJedis == null) {
  1366.             return result;
  1367.         }
  1368.         boolean broken = false;
  1369.         try {
  1370.  
  1371.             result = shardedJedis.zrevrangeByScoreWithScores(key, max, min);
  1372.  
  1373.         } catch (Exception e) {
  1374.             log.error(e.getMessage(), e);
  1375.             broken = true;
  1376.         } finally {
  1377.             redisDataSource.returnResource(shardedJedis, broken);
  1378.         }
  1379.         return result;
  1380.     }
  1381.  
  1382.     public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count) {
  1383.         Set<Tuple> result = null;
  1384.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1385.         if (shardedJedis == null) {
  1386.             return result;
  1387.         }
  1388.         boolean broken = false;
  1389.         try {
  1390.  
  1391.             result = shardedJedis.zrangeByScoreWithScores(key, min, max, offset, count);
  1392.  
  1393.         } catch (Exception e) {
  1394.             log.error(e.getMessage(), e);
  1395.             broken = true;
  1396.         } finally {
  1397.             redisDataSource.returnResource(shardedJedis, broken);
  1398.         }
  1399.         return result;
  1400.     }
  1401.  
  1402.     public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count) {
  1403.         Set<Tuple> result = null;
  1404.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1405.         if (shardedJedis == null) {
  1406.             return result;
  1407.         }
  1408.         boolean broken = false;
  1409.         try {
  1410.  
  1411.             result = shardedJedis.zrevrangeByScoreWithScores(key, max, min, offset, count);
  1412.  
  1413.         } catch (Exception e) {
  1414.             log.error(e.getMessage(), e);
  1415.             broken = true;
  1416.         } finally {
  1417.             redisDataSource.returnResource(shardedJedis, broken);
  1418.         }
  1419.         return result;
  1420.     }
  1421.  
  1422.     public Long zremrangeByRank(String key, int start, int end) {
  1423.         Long result = null;
  1424.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1425.         if (shardedJedis == null) {
  1426.             return result;
  1427.         }
  1428.         boolean broken = false;
  1429.         try {
  1430.  
  1431.             result = shardedJedis.zremrangeByRank(key, start, end);
  1432.  
  1433.         } catch (Exception e) {
  1434.             log.error(e.getMessage(), e);
  1435.             broken = true;
  1436.         } finally {
  1437.             redisDataSource.returnResource(shardedJedis, broken);
  1438.         }
  1439.         return result;
  1440.     }
  1441.  
  1442.     public Long zremrangeByScore(String key, double start, double end) {
  1443.         Long result = null;
  1444.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1445.         if (shardedJedis == null) {
  1446.             return result;
  1447.         }
  1448.         boolean broken = false;
  1449.         try {
  1450.  
  1451.             result = shardedJedis.zremrangeByScore(key, start, end);
  1452.  
  1453.         } catch (Exception e) {
  1454.             log.error(e.getMessage(), e);
  1455.             broken = true;
  1456.         } finally {
  1457.             redisDataSource.returnResource(shardedJedis, broken);
  1458.         }
  1459.         return result;
  1460.     }
  1461.  
  1462.     public Long linsert(String key, LIST_POSITION where, String pivot, String value) {
  1463.         Long result = null;
  1464.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1465.         if (shardedJedis == null) {
  1466.             return result;
  1467.         }
  1468.         boolean broken = false;
  1469.         try {
  1470.  
  1471.             result = shardedJedis.linsert(key, where, pivot, value);
  1472.  
  1473.         } catch (Exception e) {
  1474.             log.error(e.getMessage(), e);
  1475.             broken = true;
  1476.         } finally {
  1477.             redisDataSource.returnResource(shardedJedis, broken);
  1478.         }
  1479.         return result;
  1480.     }
  1481.  
  1482.     public String set(byte[] key, byte[] value) {
  1483.         String result = null;
  1484.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1485.         if (shardedJedis == null) {
  1486.             return result;
  1487.         }
  1488.         boolean broken = false;
  1489.         try {
  1490.  
  1491.             result = shardedJedis.set(key, value);
  1492.  
  1493.         } catch (Exception e) {
  1494.             log.error(e.getMessage(), e);
  1495.             broken = true;
  1496.         } finally {
  1497.             redisDataSource.returnResource(shardedJedis, broken);
  1498.         }
  1499.         return result;
  1500.     }
  1501.  
  1502.     public byte[] get(byte[] key) {
  1503.         byte[] result = null;
  1504.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1505.         if (shardedJedis == null) {
  1506.             return result;
  1507.         }
  1508.         boolean broken = false;
  1509.         try {
  1510.  
  1511.             result = shardedJedis.get(key);
  1512.  
  1513.         } catch (Exception e) {
  1514.             log.error(e.getMessage(), e);
  1515.             broken = true;
  1516.         } finally {
  1517.             redisDataSource.returnResource(shardedJedis, broken);
  1518.         }
  1519.         return result;
  1520.     }
  1521.  
  1522.     public Boolean exists(byte[] key) {
  1523.         Boolean result = false;
  1524.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1525.         if (shardedJedis == null) {
  1526.             return result;
  1527.         }
  1528.         boolean broken = false;
  1529.         try {
  1530.  
  1531.             result = shardedJedis.exists(key);
  1532.  
  1533.         } catch (Exception e) {
  1534.             log.error(e.getMessage(), e);
  1535.             broken = true;
  1536.         } finally {
  1537.             redisDataSource.returnResource(shardedJedis, broken);
  1538.         }
  1539.         return result;
  1540.     }
  1541.  
  1542.     public String type(byte[] key) {
  1543.         String result = null;
  1544.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1545.         if (shardedJedis == null) {
  1546.             return result;
  1547.         }
  1548.         boolean broken = false;
  1549.         try {
  1550.  
  1551.             result = shardedJedis.type(key);
  1552.  
  1553.         } catch (Exception e) {
  1554.             log.error(e.getMessage(), e);
  1555.             broken = true;
  1556.         } finally {
  1557.             redisDataSource.returnResource(shardedJedis, broken);
  1558.         }
  1559.         return result;
  1560.     }
  1561.  
  1562.     public Long expire(byte[] key, int seconds) {
  1563.         Long result = null;
  1564.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1565.         if (shardedJedis == null) {
  1566.             return result;
  1567.         }
  1568.         boolean broken = false;
  1569.         try {
  1570.  
  1571.             result = shardedJedis.expire(key, seconds);
  1572.  
  1573.         } catch (Exception e) {
  1574.             log.error(e.getMessage(), e);
  1575.             broken = true;
  1576.         } finally {
  1577.             redisDataSource.returnResource(shardedJedis, broken);
  1578.         }
  1579.         return result;
  1580.     }
  1581.  
  1582.     public Long expireAt(byte[] key, long unixTime) {
  1583.         Long result = null;
  1584.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1585.         if (shardedJedis == null) {
  1586.             return result;
  1587.         }
  1588.         boolean broken = false;
  1589.         try {
  1590.  
  1591.             result = shardedJedis.expireAt(key, unixTime);
  1592.  
  1593.         } catch (Exception e) {
  1594.             log.error(e.getMessage(), e);
  1595.             broken = true;
  1596.         } finally {
  1597.             redisDataSource.returnResource(shardedJedis, broken);
  1598.         }
  1599.         return result;
  1600.     }
  1601.  
  1602.     public Long ttl(byte[] key) {
  1603.         Long result = null;
  1604.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1605.         if (shardedJedis == null) {
  1606.             return result;
  1607.         }
  1608.         boolean broken = false;
  1609.         try {
  1610.  
  1611.             result = shardedJedis.ttl(key);
  1612.  
  1613.         } catch (Exception e) {
  1614.             log.error(e.getMessage(), e);
  1615.             broken = true;
  1616.         } finally {
  1617.             redisDataSource.returnResource(shardedJedis, broken);
  1618.         }
  1619.         return result;
  1620.     }
  1621.  
  1622.     public byte[] getSet(byte[] key, byte[] value) {
  1623.         byte[] result = null;
  1624.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1625.         if (shardedJedis == null) {
  1626.             return result;
  1627.         }
  1628.         boolean broken = false;
  1629.         try {
  1630.  
  1631.             result = shardedJedis.getSet(key, value);
  1632.  
  1633.         } catch (Exception e) {
  1634.             log.error(e.getMessage(), e);
  1635.             broken = true;
  1636.         } finally {
  1637.             redisDataSource.returnResource(shardedJedis, broken);
  1638.         }
  1639.         return result;
  1640.     }
  1641.  
  1642.     public Long setnx(byte[] key, byte[] value) {
  1643.         Long result = null;
  1644.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1645.         if (shardedJedis == null) {
  1646.             return result;
  1647.         }
  1648.         boolean broken = false;
  1649.         try {
  1650.  
  1651.             result = shardedJedis.setnx(key, value);
  1652.  
  1653.         } catch (Exception e) {
  1654.             log.error(e.getMessage(), e);
  1655.             broken = true;
  1656.         } finally {
  1657.             redisDataSource.returnResource(shardedJedis, broken);
  1658.         }
  1659.         return result;
  1660.     }
  1661.  
  1662.     public String setex(byte[] key, int seconds, byte[] value) {
  1663.         String result = null;
  1664.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1665.         if (shardedJedis == null) {
  1666.             return result;
  1667.         }
  1668.         boolean broken = false;
  1669.         try {
  1670.  
  1671.             result = shardedJedis.setex(key, seconds, value);
  1672.  
  1673.         } catch (Exception e) {
  1674.             log.error(e.getMessage(), e);
  1675.             broken = true;
  1676.         } finally {
  1677.             redisDataSource.returnResource(shardedJedis, broken);
  1678.         }
  1679.         return result;
  1680.     }
  1681.  
  1682.     public Long decrBy(byte[] key, long integer) {
  1683.         Long result = null;
  1684.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1685.         if (shardedJedis == null) {
  1686.             return result;
  1687.         }
  1688.         boolean broken = false;
  1689.         try {
  1690.  
  1691.             result = shardedJedis.decrBy(key, integer);
  1692.  
  1693.         } catch (Exception e) {
  1694.             log.error(e.getMessage(), e);
  1695.             broken = true;
  1696.         } finally {
  1697.             redisDataSource.returnResource(shardedJedis, broken);
  1698.         }
  1699.         return result;
  1700.     }
  1701.  
  1702.     public Long decr(byte[] key) {
  1703.         Long result = null;
  1704.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1705.         if (shardedJedis == null) {
  1706.             return result;
  1707.         }
  1708.         boolean broken = false;
  1709.         try {
  1710.  
  1711.             result = shardedJedis.decr(key);
  1712.  
  1713.         } catch (Exception e) {
  1714.             log.error(e.getMessage(), e);
  1715.             broken = true;
  1716.         } finally {
  1717.             redisDataSource.returnResource(shardedJedis, broken);
  1718.         }
  1719.         return result;
  1720.     }
  1721.  
  1722.     public Long incrBy(byte[] key, long integer) {
  1723.         Long result = null;
  1724.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1725.         if (shardedJedis == null) {
  1726.             return result;
  1727.         }
  1728.         boolean broken = false;
  1729.         try {
  1730.  
  1731.             result = shardedJedis.incrBy(key, integer);
  1732.  
  1733.         } catch (Exception e) {
  1734.             log.error(e.getMessage(), e);
  1735.             broken = true;
  1736.         } finally {
  1737.             redisDataSource.returnResource(shardedJedis, broken);
  1738.         }
  1739.         return result;
  1740.     }
  1741.  
  1742.     public Long incr(byte[] key) {
  1743.         Long result = null;
  1744.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1745.         if (shardedJedis == null) {
  1746.             return result;
  1747.         }
  1748.         boolean broken = false;
  1749.         try {
  1750.  
  1751.             result = shardedJedis.incr(key);
  1752.  
  1753.         } catch (Exception e) {
  1754.             log.error(e.getMessage(), e);
  1755.             broken = true;
  1756.         } finally {
  1757.             redisDataSource.returnResource(shardedJedis, broken);
  1758.         }
  1759.         return result;
  1760.     }
  1761.  
  1762.     public Long append(byte[] key, byte[] value) {
  1763.         Long result = null;
  1764.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1765.         if (shardedJedis == null) {
  1766.             return result;
  1767.         }
  1768.         boolean broken = false;
  1769.         try {
  1770.  
  1771.             result = shardedJedis.append(key, value);
  1772.  
  1773.         } catch (Exception e) {
  1774.             log.error(e.getMessage(), e);
  1775.             broken = true;
  1776.         } finally {
  1777.             redisDataSource.returnResource(shardedJedis, broken);
  1778.         }
  1779.         return result;
  1780.     }
  1781.  
  1782.     public byte[] substr(byte[] key, int start, int end) {
  1783.         byte[] result = null;
  1784.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1785.         if (shardedJedis == null) {
  1786.             return result;
  1787.         }
  1788.         boolean broken = false;
  1789.         try {
  1790.  
  1791.             result = shardedJedis.substr(key, start, end);
  1792.  
  1793.         } catch (Exception e) {
  1794.             log.error(e.getMessage(), e);
  1795.             broken = true;
  1796.         } finally {
  1797.             redisDataSource.returnResource(shardedJedis, broken);
  1798.         }
  1799.         return result;
  1800.     }
  1801.  
  1802.     public Long hset(byte[] key, byte[] field, byte[] value) {
  1803.         Long result = null;
  1804.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1805.         if (shardedJedis == null) {
  1806.             return result;
  1807.         }
  1808.         boolean broken = false;
  1809.         try {
  1810.  
  1811.             result = shardedJedis.hset(key, field, value);
  1812.  
  1813.         } catch (Exception e) {
  1814.             log.error(e.getMessage(), e);
  1815.             broken = true;
  1816.         } finally {
  1817.             redisDataSource.returnResource(shardedJedis, broken);
  1818.         }
  1819.         return result;
  1820.     }
  1821.  
  1822.     public byte[] hget(byte[] key, byte[] field) {
  1823.         byte[] result = null;
  1824.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1825.         if (shardedJedis == null) {
  1826.             return result;
  1827.         }
  1828.         boolean broken = false;
  1829.         try {
  1830.  
  1831.             result = shardedJedis.hget(key, field);
  1832.  
  1833.         } catch (Exception e) {
  1834.             log.error(e.getMessage(), e);
  1835.             broken = true;
  1836.         } finally {
  1837.             redisDataSource.returnResource(shardedJedis, broken);
  1838.         }
  1839.         return result;
  1840.     }
  1841.  
  1842.     public Long hsetnx(byte[] key, byte[] field, byte[] value) {
  1843.         Long result = null;
  1844.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1845.         if (shardedJedis == null) {
  1846.             return result;
  1847.         }
  1848.         boolean broken = false;
  1849.         try {
  1850.  
  1851.             result = shardedJedis.hsetnx(key, field, value);
  1852.  
  1853.         } catch (Exception e) {
  1854.  
  1855.             log.error(e.getMessage(), e);
  1856.             broken = true;
  1857.         } finally {
  1858.             redisDataSource.returnResource(shardedJedis, broken);
  1859.         }
  1860.         return result;
  1861.     }
  1862.  
  1863.     public String hmset(byte[] key, Map<byte[], byte[]> hash) {
  1864.         String result = null;
  1865.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1866.         if (shardedJedis == null) {
  1867.             return result;
  1868.         }
  1869.         boolean broken = false;
  1870.         try {
  1871.  
  1872.             result = shardedJedis.hmset(key, hash);
  1873.  
  1874.         } catch (Exception e) {
  1875.  
  1876.             log.error(e.getMessage(), e);
  1877.             broken = true;
  1878.         } finally {
  1879.             redisDataSource.returnResource(shardedJedis, broken);
  1880.         }
  1881.         return result;
  1882.     }
  1883.  
  1884.     public List<byte[]> hmget(byte[] key, byte[]... fields) {
  1885.         List<byte[]> result = null;
  1886.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1887.         if (shardedJedis == null) {
  1888.             return result;
  1889.         }
  1890.         boolean broken = false;
  1891.         try {
  1892.  
  1893.             result = shardedJedis.hmget(key, fields);
  1894.  
  1895.         } catch (Exception e) {
  1896.  
  1897.             log.error(e.getMessage(), e);
  1898.             broken = true;
  1899.         } finally {
  1900.             redisDataSource.returnResource(shardedJedis, broken);
  1901.         }
  1902.         return result;
  1903.     }
  1904.  
  1905.     public Long hincrBy(byte[] key, byte[] field, long value) {
  1906.         Long result = null;
  1907.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1908.         if (shardedJedis == null) {
  1909.             return result;
  1910.         }
  1911.         boolean broken = false;
  1912.         try {
  1913.  
  1914.             result = shardedJedis.hincrBy(key, field, value);
  1915.  
  1916.         } catch (Exception e) {
  1917.  
  1918.             log.error(e.getMessage(), e);
  1919.             broken = true;
  1920.         } finally {
  1921.             redisDataSource.returnResource(shardedJedis, broken);
  1922.         }
  1923.         return result;
  1924.     }
  1925.  
  1926.     public Boolean hexists(byte[] key, byte[] field) {
  1927.         Boolean result = false;
  1928.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1929.         if (shardedJedis == null) {
  1930.             return result;
  1931.         }
  1932.         boolean broken = false;
  1933.         try {
  1934.  
  1935.             result = shardedJedis.hexists(key, field);
  1936.  
  1937.         } catch (Exception e) {
  1938.  
  1939.             log.error(e.getMessage(), e);
  1940.             broken = true;
  1941.         } finally {
  1942.             redisDataSource.returnResource(shardedJedis, broken);
  1943.         }
  1944.         return result;
  1945.     }
  1946.  
  1947.     public Long hdel(byte[] key, byte[] field) {
  1948.         Long result = null;
  1949.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1950.         if (shardedJedis == null) {
  1951.             return result;
  1952.         }
  1953.         boolean broken = false;
  1954.         try {
  1955.  
  1956.             result = shardedJedis.hdel(key, field);
  1957.  
  1958.         } catch (Exception e) {
  1959.  
  1960.             log.error(e.getMessage(), e);
  1961.             broken = true;
  1962.         } finally {
  1963.             redisDataSource.returnResource(shardedJedis, broken);
  1964.         }
  1965.         return result;
  1966.     }
  1967.  
  1968.     public Long hlen(byte[] key) {
  1969.         Long result = null;
  1970.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1971.         if (shardedJedis == null) {
  1972.             return result;
  1973.         }
  1974.         boolean broken = false;
  1975.         try {
  1976.  
  1977.             result = shardedJedis.hlen(key);
  1978.  
  1979.         } catch (Exception e) {
  1980.  
  1981.             log.error(e.getMessage(), e);
  1982.             broken = true;
  1983.         } finally {
  1984.             redisDataSource.returnResource(shardedJedis, broken);
  1985.         }
  1986.         return result;
  1987.     }
  1988.  
  1989.     public Set<byte[]> hkeys(byte[] key) {
  1990.         Set<byte[]> result = null;
  1991.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  1992.         if (shardedJedis == null) {
  1993.             return result;
  1994.         }
  1995.         boolean broken = false;
  1996.         try {
  1997.  
  1998.             result = shardedJedis.hkeys(key);
  1999.  
  2000.         } catch (Exception e) {
  2001.  
  2002.             log.error(e.getMessage(), e);
  2003.             broken = true;
  2004.         } finally {
  2005.             redisDataSource.returnResource(shardedJedis, broken);
  2006.         }
  2007.         return result;
  2008.     }
  2009.  
  2010.     public Collection<byte[]> hvals(byte[] key) {
  2011.         Collection<byte[]> result = null;
  2012.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2013.         if (shardedJedis == null) {
  2014.             return result;
  2015.         }
  2016.         boolean broken = false;
  2017.         try {
  2018.  
  2019.             result = shardedJedis.hvals(key);
  2020.  
  2021.         } catch (Exception e) {
  2022.  
  2023.             log.error(e.getMessage(), e);
  2024.             broken = true;
  2025.         } finally {
  2026.             redisDataSource.returnResource(shardedJedis, broken);
  2027.         }
  2028.         return result;
  2029.     }
  2030.  
  2031.     public Map<byte[], byte[]> hgetAll(byte[] key) {
  2032.         Map<byte[], byte[]> result = null;
  2033.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2034.         if (shardedJedis == null) {
  2035.             return result;
  2036.         }
  2037.         boolean broken = false;
  2038.         try {
  2039.  
  2040.             result = shardedJedis.hgetAll(key);
  2041.  
  2042.         } catch (Exception e) {
  2043.  
  2044.             log.error(e.getMessage(), e);
  2045.             broken = true;
  2046.         } finally {
  2047.             redisDataSource.returnResource(shardedJedis, broken);
  2048.         }
  2049.         return result;
  2050.     }
  2051.  
  2052.     public Long rpush(byte[] key, byte[] string) {
  2053.         Long result = null;
  2054.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2055.         if (shardedJedis == null) {
  2056.             return result;
  2057.         }
  2058.         boolean broken = false;
  2059.         try {
  2060.  
  2061.             result = shardedJedis.rpush(key, string);
  2062.  
  2063.         } catch (Exception e) {
  2064.  
  2065.             log.error(e.getMessage(), e);
  2066.             broken = true;
  2067.         } finally {
  2068.             redisDataSource.returnResource(shardedJedis, broken);
  2069.         }
  2070.         return result;
  2071.     }
  2072.  
  2073.     public Long lpush(byte[] key, byte[] string) {
  2074.         Long result = null;
  2075.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2076.         if (shardedJedis == null) {
  2077.             return result;
  2078.         }
  2079.         boolean broken = false;
  2080.         try {
  2081.  
  2082.             result = shardedJedis.lpush(key, string);
  2083.  
  2084.         } catch (Exception e) {
  2085.  
  2086.             log.error(e.getMessage(), e);
  2087.             broken = true;
  2088.         } finally {
  2089.             redisDataSource.returnResource(shardedJedis, broken);
  2090.         }
  2091.         return result;
  2092.     }
  2093.  
  2094.     public Long llen(byte[] key) {
  2095.         Long result = null;
  2096.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2097.         if (shardedJedis == null) {
  2098.             return result;
  2099.         }
  2100.         boolean broken = false;
  2101.         try {
  2102.  
  2103.             result = shardedJedis.llen(key);
  2104.  
  2105.         } catch (Exception e) {
  2106.  
  2107.             log.error(e.getMessage(), e);
  2108.             broken = true;
  2109.         } finally {
  2110.             redisDataSource.returnResource(shardedJedis, broken);
  2111.         }
  2112.         return result;
  2113.     }
  2114.  
  2115.     public List<byte[]> lrange(byte[] key, int start, int end) {
  2116.         List<byte[]> result = null;
  2117.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2118.         if (shardedJedis == null) {
  2119.             return result;
  2120.         }
  2121.         boolean broken = false;
  2122.         try {
  2123.  
  2124.             result = shardedJedis.lrange(key, start, end);
  2125.  
  2126.         } catch (Exception e) {
  2127.  
  2128.             log.error(e.getMessage(), e);
  2129.             broken = true;
  2130.         } finally {
  2131.             redisDataSource.returnResource(shardedJedis, broken);
  2132.         }
  2133.         return result;
  2134.     }
  2135.  
  2136.     public String ltrim(byte[] key, int start, int end) {
  2137.         String result = null;
  2138.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2139.         if (shardedJedis == null) {
  2140.             return result;
  2141.         }
  2142.         boolean broken = false;
  2143.         try {
  2144.  
  2145.             result = shardedJedis.ltrim(key, start, end);
  2146.  
  2147.         } catch (Exception e) {
  2148.             log.error(e.getMessage(), e);
  2149.             broken = true;
  2150.         } finally {
  2151.             redisDataSource.returnResource(shardedJedis, broken);
  2152.         }
  2153.         return result;
  2154.     }
  2155.  
  2156.     public byte[] lindex(byte[] key, int index) {
  2157.         byte[] result = null;
  2158.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2159.         if (shardedJedis == null) {
  2160.             return result;
  2161.         }
  2162.         boolean broken = false;
  2163.         try {
  2164.  
  2165.             result = shardedJedis.lindex(key, index);
  2166.  
  2167.         } catch (Exception e) {
  2168.  
  2169.             log.error(e.getMessage(), e);
  2170.             broken = true;
  2171.         } finally {
  2172.             redisDataSource.returnResource(shardedJedis, broken);
  2173.         }
  2174.         return result;
  2175.     }
  2176.  
  2177.     public String lset(byte[] key, int index, byte[] value) {
  2178.         String result = null;
  2179.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2180.         if (shardedJedis == null) {
  2181.             return result;
  2182.         }
  2183.         boolean broken = false;
  2184.         try {
  2185.  
  2186.             result = shardedJedis.lset(key, index, value);
  2187.  
  2188.         } catch (Exception e) {
  2189.  
  2190.             log.error(e.getMessage(), e);
  2191.             broken = true;
  2192.         } finally {
  2193.             redisDataSource.returnResource(shardedJedis, broken);
  2194.         }
  2195.         return result;
  2196.     }
  2197.  
  2198.     public Long lrem(byte[] key, int count, byte[] value) {
  2199.         Long result = null;
  2200.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2201.         if (shardedJedis == null) {
  2202.             return result;
  2203.         }
  2204.         boolean broken = false;
  2205.         try {
  2206.  
  2207.             result = shardedJedis.lrem(key, count, value);
  2208.  
  2209.         } catch (Exception e) {
  2210.  
  2211.             log.error(e.getMessage(), e);
  2212.             broken = true;
  2213.         } finally {
  2214.             redisDataSource.returnResource(shardedJedis, broken);
  2215.         }
  2216.         return result;
  2217.     }
  2218.  
  2219.     public byte[] lpop(byte[] key) {
  2220.         byte[] result = null;
  2221.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2222.         if (shardedJedis == null) {
  2223.             return result;
  2224.         }
  2225.         boolean broken = false;
  2226.         try {
  2227.  
  2228.             result = shardedJedis.lpop(key);
  2229.  
  2230.         } catch (Exception e) {
  2231.  
  2232.             log.error(e.getMessage(), e);
  2233.             broken = true;
  2234.         } finally {
  2235.             redisDataSource.returnResource(shardedJedis, broken);
  2236.         }
  2237.         return result;
  2238.     }
  2239.  
  2240.     public byte[] rpop(byte[] key) {
  2241.         byte[] result = null;
  2242.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2243.         if (shardedJedis == null) {
  2244.             return result;
  2245.         }
  2246.         boolean broken = false;
  2247.         try {
  2248.  
  2249.             result = shardedJedis.rpop(key);
  2250.  
  2251.         } catch (Exception e) {
  2252.  
  2253.             log.error(e.getMessage(), e);
  2254.             broken = true;
  2255.         } finally {
  2256.             redisDataSource.returnResource(shardedJedis, broken);
  2257.         }
  2258.         return result;
  2259.     }
  2260.  
  2261.     public Long sadd(byte[] key, byte[] member) {
  2262.         Long result = null;
  2263.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2264.         if (shardedJedis == null) {
  2265.             return result;
  2266.         }
  2267.         boolean broken = false;
  2268.         try {
  2269.  
  2270.             result = shardedJedis.sadd(key, member);
  2271.  
  2272.         } catch (Exception e) {
  2273.  
  2274.             log.error(e.getMessage(), e);
  2275.             broken = true;
  2276.         } finally {
  2277.             redisDataSource.returnResource(shardedJedis, broken);
  2278.         }
  2279.         return result;
  2280.     }
  2281.  
  2282.     public Set<byte[]> smembers(byte[] key) {
  2283.         Set<byte[]> result = null;
  2284.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2285.         if (shardedJedis == null) {
  2286.             return result;
  2287.         }
  2288.         boolean broken = false;
  2289.         try {
  2290.  
  2291.             result = shardedJedis.smembers(key);
  2292.  
  2293.         } catch (Exception e) {
  2294.  
  2295.             log.error(e.getMessage(), e);
  2296.             broken = true;
  2297.         } finally {
  2298.             redisDataSource.returnResource(shardedJedis, broken);
  2299.         }
  2300.         return result;
  2301.     }
  2302.  
  2303.     public Long srem(byte[] key, byte[] member) {
  2304.         Long result = null;
  2305.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2306.         if (shardedJedis == null) {
  2307.             return result;
  2308.         }
  2309.         boolean broken = false;
  2310.         try {
  2311.  
  2312.             result = shardedJedis.srem(key, member);
  2313.  
  2314.         } catch (Exception e) {
  2315.  
  2316.             log.error(e.getMessage(), e);
  2317.             broken = true;
  2318.         } finally {
  2319.             redisDataSource.returnResource(shardedJedis, broken);
  2320.         }
  2321.         return result;
  2322.     }
  2323.  
  2324.     public byte[] spop(byte[] key) {
  2325.         byte[] result = null;
  2326.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2327.         if (shardedJedis == null) {
  2328.             return result;
  2329.         }
  2330.         boolean broken = false;
  2331.         try {
  2332.  
  2333.             result = shardedJedis.spop(key);
  2334.  
  2335.         } catch (Exception e) {
  2336.  
  2337.             log.error(e.getMessage(), e);
  2338.             broken = true;
  2339.         } finally {
  2340.             redisDataSource.returnResource(shardedJedis, broken);
  2341.         }
  2342.         return result;
  2343.     }
  2344.  
  2345.     public Long scard(byte[] key) {
  2346.         Long result = null;
  2347.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2348.         if (shardedJedis == null) {
  2349.             return result;
  2350.         }
  2351.         boolean broken = false;
  2352.         try {
  2353.  
  2354.             result = shardedJedis.scard(key);
  2355.  
  2356.         } catch (Exception e) {
  2357.  
  2358.             log.error(e.getMessage(), e);
  2359.             broken = true;
  2360.         } finally {
  2361.             redisDataSource.returnResource(shardedJedis, broken);
  2362.         }
  2363.         return result;
  2364.     }
  2365.  
  2366.     public Boolean sismember(byte[] key, byte[] member) {
  2367.         Boolean result = false;
  2368.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2369.         if (shardedJedis == null) {
  2370.             return result;
  2371.         }
  2372.         boolean broken = false;
  2373.         try {
  2374.  
  2375.             result = shardedJedis.sismember(key, member);
  2376.  
  2377.         } catch (Exception e) {
  2378.  
  2379.             log.error(e.getMessage(), e);
  2380.             broken = true;
  2381.         } finally {
  2382.             redisDataSource.returnResource(shardedJedis, broken);
  2383.         }
  2384.         return result;
  2385.     }
  2386.  
  2387.     public byte[] srandmember(byte[] key) {
  2388.         byte[] result = null;
  2389.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2390.         if (shardedJedis == null) {
  2391.             return result;
  2392.         }
  2393.         boolean broken = false;
  2394.         try {
  2395.  
  2396.             result = shardedJedis.srandmember(key);
  2397.  
  2398.         } catch (Exception e) {
  2399.  
  2400.             log.error(e.getMessage(), e);
  2401.             broken = true;
  2402.         } finally {
  2403.             redisDataSource.returnResource(shardedJedis, broken);
  2404.         }
  2405.         return result;
  2406.     }
  2407.  
  2408.     public Long zadd(byte[] key, double score, byte[] member) {
  2409.         Long result = null;
  2410.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2411.         if (shardedJedis == null) {
  2412.             return result;
  2413.         }
  2414.         boolean broken = false;
  2415.         try {
  2416.  
  2417.             result = shardedJedis.zadd(key, score, member);
  2418.  
  2419.         } catch (Exception e) {
  2420.  
  2421.             log.error(e.getMessage(), e);
  2422.             broken = true;
  2423.         } finally {
  2424.             redisDataSource.returnResource(shardedJedis, broken);
  2425.         }
  2426.         return result;
  2427.     }
  2428.  
  2429.     public Set<byte[]> zrange(byte[] key, int start, int end) {
  2430.         Set<byte[]> result = null;
  2431.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2432.         if (shardedJedis == null) {
  2433.             return result;
  2434.         }
  2435.         boolean broken = false;
  2436.         try {
  2437.  
  2438.             result = shardedJedis.zrange(key, start, end);
  2439.  
  2440.         } catch (Exception e) {
  2441.  
  2442.             log.error(e.getMessage(), e);
  2443.             broken = true;
  2444.         } finally {
  2445.             redisDataSource.returnResource(shardedJedis, broken);
  2446.         }
  2447.         return result;
  2448.     }
  2449.  
  2450.     public Long zrem(byte[] key, byte[] member) {
  2451.         Long result = null;
  2452.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2453.         if (shardedJedis == null) {
  2454.             return result;
  2455.         }
  2456.         boolean broken = false;
  2457.         try {
  2458.  
  2459.             result = shardedJedis.zrem(key, member);
  2460.  
  2461.         } catch (Exception e) {
  2462.  
  2463.             log.error(e.getMessage(), e);
  2464.             broken = true;
  2465.         } finally {
  2466.             redisDataSource.returnResource(shardedJedis, broken);
  2467.         }
  2468.         return result;
  2469.     }
  2470.  
  2471.     public Double zincrby(byte[] key, double score, byte[] member) {
  2472.         Double result = null;
  2473.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2474.         if (shardedJedis == null) {
  2475.             return result;
  2476.         }
  2477.         boolean broken = false;
  2478.         try {
  2479.  
  2480.             result = shardedJedis.zincrby(key, score, member);
  2481.  
  2482.         } catch (Exception e) {
  2483.  
  2484.             log.error(e.getMessage(), e);
  2485.             broken = true;
  2486.         } finally {
  2487.             redisDataSource.returnResource(shardedJedis, broken);
  2488.         }
  2489.         return result;
  2490.     }
  2491.  
  2492.     public Long zrank(byte[] key, byte[] member) {
  2493.         Long result = null;
  2494.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2495.         if (shardedJedis == null) {
  2496.             return result;
  2497.         }
  2498.         boolean broken = false;
  2499.         try {
  2500.  
  2501.             result = shardedJedis.zrank(key, member);
  2502.  
  2503.         } catch (Exception e) {
  2504.  
  2505.             log.error(e.getMessage(), e);
  2506.             broken = true;
  2507.         } finally {
  2508.             redisDataSource.returnResource(shardedJedis, broken);
  2509.         }
  2510.         return result;
  2511.     }
  2512.  
  2513.     public Long zrevrank(byte[] key, byte[] member) {
  2514.         Long result = null;
  2515.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2516.         if (shardedJedis == null) {
  2517.             return result;
  2518.         }
  2519.         boolean broken = false;
  2520.         try {
  2521.  
  2522.             result = shardedJedis.zrevrank(key, member);
  2523.  
  2524.         } catch (Exception e) {
  2525.  
  2526.             log.error(e.getMessage(), e);
  2527.             broken = true;
  2528.         } finally {
  2529.             redisDataSource.returnResource(shardedJedis, broken);
  2530.         }
  2531.         return result;
  2532.     }
  2533.  
  2534.     public Set<byte[]> zrevrange(byte[] key, int start, int end) {
  2535.         Set<byte[]> result = null;
  2536.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2537.         if (shardedJedis == null) {
  2538.             return result;
  2539.         }
  2540.         boolean broken = false;
  2541.         try {
  2542.  
  2543.             result = shardedJedis.zrevrange(key, start, end);
  2544.  
  2545.         } catch (Exception e) {
  2546.  
  2547.             log.error(e.getMessage(), e);
  2548.             broken = true;
  2549.         } finally {
  2550.             redisDataSource.returnResource(shardedJedis, broken);
  2551.         }
  2552.         return result;
  2553.     }
  2554.  
  2555.     public Set<Tuple> zrangeWithScores(byte[] key, int start, int end) {
  2556.         Set<Tuple> result = null;
  2557.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2558.         if (shardedJedis == null) {
  2559.             return result;
  2560.         }
  2561.         boolean broken = false;
  2562.         try {
  2563.  
  2564.             result = shardedJedis.zrangeWithScores(key, start, end);
  2565.  
  2566.         } catch (Exception e) {
  2567.  
  2568.             log.error(e.getMessage(), e);
  2569.             broken = true;
  2570.         } finally {
  2571.             redisDataSource.returnResource(shardedJedis, broken);
  2572.         }
  2573.         return result;
  2574.     }
  2575.  
  2576.     public Set<Tuple> zrevrangeWithScores(byte[] key, int start, int end) {
  2577.         Set<Tuple> result = null;
  2578.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2579.         if (shardedJedis == null) {
  2580.             return result;
  2581.         }
  2582.         boolean broken = false;
  2583.         try {
  2584.  
  2585.             result = shardedJedis.zrevrangeWithScores(key, start, end);
  2586.  
  2587.         } catch (Exception e) {
  2588.  
  2589.             log.error(e.getMessage(), e);
  2590.             broken = true;
  2591.         } finally {
  2592.             redisDataSource.returnResource(shardedJedis, broken);
  2593.         }
  2594.         return result;
  2595.     }
  2596.  
  2597.     public Long zcard(byte[] key) {
  2598.         Long result = null;
  2599.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2600.         if (shardedJedis == null) {
  2601.             return result;
  2602.         }
  2603.         boolean broken = false;
  2604.         try {
  2605.  
  2606.             result = shardedJedis.zcard(key);
  2607.  
  2608.         } catch (Exception e) {
  2609.  
  2610.             log.error(e.getMessage(), e);
  2611.             broken = true;
  2612.         } finally {
  2613.             redisDataSource.returnResource(shardedJedis, broken);
  2614.         }
  2615.         return result;
  2616.     }
  2617.  
  2618.     public Double zscore(byte[] key, byte[] member) {
  2619.         Double result = null;
  2620.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2621.         if (shardedJedis == null) {
  2622.             return result;
  2623.         }
  2624.         boolean broken = false;
  2625.         try {
  2626.  
  2627.             result = shardedJedis.zscore(key, member);
  2628.  
  2629.         } catch (Exception e) {
  2630.  
  2631.             log.error(e.getMessage(), e);
  2632.             broken = true;
  2633.         } finally {
  2634.             redisDataSource.returnResource(shardedJedis, broken);
  2635.         }
  2636.         return result;
  2637.     }
  2638.  
  2639.     public List<byte[]> sort(byte[] key) {
  2640.         List<byte[]> result = null;
  2641.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2642.         if (shardedJedis == null) {
  2643.             return result;
  2644.         }
  2645.         boolean broken = false;
  2646.         try {
  2647.  
  2648.             result = shardedJedis.sort(key);
  2649.  
  2650.         } catch (Exception e) {
  2651.  
  2652.             log.error(e.getMessage(), e);
  2653.             broken = true;
  2654.         } finally {
  2655.             redisDataSource.returnResource(shardedJedis, broken);
  2656.         }
  2657.         return result;
  2658.     }
  2659.  
  2660.     public List<byte[]> sort(byte[] key, SortingParams sortingParameters) {
  2661.         List<byte[]> result = null;
  2662.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2663.         if (shardedJedis == null) {
  2664.             return result;
  2665.         }
  2666.         boolean broken = false;
  2667.         try {
  2668.  
  2669.             result = shardedJedis.sort(key, sortingParameters);
  2670.  
  2671.         } catch (Exception e) {
  2672.  
  2673.             log.error(e.getMessage(), e);
  2674.             broken = true;
  2675.         } finally {
  2676.             redisDataSource.returnResource(shardedJedis, broken);
  2677.         }
  2678.         return result;
  2679.     }
  2680.  
  2681.     public Long zcount(byte[] key, double min, double max) {
  2682.         Long result = null;
  2683.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2684.         if (shardedJedis == null) {
  2685.             return result;
  2686.         }
  2687.         boolean broken = false;
  2688.         try {
  2689.  
  2690.             result = shardedJedis.zcount(key, min, max);
  2691.  
  2692.         } catch (Exception e) {
  2693.  
  2694.             log.error(e.getMessage(), e);
  2695.             broken = true;
  2696.         } finally {
  2697.             redisDataSource.returnResource(shardedJedis, broken);
  2698.         }
  2699.         return result;
  2700.     }
  2701.  
  2702.     public Set<byte[]> zrangeByScore(byte[] key, double min, double max) {
  2703.         Set<byte[]> result = null;
  2704.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2705.         if (shardedJedis == null) {
  2706.             return result;
  2707.         }
  2708.         boolean broken = false;
  2709.         try {
  2710.  
  2711.             result = shardedJedis.zrangeByScore(key, min, max);
  2712.  
  2713.         } catch (Exception e) {
  2714.  
  2715.             log.error(e.getMessage(), e);
  2716.             broken = true;
  2717.         } finally {
  2718.             redisDataSource.returnResource(shardedJedis, broken);
  2719.         }
  2720.         return result;
  2721.     }
  2722.  
  2723.     public Set<byte[]> zrangeByScore(byte[] key, double min, double max, int offset, int count) {
  2724.         Set<byte[]> result = null;
  2725.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2726.         if (shardedJedis == null) {
  2727.             return result;
  2728.         }
  2729.         boolean broken = false;
  2730.         try {
  2731.  
  2732.             result = shardedJedis.zrangeByScore(key, min, max, offset, count);
  2733.  
  2734.         } catch (Exception e) {
  2735.  
  2736.             log.error(e.getMessage(), e);
  2737.             broken = true;
  2738.         } finally {
  2739.             redisDataSource.returnResource(shardedJedis, broken);
  2740.         }
  2741.         return result;
  2742.     }
  2743.  
  2744.     public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max) {
  2745.         Set<Tuple> result = null;
  2746.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2747.         if (shardedJedis == null) {
  2748.             return result;
  2749.         }
  2750.         boolean broken = false;
  2751.         try {
  2752.  
  2753.             result = shardedJedis.zrangeByScoreWithScores(key, min, max);
  2754.  
  2755.         } catch (Exception e) {
  2756.  
  2757.             log.error(e.getMessage(), e);
  2758.             broken = true;
  2759.         } finally {
  2760.             redisDataSource.returnResource(shardedJedis, broken);
  2761.         }
  2762.         return result;
  2763.     }
  2764.  
  2765.     public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) {
  2766.         Set<Tuple> result = null;
  2767.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2768.         if (shardedJedis == null) {
  2769.             return result;
  2770.         }
  2771.         boolean broken = false;
  2772.         try {
  2773.  
  2774.             result = shardedJedis.zrangeByScoreWithScores(key, min, max, offset, count);
  2775.  
  2776.         } catch (Exception e) {
  2777.  
  2778.             log.error(e.getMessage(), e);
  2779.             broken = true;
  2780.         } finally {
  2781.             redisDataSource.returnResource(shardedJedis, broken);
  2782.         }
  2783.         return result;
  2784.     }
  2785.  
  2786.     public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min) {
  2787.         Set<byte[]> result = null;
  2788.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2789.         if (shardedJedis == null) {
  2790.             return result;
  2791.         }
  2792.         boolean broken = false;
  2793.         try {
  2794.  
  2795.             result = shardedJedis.zrevrangeByScore(key, max, min);
  2796.  
  2797.         } catch (Exception e) {
  2798.  
  2799.             log.error(e.getMessage(), e);
  2800.             broken = true;
  2801.         } finally {
  2802.             redisDataSource.returnResource(shardedJedis, broken);
  2803.         }
  2804.         return result;
  2805.     }
  2806.  
  2807.     public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
  2808.         Set<byte[]> result = null;
  2809.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2810.         if (shardedJedis == null) {
  2811.             return result;
  2812.         }
  2813.         boolean broken = false;
  2814.         try {
  2815.  
  2816.             result = shardedJedis.zrevrangeByScore(key, max, min, offset, count);
  2817.  
  2818.         } catch (Exception e) {
  2819.  
  2820.             log.error(e.getMessage(), e);
  2821.             broken = true;
  2822.         } finally {
  2823.             redisDataSource.returnResource(shardedJedis, broken);
  2824.         }
  2825.         return result;
  2826.     }
  2827.  
  2828.     public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
  2829.         Set<Tuple> result = null;
  2830.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2831.         if (shardedJedis == null) {
  2832.             return result;
  2833.         }
  2834.         boolean broken = false;
  2835.         try {
  2836.  
  2837.             result = shardedJedis.zrevrangeByScoreWithScores(key, max, min);
  2838.  
  2839.         } catch (Exception e) {
  2840.  
  2841.             log.error(e.getMessage(), e);
  2842.             broken = true;
  2843.         } finally {
  2844.             redisDataSource.returnResource(shardedJedis, broken);
  2845.         }
  2846.         return result;
  2847.     }
  2848.  
  2849.     public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
  2850.         Set<Tuple> result = null;
  2851.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2852.         if (shardedJedis == null) {
  2853.             return result;
  2854.         }
  2855.         boolean broken = false;
  2856.         try {
  2857.  
  2858.             result = shardedJedis.zrevrangeByScoreWithScores(key, max, min, offset, count);
  2859.  
  2860.         } catch (Exception e) {
  2861.  
  2862.             log.error(e.getMessage(), e);
  2863.             broken = true;
  2864.         } finally {
  2865.             redisDataSource.returnResource(shardedJedis, broken);
  2866.         }
  2867.         return result;
  2868.     }
  2869.  
  2870.     public Long zremrangeByRank(byte[] key, int start, int end) {
  2871.         Long result = null;
  2872.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2873.         if (shardedJedis == null) {
  2874.             return result;
  2875.         }
  2876.         boolean broken = false;
  2877.         try {
  2878.  
  2879.             result = shardedJedis.zremrangeByRank(key, start, end);
  2880.  
  2881.         } catch (Exception e) {
  2882.  
  2883.             log.error(e.getMessage(), e);
  2884.             broken = true;
  2885.         } finally {
  2886.             redisDataSource.returnResource(shardedJedis, broken);
  2887.         }
  2888.         return result;
  2889.     }
  2890.  
  2891.     public Long zremrangeByScore(byte[] key, double start, double end) {
  2892.         Long result = null;
  2893.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2894.         if (shardedJedis == null) {
  2895.             return result;
  2896.         }
  2897.         boolean broken = false;
  2898.         try {
  2899.  
  2900.             result = shardedJedis.zremrangeByScore(key, start, end);
  2901.  
  2902.         } catch (Exception e) {
  2903.             log.error(e.getMessage(), e);
  2904.             broken = true;
  2905.         } finally {
  2906.             redisDataSource.returnResource(shardedJedis, broken);
  2907.         }
  2908.         return result;
  2909.     }
  2910.  
  2911.     public Long linsert(byte[] key, LIST_POSITION where, byte[] pivot, byte[] value) {
  2912.         Long result = null;
  2913.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2914.         if (shardedJedis == null) {
  2915.             return result;
  2916.         }
  2917.         boolean broken = false;
  2918.         try {
  2919.  
  2920.             result = shardedJedis.linsert(key, where, pivot, value);
  2921.  
  2922.         } catch (Exception e) {
  2923.             log.error(e.getMessage(), e);
  2924.             broken = true;
  2925.         } finally {
  2926.             redisDataSource.returnResource(shardedJedis, broken);
  2927.         }
  2928.         return result;
  2929.     }
  2930.  
  2931.     public List<Object> pipelined(ShardedJedisPipeline shardedJedisPipeline) {
  2932.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2933.         List<Object> result = null;
  2934.         if (shardedJedis == null) {
  2935.             return result;
  2936.         }
  2937.         boolean broken = false;
  2938.         try {
  2939.             result = shardedJedis.pipelined(shardedJedisPipeline);
  2940.         } catch (Exception e) {
  2941.             log.error(e.getMessage(), e);
  2942.             broken = true;
  2943.         } finally {
  2944.             redisDataSource.returnResource(shardedJedis, broken);
  2945.         }
  2946.         return result;
  2947.     }
  2948.  
  2949.     public Jedis getShard(byte[] key) {
  2950.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2951.         Jedis result = null;
  2952.         if (shardedJedis == null) {
  2953.             return result;
  2954.         }
  2955.         boolean broken = false;
  2956.         try {
  2957.             result = shardedJedis.getShard(key);
  2958.         } catch (Exception e) {
  2959.             log.error(e.getMessage(), e);
  2960.             broken = true;
  2961.         } finally {
  2962.             redisDataSource.returnResource(shardedJedis, broken);
  2963.         }
  2964.         return result;
  2965.     }
  2966.  
  2967.     public Jedis getShard(String key) {
  2968.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2969.         Jedis result = null;
  2970.         if (shardedJedis == null) {
  2971.             return result;
  2972.         }
  2973.         boolean broken = false;
  2974.         try {
  2975.             result = shardedJedis.getShard(key);
  2976.         } catch (Exception e) {
  2977.             log.error(e.getMessage(), e);
  2978.             broken = true;
  2979.         } finally {
  2980.             redisDataSource.returnResource(shardedJedis, broken);
  2981.         }
  2982.         return result;
  2983.     }
  2984.  
  2985.     public JedisShardInfo getShardInfo(byte[] key) {
  2986.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  2987.         JedisShardInfo result = null;
  2988.         if (shardedJedis == null) {
  2989.             return result;
  2990.         }
  2991.         boolean broken = false;
  2992.         try {
  2993.             result = shardedJedis.getShardInfo(key);
  2994.         } catch (Exception e) {
  2995.             log.error(e.getMessage(), e);
  2996.             broken = true;
  2997.         } finally {
  2998.             redisDataSource.returnResource(shardedJedis, broken);
  2999.         }
  3000.         return result;
  3001.     }
  3002.  
  3003.     public JedisShardInfo getShardInfo(String key) {
  3004.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  3005.         JedisShardInfo result = null;
  3006.         if (shardedJedis == null) {
  3007.             return result;
  3008.         }
  3009.         boolean broken = false;
  3010.         try {
  3011.             result = shardedJedis.getShardInfo(key);
  3012.         } catch (Exception e) {
  3013.             log.error(e.getMessage(), e);
  3014.             broken = true;
  3015.         } finally {
  3016.             redisDataSource.returnResource(shardedJedis, broken);
  3017.         }
  3018.         return result;
  3019.     }
  3020.  
  3021.     public String getKeyTag(String key) {
  3022.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  3023.         String result = null;
  3024.         if (shardedJedis == null) {
  3025.             return result;
  3026.         }
  3027.         boolean broken = false;
  3028.         try {
  3029.             result = shardedJedis.getKeyTag(key);
  3030.         } catch (Exception e) {
  3031.             log.error(e.getMessage(), e);
  3032.             broken = true;
  3033.         } finally {
  3034.             redisDataSource.returnResource(shardedJedis, broken);
  3035.         }
  3036.         return result;
  3037.     }
  3038.  
  3039.     public Collection<JedisShardInfo> getAllShardInfo() {
  3040.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  3041.         Collection<JedisShardInfo> result = null;
  3042.         if (shardedJedis == null) {
  3043.             return result;
  3044.         }
  3045.         boolean broken = false;
  3046.         try {
  3047.             result = shardedJedis.getAllShardInfo();
  3048.  
  3049.         } catch (Exception e) {
  3050.             log.error(e.getMessage(), e);
  3051.             broken = true;
  3052.         } finally {
  3053.             redisDataSource.returnResource(shardedJedis, broken);
  3054.         }
  3055.         return result;
  3056.     }
  3057.  
  3058.     public Collection<Jedis> getAllShards() {
  3059.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();
  3060.         Collection<Jedis> result = null;
  3061.         if (shardedJedis == null) {
  3062.             return result;
  3063.         }
  3064.         boolean broken = false;
  3065.         try {
  3066.             result = shardedJedis.getAllShards();
  3067.  
  3068.         } catch (Exception e) {
  3069.             log.error(e.getMessage(), e);
  3070.             broken = true;
  3071.         } finally {
  3072.             redisDataSource.returnResource(shardedJedis, broken);
  3073.         }
  3074.         return result;
  3075.     }
  3076.  
  3077. }

-----------------------------------

感谢一路有你~

spring和redis的整合-超越昨天的自己系列（7）的更多相关文章

  1. spring和redis的整合

    spring和redis的整合-超越昨天的自己系列(7) 超越昨天的自己系列(7) 扯淡:  最近一直在慢慢多学习各个组件,自己搭建出一些想法.是一个涉猎的过程,慢慢意识到知识是可以融汇贯通,举一反三 ...

  2. 时间作为横轴的图表（morris.js）超越昨天的自己系列（8）

    超越昨天的自己系列(8) morris.js的官网有详细的例子:http://www.oesmith.co.uk/morris.js/ 特别注意它的依赖: <link rel="sty ...

  3. maven为不同环境打包(hibernate)-超越昨天的自己系列（6）

    超越昨天的自己系列(6) 使用ibatis开发中,耗在dao层的开发时间,调试时间,差错时间,以及适应修改需求的时间太长,导致项目看起来就添删改查,却特别费力.   在项目性能要求不高的情况下,开始寻 ...

  4. spring与redis简单整合

    项目结构 整合需要的依赖 <dependencies> <dependency> <groupId>org.springframework</groupId& ...

  5. Redis入门到高可用（十）—— Spring与Redis的整合

    1.pom文件 <!--redis--> <dependency> <groupId>org.springframework.data</groupId> ...

  6. HashMap归档-超越昨天的自己系列

    java HashMap 读一下源码,一个数组存储数据: transient Entry[] table; 内部存key和value的内部类: static class Entry<K,V> ...

  7. Collections.reverse 代码思考-超越昨天的自己系列(13)

    点进Collections.reverse的代码瞄了眼,然后就开始了一些基础知识的收集. 现在发现知道的越多,知道不知道的越多. 列几个记录下: reverse方法源码: /** * Reverses ...

  8. crontab 移动日志-超越昨天的自己系列(12)

    linux上定时执行某些脚本是管理服务器的时候比较常用的场景,比如定时检查进程是否存在,定时启动或关闭进程,定时检查日志删除日志等. 当我打开google百度crontab时长篇大论的一大堆,详细解释 ...

  9. java进程性能分析步骤-超越昨天的自己系列(11)

    java进程load过高分析步骤: top 查看java进程情况     top -Hp 查看某个进程的具体线程情况   printf 0x%x 确认哪一个线程占用cpu比较多,拿出来转成16进制   ...

随机推荐

  1. 用户上网的基本流程图与DNS解析原理

    1.用户上网发送请求,首先确认本地的hosts中是否含有域名,有则进行ip访问,如果没有呢?看本机的display缓存中有没有访问网站的ip,有就直接去访问 那么如果本地的hosts和缓存都没有呢?这 ...

  2. Hibernate中的组合映射

    1.实体bean设计 car: public class Car { private int id; private String name; private Wheel wheel; set... ...

  3. 原子操作 Interlocked系列函数

    上一篇<多线程第一次亲密接触 CreateThread与_beginthreadex本质区别>中讲到一个多线程报数功能.为了描述方便和代码简洁起见,我们可以只输出最后的报数结果来观察程序是 ...

  4. Word2013可以写博客

    步骤如下http://www.cnblogs.com/guyichang/p/4629211.html

  5. Android程序之全国天气预报查询接口演示

    一.项目演示效果如下: 二.使用 聚合数据SDK 注册账号-创建一个新应用(在个人中心页面-数据中心-申请数据)–填入自己的应用–找到分类–天气预报-全国天气预报 下载sdk (由于项目使用的是1点几 ...

  6. swift语言之多线程操作和操作队列（下）———坚持51天吃掉大象（写技术文章）

    欢迎有兴趣的朋友,参与我的美女同事发起的活动<51天吃掉大象>,该美女真的很疯狂,希望和大家一起坚持51天做一件事情,我加入这个队伍,希望坚持51天每天写一篇技术文章.关注她的微信公众号: ...

  7. Activity(活动)-初讲

    是一种可以包含用户界面的组件,主要用于和用户进行交互. 上一次我们的MainActivity.java 是ADT帮我们自动创建的.手动创建Activity可以加深我们的理解和记忆,于是我们先自己手动创 ...

  8. <二叉树的基本操作（有层次遍历）>

    #include<stdio.h> #include<stdlib.h> #include<string.h> #define num 100 #define OK ...

  9. js库之art.dialog

    自适应内容 artDialog的特殊UI框架能够适应内容变化,甚至连外部程序动态插入的内容它仍然能自适应,因此你不必去考虑消息内容尺寸使用它.它的消息容器甚至能够根据宽度让文本居中或居左对齐——这一切 ...

  10. mongo db 分享 ppt

    在公司内部的mongo db的ppt.初步进阶 http://files.cnblogs.com/files/yuhan-TB/mongoDB.pptx