java之redis篇(spring-data-redis整合)

Redis的知识：官网

1，利用spring-data-redis整合

项目使用的pom.xml：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.x.redis</groupId>
  <artifactId>Spring_redis</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>Spring_redis</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
     <dependency>  
        <groupId>org.springframework.data</groupId>  
        <artifactId>spring-data-redis</artifactId>  
        <version>1.0.2.RELEASE</version>  
    </dependency>  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-core</artifactId>  
        <version>3.1.2.RELEASE</version>  
    </dependency>  

      
    <dependency>  
        <groupId>redis.clients</groupId>  
        <artifactId>jedis</artifactId>  
        <version>2.1.0</version>  
    </dependency>  
      
     <dependency>  
        <groupId>junit</groupId>  
        <artifactId>junit</artifactId>  
        <version>4.8.2</version>  
        <scope>test</scope>  
    </dependency>  
                <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>1.6.1</version>
            </dependency>
            <!-- 将现有的jakarta commons logging的调用转换成lsf4j的调用。 -->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>jcl-over-slf4j</artifactId>
                <version>1.6.1</version>
            </dependency>
            <!-- Hack：确保commons-logging的jar包不被引入，否则将和jcl-over-slf4j冲突 -->
            <dependency>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
                <version>1.1.1</version>
                <scope>provided</scope>
            </dependency>
            <!-- slf4j的实现：logback，用来取代log4j。更快、更强！ -->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>0.9.24</version>
                <scope>runtime</scope>
            </dependency>
  </dependencies>
</project>

View Code

除了log部分，只有一个spring core 和 spring-data-redis了

项目文件目录结构：

 

applicationContext.xml：

1，context:property-placeholder 标签用来导入properties文件。从而替换${redis.maxIdle}这样的变量。

2，context:component-scan 是为了在com.x.redis.dao报下的类能够实用spring的注解注入的方式。

3，事实上我们只需要把JedisPoolConfig配数来就好了，接下来就是spring的封装了。所以直接看UserDAOImpl的实现就明白了。

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="  
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">  
  
    <context:property-placeholder location="classpath:redis.properties" />  
    <context:component-scan base-package="com.x.redis.dao">
    </context:component-scan>
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">  
        <property name="maxIdle" value="${redis.maxIdle}" />  
        <property name="maxActive" value="${redis.maxActive}" />  
        <property name="maxWait" value="${redis.maxWait}" />  
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
    </bean>  
      
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  
        p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"  p:pool-config-ref="poolConfig"/>  
      
    <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">  
        <property name="connectionFactory"   ref="connectionFactory" />  
    </bean>         
      
    <bean id="userDAO" class="com.x.redis.dao.impl.UserDAOImpl" />   
</beans> 

redis.properties：

# Redis settings
#redis.host=192.168.20.101
#redis.port=6380
#redis.pass=foobared
redis.host=127.0.0.1
redis.port=6379
redis.pass=
  
redis.maxIdle=300
redis.maxActive=600
redis.maxWait=1000
redis.testOnBorrow=true

View Code

 

UserDAOImpl：

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

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

public class UserDAOImpl implements UserDAO {

    @Autowired
    protected RedisTemplate<Serializable, Serializable> redisTemplate;

    public void saveUser(final User user) {
        redisTemplate.execute(new RedisCallback<Object>() {

            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                connection.set(redisTemplate.getStringSerializer().serialize("user.uid." + user.getId()),
                               redisTemplate.getStringSerializer().serialize(user.getName()));
                return null;
            }
        });
    }

    @Override
    public User getUser(final long id) {
        return redisTemplate.execute(new RedisCallback<User>() {
            @Override
            public User doInRedis(RedisConnection connection) throws DataAccessException {
                byte[] key = redisTemplate.getStringSerializer().serialize("user.uid." + id);
                if (connection.exists(key)) {
                    byte[] value = connection.get(key);
                    String name = redisTemplate.getStringSerializer().deserialize(value);
                    User user = new User();
                    user.setName(name);
                    user.setId(id);
                    return user;
                }
                return null;
            }
        });
    }

}

其他：

User：

public class User {

    private long id;
    private String name;
    
    public long getId() {
        return id;
    }
    
    public void setId(long id) {
        this.id = id;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

View Code

测试代码：

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

 

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

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

pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.d.work</groupId>
  <artifactId>Redis_Templete</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>Redis_Templete</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>  
        <groupId>redis.clients</groupId>  
        <artifactId>jedis</artifactId>  
        <version>2.1.0</version>  
    </dependency>  
        <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-core</artifactId>  
        <version>3.1.2.RELEASE</version>  
    </dependency>  
        <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-beans</artifactId>  
        <version>3.1.2.RELEASE</version>  
    </dependency> 
        <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-context</artifactId>  
        <version>3.1.2.RELEASE</version>  
    </dependency> 
    <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>1.6.1</version>
            </dependency>
            <!-- 将现有的jakarta commons logging的调用转换成lsf4j的调用。 -->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>jcl-over-slf4j</artifactId>
                <version>1.6.1</version>
            </dependency>
            <!-- Hack：确保commons-logging的jar包不被引入，否则将和jcl-over-slf4j冲突 -->
            <dependency>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
                <version>1.1.1</version>
                <scope>provided</scope>
            </dependency>
            <!-- slf4j的实现：logback，用来取代log4j。更快、更强！ -->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>0.9.24</version>
                <scope>runtime</scope>
            </dependency>
  </dependencies>
</project>

View Code

目录结构：

data-source.xml

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

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

一个是分片形式，可以连接有主备的redis服务端，一个是单个的。详细后续学习

 

3，因为不使用spring-data-redis的封装，所以自己要自己封装一个

[java]  view plain  copy

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:定义三个方法

[java]  view plain  copy

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，这三个方法的作用：

 

getRedisClient() ： 取得redis的客户端，可以执行命令了。

returnResource(ShardedJedis shardedJedis) ： 将资源返还给pool

returnResource(ShardedJedis shardedJedis, boolean broken) : 出现异常后，将资源返还给pool （其实不需要第二个方法）

[java]  view plain  copy

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中链接的取得和返还问题了。

[java]  view plain  copy

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. }  

测试代码：

[java]  view plain  copy

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. }  

喜欢我的文章的，可以关注微信公众号“测试项目开发”，需要什么内容可以在里面提，我看到后会给大家解答。