spring-data-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>

除了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

UserDAOImpl：

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

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

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

其他：

User：

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

测试代码：

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

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

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

pom.xml:

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

目录结构：

data-source.xml

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

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

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

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

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="  
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">  

    <context:property-placeholder location="classpath:redis.properties" />  
    <context:component-scan base-package="com.d.work.main">
    </context:component-scan>
        <context:component-scan base-package="com.d.work.redis">
    </context:component-scan>
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxActive" value="50" />
        <property name="maxIdle" value="8" />
        <property name="maxWait" value="1000" />
        <property name="testOnBorrow" value="true"/>
        <property name="testOnReturn" value="true"/>
        <!-- <property name="testWhileIdle" value="true"/> -->
    </bean>

    <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool"  scope="singleton">
        <constructor-arg index="0" ref="jedisPoolConfig" />
        <constructor-arg index="1">
            <list>
                <bean class="redis.clients.jedis.JedisShardInfo">
                    <constructor-arg name="host" value="${redis.host}" />
                    <constructor-arg name="port" value="${redis.port}" />
                    <constructor-arg name="timeout" value="${redis.timeout}" />
                    <constructor-arg name="weight" value="1" />
                </bean>
            </list>
        </constructor-arg>
    </bean>
</beans>

RedisDataSource:定义三个方法

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 （其实不需要第二个方法）

 1 @Repository("redisDataSource")
 2 public class RedisDataSourceImpl implements RedisDataSource {
 3 
 4     private static final Logger log = LoggerFactory.getLogger(RedisDataSourceImpl.class);
 5 
 6     @Autowired
 7     private ShardedJedisPool    shardedJedisPool;
 8 
 9     public ShardedJedis getRedisClient() {
10         try {
11             ShardedJedis shardJedis = shardedJedisPool.getResource();
12             return shardJedis;
13         } catch (Exception e) {
14             log.error("getRedisClent error", e);
15         }
16         return null;
17     }
18 
19     public void returnResource(ShardedJedis shardedJedis) {
20         shardedJedisPool.returnResource(shardedJedis);
21     }
22 
23     public void returnResource(ShardedJedis shardedJedis, boolean broken) {
24         if (broken) {
25             shardedJedisPool.returnBrokenResource(shardedJedis);
26         } else {
27             shardedJedisPool.returnResource(shardedJedis);
28         }
29     }
30 }

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

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

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

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

测试代码：

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

附上RedisClientTemplate全部实现：

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

相关阅读:
学习笔记
 博客园css
linux命令随时添加
 spring注解
 springboot常用注解
 Ubuntu（16.04）安装Redis
Mac OS 10.15 虚拟机安装（提供镜像，安装VMware tools，更改分辨率）
SSM-员工管理项目实战-CRUD-增删改查
 蓝桥杯 2014届真题地宫取宝动态规划解法
 设计模式-工厂方法模式实战演习代码实现
原文地址：https://www.cnblogs.com/link1988/p/5503670.html