Redis客戶端之Spring整合Jedis，redisspringjedis

Redis客戶端之Spring整合Jedis，redisspringjedis

1.下載相關jar包，並引入工程：

jedis-2.4.2.jar

commons-pool2-2.0.jar

2.將以下XML配置引入spring

1. <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">  
2.        <constructor-arg index="0" ref="jedisPoolConfig"/>  
3.        <constructor-arg index="1">  
4.            <list>  
5.                 <bean name="slaver" class="redis.clients.jedis.JedisShardInfo">  
6.                    <constructor-arg index="0" value="${redis.slaver.host}"/>  
7.                    <constructor-arg index="1" value="${redis.slaver.port}" type="int"/>  
8.                </bean>  
9.                 <bean name="master" class="redis.clients.jedis.JedisShardInfo">  
10.                    <constructor-arg index="0" value="${redis.master.host}"/>  
11.                    <constructor-arg index="1" value="${redis.master.port}" type="int"/>  
12.                </bean>  
13.            </list>  
14.        </constructor-arg>  
15.    </bean>  
16.   
17.    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">  
18.        <property name="maxTotal" value="2048" />  
19.        <property name="maxIdle" value="200" />  
20.        <property name="numTestsPerEvictionRun" value="1024"/>  
21.        <property name="timeBetweenEvictionRunsMillis" value="30000" />  
22.        <property name="minEvictableIdleTimeMillis" value="-1" />  
23.        <property name="softMinEvictableIdleTimeMillis" value="10000" />  
24.        <property name="maxWaitMillis" value="1500"/>  
25.        <property name="testOnBorrow" value="true" />  
26.        <property name="testWhileIdle" value="true"/>  
27.        <property name="testOnReturn" value="false"/>  
28.        <property name="jmxEnabled" value="true"/>  
29.        <property name="jmxNamePrefix" value="youyuan"/>  
30.        <property name="blockWhenExhausted" value="false"/>  
31.    </bean>  

3.將shardedJedisPool注入相關的類中即可使用

1. @Resource  
2.     private ShardedJedisPool shardedJedisPool;  
3.   
4.   
5.     /** 
6.      * 設置一個key的過期時間（單位：秒） 
7.      * @param key key值 
8.      * @param seconds 多少秒後過期 
9.      * @return 1：設置了過期時間  0：沒有設置過期時間/不能設置過期時間 
10.      */  
11.     public long expire(String key, int seconds) {  
12.         if (key==null || key.equals("")) {  
13.             return 0;  
14.         }  
15.   
16.         ShardedJedis shardedJedis = null;  
17.         try {  
18.             shardedJedis = shardedJedisPool.getResource();  
19.             return shardedJedis.expire(key, seconds);  
20.         } catch (Exception ex) {  
21.             logger.error("EXPIRE error[key=" + key + " seconds=" + seconds + "]" + ex.getMessage(), ex);  
22.             returnBrokenResource(shardedJedis);  
23.         } finally {  
24.             returnResource(shardedJedis);  
25.         }  
26.         return 0;  
27.     }  
28.   
29.     /** 
30.      * 設置一個key在某個時間點過期 
31.      * @param key key值 
32.      * @param unixTimestamp unix時間戳，從1970-01-01 00:00:00開始到現在的秒數 
33.      * @return 1：設置了過期時間  0：沒有設置過期時間/不能設置過期時間 
34.      */  
35.     public long expireAt(String key, int unixTimestamp) {  
36.         if (key==null || key.equals("")) {  
37.             return 0;  
38.         }  
39.   
40.         ShardedJedis shardedJedis = null;  
41.         try {  
42.             shardedJedis = shardedJedisPool.getResource();  
43.             return shardedJedis.expireAt(key, unixTimestamp);  
44.         } catch (Exception ex) {  
45.             logger.error("EXPIRE error[key=" + key + " unixTimestamp=" + unixTimestamp + "]" + ex.getMessage(), ex);  
46.             returnBrokenResource(shardedJedis);  
47.         } finally {  
48.             returnResource(shardedJedis);  
49.         }  
50.         return 0;  
51.     }  
52.   
53.     /** 
54.      * 截斷一個List 
55.      * @param key 列表key 
56.      * @param start 開始位置 從0開始 
57.      * @param end 結束位置 
58.      * @return 狀態碼 
59.      */  
60.     public String trimList(String key, long start, long end) {  
61.         if (key == null || key.equals("")) {  
62.             return "-";  
63.         }  
64.         ShardedJedis shardedJedis = null;  
65.         try {  
66.             shardedJedis = shardedJedisPool.getResource();  
67.             return shardedJedis.ltrim(key, start, end);  
68.         } catch (Exception ex) {  
69.             logger.error("LTRIM 出錯[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);  
70.             returnBrokenResource(shardedJedis);  
71.         } finally {  
72.             returnResource(shardedJedis);  
73.         }  
74.         return "-";  
75.     }  
76.     /** 
77.      * 檢查Set長度 
78.      * @param key 
79.      * @return 
80.      */  
81.     public long countSet(String key){  
82.         if(key == null ){  
83.             return 0;  
84.         }  
85.         ShardedJedis shardedJedis = null;  
86.         try {  
87.             shardedJedis = shardedJedisPool.getResource();  
88.             return shardedJedis.scard(key);  
89.         } catch (Exception ex) {  
90.             logger.error("countSet error.", ex);  
91.             returnBrokenResource(shardedJedis);  
92.         } finally {  
93.             returnResource(shardedJedis);  
94.         }  
95.         return 0;  
96.     }  
97.     /** 
98.      * 添加到Set中（同時設置過期時間） 
99.      * @param key key值 
100.      * @param seconds 過期時間 單位s 
101.      * @param value 
102.      * @return 
103.      */  
104.     public boolean addSet(String key,int seconds, String... value) {  
105.         boolean result = addSet(key, value);  
106.         if(result){  
107.             long i = expire(key, seconds);  
108.             return i==1;  
109.         }  
110.         return false;  
111.     }  
112.     /** 
113.      * 添加到Set中 
114.      * @param key 
115.      * @param value 
116.      * @return 
117.      */  
118.     public boolean addSet(String key, String... value) {  
119.         if(key == null || value == null){  
120.             return false;  
121.         }  
122.         ShardedJedis shardedJedis = null;  
123.         try {  
124.             shardedJedis = shardedJedisPool.getResource();  
125.             shardedJedis.sadd(key, value);  
126.             return true;  
127.         } catch (Exception ex) {  
128.             logger.error("setList error.", ex);  
129.             returnBrokenResource(shardedJedis);  
130.         } finally {  
131.             returnResource(shardedJedis);  
132.         }  
133.         return false;  
134.     }  
135.   
136.       
137.     /** 
138.      * @param key 
139.      * @param value 
140.      * @return 判斷值是否包含在set中 
141.      */  
142.     public boolean containsInSet(String key, String value) {  
143.         if(key == null || value == null){  
144.             return false;  
145.         }  
146.         ShardedJedis shardedJedis = null;  
147.         try {  
148.             shardedJedis = shardedJedisPool.getResource();  
149.             return shardedJedis.sismember(key, value);  
150.         } catch (Exception ex) {  
151.             logger.error("setList error.", ex);  
152.             returnBrokenResource(shardedJedis);  
153.         } finally {  
154.             returnResource(shardedJedis);  
155.         }  
156.         return false;  
157.     }  
158.     /** 
159.      * 獲取Set 
160.      * @param key 
161.      * @return 
162.      */  
163.     public  Set<String> getSet(String key){  
164.         ShardedJedis shardedJedis = null;  
165.         try {  
166.             shardedJedis = shardedJedisPool.getResource();  
167.             return shardedJedis.smembers(key);  
168.         } catch (Exception ex) {  
169.             logger.error("getList error.", ex);  
170.             returnBrokenResource(shardedJedis);  
171.         } finally {  
172.             returnResource(shardedJedis);  
173.         }  
174.         return null;  
175.     }  
176.   
177.     /** 
178.      * 從set中刪除value 
179.      * @param key 
180.      * @return 
181.      */  
182.     public  boolean removeSetValue(String key,String... value){  
183.         ShardedJedis shardedJedis = null;  
184.         try {  
185.             shardedJedis = shardedJedisPool.getResource();  
186.             shardedJedis.srem(key, value);  
187.             return true;  
188.         } catch (Exception ex) {  
189.             logger.error("getList error.", ex);  
190.             returnBrokenResource(shardedJedis);  
191.         } finally {  
192.             returnResource(shardedJedis);  
193.         }  
194.         return false;  
195.     }  
196.       
197.       
198.       
199.     /** 
200.      * 從list中刪除value 默認count 1 
201.      * @param key 
202.      * @param values 值list 
203.      * @return 
204.      */  
205.     public  int removeListValue(String key,List<String> values){  
206.         return removeListValue(key, 1, values);  
207.     }  
208.     /** 
209.      * 從list中刪除value 
210.      * @param key 
211.      * @param count  
212.      * @param values 值list 
213.      * @return 
214.      */  
215.     public  int removeListValue(String key,long count,List<String> values){  
216.         int result = 0;  
217.         if(values != null && values.size()>0){  
218.             for(String value : values){  
219.                 if(removeListValue(key, count, value)){  
220.                     result++;  
221.                 }  
222.             }  
223.         }  
224.         return result;  
225.     }  
226.     /** 
227.      *  從list中刪除value 
228.      * @param key 
229.      * @param count 要刪除個數 
230.      * @param value 
231.      * @return 
232.      */  
233.     public  boolean removeListValue(String key,long count,String value){  
234.         ShardedJedis shardedJedis = null;  
235.         try {  
236.             shardedJedis = shardedJedisPool.getResource();  
237.             shardedJedis.lrem(key, count, value);  
238.             return true;  
239.         } catch (Exception ex) {  
240.             logger.error("getList error.", ex);  
241.             returnBrokenResource(shardedJedis);  
242.         } finally {  
243.             returnResource(shardedJedis);  
244.         }  
245.         return false;  
246.     }  
247.       
248.     /** 
249.      * 截取List 
250.      * @param key  
251.      * @param start 起始位置 
252.      * @param end 結束位置 
253.      * @return 
254.      */  
255.     public List<String> rangeList(String key, long start, long end) {  
256.         if (key == null || key.equals("")) {  
257.             return null;  
258.         }  
259.         ShardedJedis shardedJedis = null;  
260.         try {  
261.             shardedJedis = shardedJedisPool.getResource();  
262.             return shardedJedis.lrange(key, start, end);  
263.         } catch (Exception ex) {  
264.             logger.error("rangeList 出錯[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);  
265.             returnBrokenResource(shardedJedis);  
266.         } finally {  
267.             returnResource(shardedJedis);  
268.         }  
269.         return null;  
270.     }  
271.       
272.     /** 
273.      * 檢查List長度 
274.      * @param key 
275.      * @return 
276.      */  
277.     public long countList(String key){  
278.         if(key == null ){  
279.             return 0;  
280.         }  
281.         ShardedJedis shardedJedis = null;  
282.         try {  
283.             shardedJedis = shardedJedisPool.getResource();  
284.             return shardedJedis.llen(key);  
285.         } catch (Exception ex) {  
286.             logger.error("countList error.", ex);  
287.             returnBrokenResource(shardedJedis);  
288.         } finally {  
289.             returnResource(shardedJedis);  
290.         }  
291.         return 0;  
292.     }  
293.       
294.     /** 
295.      * 添加到List中（同時設置過期時間） 
296.      * @param key key值 
297.      * @param seconds 過期時間 單位s 
298.      * @param value  
299.      * @return  
300.      */  
301.     public boolean addList(String key,int seconds, String... value){  
302.         boolean result = addList(key, value);  
303.         if(result){  
304.             long i = expire(key, seconds);  
305.             return i==1;  
306.         }  
307.         return false;  
308.     }  
309.     /** 
310.      * 添加到List 
311.      * @param key 
312.      * @param value 
313.      * @return 
314.      */  
315.     public boolean addList(String key, String... value) {  
316.         if(key == null || value == null){  
317.             return false;  
318.         }  
319.         ShardedJedis shardedJedis = null;  
320.         try {  
321.             shardedJedis = shardedJedisPool.getResource();  
322.             shardedJedis.lpush(key, value);  
323.             return true;  
324.         } catch (Exception ex) {  
325.             logger.error("setList error.", ex);  
326.             returnBrokenResource(shardedJedis);  
327.         } finally {  
328.             returnResource(shardedJedis);  
329.         }  
330.         return false;  
331.     }  
332.     /** 
333.      * 添加到List(只新增) 
334.      * @param key 
335.      * @param value 
336.      * @return 
337.      */  
338.     public boolean addList(String key, List<String> list) {  
339.         if(key == null || list == null || list.size() == 0){  
340.             return false;  
341.         }  
342.         for(String value : list){  
343.             addList(key, value);  
344.         }  
345.         return true;  
346.     }  
347.       
348.     /** 
349.      * 獲取List 
350.      * @param key 
351.      * @return 
352.      */  
353.     public  List<String> getList(String key){  
354.         ShardedJedis shardedJedis = null;  
355.         try {  
356.             shardedJedis = shardedJedisPool.getResource();  
357.             return shardedJedis.lrange(key, 0, -1);  
358.         } catch (Exception ex) {  
359.             logger.error("getList error.", ex);  
360.             returnBrokenResource(shardedJedis);  
361.         } finally {  
362.             returnResource(shardedJedis);  
363.         }  
364.         return null;  
365.     }  
366.     /** 
367.      * 設置HashSet對象 
368.      * 
369.      * @param domain 域名 
370.      * @param key    鍵值 
371.      * @param value  Json String or String value 
372.      * @return 
373.      */  
374.     public boolean setHSet(String domain, String key, String value) {  
375.         if (value == null) return false;  
376.         ShardedJedis shardedJedis = null;  
377.         try {  
378.             shardedJedis = shardedJedisPool.getResource();  
379.             shardedJedis.hset(domain, key, value);  
380.             return true;  
381.         } catch (Exception ex) {  
382.             logger.error("setHSet error.", ex);  
383.             returnBrokenResource(shardedJedis);  
384.         } finally {  
385.             returnResource(shardedJedis);  
386.         }  
387.         return false;  
388.     }  
389.   
390.     /** 
391.      * 獲得HashSet對象 
392.      * 
393.      * @param domain 域名 
394.      * @param key    鍵值 
395.      * @return Json String or String value 
396.      */  
397.     public String getHSet(String domain, String key) {  
398.         ShardedJedis shardedJedis = null;  
399.         try {  
400.             shardedJedis = shardedJedisPool.getResource();  
401.             return shardedJedis.hget(domain, key);  
402.         } catch (Exception ex) {  
403.             logger.error("getHSet error.", ex);  
404.             returnBrokenResource(shardedJedis);  
405.         } finally {  
406.             returnResource(shardedJedis);  
407.         }  
408.         return null;  
409.     }  
410.   
411.     /** 
412.      * 刪除HashSet對象 
413.      * 
414.      * @param domain 域名 
415.      * @param key    鍵值 
416.      * @return 刪除的記錄數 
417.      */  
418.     public long delHSet(String domain, String key) {  
419.         ShardedJedis shardedJedis = null;  
420.         long count = 0;  
421.         try {  
422.             shardedJedis = shardedJedisPool.getResource();  
423.             count = shardedJedis.hdel(domain, key);  
424.         } catch (Exception ex) {  
425.             logger.error("delHSet error.", ex);  
426.             returnBrokenResource(shardedJedis);  
427.         } finally {  
428.             returnResource(shardedJedis);  
429.         }  
430.         return count;  
431.     }  
432.   
433.     /** 
434.      * 刪除HashSet對象 
435.      * 
436.      * @param domain 域名 
437.      * @param key    鍵值 
438.      * @return 刪除的記錄數 
439.      */  
440.     public long delHSet(String domain, String... key) {  
441.         ShardedJedis shardedJedis = null;  
442.         long count = 0;  
443.         try {  
444.             shardedJedis = shardedJedisPool.getResource();  
445.             count = shardedJedis.hdel(domain, key);  
446.         } catch (Exception ex) {  
447.             logger.error("delHSet error.", ex);  
448.             returnBrokenResource(shardedJedis);  
449.         } finally {  
450.             returnResource(shardedJedis);  
451.         }  
452.         return count;  
453.     }  
454.   
455.     /** 
456.      * 判斷key是否存在 
457.      * 
458.      * @param domain 域名 
459.      * @param key    鍵值 
460.      * @return 
461.      */  
462.     public boolean existsHSet(String domain, String key) {  
463.         ShardedJedis shardedJedis = null;  
464.         boolean isExist = false;  
465.         try {  
466.             shardedJedis = shardedJedisPool.getResource();  
467.             isExist = shardedJedis.hexists(domain, key);  
468.         } catch (Exception ex) {  
469.             logger.error("existsHSet error.", ex);  
470.             returnBrokenResource(shardedJedis);  
471.         } finally {  
472.             returnResource(shardedJedis);  
473.         }  
474.         return isExist;  
475.     }  
476.   
477.     /** 
478.      * 全局掃描hset 
479.      * 
480.      * @param match field匹配模式 
481.      * @return 
482.      */  
483.     public List<Map.Entry<String, String>> scanHSet(String domain, String match) {  
484.         ShardedJedis shardedJedis = null;  
485.         try {  
486.             int cursor = 0;  
487.             shardedJedis = shardedJedisPool.getResource();  
488.             ScanParams scanParams = new ScanParams();  
489.             scanParams.match(match);  
490.             Jedis jedis = shardedJedis.getShard(domain);  
491.             ScanResult<Map.Entry<String, String>> scanResult;  
492.             List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>();  
493.             do {  
494.                 scanResult = jedis.hscan(domain, String.valueOf(cursor), scanParams);  
495.                 list.addAll(scanResult.getResult());  
496.                 cursor = Integer.parseInt(scanResult.getStringCursor());  
497.             } while (cursor > 0);  
498.             return list;  
499.         } catch (Exception ex) {  
500.             logger.error("scanHSet error.", ex);  
501.             returnBrokenResource(shardedJedis);  
502.         } finally {  
503.             returnResource(shardedJedis);  
504.         }  
505.         return null;  
506.     }  
507.   
508.   
509.     /** 
510.      * 返回 domain 指定的哈希集中所有字段的value值 
511.      * 
512.      * @param domain 
513.      * @return 
514.      */  
515.   
516.     public List<String> hvals(String domain) {  
517.         ShardedJedis shardedJedis = null;  
518.         List<String> retList = null;  
519.         try {  
520.             shardedJedis = shardedJedisPool.getResource();  
521.             retList = shardedJedis.hvals(domain);  
522.         } catch (Exception ex) {  
523.             logger.error("hvals error.", ex);  
524.             returnBrokenResource(shardedJedis);  
525.         } finally {  
526.             returnResource(shardedJedis);  
527.         }  
528.         return retList;  
529.     }  
530.   
531.     /** 
532.      * 返回 domain 指定的哈希集中所有字段的key值 
533.      * 
534.      * @param domain 
535.      * @return 
536.      */  
537.   
538.     public Set<String> hkeys(String domain) {  
539.         ShardedJedis shardedJedis = null;  
540.         Set<String> retList = null;  
541.         try {  
542.             shardedJedis = shardedJedisPool.getResource();  
543.             retList = shardedJedis.hkeys(domain);  
544.         } catch (Exception ex) {  
545.             logger.error("hkeys error.", ex);  
546.             returnBrokenResource(shardedJedis);  
547.         } finally {  
548.             returnResource(shardedJedis);  
549.         }  
550.         return retList;  
551.     }  
552.   
553.     /** 
554.      * 返回 domain 指定的哈希key值總數 
555.      * 
556.      * @param domain 
557.      * @return 
558.      */  
559.     public long lenHset(String domain) {  
560.         ShardedJedis shardedJedis = null;  
561.         long retList = 0;  
562.         try {  
563.             shardedJedis = shardedJedisPool.getResource();  
564.             retList = shardedJedis.hlen(domain);  
565.         } catch (Exception ex) {  
566.             logger.error("hkeys error.", ex);  
567.             returnBrokenResource(shardedJedis);  
568.         } finally {  
569.             returnResource(shardedJedis);  
570.         }  
571.         return retList;  
572.     }  
573.   
574.     /** 
575.      * 設置排序集合 
576.      * 
577.      * @param key 
578.      * @param score 
579.      * @param value 
580.      * @return 
581.      */  
582.     public boolean setSortedSet(String key, long score, String value) {  
583.         ShardedJedis shardedJedis = null;  
584.         try {  
585.             shardedJedis = shardedJedisPool.getResource();  
586.             shardedJedis.zadd(key, score, value);  
587.             return true;  
588.         } catch (Exception ex) {  
589.             logger.error("setSortedSet error.", ex);  
590.             returnBrokenResource(shardedJedis);  
591.         } finally {  
592.             returnResource(shardedJedis);  
593.         }  
594.         return false;  
595.     }  
596.   
597.     /** 
598.      * 獲得排序集合 
599.      * 
600.      * @param key 
601.      * @param startScore 
602.      * @param endScore 
603.      * @param orderByDesc 
604.      * @return 
605.      */  
606.     public Set<String> getSoredSet(String key, long startScore, long endScore, boolean orderByDesc) {  
607.         ShardedJedis shardedJedis = null;  
608.         try {  
609.             shardedJedis = shardedJedisPool.getResource();  
610.             if (orderByDesc) {  
611.                 return shardedJedis.zrevrangeByScore(key, endScore, startScore);  
612.             } else {  
613.                 return shardedJedis.zrangeByScore(key, startScore, endScore);  
614.             }  
615.         } catch (Exception ex) {  
616.             logger.error("getSoredSet error.", ex);  
617.             returnBrokenResource(shardedJedis);  
618.         } finally {  
619.             returnResource(shardedJedis);  
620.         }  
621.         return null;  
622.     }  
623.   
624.     /** 
625.      * 計算排序長度 
626.      * 
627.      * @param key 
628.      * @param startScore 
629.      * @param endScore 
630.      * @return 
631.      */  
632.     public long countSoredSet(String key, long startScore, long endScore) {  
633.         ShardedJedis shardedJedis = null;  
634.         try {  
635.             shardedJedis = shardedJedisPool.getResource();  
636.             Long count = shardedJedis.zcount(key, startScore, endScore);  
637.             return count == null ? 0L : count;  
638.         } catch (Exception ex) {  
639.             logger.error("countSoredSet error.", ex);  
640.             returnBrokenResource(shardedJedis);  
641.         } finally {  
642.             returnResource(shardedJedis);  
643.         }  
644.         return 0L;  
645.     }  
646.   
647.     /** 
648.      * 刪除排序集合 
649.      * 
650.      * @param key 
651.      * @param value 
652.      * @return 
653.      */  
654.     public boolean delSortedSet(String key, String value) {  
655.         ShardedJedis shardedJedis = null;  
656.         try {  
657.             shardedJedis = shardedJedisPool.getResource();  
658.             long count = shardedJedis.zrem(key, value);  
659.             return count > 0;  
660.         } catch (Exception ex) {  
661.             logger.error("delSortedSet error.", ex);  
662.             returnBrokenResource(shardedJedis);  
663.         } finally {  
664.             returnResource(shardedJedis);  
665.         }  
666.         return false;  
667.     }  
668.   
669.     /** 
670.      * 獲得排序集合 
671.      * 
672.      * @param key 
673.      * @param startRange 
674.      * @param endRange 
675.      * @param orderByDesc 
676.      * @return 
677.      */  
678.     public Set<String> getSoredSetByRange(String key, int startRange, int endRange, boolean orderByDesc) {  
679.         ShardedJedis shardedJedis = null;  
680.         try {  
681.             shardedJedis = shardedJedisPool.getResource();  
682.             if (orderByDesc) {  
683.                 return shardedJedis.zrevrange(key, startRange, endRange);  
684.             } else {  
685.                 return shardedJedis.zrange(key, startRange, endRange);  
686.             }  
687.         } catch (Exception ex) {  
688.             logger.error("getSoredSetByRange error.", ex);  
689.             returnBrokenResource(shardedJedis);  
690.         } finally {  
691.             returnResource(shardedJedis);  
692.         }  
693.         return null;  
694.     }  
695.   
696.     /** 
697.      * 獲得排序打分 
698.      * 
699.      * @param key 
700.      * @return 
701.      */  
702.     public Double getScore(String key, String member) {  
703.         ShardedJedis shardedJedis = null;  
704.         try {  
705.             shardedJedis = shardedJedisPool.getResource();  
706.             return shardedJedis.zscore(key, member);  
707.         } catch (Exception ex) {  
708.             logger.error("getSoredSet error.", ex);  
709.             returnBrokenResource(shardedJedis);  
710.         } finally {  
711.             returnResource(shardedJedis);  
712.         }  
713.         return null;  
714.     }  
715.   
716.     public boolean set(String key, String value, int second) {  
717.         ShardedJedis shardedJedis = null;  
718.         try {  
719.             shardedJedis = shardedJedisPool.getResource();  
720.             shardedJedis.setex(key, second, value);  
721.             return true;  
722.         } catch (Exception ex) {  
723.             logger.error("set error.", ex);  
724.             returnBrokenResource(shardedJedis);  
725.         } finally {  
726.             returnResource(shardedJedis);  
727.         }  
728.         return false;  
729.     }  
730.   
731.     public boolean set(String key, String value) {  
732.         ShardedJedis shardedJedis = null;  
733.         try {  
734.             shardedJedis = shardedJedisPool.getResource();  
735.             shardedJedis.set(key, value);  
736.             return true;  
737.         } catch (Exception ex) {  
738.             logger.error("set error.", ex);  
739.             returnBrokenResource(shardedJedis);  
740.         } finally {  
741.             returnResource(shardedJedis);  
742.         }  
743.         return false;  
744.     }  
745.   
746.     public String get(String key, String defaultValue) {  
747.         ShardedJedis shardedJedis = null;  
748.         try {  
749.             shardedJedis = shardedJedisPool.getResource();  
750.             return shardedJedis.get(key) == null?defaultValue:shardedJedis.get(key);  
751.         } catch (Exception ex) {  
752.             logger.error("get error.", ex);  
753.             returnBrokenResource(shardedJedis);  
754.         } finally {  
755.             returnResource(shardedJedis);  
756.         }  
757.         return defaultValue;  
758.     }  
759.   
760.     public boolean del(String key) {  
761.         ShardedJedis shardedJedis = null;  
762.         try {  
763.             shardedJedis = shardedJedisPool.getResource();  
764.             shardedJedis.del(key);  
765.             return true;  
766.         } catch (Exception ex) {  
767.             logger.error("del error.", ex);  
768.             returnBrokenResource(shardedJedis);  
769.         } finally {  
770.             returnResource(shardedJedis);  
771.         }  
772.         return false;  
773.     }  
774.   
775.     public long incr(String key) {  
776.         ShardedJedis shardedJedis = null;  
777.         try {  
778.             shardedJedis = shardedJedisPool.getResource();  
779.             return shardedJedis.incr(key);  
780.         } catch (Exception ex) {  
781.             logger.error("incr error.", ex);  
782.             returnBrokenResource(shardedJedis);  
783.         } finally {  
784.             returnResource(shardedJedis);  
785.         }  
786.         return 0;  
787.     }  
788.   
789.     public long decr(String key) {  
790.         ShardedJedis shardedJedis = null;  
791.         try {  
792.             shardedJedis = shardedJedisPool.getResource();  
793.             return shardedJedis.decr(key);  
794.         } catch (Exception ex) {  
795.             logger.error("incr error.", ex);  
796.             returnBrokenResource(shardedJedis);  
797.         } finally {  
798.             returnResource(shardedJedis);  
799.         }  
800.         return 0;  
801.     }  
802.   
803.   
804.   
805.     private void returnBrokenResource(ShardedJedis shardedJedis) {  
806.         try {  
807.             shardedJedisPool.returnBrokenResource(shardedJedis);  
808.         } catch (Exception e) {  
809.             logger.error("returnBrokenResource error.", e);  
810.         }  
811.     }  
812.   
813.     private void returnResource(ShardedJedis shardedJedis) {  
814.         try {  
815.             shardedJedisPool.returnResource(shardedJedis);  
816.         } catch (Exception e) {  
817.             logger.error("returnResource error.", e);  
818.         }  
819.     }