Java操作Redis

目前Jedis是官方推荐的比较好的Redis操作API包，我们这里结合Spring来看下如何使用Redis这一神器。

1、在pom文件中引入jredis包：

<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>2.8.1</version>
</dependency>

2、在Spring的resource目录中增加Redis的配置文件/src/main/resources/redis.properties

# Redis settings
redis.host=192.168.56.101
redis.port=6379
redis.pass=lxh20160330
redis.timeout=0

redis.maxIdle=300
redis.maxActive=600
redis.maxWait=1000
redis.testOnBorrow=true

3、在Spring的配置文件中配置好Redis的相关Bean注入：

[java]  view plain  copy

1. 1 <?xml version="1.0" encoding="UTF-8"?>    
2.  2 <beans xmlns="http://www.springframework.org/schema/beans"    
3.  3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"    
4.  4     xmlns:context="http://www.springframework.org/schema/context"    
5.  5     xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"    
6.  6     xmlns:aop="http://www.springframework.org/schema/aop"    
7.  7     xsi:schemaLocation="    
8.  8             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd    
9.  9             http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">    
10. 10   
11. 11     <context:property-placeholder location="classpath:redis.properties" />    
12. 12     <context:component-scan base-package="com.redis.demo" />  
13. 13       
14. 14     <bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor" />  
15. 15       
16. 16     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">  
17. 17         <property name="maxActive" value="50" />  
18. 18         <property name="maxIdle" value="8" />  
19. 19         <property name="maxWait" value="1000" />  
20. 20         <property name="testOnBorrow" value="true"/>  
21. 21         <property name="testOnReturn" value="true"/>  
22. 22         <!-- <property name="testWhileIdle" value="true"/> -->  
23. 23     </bean>  
24. 24   
25. 25     <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool"  scope="singleton">  
26. 26         <constructor-arg index="0" ref="jedisPoolConfig" />  
27. 27         <constructor-arg index="1">  
28. 28             <list>  
29. 29                 <bean class="redis.clients.jedis.JedisShardInfo">  
30. 30                     <constructor-arg name="host" value="${redis.host}" />  
31. 31                     <constructor-arg name="port" value="${redis.port}" />  
32. 32                     <constructor-arg name="timeout" value="${redis.timeout}" />  
33. 33                     <constructor-arg name="weight" value="1" />  
34. 34                 </bean>  
35. 35             </list>  
36. 36         </constructor-arg>  
37. 37     </bean>  
38. 38 </beans>  

4、获取Redis客户端对象的类

package com.redis.demo.service.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.redis.demo.service.RedisService;

import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

@Repository("redisService")
public class RedisServiceImpl implements RedisService {
     private static final Logger log = LoggerFactory.getLogger(RedisServiceImpl.class);

    @Autowired
    private ShardedJedisPool shardedJedisPool;
 
     public ShardedJedis getRedisClient() {
         try {
            ShardedJedis shardJedis = shardedJedisPool.getResource();
             return shardJedis;
         } catch (Exception e) {
             log.error("getRedisClent error", e);
         }
         return null;
    }
 
     public void returnResource(ShardedJedis shardedJedis) {
         shardedJedisPool.returnResource(shardedJedis);
     }
 
     public void returnResource(ShardedJedis shardedJedis, boolean broken) {
         if (broken) {
             shardedJedisPool.returnBrokenResource(shardedJedis);
         } else {
             shardedJedisPool.returnResource(shardedJedis);
         }
     }
 }

5、RedisClient类中实现Redis的相关操作

[java]  view plain  copy

1. package com.redis.demo;  
2.     
3.   import java.util.Collection;  
4.   import java.util.List;  
5.   import java.util.Map;  
6.   import java.util.Set;  
7.     
8.   import org.slf4j.Logger;  
9.   import org.slf4j.LoggerFactory;  
10.  import org.springframework.beans.factory.annotation.Autowired;  
11.    
12.  import com.redis.demo.service.impl.RedisServiceImpl;  
13.    
14.  import redis.clients.jedis.BinaryClient.LIST_POSITION;  
15.  import redis.clients.jedis.Jedis;  
16.  import redis.clients.jedis.JedisShardInfo;  
17.  import redis.clients.jedis.ShardedJedis;  
18.  import redis.clients.jedis.ShardedJedisPipeline;  
19.  import redis.clients.jedis.SortingParams;  
20.  import redis.clients.jedis.Tuple;  
21.    
22.   
23.  public class RedisClient {  
24.    
25.      private static final Logger log = LoggerFactory.getLogger(RedisClient.class);  
26.    
27.      @Autowired  
28.      private RedisServiceImpl redisService;  
29.    
30.      public void disconnect() {  
31.          ShardedJedis shardedJedis = redisService.getRedisClient();  
32.          shardedJedis.disconnect();  
33.      }  
34.    
35.      /** 
36.       * 设置单个值 
37.       */  
38.      public String set(String key, String value) {  
39.          String result = null;  
40.    
41.          ShardedJedis shardedJedis = redisService.getRedisClient();  
42.          if (shardedJedis == null) {  
43.              return result;  
44.          }  
45.          boolean flag = false;  
46.          try {  
47.              result = shardedJedis.set(key, value);  
48.          } catch (Exception e) {  
49.              log.error(e.getMessage(), e);  
50.              flag = true;  
51.          } finally {  
52.              redisService.returnResource(shardedJedis, flag);  
53.          }  
54.          return result;  
55.      }  
56.    
57.      /** 
58.       * 获取单个值 
59.       */  
60.      public String get(String key) {  
61.          String result = null;  
62.          ShardedJedis shardedJedis = redisService.getRedisClient();  
63.          if (shardedJedis == null) {  
64.              return result;  
65.          }  
66.    
67.          boolean flag = false;  
68.          try {  
69.              result = shardedJedis.get(key);  
70.    
71.          } catch (Exception e) {  
72.              log.error(e.getMessage(), e);  
73.              flag = true;  
74.          } finally {  
75.              redisService.returnResource(shardedJedis, flag);  
76.          }  
77.          return result;  
78.      }  
79.    
80.      public Boolean exists(String key) {  
81.          Boolean result = false;  
82.          ShardedJedis shardedJedis = redisService.getRedisClient();  
83.          if (shardedJedis == null) {  
84.              return result;  
85.          }  
86.          boolean flag = false;  
87.          try {  
88.              result = shardedJedis.exists(key);  
89.          } catch (Exception e) {  
90.              log.error(e.getMessage(), e);  
91.              flag = true;  
92.          } finally {  
93.              redisService.returnResource(shardedJedis, flag);  
94.          }  
95.          return result;  
96.     }  
97.   
98.     public String type(String key) {  
99.         String result = null;  
100.         ShardedJedis shardedJedis = redisService.getRedisClient();  
101.         if (shardedJedis == null) {  
102.             return result;  
103.         }  
104.         boolean flag = false;  
105.         try {  
106.             result = shardedJedis.type(key);  
107.   
108.         } catch (Exception e) {  
109.             log.error(e.getMessage(), e);  
110.             flag = true;  
111.         } finally {  
112.             redisService.returnResource(shardedJedis, flag);  
113.         }  
114.         return result;  
115.     }  
116.   
117.     /** 
118.      * 在某段时间后失效 
119.      */  
120.     public Long expire(String key, int seconds) {  
121.         Long result = null;  
122.         ShardedJedis shardedJedis = redisService.getRedisClient();  
123.         if (shardedJedis == null) {  
124.             return result;  
125.         }  
126.         boolean flag = false;  
127.         try {  
128.             result = shardedJedis.expire(key, seconds);  
129.   
130.         } catch (Exception e) {  
131.             log.error(e.getMessage(), e);  
132.             flag = true;  
133.         } finally {  
134.             redisService.returnResource(shardedJedis, flag);  
135.         }  
136.         return result;  
137.     }  
138.   
139.     /** 
140.      * 在某个时间点失效 
141.      */  
142.     public Long expireAt(String key, long time) {  
143.         Long result = null;  
144.         ShardedJedis shardedJedis = redisService.getRedisClient();  
145.         if (shardedJedis == null) {  
146.             return result;  
147.         }  
148.         boolean flag = false;  
149.         try {  
150.             result = shardedJedis.expireAt(key, time);  
151.   
152.         } catch (Exception e) {  
153.             log.error(e.getMessage(), e);  
154.             flag = true;  
155.         } finally {  
156.             redisService.returnResource(shardedJedis, flag);  
157.         }  
158.         return result;  
159.     }  
160.   
161.     public Long ttl(String key) {  
162.         Long result = null;  
163.         ShardedJedis shardedJedis = redisService.getRedisClient();  
164.         if (shardedJedis == null) {  
165.             return result;  
166.         }  
167.         boolean flag = false;  
168.         try {  
169.             result = shardedJedis.ttl(key);  
170.   
171.         } catch (Exception e) {  
172.             log.error(e.getMessage(), e);  
173.             flag = true;  
174.         } finally {  
175.             redisService.returnResource(shardedJedis, flag);  
176.         }  
177.         return result;  
178.     }  
179.   
180.     public boolean setbit(String key, long offset, boolean value) {  
181.   
182.         ShardedJedis shardedJedis = redisService.getRedisClient();  
183.         boolean result = false;  
184.         if (shardedJedis == null) {  
185.             return result;  
186.         }  
187.         boolean flag = false;  
188.         try {  
189.             result = shardedJedis.setbit(key, offset, value);  
190.         } catch (Exception e) {  
191.             log.error(e.getMessage(), e);  
192.             flag = true;  
193.         } finally {  
194.             redisService.returnResource(shardedJedis, flag);  
195.         }  
196.         return result;  
197.     }  
198.   
199.     public boolean getbit(String key, long offset) {  
200.         ShardedJedis shardedJedis = redisService.getRedisClient();  
201.         boolean result = false;  
202.         if (shardedJedis == null) {  
203.             return result;  
204.         }  
205.         boolean flag = false;  
206.   
207.         try {  
208.             result = shardedJedis.getbit(key, offset);  
209.         } catch (Exception e) {  
210.             log.error(e.getMessage(), e);  
211.             flag = true;  
212.         } finally {  
213.             redisService.returnResource(shardedJedis, flag);  
214.         }  
215.         return result;  
216.     }  
217.   
218.     public long setrange(String key, long offset, String value) {  
219.         ShardedJedis shardedJedis = redisService.getRedisClient();  
220.         long result = ;  
221.         if (shardedJedis == null) {  
222.             return result;  
223.         }  
224.         boolean flag = false;  
225.         try {  
226.             result = shardedJedis.setrange(key, offset, value);  
227.         } catch (Exception e) {  
228.             log.error(e.getMessage(), e);  
229.             flag = true;  
230.         } finally {  
231.             redisService.returnResource(shardedJedis, flag);  
232.         }  
233.         return result;  
234.     }  
235.   
236.     public String getrange(String key, long startOffset, long endOffset) {  
237.         ShardedJedis shardedJedis = redisService.getRedisClient();  
238.         String result = null;  
239.         if (shardedJedis == null) {  
240.             return result;  
241.         }  
242.         boolean flag = false;  
243.         try {  
244.             result = shardedJedis.getrange(key, startOffset, endOffset);  
245.   
246.         } catch (Exception e) {  
247.             log.error(e.getMessage(), e);  
248.             flag = true;  
249.         } finally {  
250.             redisService.returnResource(shardedJedis, flag);  
251.         }  
252.         return result;  
253.     }  
254.   
255.     public String getSet(String key, String value) {  
256.         String result = null;  
257.         ShardedJedis shardedJedis = redisService.getRedisClient();  
258.         if (shardedJedis == null) {  
259.             return result;  
260.         }  
261.         boolean flag = false;  
262.         try {  
263.             result = shardedJedis.getSet(key, value);  
264.         } catch (Exception e) {  
265.             log.error(e.getMessage(), e);  
266.             flag = true;  
267.         } finally {  
268.             redisService.returnResource(shardedJedis, flag);  
269.         }  
270.         return result;  
271.     }  
272.   
273.     public Long setnx(String key, String value) {  
274.         Long result = null;  
275.         ShardedJedis shardedJedis = redisService.getRedisClient();  
276.         if (shardedJedis == null) {  
277.             return result;  
278.         }  
279.         boolean flag = false;  
280.         try {  
281.             result = shardedJedis.setnx(key, value);  
282.         } catch (Exception e) {  
283.             log.error(e.getMessage(), e);  
284.             flag = true;  
285.         } finally {  
286.             redisService.returnResource(shardedJedis, flag);  
287.         }  
288.         return result;  
289.     }  
290.   
291.     public String setex(String key, int seconds, String value) {  
292.         String result = null;  
293.         ShardedJedis shardedJedis = redisService.getRedisClient();  
294.         if (shardedJedis == null) {  
295.             return result;  
296.         }  
297.         boolean flag = false;  
298.         try {  
299.             result = shardedJedis.setex(key, seconds, value);  
300.   
301.         } catch (Exception e) {  
302.             log.error(e.getMessage(), e);  
303.             flag = true;  
304.         } finally {  
305.             redisService.returnResource(shardedJedis, flag);  
306.         }  
307.         return result;  
308.     }  
309.   
310.     public Long decrBy(String key, long integer) {  
311.         Long result = null;  
312.         ShardedJedis shardedJedis = redisService.getRedisClient();  
313.         if (shardedJedis == null) {  
314.             return result;  
315.         }  
316.         boolean flag = false;  
317.         try {  
318.             result = shardedJedis.decrBy(key, integer);  
319.   
320.         } catch (Exception e) {  
321.             log.error(e.getMessage(), e);  
322.             flag = true;  
323.         } finally {  
324.             redisService.returnResource(shardedJedis, flag);  
325.         }  
326.         return result;  
327.     }  
328.   
329.     public Long decr(String key) {  
330.         Long result = null;  
331.         ShardedJedis shardedJedis = redisService.getRedisClient();  
332.         if (shardedJedis == null) {  
333.             return result;  
334.         }  
335.         boolean flag = false;  
336.         try {  
337.             result = shardedJedis.decr(key);  
338.   
339.         } catch (Exception e) {  
340.             log.error(e.getMessage(), e);  
341.             flag = true;  
342.         } finally {  
343.             redisService.returnResource(shardedJedis, flag);  
344.         }  
345.         return result;  
346.     }  
347.   
348.     public Long incrBy(String key, long integer) {  
349.         Long result = null;  
350.         ShardedJedis shardedJedis = redisService.getRedisClient();  
351.         if (shardedJedis == null) {  
352.             return result;  
353.         }  
354.         boolean flag = false;  
355.         try {  
356.             result = shardedJedis.incrBy(key, integer);  
357.   
358.         } catch (Exception e) {  
359.             log.error(e.getMessage(), e);  
360.             flag = true;  
361.         } finally {  
362.             redisService.returnResource(shardedJedis, flag);  
363.         }  
364.         return result;  
365.     }  
366.   
367.     public Long incr(String key) {  
368.         Long result = null;  
369.         ShardedJedis shardedJedis = redisService.getRedisClient();  
370.         if (shardedJedis == null) {  
371.             return result;  
372.         }  
373.         boolean flag = false;  
374.         try {  
375.             result = shardedJedis.incr(key);  
376.   
377.         } catch (Exception e) {  
378.             log.error(e.getMessage(), e);  
379.             flag = true;  
380.         } finally {  
381.             redisService.returnResource(shardedJedis, flag);  
382.         }  
383.         return result;  
384.     }  
385.   
386.     public Long append(String key, String value) {  
387.         Long result = null;  
388.         ShardedJedis shardedJedis = redisService.getRedisClient();  
389.         if (shardedJedis == null) {  
390.             return result;  
391.         }  
392.         boolean flag = false;  
393.         try {  
394.             result = shardedJedis.append(key, value);  
395.   
396.         } catch (Exception e) {  
397.             log.error(e.getMessage(), e);  
398.             flag = true;  
399.         } finally {  
400.             redisService.returnResource(shardedJedis, flag);  
401.         }  
402.         return result;  
403.     }  
404.   
405.     public String substr(String key, int start, int end) {  
406.         String result = null;  
407.         ShardedJedis shardedJedis = redisService.getRedisClient();  
408.         if (shardedJedis == null) {  
409.             return result;  
410.         }  
411.         boolean flag = false;  
412.         try {  
413.             result = shardedJedis.substr(key, start, end);  
414.   
415.         } catch (Exception e) {  
416.             log.error(e.getMessage(), e);  
417.             flag = true;  
418.         } finally {  
419.             redisService.returnResource(shardedJedis, flag);  
420.         }  
421.         return result;  
422.     }  
423.   
424.     public Long hset(String key, String field, String value) {  
425.         Long result = null;  
426.         ShardedJedis shardedJedis = redisService.getRedisClient();  
427.         if (shardedJedis == null) {  
428.             return result;  
429.         }  
430.         boolean flag = false;  
431.         try {  
432.             result = shardedJedis.hset(key, field, value);  
433.   
434.         } catch (Exception e) {  
435.             log.error(e.getMessage(), e);  
436.             flag = true;  
437.         } finally {  
438.             redisService.returnResource(shardedJedis, flag);  
439.         }  
440.         return result;  
441.     }  
442.   
443.     public String hget(String key, String field) {  
444.         String result = null;  
445.         ShardedJedis shardedJedis = redisService.getRedisClient();  
446.         if (shardedJedis == null) {  
447.             return result;  
448.         }  
449.         boolean flag = false;  
450.         try {  
451.             result = shardedJedis.hget(key, field);  
452.   
453.         } catch (Exception e) {  
454.             log.error(e.getMessage(), e);  
455.             flag = true;  
456.         } finally {  
457.             redisService.returnResource(shardedJedis, flag);  
458.         }  
459.         return result;  
460.     }  
461.   
462.     public Long hsetnx(String key, String field, String value) {  
463.         Long result = null;  
464.         ShardedJedis shardedJedis = redisService.getRedisClient();  
465.         if (shardedJedis == null) {  
466.             return result;  
467.         }  
468.         boolean flag = false;  
469.         try {  
470.             result = shardedJedis.hsetnx(key, field, value);  
471.   
472.         } catch (Exception e) {  
473.             log.error(e.getMessage(), e);  
474.             flag = true;  
475.         } finally {  
476.             redisService.returnResource(shardedJedis, flag);  
477.         }  
478.         return result;  
479.     }  
480.   
481.     public String hmset(String key, Map<String, String> hash) {  
482.         String result = null;  
483.         ShardedJedis shardedJedis = redisService.getRedisClient();  
484.         if (shardedJedis == null) {  
485.             return result;  
486.         }  
487.         boolean flag = false;  
488.         try {  
489.             result = shardedJedis.hmset(key, hash);  
490.   
491.         } catch (Exception e) {  
492.             log.error(e.getMessage(), e);  
493.             flag = true;  
494.         } finally {  
495.             redisService.returnResource(shardedJedis, flag);  
496.         }  
497.         return result;  
498.     }  
499.   
500.     public List<String> hmget(String key, String... fields) {  
501.         List<String> result = null;  
502.         ShardedJedis shardedJedis = redisService.getRedisClient();  
503.         if (shardedJedis == null) {  
504.             return result;  
505.         }  
506.         boolean flag = false;  
507.         try {  
508.             result = shardedJedis.hmget(key, fields);  
509.   
510.         } catch (Exception e) {  
511.             log.error(e.getMessage(), e);  
512.             flag = true;  
513.         } finally {  
514.             redisService.returnResource(shardedJedis, flag);  
515.         }  
516.         return result;  
517.     }  
518.   
519.     public Long hincrBy(String key, String field, long value) {  
520.         Long result = null;  
521.         ShardedJedis shardedJedis = redisService.getRedisClient();  
522.         if (shardedJedis == null) {  
523.             return result;  
524.         }  
525.         boolean flag = false;  
526.         try {  
527.             result = shardedJedis.hincrBy(key, field, value);  
528.   
529.         } catch (Exception e) {  
530.             log.error(e.getMessage(), e);  
531.             flag = true;  
532.         } finally {  
533.             redisService.returnResource(shardedJedis, flag);  
534.         }  
535.         return result;  
536.     }  
537.   
538.     public Boolean hexists(String key, String field) {  
539.         Boolean result = false;  
540.         ShardedJedis shardedJedis = redisService.getRedisClient();  
541.         if (shardedJedis == null) {  
542.             return result;  
543.         }  
544.         boolean flag = false;  
545.         try {  
546.             result = shardedJedis.hexists(key, field);  
547.   
548.         } catch (Exception e) {  
549.             log.error(e.getMessage(), e);  
550.             flag = true;  
551.         } finally {  
552.             redisService.returnResource(shardedJedis, flag);  
553.         }  
554.         return result;  
555.     }  
556.   
557.     public Long del(String key) {  
558.         Long result = null;  
559.         ShardedJedis shardedJedis = redisService.getRedisClient();  
560.         if (shardedJedis == null) {  
561.             return result;  
562.         }  
563.         boolean flag = false;  
564.         try {  
565.             result = shardedJedis.del(key);  
566.   
567.         } catch (Exception e) {  
568.             log.error(e.getMessage(), e);  
569.             flag = true;  
570.         } finally {  
571.             redisService.returnResource(shardedJedis, flag);  
572.         }  
573.         return result;  
574.     }  
575.   
576.     public Long hdel(String key, String field) {  
577.         Long result = null;  
578.         ShardedJedis shardedJedis = redisService.getRedisClient();  
579.         if (shardedJedis == null) {  
580.             return result;  
581.         }  
582.         boolean flag = false;  
583.         try {  
584.             result = shardedJedis.hdel(key, field);  
585.   
586.         } catch (Exception e) {  
587.             log.error(e.getMessage(), e);  
588.             flag = true;  
589.         } finally {  
590.             redisService.returnResource(shardedJedis, flag);  
591.         }  
592.         return result;  
593.     }  
594.   
595.     public Long hlen(String key) {  
596.         Long result = null;  
597.         ShardedJedis shardedJedis = redisService.getRedisClient();  
598.         if (shardedJedis == null) {  
599.             return result;  
600.         }  
601.         boolean flag = false;  
602.         try {  
603.             result = shardedJedis.hlen(key);  
604.   
605.         } catch (Exception e) {  
606.             log.error(e.getMessage(), e);  
607.             flag = true;  
608.         } finally {  
609.             redisService.returnResource(shardedJedis, flag);  
610.         }  
611.         return result;  
612.     }  
613.   
614.     public Set<String> hkeys(String key) {  
615.         Set<String> result = null;  
616.         ShardedJedis shardedJedis = redisService.getRedisClient();  
617.         if (shardedJedis == null) {  
618.             return result;  
619.         }  
620.         boolean flag = false;  
621.         try {  
622.             result = shardedJedis.hkeys(key);  
623.   
624.         } catch (Exception e) {  
625.             log.error(e.getMessage(), e);  
626.             flag = true;  
627.         } finally {  
628.             redisService.returnResource(shardedJedis, flag);  
629.         }  
630.         return result;  
631.     }  
632.   
633.     public List<String> hvals(String key) {  
634.         List<String> result = null;  
635.         ShardedJedis shardedJedis = redisService.getRedisClient();  
636.         if (shardedJedis == null) {  
637.             return result;  
638.         }  
639.         boolean flag = false;  
640.         try {  
641.             result = shardedJedis.hvals(key);  
642.   
643.         } catch (Exception e) {  
644.             log.error(e.getMessage(), e);  
645.             flag = true;  
646.         } finally {  
647.             redisService.returnResource(shardedJedis, flag);  
648.         }  
649.         return result;  
650.     }  
651.   
652.     public Map<String, String> hgetAll(String key) {  
653.         Map<String, String> result = null;  
654.         ShardedJedis shardedJedis = redisService.getRedisClient();  
655.         if (shardedJedis == null) {  
656.             return result;  
657.         }  
658.         boolean flag = false;  
659.         try {  
660.             result = shardedJedis.hgetAll(key);  
661.   
662.         } catch (Exception e) {  
663.             log.error(e.getMessage(), e);  
664.             flag = true;  
665.         } finally {  
666.             redisService.returnResource(shardedJedis, flag);  
667.         }  
668.         return result;  
669.     }  
670.   
671.     /** 
672.      * 在redis list尾部增加一个String 
673.      * */  
674.     public Long rpush(String key, String string) {  
675.         Long result = null;  
676.         ShardedJedis shardedJedis = redisService.getRedisClient();  
677.         if (shardedJedis == null) {  
678.             return result;  
679.         }  
680.         boolean flag = false;  
681.         try {  
682.             result = shardedJedis.rpush(key, string);  
683.   
684.         } catch (Exception e) {  
685.             log.error(e.getMessage(), e);  
686.             flag = true;  
687.         } finally {  
688.             redisService.returnResource(shardedJedis, flag);  
689.         }  
690.         return result;  
691.     }  
692.   
693.     /** 
694.      * 在redis list头部增加一个String 
695.      * */  
696.     public Long lpush(String key, String string) {  
697.         Long result = null;  
698.         ShardedJedis shardedJedis = redisService.getRedisClient();  
699.         if (shardedJedis == null) {  
700.             return result;  
701.         }  
702.         boolean flag = false;  
703.         try {  
704.             result = shardedJedis.lpush(key, string);  
705.   
706.         } catch (Exception e) {  
707.             log.error(e.getMessage(), e);  
708.             flag = true;  
709.         } finally {  
710.             redisService.returnResource(shardedJedis, flag);  
711.         }  
712.         return result;  
713.     }  
714.   
715.     public Long llen(String key) {  
716.         Long result = null;  
717.         ShardedJedis shardedJedis = redisService.getRedisClient();  
718.         if (shardedJedis == null) {  
719.             return result;  
720.         }  
721.         boolean flag = false;  
722.         try {  
723.             result = shardedJedis.llen(key);  
724.   
725.         } catch (Exception e) {  
726.             log.error(e.getMessage(), e);  
727.             flag = true;  
728.         } finally {  
729.             redisService.returnResource(shardedJedis, flag);  
730.         }  
731.         return result;  
732.     }  
733.   
734.     public List<String> lrange(String key, long start, long end) {  
735.         List<String> result = null;  
736.         ShardedJedis shardedJedis = redisService.getRedisClient();  
737.         if (shardedJedis == null) {  
738.             return result;  
739.         }  
740.         boolean flag = false;  
741.         try {  
742.             result = shardedJedis.lrange(key, start, end);  
743.   
744.         } catch (Exception e) {  
745.             log.error(e.getMessage(), e);  
746.             flag = true;  
747.         } finally {  
748.             redisService.returnResource(shardedJedis, flag);  
749.         }  
750.         return result;  
751.     }  
752.   
753.     public String ltrim(String key, long start, long end) {  
754.         String result = null;  
755.         ShardedJedis shardedJedis = redisService.getRedisClient();  
756.         if (shardedJedis == null) {  
757.             return result;  
758.         }  
759.         boolean flag = false;  
760.         try {  
761.             result = shardedJedis.ltrim(key, start, end);  
762.   
763.         } catch (Exception e) {  
764.             log.error(e.getMessage(), e);  
765.             flag = true;  
766.         } finally {  
767.             redisService.returnResource(shardedJedis, flag);  
768.         }  
769.         return result;  
770.     }  
771.   
772.     public String lIndex(String key, long index) {  
773.         String result = null;  
774.         ShardedJedis shardedJedis = redisService.getRedisClient();  
775.         if (shardedJedis == null) {  
776.             return result;  
777.         }  
778.         boolean flag = false;  
779.         try {  
780.             result = shardedJedis.lindex(key, index);  
781.   
782.         } catch (Exception e) {  
783.             log.error(e.getMessage(), e);  
784.             flag = true;  
785.         } finally {  
786.             redisService.returnResource(shardedJedis, flag);  
787.         }  
788.         return result;  
789.     }  
790.   
791.     public String lset(String key, long index, String value) {  
792.         String result = null;  
793.         ShardedJedis shardedJedis = redisService.getRedisClient();  
794.         if (shardedJedis == null) {  
795.             return result;  
796.         }  
797.         boolean flag = false;  
798.         try {  
799.             result = shardedJedis.lset(key, index, value);  
800.   
801.         } catch (Exception e) {  
802.             log.error(e.getMessage(), e);  
803.             flag = true;  
804.         } finally {  
805.             redisService.returnResource(shardedJedis, flag);  
806.         }  
807.         return result;  
808.     }  
809.   
810.     public Long lrem(String key, long count, String value) {  
811.         Long result = null;  
812.         ShardedJedis shardedJedis = redisService.getRedisClient();  
813.         if (shardedJedis == null) {  
814.             return result;  
815.         }  
816.         boolean flag = false;  
817.         try {  
818.             result = shardedJedis.lrem(key, count, value);  
819.   
820.         } catch (Exception e) {  
821.             log.error(e.getMessage(), e);  
822.             flag = true;  
823.         } finally {  
824.             redisService.returnResource(shardedJedis, flag);  
825.         }  
826.         return result;  
827.     }  
828.   
829.     /** 
830.      * 从redis list头部取出一个key 
831.      * */  
832.     public String lpop(String key) {  
833.         String result = null;  
834.         ShardedJedis shardedJedis = redisService.getRedisClient();  
835.         if (shardedJedis == null) {  
836.             return result;  
837.         }  
838.         boolean flag = false;  
839.         try {  
840.             result = shardedJedis.lpop(key);  
841.   
842.         } catch (Exception e) {  
843.             log.error(e.getMessage(), e);  
844.             flag = true;  
845.         } finally {  
846.             redisService.returnResource(shardedJedis, flag);  
847.         }  
848.         return result;  
849.     }  
850.   
851.     /** 
852.      * 从redis list尾部取出一个key 
853.      * */  
854.     public String rpop(String key) {  
855.         String result = null;  
856.         ShardedJedis shardedJedis = redisService.getRedisClient();  
857.         if (shardedJedis == null) {  
858.             return result;  
859.         }  
860.         boolean flag = false;  
861.         try {  
862.             result = shardedJedis.rpop(key);  
863.   
864.         } catch (Exception e) {  
865.             log.error(e.getMessage(), e);  
866.             flag = true;  
867.         } finally {  
868.             redisService.returnResource(shardedJedis, flag);  
869.         }  
870.         return result;  
871.     }  
872.   
873.     public Long sadd(String key, String member) {  
874.         Long result = null;  
875.         ShardedJedis shardedJedis = redisService.getRedisClient();  
876.         if (shardedJedis == null) {  
877.             return result;  
878.         }  
879.         boolean flag = false;  
880.         try {  
881.             result = shardedJedis.sadd(key, member);  
882.   
883.         } catch (Exception e) {  
884.             log.error(e.getMessage(), e);  
885.             flag = true;  
886.         } finally {  
887.             redisService.returnResource(shardedJedis, flag);  
888.         }  
889.         return result;  
890.     }  
891.   
892.     public Set<String> smembers(String key) {  
893.         Set<String> result = null;  
894.         ShardedJedis shardedJedis = redisService.getRedisClient();  
895.         if (shardedJedis == null) {  
896.             return result;  
897.         }  
898.         boolean flag = false;  
899.         try {  
900.             result = shardedJedis.smembers(key);  
901.   
902.         } catch (Exception e) {  
903.             log.error(e.getMessage(), e);  
904.             flag = true;  
905.         } finally {  
906.             redisService.returnResource(shardedJedis, flag);  
907.         }  
908.         return result;  
909.     }  
910.   
911.     public Long srem(String key, String member) {  
912.         ShardedJedis shardedJedis = redisService.getRedisClient();  
913.   
914.         Long result = null;  
915.         if (shardedJedis == null) {  
916.             return result;  
917.         }  
918.         boolean flag = false;  
919.         try {  
920.             result = shardedJedis.srem(key, member);  
921.         } catch (Exception e) {  
922.             log.error(e.getMessage(), e);  
923.             flag = true;  
924.         } finally {  
925.             redisService.returnResource(shardedJedis, flag);  
926.         }  
927.         return result;  
928.     }  
929.   
930.     public String spop(String key) {  
931.         ShardedJedis shardedJedis = redisService.getRedisClient();  
932.         String result = null;  
933.         if (shardedJedis == null) {  
934.             return result;  
935.         }  
936.         boolean flag = false;  
937.         try {  
938.             result = shardedJedis.spop(key);  
939.         } catch (Exception e) {  
940.             log.error(e.getMessage(), e);  
941.             flag = true;  
942.         } finally {  
943.             redisService.returnResource(shardedJedis, flag);  
944.         }  
945.         return result;  
946.     }  
947.   
948.     public Long scard(String key) {  
949.         ShardedJedis shardedJedis = redisService.getRedisClient();  
950.         Long result = null;  
951.         if (shardedJedis == null) {  
952.             return result;  
953.         }  
954.         boolean flag = false;  
955.         try {  
956.             result = shardedJedis.scard(key);  
957.   
958.         } catch (Exception e) {  
959.             log.error(e.getMessage(), e);  
960.             flag = true;  
961.         } finally {  
962.             redisService.returnResource(shardedJedis, flag);  
963.         }  
964.         return result;  
965.     }  
966.   
967.     public Boolean sismember(String key, String member) {  
968.         ShardedJedis shardedJedis = redisService.getRedisClient();  
969.         Boolean result = null;  
970.         if (shardedJedis == null) {  
971.             return result;  
972.         }  
973.         boolean flag = false;  
974.         try {  
975.             result = shardedJedis.sismember(key, member);  
976.         } catch (Exception e) {  
977.             log.error(e.getMessage(), e);  
978.             flag = true;  
979.         } finally {  
980.             redisService.returnResource(shardedJedis, flag);  
981.         }  
982.         return result;  
983.     }  
984.   
985.     public String srandmember(String key) {  
986.         ShardedJedis shardedJedis = redisService.getRedisClient();  
987.         String result = null;  
988.         if (shardedJedis == null) {  
989.             return result;  
990.         }  
991.         boolean flag = false;  
992.         try {  
993.             result = shardedJedis.srandmember(key);  
994.         } catch (Exception e) {  
995.             log.error(e.getMessage(), e);  
996.            flag = true;  
997.        } finally {  
998.            redisService.returnResource(shardedJedis, flag);  
999.        }  
1000.        return result;  
1001.    }  
1002.   
1003.    public Long zadd(String key, double score, String member) {  
1004.        Long result = null;  
1005.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1006.        if (shardedJedis == null) {  
1007.            return result;  
1008.        }  
1009.        boolean flag = false;  
1010.        try {  
1011.            result = shardedJedis.zadd(key, score, member);  
1012.        } catch (Exception e) {  
1013.            log.error(e.getMessage(), e);  
1014.            flag = true;  
1015.        } finally {  
1016.            redisService.returnResource(shardedJedis, flag);  
1017.        }  
1018.        return result;  
1019.    }  
1020.   
1021.    public Set<String> zrange(String key, int start, int end) {  
1022.        Set<String> result = null;  
1023.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1024.        if (shardedJedis == null) {  
1025.            return result;  
1026.        }  
1027.        boolean flag = false;  
1028.        try {  
1029.            result = shardedJedis.zrange(key, start, end);  
1030.        } catch (Exception e) {  
1031.            log.error(e.getMessage(), e);  
1032.            flag = true;  
1033.        } finally {  
1034.            redisService.returnResource(shardedJedis, flag);  
1035.        }  
1036.        return result;  
1037.    }  
1038.   
1039.    public Long zrem(String key, String member) {  
1040.        Long result = null;  
1041.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1042.        if (shardedJedis == null) {  
1043.            return result;  
1044.        }  
1045.        boolean flag = false;  
1046.        try {  
1047.            result = shardedJedis.zrem(key, member);  
1048.        } catch (Exception e) {  
1049.            log.error(e.getMessage(), e);  
1050.            flag = true;  
1051.        } finally {  
1052.            redisService.returnResource(shardedJedis, flag);  
1053.        }  
1054.        return result;  
1055.    }  
1056.   
1057.    public Double zincrby(String key, double score, String member) {  
1058.        Double result = null;  
1059.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1060.        if (shardedJedis == null) {  
1061.            return result;  
1062.        }  
1063.        boolean flag = false;  
1064.        try {  
1065.   
1066.            result = shardedJedis.zincrby(key, score, member);  
1067.   
1068.        } catch (Exception e) {  
1069.            log.error(e.getMessage(), e);  
1070.            flag = true;  
1071.        } finally {  
1072.            redisService.returnResource(shardedJedis, flag);  
1073.        }  
1074.        return result;  
1075.    }  
1076.   
1077.    public Long zrank(String key, String member) {  
1078.        Long result = null;  
1079.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1080.        if (shardedJedis == null) {  
1081.            return result;  
1082.        }  
1083.        boolean flag = false;  
1084.        try {  
1085.   
1086.            result = shardedJedis.zrank(key, member);  
1087.   
1088.        } catch (Exception e) {  
1089.            log.error(e.getMessage(), e);  
1090.            flag = true;  
1091.        } finally {  
1092.            redisService.returnResource(shardedJedis, flag);  
1093.        }  
1094.        return result;  
1095.    }  
1096.   
1097.    public Long zrevrank(String key, String member) {  
1098.        Long result = null;  
1099.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1100.        if (shardedJedis == null) {  
1101.            return result;  
1102.        }  
1103.        boolean flag = false;  
1104.        try {  
1105.   
1106.            result = shardedJedis.zrevrank(key, member);  
1107.   
1108.        } catch (Exception e) {  
1109.            log.error(e.getMessage(), e);  
1110.            flag = true;  
1111.        } finally {  
1112.            redisService.returnResource(shardedJedis, flag);  
1113.        }  
1114.        return result;  
1115.    }  
1116.   
1117.    public Set<String> zrevrange(String key, int start, int end) {  
1118.        Set<String> result = null;  
1119.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1120.        if (shardedJedis == null) {  
1121.            return result;  
1122.        }  
1123.        boolean flag = false;  
1124.        try {  
1125.   
1126.            result = shardedJedis.zrevrange(key, start, end);  
1127.   
1128.        } catch (Exception e) {  
1129.            log.error(e.getMessage(), e);  
1130.            flag = true;  
1131.        } finally {  
1132.            redisService.returnResource(shardedJedis, flag);  
1133.        }  
1134.        return result;  
1135.    }  
1136.   
1137.    public Set<Tuple> zrangeWithScores(String key, int start, int end) {  
1138.        Set<Tuple> result = null;  
1139.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1140.        if (shardedJedis == null) {  
1141.            return result;  
1142.        }  
1143.        boolean flag = false;  
1144.        try {  
1145.   
1146.            result = shardedJedis.zrangeWithScores(key, start, end);  
1147.   
1148.        } catch (Exception e) {  
1149.            log.error(e.getMessage(), e);  
1150.            flag = true;  
1151.        } finally {  
1152.            redisService.returnResource(shardedJedis, flag);  
1153.        }  
1154.        return result;  
1155.    }  
1156.   
1157.    public Set<Tuple> zrevrangeWithScores(String key, int start, int end) {  
1158.        Set<Tuple> result = null;  
1159.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1160.        if (shardedJedis == null) {  
1161.            return result;  
1162.        }  
1163.        boolean flag = false;  
1164.        try {  
1165.   
1166.            result = shardedJedis.zrevrangeWithScores(key, start, end);  
1167.   
1168.        } catch (Exception e) {  
1169.            log.error(e.getMessage(), e);  
1170.            flag = true;  
1171.        } finally {  
1172.            redisService.returnResource(shardedJedis, flag);  
1173.        }  
1174.        return result;  
1175.    }  
1176.   
1177.    public Long zcard(String key) {  
1178.        Long result = null;  
1179.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1180.        if (shardedJedis == null) {  
1181.            return result;  
1182.        }  
1183.        boolean flag = false;  
1184.        try {  
1185.   
1186.            result = shardedJedis.zcard(key);  
1187.   
1188.        } catch (Exception e) {  
1189.            log.error(e.getMessage(), e);  
1190.            flag = true;  
1191.        } finally {  
1192.            redisService.returnResource(shardedJedis, flag);  
1193.        }  
1194.        return result;  
1195.    }  
1196.   
1197.    public Double zscore(String key, String member) {  
1198.        Double result = null;  
1199.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1200.        if (shardedJedis == null) {  
1201.            return result;  
1202.        }  
1203.        boolean flag = false;  
1204.        try {  
1205.   
1206.            result = shardedJedis.zscore(key, member);  
1207.   
1208.        } catch (Exception e) {  
1209.            log.error(e.getMessage(), e);  
1210.            flag = true;  
1211.        } finally {  
1212.            redisService.returnResource(shardedJedis, flag);  
1213.        }  
1214.        return result;  
1215.    }  
1216.   
1217.    public List<String> sort(String key) {  
1218.        List<String> result = null;  
1219.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1220.        if (shardedJedis == null) {  
1221.            return result;  
1222.        }  
1223.        boolean flag = false;  
1224.        try {  
1225.   
1226.            result = shardedJedis.sort(key);  
1227.   
1228.        } catch (Exception e) {  
1229.            log.error(e.getMessage(), e);  
1230.            flag = true;  
1231.        } finally {  
1232.            redisService.returnResource(shardedJedis, flag);  
1233.        }  
1234.        return result;  
1235.    }  
1236.   
1237.    public List<String> sort(String key, SortingParams sortingParameters) {  
1238.        List<String> result = null;  
1239.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1240.        if (shardedJedis == null) {  
1241.            return result;  
1242.        }  
1243.        boolean flag = false;  
1244.        try {  
1245.   
1246.            result = shardedJedis.sort(key, sortingParameters);  
1247.   
1248.        } catch (Exception e) {  
1249.            log.error(e.getMessage(), e);  
1250.            flag = true;  
1251.        } finally {  
1252.            redisService.returnResource(shardedJedis, flag);  
1253.        }  
1254.        return result;  
1255.    }  
1256.   
1257.    public Long zcount(String key, double min, double max) {  
1258.        Long result = null;  
1259.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1260.        if (shardedJedis == null) {  
1261.            return result;  
1262.        }  
1263.        boolean flag = false;  
1264.        try {  
1265.   
1266.            result = shardedJedis.zcount(key, min, max);  
1267.   
1268.        } catch (Exception e) {  
1269.            log.error(e.getMessage(), e);  
1270.            flag = true;  
1271.        } finally {  
1272.            redisService.returnResource(shardedJedis, flag);  
1273.        }  
1274.        return result;  
1275.    }  
1276.   
1277.    public Set<String> zrangeByScore(String key, double min, double max) {  
1278.        Set<String> result = null;  
1279.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1280.        if (shardedJedis == null) {  
1281.            return result;  
1282.        }  
1283.        boolean flag = false;  
1284.        try {  
1285.   
1286.            result = shardedJedis.zrangeByScore(key, min, max);  
1287.   
1288.        } catch (Exception e) {  
1289.            log.error(e.getMessage(), e);  
1290.            flag = true;  
1291.        } finally {  
1292.            redisService.returnResource(shardedJedis, flag);  
1293.        }  
1294.        return result;  
1295.    }  
1296.   
1297.    public Set<String> zrevrangeByScore(String key, double max, double min) {  
1298.        Set<String> result = null;  
1299.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1300.        if (shardedJedis == null) {  
1301.            return result;  
1302.        }  
1303.        boolean flag = false;  
1304.        try {  
1305.   
1306.            result = shardedJedis.zrevrangeByScore(key, max, min);  
1307.   
1308.        } catch (Exception e) {  
1309.            log.error(e.getMessage(), e);  
1310.            flag = true;  
1311.        } finally {  
1312.            redisService.returnResource(shardedJedis, flag);  
1313.        }  
1314.        return result;  
1315.    }  
1316.   
1317.    public Set<String> zrangeByScore(String key, double min, double max,  
1318.            int offset, int count) {  
1319.        Set<String> result = null;  
1320.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1321.        if (shardedJedis == null) {  
1322.            return result;  
1323.        }  
1324.        boolean flag = false;  
1325.        try {  
1326.   
1327.            result = shardedJedis.zrangeByScore(key, min, max, offset, count);  
1328.   
1329.        } catch (Exception e) {  
1330.            log.error(e.getMessage(), e);  
1331.            flag = true;  
1332.        } finally {  
1333.            redisService.returnResource(shardedJedis, flag);  
1334.        }  
1335.        return result;  
1336.    }  
1337.   
1338.    public Set<String> zrevrangeByScore(String key, double max, double min,  
1339.            int offset, int count) {  
1340.        Set<String> result = null;  
1341.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1342.        if (shardedJedis == null) {  
1343.            return result;  
1344.        }  
1345.        boolean flag = false;  
1346.        try {  
1347.   
1348.            result = shardedJedis  
1349.                    .zrevrangeByScore(key, max, min, offset, count);  
1350.   
1351.        } catch (Exception e) {  
1352.            log.error(e.getMessage(), e);  
1353.            flag = true;  
1354.        } finally {  
1355.            redisService.returnResource(shardedJedis, flag);  
1356.        }  
1357.        return result;  
1358.    }  
1359.   
1360.    public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max) {  
1361.   
1362.        Set<Tuple> result = null;  
1363.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1364.        if (shardedJedis == null) {  
1365.            return result;  
1366.        }  
1367.        boolean flag = false;  
1368.        try {  
1369.   
1370.            result = shardedJedis.zrangeByScoreWithScores(key, min, max);  
1371.   
1372.        } catch (Exception e) {  
1373.            log.error(e.getMessage(), e);  
1374.            flag = true;  
1375.        } finally {  
1376.            redisService.returnResource(shardedJedis, flag);  
1377.        }  
1378.        return result;  
1379.    }  
1380.   
1381.    public Set<Tuple> zrevrangeByScoreWithScores(String key, double max,  
1382.            double min) {  
1383.        Set<Tuple> result = null;  
1384.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1385.        if (shardedJedis == null) {  
1386.            return result;  
1387.        }  
1388.        boolean flag = false;  
1389.        try {  
1390.   
1391.            result = shardedJedis.zrevrangeByScoreWithScores(key, max, min);  
1392.   
1393.        } catch (Exception e) {  
1394.            log.error(e.getMessage(), e);  
1395.            flag = true;  
1396.        } finally {  
1397.            redisService.returnResource(shardedJedis, flag);  
1398.        }  
1399.        return result;  
1400.    }  
1401.   
1402.    public Set<Tuple> zrangeByScoreWithScores(String key, double min,  
1403.            double max, int offset, int count) {  
1404.        Set<Tuple> result = null;  
1405.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1406.        if (shardedJedis == null) {  
1407.            return result;  
1408.        }  
1409.        boolean flag = false;  
1410.        try {  
1411.   
1412.            result = shardedJedis.zrangeByScoreWithScores(key, min, max,  
1413.                    offset, count);  
1414.   
1415.        } catch (Exception e) {  
1416.            log.error(e.getMessage(), e);  
1417.            flag = true;  
1418.        } finally {  
1419.            redisService.returnResource(shardedJedis, flag);  
1420.        }  
1421.        return result;  
1422.    }  
1423.   
1424.    public Set<Tuple> zrevrangeByScoreWithScores(String key, double max,  
1425.            double min, int offset, int count) {  
1426.        Set<Tuple> result = null;  
1427.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1428.        if (shardedJedis == null) {  
1429.            return result;  
1430.        }  
1431.        boolean flag = false;  
1432.        try {  
1433.   
1434.            result = shardedJedis.zrevrangeByScoreWithScores(key, max, min,  
1435.                    offset, count);  
1436.   
1437.        } catch (Exception e) {  
1438.            log.error(e.getMessage(), e);  
1439.            flag = true;  
1440.        } finally {  
1441.            redisService.returnResource(shardedJedis, flag);  
1442.        }  
1443.        return result;  
1444.    }  
1445.   
1446.    public Long zremrangeByRank(String key, int start, int end) {  
1447.        Long result = null;  
1448.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1449.        if (shardedJedis == null) {  
1450.            return result;  
1451.        }  
1452.        boolean flag = false;  
1453.        try {  
1454.   
1455.            result = shardedJedis.zremrangeByRank(key, start, end);  
1456.   
1457.        } catch (Exception e) {  
1458.            log.error(e.getMessage(), e);  
1459.            flag = true;  
1460.        } finally {  
1461.            redisService.returnResource(shardedJedis, flag);  
1462.        }  
1463.        return result;  
1464.    }  
1465.   
1466.    public Long zremrangeByScore(String key, double start, double end) {  
1467.        Long result = null;  
1468.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1469.        if (shardedJedis == null) {  
1470.            return result;  
1471.        }  
1472.        boolean flag = false;  
1473.        try {  
1474.   
1475.            result = shardedJedis.zremrangeByScore(key, start, end);  
1476.   
1477.        } catch (Exception e) {  
1478.            log.error(e.getMessage(), e);  
1479.            flag = true;  
1480.        } finally {  
1481.            redisService.returnResource(shardedJedis, flag);  
1482.        }  
1483.        return result;  
1484.    }  
1485.   
1486.    public Long linsert(String key, LIST_POSITION where, String pivot,  
1487.            String value) {  
1488.        Long result = null;  
1489.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1490.        if (shardedJedis == null) {  
1491.            return result;  
1492.        }  
1493.        boolean flag = false;  
1494.        try {  
1495.   
1496.            result = shardedJedis.linsert(key, where, pivot, value);  
1497.   
1498.        } catch (Exception e) {  
1499.            log.error(e.getMessage(), e);  
1500.            flag = true;  
1501.        } finally {  
1502.            redisService.returnResource(shardedJedis, flag);  
1503.        }  
1504.        return result;  
1505.    }  
1506.   
1507.      
1508.    @SuppressWarnings("deprecation")  
1509.    public List<Object> pipelined(ShardedJedisPipeline shardedJedisPipeline) {  
1510.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1511.        List<Object> result = null;  
1512.        if (shardedJedis == null) {  
1513.            return result;  
1514.        }  
1515.        boolean flag = false;  
1516.        try {  
1517.            result = shardedJedis.pipelined(shardedJedisPipeline);  
1518.        } catch (Exception e) {  
1519.            log.error(e.getMessage(), e);  
1520.            flag = true;  
1521.        } finally {  
1522.            redisService.returnResource(shardedJedis, flag);  
1523.        }  
1524.        return result;  
1525.    }  
1526.   
1527.    public Jedis getShard(String key) {  
1528.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1529.        Jedis result = null;  
1530.        if (shardedJedis == null) {  
1531.            return result;  
1532.        }  
1533.        boolean flag = false;  
1534.        try {  
1535.            result = shardedJedis.getShard(key);  
1536.        } catch (Exception e) {  
1537.            log.error(e.getMessage(), e);  
1538.            flag = true;  
1539.        } finally {  
1540.            redisService.returnResource(shardedJedis, flag);  
1541.        }  
1542.        return result;  
1543.    }  
1544.   
1545.    public JedisShardInfo getShardInfo(String key) {  
1546.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1547.        JedisShardInfo result = null;  
1548.        if (shardedJedis == null) {  
1549.            return result;  
1550.        }  
1551.        boolean flag = false;  
1552.        try {  
1553.            result = shardedJedis.getShardInfo(key);  
1554.        } catch (Exception e) {  
1555.            log.error(e.getMessage(), e);  
1556.            flag = true;  
1557.        } finally {  
1558.            redisService.returnResource(shardedJedis, flag);  
1559.        }  
1560.        return result;  
1561.    }  
1562.   
1563.    public String getKeyTag(String key) {  
1564.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1565.        String result = null;  
1566.        if (shardedJedis == null) {  
1567.            return result;  
1568.        }  
1569.        boolean flag = false;  
1570.        try {  
1571.            result = shardedJedis.getKeyTag(key);  
1572.        } catch (Exception e) {  
1573.            log.error(e.getMessage(), e);  
1574.            flag = true;  
1575.        } finally {  
1576.            redisService.returnResource(shardedJedis, flag);  
1577.        }  
1578.        return result;  
1579.    }  
1580.   
1581.    public Collection<JedisShardInfo> getAllShardInfo() {  
1582.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1583.        Collection<JedisShardInfo> result = null;  
1584.        if (shardedJedis == null) {  
1585.            return result;  
1586.        }  
1587.        boolean flag = false;  
1588.        try {  
1589.            result = shardedJedis.getAllShardInfo();  
1590.   
1591.        } catch (Exception e) {  
1592.            log.error(e.getMessage(), e);  
1593.            flag = true;  
1594.        } finally {  
1595.            redisService.returnResource(shardedJedis, flag);  
1596.        }  
1597.        return result;  
1598.    }  
1599.   
1600.    public Collection<Jedis> getAllShards() {  
1601.        ShardedJedis shardedJedis = redisService.getRedisClient();  
1602.        Collection<Jedis> result = null;  
1603.        if (shardedJedis == null) {  
1604.            return result;  
1605.        }  
1606.        boolean flag = false;  
1607.        try {  
1608.            result = shardedJedis.getAllShards();  
1609.   
1610.        } catch (Exception e) {  
1611.            log.error(e.getMessage(), e);  
1612.            flag = true;  
1613.        } finally {  
1614.            redisService.returnResource(shardedJedis, flag);  
1615.        }  
1616.        return result;  
1617.    }