redis在Java web項目的一些方法解釋

1. package com.redis;  
2. import org.slf4j.LoggerFactory;  
3. import org.springframework.beans.factory.annotation.Autowired;  
4. import redis.clients.jedis.Jedis;  
5. import redis.clients.jedis.JedisShardInfo;  
6. import redis.clients.jedis.ShardedJedis;  
7. public class RedisClientTemplate {  
8.     private static final org.slf4j.Logger log=LoggerFactory.getLogger(RedisClientTemplate.class);  
9.     @Autowired  
10.     private RedisDataSource redisDataSource;  
11.     public RedisDataSource getRedisDataSource() {  
12.         return redisDataSource;  
13.     }  
14.     public void setRedisDataSource(RedisDataSource redisDataSource) {  
15.         this.redisDataSource = redisDataSource;  
16.     }  
17.     public void disconnect(){  
18.         ShardedJedis shardedJedis=redisDataSource.getRedisClient();  
19.         shardedJedis.disconnect();  
20.     }  
21.     public String set(String key, String value){  
22.         String result=null;  
23.         ShardedJedis shardedJedis=redisDataSource.getRedisClient();  
24.         if(shardedJedis==null){  
25.             return result;  
26.         }  
27.         boolean broken=false;  
28.         try {  
29.             result=shardedJedis.set(key, value);  
30.         } catch (Exception e) {  
31.             broken=true;  
32.             e.printStackTrace();  
33.         }finally{  
34.             redisDataSource.returnResource(shardedJedis, broken);  
35.         }  
36.         return result;  
37.     }  
38.     public String get(String key) {  
39.         String result = null;  
40.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
41.         if (shardedJedis == null) {  
42.             return result;  
43.         }  
44.         boolean broken = false;  
45.         try {  
46.             result = shardedJedis.get(key);  
47.         } catch (Exception e) {  
48.             log.error(e.getMessage(), e);  
49.             broken = true;  
50.         } finally {  
51.             redisDataSource.returnResource(shardedJedis, broken);  
52.         }  
53.         return result;  
54.     }  
55.     public Boolean exists(String key) {  
56.         Boolean result = false;  
57.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
58.         if (shardedJedis == null) {  
59.             return result;  
60.         }  
61.         boolean broken = false;  
62.         try {  
63.             result = shardedJedis.exists(key);  
64.         } catch (Exception e) {  
65.             log.error(e.getMessage(), e);  
66.             broken = true;  
67.         } finally {  
68.             redisDataSource.returnResource(shardedJedis, broken);  
69.         }  
70.         return result;  
71.     }  
72.     public String type(String key) {  
73.         String result = null;  
74.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
75.         if (shardedJedis == null) {  
76.             return result;  
77.         }  
78.         boolean broken = false;  
79.         try {  
80.             result = shardedJedis.type(key);  
81.         } catch (Exception e) {  
82.             log.error(e.getMessage(), e);  
83.             broken = true;  
84.         } finally {  
85.             redisDataSource.returnResource(shardedJedis, broken);  
86.         }  
87.         return result;  
88.     }  
89.     public Long expire(String key, int seconds) {  
90.         Long result = null;  
91.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
92.         if (shardedJedis == null) {  
93.             return result;  
94.         }  
95.         boolean broken = false;  
96.         try {  
97.             result = shardedJedis.expire(key, seconds);  
98.         } catch (Exception e) {  
99.             log.error(e.getMessage(), e);  
100.             broken = true;  
101.         } finally {  
102.             redisDataSource.returnResource(shardedJedis, broken);  
103.         }  
104.         return result;  
105.     }  
106.     public Long expireAt(String key, long unixTime) {  
107.         Long result = null;  
108.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
109.         if (shardedJedis == null) {  
110.             return result;  
111.         }  
112.         boolean broken = false;  
113.         try {  
114.             result = shardedJedis.expireAt(key, unixTime);  
115.         } catch (Exception e) {  
116.             log.error(e.getMessage(), e);  
117.             broken = true;  
118.         } finally {  
119.             redisDataSource.returnResource(shardedJedis, broken);  
120.         }  
121.         return result;  
122.     }  
123.     public Long ttl(String key) {  
124.         Long result = null;  
125.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
126.         if (shardedJedis == null) {  
127.             return result;  
128.         }  
129.         boolean broken = false;  
130.         try {  
131.             result = shardedJedis.ttl(key);  
132.         } catch (Exception e) {  
133.             log.error(e.getMessage(), e);  
134.             broken = true;  
135.         } finally {  
136.             redisDataSource.returnResource(shardedJedis, broken);  
137.         }  
138.         return result;  
139.     }  
140.     public Long setnx(String key, String value) {  
141.         Long result = null;  
142.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
143.         if (shardedJedis == null) {  
144.             return result;  
145.         }  
146.         boolean broken = false;  
147.         try {  
148.             result = shardedJedis.setnx(key, value);  
149.         } catch (Exception e) {  
150.             log.error(e.getMessage(), e);  
151.             broken = true;  
152.         } finally {  
153.             redisDataSource.returnResource(shardedJedis, broken);  
154.         }  
155.         return result;  
156.     }  
157.     public String setex(String key, int seconds, String value) {  
158.         String result = null;  
159.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
160.         if (shardedJedis == null) {  
161.             return result;  
162.         }  
163.         boolean broken = false;  
164.         try {  
165.             result = shardedJedis.setex(key, seconds, value);  
166.         } catch (Exception e) {  
167.             log.error(e.getMessage(), e);  
168.             broken = true;  
169.         } finally {  
170.             redisDataSource.returnResource(shardedJedis, broken);  
171.         }  
172.         return result;  
173.     }  
174.     public Long decrBy(String key, long integer) {  
175.         Long result = null;  
176.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
177.         if (shardedJedis == null) {  
178.             return result;  
179.         }  
180.         boolean broken = false;  
181.         try {  
182.             result = shardedJedis.decrBy(key, integer);  
183.         } catch (Exception e) {  
184.             log.error(e.getMessage(), e);  
185.             broken = true;  
186.         } finally {  
187.             redisDataSource.returnResource(shardedJedis, broken);  
188.         }  
189.         return result;  
190.     }  
191.     public Long decr(String key) {  
192.         Long result = null;  
193.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
194.         if (shardedJedis == null) {  
195.             return result;  
196.         }  
197.         boolean broken = false;  
198.         try {  
199.             result = shardedJedis.decr(key);  
200.         } catch (Exception e) {  
201.             log.error(e.getMessage(), e);  
202.             broken = true;  
203.         } finally {  
204.             redisDataSource.returnResource(shardedJedis, broken);  
205.         }  
206.         return result;  
207.     }  
208.     public Long incrBy(String key, long integer) {  
209.         Long result = null;  
210.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
211.         if (shardedJedis == null) {  
212.             return result;  
213.         }  
214.         boolean broken = false;  
215.         try {  
216.             result = shardedJedis.incrBy(key, integer);  
217.         } catch (Exception e) {  
218.             log.error(e.getMessage(), e);  
219.             broken = true;  
220.         } finally {  
221.             redisDataSource.returnResource(shardedJedis, broken);  
222.         }  
223.         return result;  
224.     }  
225.     public Long incr(String key) {  
226.         Long result = null;  
227.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
228.         if (shardedJedis == null) {  
229.             return result;  
230.         }  
231.         boolean broken = false;  
232.         try {  
233.             result = shardedJedis.incr(key);  
234.         } catch (Exception e) {  
235.             log.error(e.getMessage(), e);  
236.             broken = true;  
237.         } finally {  
238.             redisDataSource.returnResource(shardedJedis, broken);  
239.         }  
240.         return result;  
241.     }  
242.     public Long append(String key, String value) {  
243.         Long result = null;  
244.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
245.         if (shardedJedis == null) {  
246.             return result;  
247.         }  
248.         boolean broken = false;  
249.         try {  
250.             result = shardedJedis.append(key, value);  
251.         } catch (Exception e) {  
252.             log.error(e.getMessage(), e);  
253.             broken = true;  
254.         } finally {  
255.             redisDataSource.returnResource(shardedJedis, broken);  
256.         }  
257.         return result;  
258.     }  
259.     public String substr(String key, int start, int end) {  
260.         String result = null;  
261.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
262.         if (shardedJedis == null) {  
263.             return result;  
264.         }  
265.         boolean broken = false;  
266.         try {  
267.             result = shardedJedis.substr(key, start, end);  
268.         } catch (Exception e) {  
269.             log.error(e.getMessage(), e);  
270.             broken = true;  
271.         } finally {  
272.             redisDataSource.returnResource(shardedJedis, broken);  
273.         }  
274.         return result;  
275.     }  
276.     public Long hset(String key, String field, String value) {  
277.         Long result = null;  
278.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
279.         if (shardedJedis == null) {  
280.             return result;  
281.         }  
282.         boolean broken = false;  
283.         try {  
284.             result = shardedJedis.hset(key, field, value);  
285.         } catch (Exception e) {  
286.             log.error(e.getMessage(), e);  
287.             broken = true;  
288.         } finally {  
289.             redisDataSource.returnResource(shardedJedis, broken);  
290.         }  
291.         return result;  
292.     }  
293.     public String hget(String key, String field) {  
294.         String result = null;  
295.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
296.         if (shardedJedis == null) {  
297.             return result;  
298.         }  
299.         boolean broken = false;  
300.         try {  
301.             result = shardedJedis.hget(key, field);  
302.         } catch (Exception e) {  
303.             log.error(e.getMessage(), e);  
304.             broken = true;  
305.         } finally {  
306.             redisDataSource.returnResource(shardedJedis, broken);  
307.         }  
308.         return result;  
309.     }  
310.     public String hmset(String key, Map<String, String> hash) {  
311.         String result = null;  
312.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
313.         if (shardedJedis == null) {  
314.             return result;  
315.         }  
316.         boolean broken = false;  
317.         try {  
318.             result = shardedJedis.hmset(key, hash);  
319.         } catch (Exception e) {  
320.             log.error(e.getMessage(), e);  
321.             broken = true;  
322.         } finally {  
323.             redisDataSource.returnResource(shardedJedis, broken);  
324.         }  
325.         return result;  
326.     }  
327.     public List<String> hmget(String key, String... fields) {  
328.         List<String> result = null;  
329.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
330.         if (shardedJedis == null) {  
331.             return result;  
332.         }  
333.         boolean broken = false;  
334.         try {  
335.             result = shardedJedis.hmget(key, fields);  
336.         } catch (Exception e) {  
337.             log.error(e.getMessage(), e);  
338.             broken = true;  
339.         } finally {  
340.             redisDataSource.returnResource(shardedJedis, broken);  
341.         }  
342.         return result;  
343.     }  
344.     public Long hincrBy(String key, String field, long value) {  
345.         Long result = null;  
346.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
347.         if (shardedJedis == null) {  
348.             return result;  
349.         }  
350.         boolean broken = false;  
351.         try {  
352.             result = shardedJedis.hincrBy(key, field, value);  
353.         } catch (Exception e) {  
354.             log.error(e.getMessage(), e);  
355.             broken = true;  
356.         } finally {  
357.             redisDataSource.returnResource(shardedJedis, broken);  
358.         }  
359.         return result;  
360.     }  
361.     public Boolean hexists(String key, String field) {  
362.         Boolean result = false;  
363.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
364.         if (shardedJedis == null) {  
365.             return result;  
366.         }  
367.         boolean broken = false;  
368.         try {  
369.             result = shardedJedis.hexists(key, field);  
370.         } catch (Exception e) {  
371.             log.error(e.getMessage(), e);  
372.             broken = true;  
373.         } finally {  
374.             redisDataSource.returnResource(shardedJedis, broken);  
375.         }  
376.         return result;  
377.     }  
378.     public Long del(String key) {  
379.         Long result = null;  
380.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
381.         if (shardedJedis == null) {  
382.             return result;  
383.         }  
384.         boolean broken = false;  
385.         try {  
386.             result = shardedJedis.del(key);  
387.         } catch (Exception e) {  
388.             log.error(e.getMessage(), e);  
389.             broken = true;  
390.         } finally {  
391.             redisDataSource.returnResource(shardedJedis, broken);  
392.         }  
393.         return result;  
394.     }  
395.     public Long hdel(String key, String field) {  
396.         Long result = null;  
397.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
398.         if (shardedJedis == null) {  
399.             return result;  
400.         }  
401.         boolean broken = false;  
402.         try {  
403.             result = shardedJedis.hdel(key, field);  
404.         } catch (Exception e) {  
405.             log.error(e.getMessage(), e);  
406.             broken = true;  
407.         } finally {  
408.             redisDataSource.returnResource(shardedJedis, broken);  
409.         }  
410.         return result;  
411.     }  
412.     public Long hlen(String key) {  
413.         Long result = null;  
414.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
415.         if (shardedJedis == null) {  
416.             return result;  
417.         }  
418.         boolean broken = false;  
419.         try {  
420.             result = shardedJedis.hlen(key);  
421.         } catch (Exception e) {  
422.             log.error(e.getMessage(), e);  
423.             broken = true;  
424.         } finally {  
425.             redisDataSource.returnResource(shardedJedis, broken);  
426.         }  
427.         return result;  
428.     }  
429.     public Set<String> hkeys(String key) {  
430.         Set<String> result = null;  
431.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
432.         if (shardedJedis == null) {  
433.             return result;  
434.         }  
435.         boolean broken = false;  
436.         try {  
437.             result = shardedJedis.hkeys(key);  
438.         } catch (Exception e) {  
439.             log.error(e.getMessage(), e);  
440.             broken = true;  
441.         } finally {  
442.             redisDataSource.returnResource(shardedJedis, broken);  
443.         }  
444.         return result;  
445.     }  
446.     public List<String> hvals(String key) {  
447.         List<String> result = null;  
448.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
449.         if (shardedJedis == null) {  
450.             return result;  
451.         }  
452.         boolean broken = false;  
453.         try {  
454.             result = shardedJedis.hvals(key);  
455.         } catch (Exception e) {  
456.             log.error(e.getMessage(), e);  
457.             broken = true;  
458.         } finally {  
459.             redisDataSource.returnResource(shardedJedis, broken);  
460.         }  
461.         return result;  
462.     }  
463.     public Map<String, String> hgetAll(String key) {  
464.         Map<String, String> result = null;  
465.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
466.         if (shardedJedis == null) {  
467.             return result;  
468.         }  
469.         boolean broken = false;  
470.         try {  
471.             result = shardedJedis.hgetAll(key);  
472.         } catch (Exception e) {  
473.             log.error(e.getMessage(), e);  
474.             broken = true;  
475.         } finally {  
476.             redisDataSource.returnResource(shardedJedis, broken);  
477.         }  
478.         return result;  
479.     }  
480.     // ================list ====== l表示 list或 left, r表示right====================  
481.     public Long rpush(String key, String string) {  
482.         Long result = null;  
483.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
484.         if (shardedJedis == null) {  
485.             return result;  
486.         }  
487.         boolean broken = false;  
488.         try {  
489.             result = shardedJedis.rpush(key, string);  
490.         } catch (Exception e) {  
491.             log.error(e.getMessage(), e);  
492.             broken = true;  
493.         } finally {  
494.             redisDataSource.returnResource(shardedJedis, broken);  
495.         }  
496.         return result;  
497.     }  
498.     public Long lpush(String key, String string) {  
499.         Long result = null;  
500.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
501.         if (shardedJedis == null) {  
502.             return result;  
503.         }  
504.         boolean broken = false;  
505.         try {  
506.             result = shardedJedis.lpush(key, string);  
507.         } catch (Exception e) {  
508.             log.error(e.getMessage(), e);  
509.             broken = true;  
510.         } finally {  
511.             redisDataSource.returnResource(shardedJedis, broken);  
512.         }  
513.         return result;  
514.     }  
515.     public Long llen(String key) {  
516.         Long result = null;  
517.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
518.         if (shardedJedis == null) {  
519.             return result;  
520.         }  
521.         boolean broken = false;  
522.         try {  
523.             result = shardedJedis.llen(key);  
524.         } catch (Exception e) {  
525.             log.error(e.getMessage(), e);  
526.             broken = true;  
527.         } finally {  
528.             redisDataSource.returnResource(shardedJedis, broken);  
529.         }  
530.         return result;  
531.     }  
532.     public List<String> lrange(String key, long start, long end) {  
533.         List<String> result = null;  
534.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
535.         if (shardedJedis == null) {  
536.             return result;  
537.         }  
538.         boolean broken = false;  
539.         try {  
540.             result = shardedJedis.lrange(key, start, end);  
541.         } catch (Exception e) {  
542.             log.error(e.getMessage(), e);  
543.             broken = true;  
544.         } finally {  
545.             redisDataSource.returnResource(shardedJedis, broken);  
546.         }  
547.         return result;  
548.     }  
549.     public String ltrim(String key, long start, long end) {  
550.         String result = null;  
551.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
552.         if (shardedJedis == null) {  
553.             return result;  
554.         }  
555.         boolean broken = false;  
556.         try {  
557.             result = shardedJedis.ltrim(key, start, end);  
558.         } catch (Exception e) {  
559.             log.error(e.getMessage(), e);  
560.             broken = true;  
561.         } finally {  
562.             redisDataSource.returnResource(shardedJedis, broken);  
563.         }  
564.         return result;  
565.     }  
566.     public String lindex(String key, long index) {  
567.         String result = null;  
568.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
569.         if (shardedJedis == null) {  
570.             return result;  
571.         }  
572.         boolean broken = false;  
573.         try {  
574.             result = shardedJedis.lindex(key, index);  
575.         } catch (Exception e) {  
576.             log.error(e.getMessage(), e);  
577.             broken = true;  
578.         } finally {  
579.             redisDataSource.returnResource(shardedJedis, broken);  
580.         }  
581.         return result;  
582.     }  
583.     public String lset(String key, long index, String value) {  
584.         String result = null;  
585.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
586.         if (shardedJedis == null) {  
587.             return result;  
588.         }  
589.         boolean broken = false;  
590.         try {  
591.             result = shardedJedis.lset(key, index, value);  
592.         } catch (Exception e) {  
593.             log.error(e.getMessage(), e);  
594.             broken = true;  
595.         } finally {  
596.             redisDataSource.returnResource(shardedJedis, broken);  
597.         }  
598.         return result;  
599.     }  
600.     public String lpop(String key) {  
601.         String result = null;  
602.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
603.         if (shardedJedis == null) {  
604.             return result;  
605.         }  
606.         boolean broken = false;  
607.         try {  
608.             result = shardedJedis.lpop(key);  
609.         } catch (Exception e) {  
610.             log.error(e.getMessage(), e);  
611.             broken = true;  
612.         } finally {  
613.             redisDataSource.returnResource(shardedJedis, broken);  
614.         }  
615.         return result;  
616.     }  
617.     public String rpop(String key) {  
618.         String result = null;  
619.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
620.         if (shardedJedis == null) {  
621.             return result;  
622.         }  
623.         boolean broken = false;  
624.         try {  
625.             result = shardedJedis.rpop(key);  
626.         } catch (Exception e) {  
627.             log.error(e.getMessage(), e);  
628.             broken = true;  
629.         } finally {  
630.             redisDataSource.returnResource(shardedJedis, broken);  
631.         }  
632.         return result;  
633.     }  
634.     //return 1 add a not exist value ,  
635.     //return 0 add a exist value  
636.     public Long sadd(String key, String member) {  
637.         Long result = null;  
638.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
639.         if (shardedJedis == null) {  
640.             return result;  
641.         }  
642.         boolean broken = false;  
643.         try {  
644.             result = shardedJedis.sadd(key, member);  
645.         } catch (Exception e) {  
646.             log.error(e.getMessage(), e);  
647.             broken = true;  
648.         } finally {  
649.             redisDataSource.returnResource(shardedJedis, broken);  
650.         }  
651.         return result;  
652.     }  
653.     public Set<String> smembers(String key) {  
654.         Set<String> result = null;  
655.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
656.         if (shardedJedis == null) {  
657.             return result;  
658.         }  
659.         boolean broken = false;  
660.         try {  
661.             result = shardedJedis.smembers(key);  
662.         } catch (Exception e) {  
663.             log.error(e.getMessage(), e);  
664.             broken = true;  
665.         } finally {  
666.             redisDataSource.returnResource(shardedJedis, broken);  
667.         }  
668.         return result;  
669.     }  
670.     public Long scard(String key) {  
671.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
672.         Long result = null;  
673.         if (shardedJedis == null) {  
674.             return result;  
675.         }  
676.         boolean broken = false;  
677.         try {  
678.             result = shardedJedis.scard(key);  
679.         } catch (Exception e) {  
680.             log.error(e.getMessage(), e);  
681.             broken = true;  
682.         } finally {  
683.             redisDataSource.returnResource(shardedJedis, broken);  
684.         }  
685.         return result;  
686.     }  
687.     public Long zadd(String key, double score, String member) {  
688.         Long result = null;  
689.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
690.         if (shardedJedis == null) {  
691.             return result;  
692.         }  
693.         boolean broken = false;  
694.         try {  
695.             result = shardedJedis.zadd(key, score, member);  
696.         } catch (Exception e) {  
697.             log.error(e.getMessage(), e);  
698.             broken = true;  
699.         } finally {  
700.             redisDataSource.returnResource(shardedJedis, broken);  
701.         }  
702.         return result;  
703.     }  
704.     public Set<String> zrange(String key, int start, int end) {  
705.         Set<String> result = null;  
706.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
707.         if (shardedJedis == null) {  
708.             return result;  
709.         }  
710.         boolean broken = false;  
711.         try {  
712.             result = shardedJedis.zrange(key, start, end);  
713.         } catch (Exception e) {  
714.             log.error(e.getMessage(), e);  
715.             broken = true;  
716.         } finally {  
717.             redisDataSource.returnResource(shardedJedis, broken);  
718.         }  
719.         return result;  
720.     }  
721.     public Long zrem(String key, String member) {  
722.         Long result = null;  
723.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
724.         if (shardedJedis == null) {  
725.             return result;  
726.         }  
727.         boolean broken = false;  
728.         try {  
729.             result = shardedJedis.zrem(key, member);  
730.         } catch (Exception e) {  
731.             log.error(e.getMessage(), e);  
732.             broken = true;  
733.         } finally {  
734.             redisDataSource.returnResource(shardedJedis, broken);  
735.         }  
736.         return result;  
737.     }  
738.     public Double zincrby(String key, double score, String member) {  
739.         Double result = null;  
740.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
741.         if (shardedJedis == null) {  
742.             return result;  
743.         }  
744.         boolean broken = false;  
745.         try {  
746.             result = shardedJedis.zincrby(key, score, member);  
747.         } catch (Exception e) {  
748.             log.error(e.getMessage(), e);  
749.             broken = true;  
750.         } finally {  
751.             redisDataSource.returnResource(shardedJedis, broken);  
752.         }  
753.         return result;  
754.     }  
755.     public Long zrank(String key, String member) {  
756.         Long result = null;  
757.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
758.         if (shardedJedis == null) {  
759.             return result;  
760.         }  
761.         boolean broken = false;  
762.         try {  
763.             result = shardedJedis.zrank(key, member);  
764.         } catch (Exception e) {  
765.             log.error(e.getMessage(), e);  
766.             broken = true;  
767.         } finally {  
768.             redisDataSource.returnResource(shardedJedis, broken);  
769.         }  
770.         return result;  
771.     }  
772.         public Long zcard(String key) {  
773.         Long result = null;  
774.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
775.         if (shardedJedis == null) {  
776.             return result;  
777.         }  
778.         boolean broken = false;  
779.         try {  
780.             result = shardedJedis.zcard(key);  
781.         } catch (Exception e) {  
782.             log.error(e.getMessage(), e);  
783.             broken = true;  
784.         } finally {  
785.             redisDataSource.returnResource(shardedJedis, broken);  
786.         }  
787.         return result;  
788.     }  
789.     public Double zscore(String key, String member) {  
790.         Double result = null;  
791.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
792.         if (shardedJedis == null) {  
793.             return result;  
794.         }  
795.         boolean broken = false;  
796.         try {  
797.             result = shardedJedis.zscore(key, member);  
798.         } catch (Exception e) {  
799.             log.error(e.getMessage(), e);  
800.             broken = true;  
801.         } finally {  
802.             redisDataSource.returnResource(shardedJedis, broken);  
803.         }  
804.         return result;  
805.     }  
806.     public Long zcount(String key, double min, double max) {  
807.         Long result = null;  
808.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
809.         if (shardedJedis == null) {  
810.             return result;  
811.         }  
812.         boolean broken = false;  
813.         try {  
814.             result = shardedJedis.zcount(key, min, max);  
815.         } catch (Exception e) {  
816.             log.error(e.getMessage(), e);  
817.             broken = true;  
818.         } finally {  
819.             redisDataSource.returnResource(shardedJedis, broken);  
820.         }  
821.         return result;  
822.     }  
823.     public String set(byte[] key, byte[] value) {  
824.         String result = null;  
825.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
826.         if (shardedJedis == null) {  
827.             return result;  
828.         }  
829.         boolean broken = false;  
830.         try {  
831.             result = shardedJedis.set(key, value);  
832.         } catch (Exception e) {  
833.             log.error(e.getMessage(), e);  
834.             broken = true;  
835.         } finally {  
836.             redisDataSource.returnResource(shardedJedis, broken);  
837.         }  
838.         return result;  
839.     }  
840.     public byte[] get(byte[] key) {  
841.         byte[] result = null;  
842.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
843.         if (shardedJedis == null) {  
844.             return result;  
845.         }  
846.         boolean broken = false;  
847.         try {  
848.             result = shardedJedis.get(key);  
849.         } catch (Exception e) {  
850.             log.error(e.getMessage(), e);  
851.             broken = true;  
852.         } finally {  
853.             redisDataSource.returnResource(shardedJedis, broken);  
854.         }  
855.         return result;  
856.     }  
857.     public Boolean exists(byte[] key) {  
858.         Boolean result = false;  
859.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
860.         if (shardedJedis == null) {  
861.             return result;  
862.         }  
863.         boolean broken = false;  
864.         try {  
865.             result = shardedJedis.exists(key);  
866.         } catch (Exception e) {  
867.             log.error(e.getMessage(), e);  
868.             broken = true;  
869.         } finally {  
870.             redisDataSource.returnResource(shardedJedis, broken);  
871.         }  
872.         return result;  
873.     }  
874.     public Long expire(byte[] key, int seconds) {  
875.         Long result = null;  
876.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
877.         if (shardedJedis == null) {  
878.             return result;  
879.         }  
880.         boolean broken = false;  
881.         try {  
882.             result = shardedJedis.expire(key, seconds);  
883.         } catch (Exception e) {  
884.             log.error(e.getMessage(), e);  
885.             broken = true;  
886.         } finally {  
887.             redisDataSource.returnResource(shardedJedis, broken);  
888.         }  
889.         return result;  
890.     }  
891.     public Long expireAt(byte[] key, long unixTime) {  
892.         Long result = null;  
893.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
894.         if (shardedJedis == null) {  
895.             return result;  
896.         }  
897.         boolean broken = false;  
898.         try {  
899.             result = shardedJedis.expireAt(key, unixTime);  
900.         } catch (Exception e) {  
901.             log.error(e.getMessage(), e);  
902.             broken = true;  
903.         } finally {  
904.             redisDataSource.returnResource(shardedJedis, broken);  
905.         }  
906.         return result;  
907.     }  
908.     public Long ttl(byte[] key) {  
909.         Long result = null;  
910.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
911.         if (shardedJedis == null) {  
912.             return result;  
913.         }  
914.         boolean broken = false;  
915.         try {  
916.             result = shardedJedis.ttl(key);  
917.         } catch (Exception e) {  
918.             log.error(e.getMessage(), e);  
919.             broken = true;  
920.         } finally {  
921.             redisDataSource.returnResource(shardedJedis, broken);  
922.         }  
923.         return result;  
924.     }  
925.     public Long append(byte[] key, byte[] value) {  
926.         Long result = null;  
927.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
928.         if (shardedJedis == null) {  
929.             return result;  
930.         }  
931.         boolean broken = false;  
932.         try {  
933.             result = shardedJedis.append(key, value);  
934.         } catch (Exception e) {  
935.             log.error(e.getMessage(), e);  
936.             broken = true;  
937.         } finally {  
938.             redisDataSource.returnResource(shardedJedis, broken);  
939.         }  
940.         return result;  
941.     }  
942.     public Long hset(byte[] key, byte[] field, byte[] value) {  
943.         Long result = null;  
944.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
945.         if (shardedJedis == null) {  
946.             return result;  
947.         }  
948.         boolean broken = false;  
949.         try {  
950.             result = shardedJedis.hset(key, field, value);  
951.         } catch (Exception e) {  
952.             log.error(e.getMessage(), e);  
953.             broken = true;  
954.         } finally {  
955.             redisDataSource.returnResource(shardedJedis, broken);  
956.         }  
957.         return result;  
958.     }  
959.     public byte[] hget(byte[] key, byte[] field) {  
960.         byte[] result = null;  
961.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
962.         if (shardedJedis == null) {  
963.             return result;  
964.         }  
965.         boolean broken = false;  
966.         try {  
967.             result = shardedJedis.hget(key, field);  
968.         } catch (Exception e) {  
969.             log.error(e.getMessage(), e);  
970.             broken = true;  
971.         } finally {  
972.             redisDataSource.returnResource(shardedJedis, broken);  
973.         }  
974.         return result;  
975.     }  
976.     public String hmset(byte[] key, Map<byte[], byte[]> hash) {  
977.         String result = null;  
978.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
979.         if (shardedJedis == null) {  
980.             return result;  
981.         }  
982.         boolean broken = false;  
983.         try {  
984.             result = shardedJedis.hmset(key, hash);  
985.         } catch (Exception e) {  
986.             log.error(e.getMessage(), e);  
987.             broken = true;  
988.         } finally {  
989.             redisDataSource.returnResource(shardedJedis, broken);  
990.         }  
991.         return result;  
992.     }  
993.     public List<byte[]> hmget(byte[] key, byte[]... fields) {  
994.         List<byte[]> result = null;  
995.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
996.         if (shardedJedis == null) {  
997.             return result;  
998.         }  
999.         boolean broken = false;  
1000.         try {  
1001.             result = shardedJedis.hmget(key, fields);  
1002.         } catch (Exception e) {  
1003.             log.error(e.getMessage(), e);  
1004.             broken = true;  
1005.         } finally {  
1006.             redisDataSource.returnResource(shardedJedis, broken);  
1007.         }  
1008.         return result;  
1009.     }  
1010.     public Boolean hexists(byte[] key, byte[] field) {  
1011.         Boolean result = false;  
1012.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1013.         if (shardedJedis == null) {  
1014.             return result;  
1015.         }  
1016.         boolean broken = false;  
1017.         try {  
1018.             result = shardedJedis.hexists(key, field);  
1019.         } catch (Exception e) {  
1020.             log.error(e.getMessage(), e);  
1021.             broken = true;  
1022.         } finally {  
1023.             redisDataSource.returnResource(shardedJedis, broken);  
1024.         }  
1025.         return result;  
1026.     }  
1027.     public Long hdel(byte[] key, byte[] field) {  
1028.         Long result = null;  
1029.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1030.         if (shardedJedis == null) {  
1031.             return result;  
1032.         }  
1033.         boolean broken = false;  
1034.         try {  
1035.             result = shardedJedis.hdel(key, field);  
1036.         } catch (Exception e) {  
1037.             log.error(e.getMessage(), e);  
1038.             broken = true;  
1039.         } finally {  
1040.             redisDataSource.returnResource(shardedJedis, broken);  
1041.         }  
1042.         return result;  
1043.     }  
1044.     public Long rpush(byte[] key, byte[] string) {  
1045.         Long result = null;  
1046.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1047.         if (shardedJedis == null) {  
1048.             return result;  
1049.         }  
1050.         boolean broken = false;  
1051.         try {  
1052.             result = shardedJedis.rpush(key, string);  
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.     public Long lpush(byte[] key, byte[] string) {  
1062.         Long result = null;  
1063.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1064.         if (shardedJedis == null) {  
1065.             return result;  
1066.         }  
1067.         boolean broken = false;  
1068.         try {  
1069.             result = shardedJedis.lpush(key, string);  
1070.         } catch (Exception e) {  
1071.             log.error(e.getMessage(), e);  
1072.             broken = true;  
1073.         } finally {  
1074.             redisDataSource.returnResource(shardedJedis, broken);  
1075.         }  
1076.         return result;  
1077.     }  
1078.     public Long llen(byte[] key) {  
1079.         Long result = null;  
1080.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1081.         if (shardedJedis == null) {  
1082.             return result;  
1083.         }  
1084.         boolean broken = false;  
1085.         try {  
1086.             result = shardedJedis.llen(key);  
1087.         } catch (Exception e) {  
1088.             log.error(e.getMessage(), e);  
1089.             broken = true;  
1090.         } finally {  
1091.             redisDataSource.returnResource(shardedJedis, broken);  
1092.         }  
1093.         return result;  
1094.     }  
1095.     public List<byte[]> lrange(byte[] key, int start, int end) {  
1096.         List<byte[]> result = null;  
1097.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1098.         if (shardedJedis == null) {  
1099.             return result;  
1100.         }  
1101.         boolean broken = false;  
1102.         try {  
1103.             result = shardedJedis.lrange(key, start, end);  
1104.         } catch (Exception e) {  
1105.             log.error(e.getMessage(), e);  
1106.             broken = true;  
1107.         } finally {  
1108.             redisDataSource.returnResource(shardedJedis, broken);  
1109.         }  
1110.         return result;  
1111.     }  
1112.     public String lset(byte[] key, int index, byte[] value) {  
1113.         String result = null;  
1114.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1115.         if (shardedJedis == null) {  
1116.             return result;  
1117.         }  
1118.         boolean broken = false;  
1119.         try {  
1120.             result = shardedJedis.lset(key, index, value);  
1121.         } catch (Exception e) {  
1122.             log.error(e.getMessage(), e);  
1123.             broken = true;  
1124.         } finally {  
1125.             redisDataSource.returnResource(shardedJedis, broken);  
1126.         }  
1127.         return result;  
1128.     }  
1129.     public Long lrem(byte[] key, int count, byte[] value) {  
1130.         Long result = null;  
1131.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1132.         if (shardedJedis == null) {  
1133.             return result;  
1134.         }  
1135.         boolean broken = false;  
1136.         try {  
1137.             result = shardedJedis.lrem(key, count, value);  
1138.         } catch (Exception e) {  
1139.             log.error(e.getMessage(), e);  
1140.             broken = true;  
1141.         } finally {  
1142.             redisDataSource.returnResource(shardedJedis, broken);  
1143.         }  
1144.         return result;  
1145.     }  
1146.     public byte[] lpop(byte[] key) {  
1147.         byte[] result = null;  
1148.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1149.         if (shardedJedis == null) {  
1150.             return result;  
1151.         }  
1152.         boolean broken = false;  
1153.         try {  
1154.             result = shardedJedis.lpop(key);  
1155.         } catch (Exception e) {  
1156.             log.error(e.getMessage(), e);  
1157.             broken = true;  
1158.         } finally {  
1159.             redisDataSource.returnResource(shardedJedis, broken);  
1160.         }  
1161.         return result;  
1162.     }  
1163.     public byte[] rpop(byte[] key) {  
1164.         byte[] result = null;  
1165.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1166.         if (shardedJedis == null) {  
1167.             return result;  
1168.         }  
1169.         boolean broken = false;  
1170.         try {  
1171.             result = shardedJedis.rpop(key);  
1172.         } catch (Exception e) {  
1173.             log.error(e.getMessage(), e);  
1174.             broken = true;  
1175.         } finally {  
1176.             redisDataSource.returnResource(shardedJedis, broken);  
1177.         }  
1178.         return result;  
1179.     }  
1180.     public Long sadd(byte[] key, byte[] member) {  
1181.         Long result = null;  
1182.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1183.         if (shardedJedis == null) {  
1184.             return result;  
1185.         }  
1186.         boolean broken = false;  
1187.         try {  
1188.             result = shardedJedis.sadd(key, member);  
1189.         } catch (Exception e) {  
1190.             log.error(e.getMessage(), e);  
1191.             broken = true;  
1192.         } finally {  
1193.             redisDataSource.returnResource(shardedJedis, broken);  
1194.         }  
1195.         return result;  
1196.     }  
1197.     public Set<byte[]> smembers(byte[] key) {  
1198.         Set<byte[]> result = null;  
1199.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1200.         if (shardedJedis == null) {  
1201.             return result;  
1202.         }  
1203.         boolean broken = false;  
1204.         try {  
1205.             result = shardedJedis.smembers(key);  
1206.         } catch (Exception e) {  
1207.             log.error(e.getMessage(), e);  
1208.             broken = true;  
1209.         } finally {  
1210.             redisDataSource.returnResource(shardedJedis, broken);  
1211.         }  
1212.         return result;  
1213.     }  
1214.     public Long scard(byte[] key) {  
1215.         Long result = null;  
1216.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1217.         if (shardedJedis == null) {  
1218.             return result;  
1219.         }  
1220.         boolean broken = false;  
1221.         try {  
1222.             result = shardedJedis.scard(key);  
1223.         } catch (Exception e) {  
1224.             log.error(e.getMessage(), e);  
1225.             broken = true;  
1226.         } finally {  
1227.             redisDataSource.returnResource(shardedJedis, broken);  
1228.         }  
1229.         return result;  
1230.     }  
1231.     public Long zadd(byte[] key, double score, byte[] member) {  
1232.         Long result = null;  
1233.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1234.         if (shardedJedis == null) {  
1235.             return result;  
1236.         }  
1237.         boolean broken = false;  
1238.         try {  
1239.             result = shardedJedis.zadd(key, score, member);  
1240.         } catch (Exception e) {  
1241.             log.error(e.getMessage(), e);  
1242.             broken = true;  
1243.         } finally {  
1244.             redisDataSource.returnResource(shardedJedis, broken);  
1245.         }  
1246.         return result;  
1247.     }  
1248.     public Long zcard(byte[] key) {  
1249.         Long result = null;  
1250.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1251.         if (shardedJedis == null) {  
1252.             return result;  
1253.         }  
1254.         boolean broken = false;  
1255.         try {  
1256.             result = shardedJedis.zcard(key);  
1257.         } catch (Exception e) {  
1258.             log.error(e.getMessage(), e);  
1259.             broken = true;  
1260.         } finally {  
1261.             redisDataSource.returnResource(shardedJedis, broken);  
1262.         }  
1263.         return result;  
1264.     }  
1265.     public JedisShardInfo getShardInfo(String key) {  
1266.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1267.         JedisShardInfo result = null;  
1268.         if (shardedJedis == null) {  
1269.             return result;  
1270.         }  
1271.         boolean broken = false;  
1272.         try {  
1273.             result = shardedJedis.getShardInfo(key);  
1274.         } catch (Exception e) {  
1275.             log.error(e.getMessage(), e);  
1276.             broken = true;  
1277.         } finally {  
1278.             redisDataSource.returnResource(shardedJedis, broken);  
1279.         }  
1280.         return result;  
1281.     }  
1282.     public Collection<JedisShardInfo> getAllShardInfo() {  
1283.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1284.         Collection<JedisShardInfo> result = null;  
1285.         if (shardedJedis == null) {  
1286.             return result;  
1287.         }  
1288.         boolean broken = false;  
1289.         try {  
1290.             result = shardedJedis.getAllShardInfo();  
1291.         } catch (Exception e) {  
1292.             log.error(e.getMessage(), e);  
1293.             broken = true;  
1294.         } finally {  
1295.             redisDataSource.returnResource(shardedJedis, broken);  
1296.         }  
1297.         return result;  
1298.     }  
1299.     public Collection<Jedis> getAllShards() {  
1300.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();  
1301.         Collection<Jedis> result = null;  
1302.         if (shardedJedis == null) {  
1303.             return result;  
1304.         }  
1305.         boolean broken = false;  
1306.         try {  
1307.             result = shardedJedis.getAllShards();  
1308.         } catch (Exception e) {  
1309.             log.error(e.getMessage(), e);  
1310.             broken = true;  
1311.         } finally {  
1312.             redisDataSource.returnResource(shardedJedis, broken);  
1313.         }  
1314.         return result;  
1315.     }  
1316. }  

1. package com.redis;

2. import org.slf4j.LoggerFactory;

3. import org.springframework.beans.factory.annotation.Autowired;

4. import redis.clients.jedis.Jedis;

5. import redis.clients.jedis.JedisShardInfo;

6. import redis.clients.jedis.ShardedJedis;

8. public class RedisClientTemplate {

9. private static final org.slf4j.Logger log=LoggerFactory.getLogger(RedisClientTemplate.class);

10. @Autowired

11. private RedisDataSource redisDataSource;

12. public RedisDataSource getRedisDataSource() {

13. return redisDataSource;

14. }

15. public void setRedisDataSource(RedisDataSource redisDataSource) {

16. this.redisDataSource = redisDataSource;

17. }

18. public void disconnect(){

19. ShardedJedis shardedJedis=redisDataSource.getRedisClient();

20. shardedJedis.disconnect();

21. }

23. public String set(String key, String value){

24. String result=null;

25. ShardedJedis shardedJedis=redisDataSource.getRedisClient();

26. if(shardedJedis==null){

27. return result;

28. }

29. boolean broken=false;

30. try {

31. result=shardedJedis.set(key, value);

32. } catch (Exception e) {

33. broken=true;

34. e.printStackTrace();

35. }finally{

36. redisDataSource.returnResource(shardedJedis, broken);

37. }

38. return result;

39. }

41. public String get(String key) {

42. String result = null;

43. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

44. if (shardedJedis == null) {

45. return result;

46. }

47. boolean broken = false;

48. try {

49. result = shardedJedis.get(key);

50. } catch (Exception e) {

51. log.error(e.getMessage(), e);

52. broken = true;

53. } finally {

54. redisDataSource.returnResource(shardedJedis, broken);

55. }

56. return result;

57. }

59. public Boolean exists(String key) {

60. Boolean result = false;

61. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

62. if (shardedJedis == null) {

63. return result;

64. }

65. boolean broken = false;

66. try {

67. result = shardedJedis.exists(key);

68. } catch (Exception e) {

69. log.error(e.getMessage(), e);

70. broken = true;

71. } finally {

72. redisDataSource.returnResource(shardedJedis, broken);

73. }

74. return result;

75. }

77. public String type(String key) {

78. String result = null;

79. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

80. if (shardedJedis == null) {

81. return result;

82. }

83. boolean broken = false;

84. try {

85. result = shardedJedis.type(key);

86. } catch (Exception e) {

87. log.error(e.getMessage(), e);

88. broken = true;

89. } finally {

90. redisDataSource.returnResource(shardedJedis, broken);

91. }

92. return result;

93. }

95. public Long expire(String key, int seconds) {

96. Long result = null;

97. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

98. if (shardedJedis == null) {

99. return result;

100. }

101. boolean broken = false;

102. try {

103. result = shardedJedis.expire(key, seconds);

104. } catch (Exception e) {

105. log.error(e.getMessage(), e);

106. broken = true;

107. } finally {

108. redisDataSource.returnResource(shardedJedis, broken);

109. }

110. return result;

111. }

113. public Long expireAt(String key, long unixTime) {

114. Long result = null;

115. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

116. if (shardedJedis == null) {

117. return result;

118. }

119. boolean broken = false;

120. try {

121. result = shardedJedis.expireAt(key, unixTime);

122. } catch (Exception e) {

123. log.error(e.getMessage(), e);

124. broken = true;

125. } finally {

126. redisDataSource.returnResource(shardedJedis, broken);

127. }

128. return result;

129. }

131. public Long ttl(String key) {

132. Long result = null;

133. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

134. if (shardedJedis == null) {

135. return result;

136. }

137. boolean broken = false;

138. try {

139. result = shardedJedis.ttl(key);

140. } catch (Exception e) {

141. log.error(e.getMessage(), e);

142. broken = true;

143. } finally {

144. redisDataSource.returnResource(shardedJedis, broken);

145. }

146. return result;

147. }

149. public Long setnx(String key, String value) {

150. Long result = null;

151. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

152. if (shardedJedis == null) {

153. return result;

154. }

155. boolean broken = false;

156. try {

157. result = shardedJedis.setnx(key, value);

158. } catch (Exception e) {

159. log.error(e.getMessage(), e);

160. broken = true;

161. } finally {

162. redisDataSource.returnResource(shardedJedis, broken);

163. }

164. return result;

165. }

167. public String setex(String key, int seconds, String value) {

168. String result = null;

169. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

170. if (shardedJedis == null) {

171. return result;

172. }

173. boolean broken = false;

174. try {

175. result = shardedJedis.setex(key, seconds, value);

176. } catch (Exception e) {

177. log.error(e.getMessage(), e);

178. broken = true;

179. } finally {

180. redisDataSource.returnResource(shardedJedis, broken);

181. }

182. return result;

183. }

185. public Long decrBy(String key, long integer) {

186. Long result = null;

187. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

188. if (shardedJedis == null) {

189. return result;

190. }

191. boolean broken = false;

192. try {

193. result = shardedJedis.decrBy(key, integer);

194. } catch (Exception e) {

195. log.error(e.getMessage(), e);

196. broken = true;

197. } finally {

198. redisDataSource.returnResource(shardedJedis, broken);

199. }

200. return result;

201. }

203. public Long decr(String key) {

204. Long result = null;

205. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

206. if (shardedJedis == null) {

207. return result;

208. }

209. boolean broken = false;

210. try {

211. result = shardedJedis.decr(key);

212. } catch (Exception e) {

213. log.error(e.getMessage(), e);

214. broken = true;

215. } finally {

216. redisDataSource.returnResource(shardedJedis, broken);

217. }

218. return result;

219. }

221. public Long incrBy(String key, long integer) {

222. Long result = null;

223. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

224. if (shardedJedis == null) {

225. return result;

226. }

227. boolean broken = false;

228. try {

229. result = shardedJedis.incrBy(key, integer);

230. } catch (Exception e) {

231. log.error(e.getMessage(), e);

232. broken = true;

233. } finally {

234. redisDataSource.returnResource(shardedJedis, broken);

235. }

236. return result;

237. }

239. public Long incr(String key) {

240. Long result = null;

241. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

242. if (shardedJedis == null) {

243. return result;

244. }

245. boolean broken = false;

246. try {

247. result = shardedJedis.incr(key);

248. } catch (Exception e) {

249. log.error(e.getMessage(), e);

250. broken = true;

251. } finally {

252. redisDataSource.returnResource(shardedJedis, broken);

253. }

254. return result;

255. }

257. public Long append(String key, String value) {

258. Long result = null;

259. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

260. if (shardedJedis == null) {

261. return result;

262. }

263. boolean broken = false;

264. try {

265. result = shardedJedis.append(key, value);

266. } catch (Exception e) {

267. log.error(e.getMessage(), e);

268. broken = true;

269. } finally {

270. redisDataSource.returnResource(shardedJedis, broken);

271. }

272. return result;

273. }

275. public String substr(String key, int start, int end) {

276. String result = null;

277. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

278. if (shardedJedis == null) {

279. return result;

280. }

281. boolean broken = false;

282. try {

283. result = shardedJedis.substr(key, start, end);

284. } catch (Exception e) {

285. log.error(e.getMessage(), e);

286. broken = true;

287. } finally {

288. redisDataSource.returnResource(shardedJedis, broken);

289. }

290. return result;

291. }

293. public Long hset(String key, String field, String value) {

294. Long result = null;

295. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

296. if (shardedJedis == null) {

297. return result;

298. }

299. boolean broken = false;

300. try {

301. result = shardedJedis.hset(key, field, value);

302. } catch (Exception e) {

303. log.error(e.getMessage(), e);

304. broken = true;

305. } finally {

306. redisDataSource.returnResource(shardedJedis, broken);

307. }

308. return result;

309. }

311. public String hget(String key, String field) {

312. String result = null;

313. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

314. if (shardedJedis == null) {

315. return result;

316. }

317. boolean broken = false;

318. try {

319. result = shardedJedis.hget(key, field);

320. } catch (Exception e) {

321. log.error(e.getMessage(), e);

322. broken = true;

323. } finally {

324. redisDataSource.returnResource(shardedJedis, broken);

325. }

326. return result;

327. }

329. public String hmset(String key, Map<String, String> hash) {

330. String result = null;

331. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

332. if (shardedJedis == null) {

333. return result;

334. }

335. boolean broken = false;

336. try {

337. result = shardedJedis.hmset(key, hash);

338. } catch (Exception e) {

339. log.error(e.getMessage(), e);

340. broken = true;

341. } finally {

342. redisDataSource.returnResource(shardedJedis, broken);

343. }

344. return result;

345. }

347. public List<String> hmget(String key, String... fields) {

348. List<String> result = null;

349. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

350. if (shardedJedis == null) {

351. return result;

352. }

353. boolean broken = false;

354. try {

355. result = shardedJedis.hmget(key, fields);

356. } catch (Exception e) {

357. log.error(e.getMessage(), e);

358. broken = true;

359. } finally {

360. redisDataSource.returnResource(shardedJedis, broken);

361. }

362. return result;

363. }

365. public Long hincrBy(String key, String field, long value) {

366. Long result = null;

367. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

368. if (shardedJedis == null) {

369. return result;

370. }

371. boolean broken = false;

372. try {

373. result = shardedJedis.hincrBy(key, field, value);

374. } catch (Exception e) {

375. log.error(e.getMessage(), e);

376. broken = true;

377. } finally {

378. redisDataSource.returnResource(shardedJedis, broken);

379. }

380. return result;

381. }

383. public Boolean hexists(String key, String field) {

384. Boolean result = false;

385. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

386. if (shardedJedis == null) {

387. return result;

388. }

389. boolean broken = false;

390. try {

391. result = shardedJedis.hexists(key, field);

392. } catch (Exception e) {

393. log.error(e.getMessage(), e);

394. broken = true;

395. } finally {

396. redisDataSource.returnResource(shardedJedis, broken);

397. }

398. return result;

399. }

401. public Long del(String key) {

402. Long result = null;

403. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

404. if (shardedJedis == null) {

405. return result;

406. }

407. boolean broken = false;

408. try {

409. result = shardedJedis.del(key);

410. } catch (Exception e) {

411. log.error(e.getMessage(), e);

412. broken = true;

413. } finally {

414. redisDataSource.returnResource(shardedJedis, broken);

415. }

416. return result;

417. }

419. public Long hdel(String key, String field) {

420. Long result = null;

421. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

422. if (shardedJedis == null) {

423. return result;

424. }

425. boolean broken = false;

426. try {

427. result = shardedJedis.hdel(key, field);

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

437. public Long hlen(String key) {

438. Long result = null;

439. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

440. if (shardedJedis == null) {

441. return result;

442. }

443. boolean broken = false;

444. try {

445. result = shardedJedis.hlen(key);

446. } catch (Exception e) {

447. log.error(e.getMessage(), e);

448. broken = true;

449. } finally {

450. redisDataSource.returnResource(shardedJedis, broken);

451. }

452. return result;

453. }

455. public Set<String> hkeys(String key) {

456. Set<String> result = null;

457. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

458. if (shardedJedis == null) {

459. return result;

460. }

461. boolean broken = false;

462. try {

463. result = shardedJedis.hkeys(key);

464. } catch (Exception e) {

465. log.error(e.getMessage(), e);

466. broken = true;

467. } finally {

468. redisDataSource.returnResource(shardedJedis, broken);

469. }

470. return result;

471. }

473. public List<String> hvals(String key) {

474. List<String> result = null;

475. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

476. if (shardedJedis == null) {

477. return result;

478. }

479. boolean broken = false;

480. try {

481. result = shardedJedis.hvals(key);

482. } catch (Exception e) {

483. log.error(e.getMessage(), e);

484. broken = true;

485. } finally {

486. redisDataSource.returnResource(shardedJedis, broken);

487. }

488. return result;

489. }

491. public Map<String, String> hgetAll(String key) {

492. Map<String, String> result = null;

493. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

494. if (shardedJedis == null) {

495. return result;

496. }

497. boolean broken = false;

498. try {

499. result = shardedJedis.hgetAll(key);

500. } catch (Exception e) {

501. log.error(e.getMessage(), e);

502. broken = true;

503. } finally {

504. redisDataSource.returnResource(shardedJedis, broken);

505. }

506. return result;

507. }

508. // ================list ====== l表示 list或 left, r表示right====================

510. public Long rpush(String key, String string) {

511. Long result = null;

512. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

513. if (shardedJedis == null) {

514. return result;

515. }

516. boolean broken = false;

517. try {

518. result = shardedJedis.rpush(key, string);

519. } catch (Exception e) {

520. log.error(e.getMessage(), e);

521. broken = true;

522. } finally {

523. redisDataSource.returnResource(shardedJedis, broken);

524. }

525. return result;

526. }

528. public Long lpush(String key, String string) {

529. Long result = null;

530. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

531. if (shardedJedis == null) {

532. return result;

533. }

534. boolean broken = false;

535. try {

536. result = shardedJedis.lpush(key, string);

537. } catch (Exception e) {

538. log.error(e.getMessage(), e);

539. broken = true;

540. } finally {

541. redisDataSource.returnResource(shardedJedis, broken);

542. }

543. return result;

544. }

546. public Long llen(String key) {

547. Long result = null;

548. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

549. if (shardedJedis == null) {

550. return result;

551. }

552. boolean broken = false;

553. try {

554. result = shardedJedis.llen(key);

555. } catch (Exception e) {

556. log.error(e.getMessage(), e);

557. broken = true;

558. } finally {

559. redisDataSource.returnResource(shardedJedis, broken);

560. }

561. return result;

562. }

564. public List<String> lrange(String key, long start, long end) {

565. List<String> result = null;

566. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

567. if (shardedJedis == null) {

568. return result;

569. }

570. boolean broken = false;

571. try {

572. result = shardedJedis.lrange(key, start, end);

573. } catch (Exception e) {

574. log.error(e.getMessage(), e);

575. broken = true;

576. } finally {

577. redisDataSource.returnResource(shardedJedis, broken);

578. }

579. return result;

580. }

582. public String ltrim(String key, long start, long end) {

583. String result = null;

584. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

585. if (shardedJedis == null) {

586. return result;

587. }

588. boolean broken = false;

589. try {

590. result = shardedJedis.ltrim(key, start, end);

591. } catch (Exception e) {

592. log.error(e.getMessage(), e);

593. broken = true;

594. } finally {

595. redisDataSource.returnResource(shardedJedis, broken);

596. }

597. return result;

598. }

600. public String lindex(String key, long index) {

601. String result = null;

602. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

603. if (shardedJedis == null) {

604. return result;

605. }

606. boolean broken = false;

607. try {

608. result = shardedJedis.lindex(key, index);

609. } catch (Exception e) {

610. log.error(e.getMessage(), e);

611. broken = true;

612. } finally {

613. redisDataSource.returnResource(shardedJedis, broken);

614. }

615. return result;

616. }

618. public String lset(String key, long index, String value) {

619. String result = null;

620. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

621. if (shardedJedis == null) {

622. return result;

623. }

624. boolean broken = false;

625. try {

626. result = shardedJedis.lset(key, index, value);

627. } catch (Exception e) {

628. log.error(e.getMessage(), e);

629. broken = true;

630. } finally {

631. redisDataSource.returnResource(shardedJedis, broken);

632. }

633. return result;

634. }

636. public String lpop(String key) {

637. String result = null;

638. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

639. if (shardedJedis == null) {

640. return result;

641. }

642. boolean broken = false;

643. try {

644. result = shardedJedis.lpop(key);

645. } catch (Exception e) {

646. log.error(e.getMessage(), e);

647. broken = true;

648. } finally {

649. redisDataSource.returnResource(shardedJedis, broken);

650. }

651. return result;

652. }

654. public String rpop(String key) {

655. String result = null;

656. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

657. if (shardedJedis == null) {

658. return result;

659. }

660. boolean broken = false;

661. try {

662. result = shardedJedis.rpop(key);

663. } catch (Exception e) {

664. log.error(e.getMessage(), e);

665. broken = true;

666. } finally {

667. redisDataSource.returnResource(shardedJedis, broken);

668. }

669. return result;

670. }

671. //return 1 add a not exist value ,

672. //return 0 add a exist value

674. public Long sadd(String key, String member) {

675. Long result = null;

676. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

677. if (shardedJedis == null) {

678. return result;

679. }

680. boolean broken = false;

681. try {

682. result = shardedJedis.sadd(key, member);

683. } catch (Exception e) {

684. log.error(e.getMessage(), e);

685. broken = true;

686. } finally {

687. redisDataSource.returnResource(shardedJedis, broken);

688. }

689. return result;

690. }

692. public Set<String> smembers(String key) {

693. Set<String> result = null;

694. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

695. if (shardedJedis == null) {

696. return result;

697. }

698. boolean broken = false;

699. try {

700. result = shardedJedis.smembers(key);

701. } catch (Exception e) {

702. log.error(e.getMessage(), e);

703. broken = true;

704. } finally {

705. redisDataSource.returnResource(shardedJedis, broken);

706. }

707. return result;

708. }

710. public Long scard(String key) {

711. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

712. Long result = null;

713. if (shardedJedis == null) {

714. return result;

715. }

716. boolean broken = false;

717. try {

718. result = shardedJedis.scard(key);

719. } catch (Exception e) {

720. log.error(e.getMessage(), e);

721. broken = true;

722. } finally {

723. redisDataSource.returnResource(shardedJedis, broken);

724. }

725. return result;

726. }

728. public Long zadd(String key, double score, String member) {

729. Long result = null;

730. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

731. if (shardedJedis == null) {

732. return result;

733. }

734. boolean broken = false;

735. try {

736. result = shardedJedis.zadd(key, score, member);

737. } catch (Exception e) {

738. log.error(e.getMessage(), e);

739. broken = true;

740. } finally {

741. redisDataSource.returnResource(shardedJedis, broken);

742. }

743. return result;

744. }

746. public Set<String> zrange(String key, int start, int end) {

747. Set<String> result = null;

748. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

749. if (shardedJedis == null) {

750. return result;

751. }

752. boolean broken = false;

753. try {

754. result = shardedJedis.zrange(key, start, end);

755. } catch (Exception e) {

756. log.error(e.getMessage(), e);

757. broken = true;

758. } finally {

759. redisDataSource.returnResource(shardedJedis, broken);

760. }

761. return result;

762. }

764. public Long zrem(String key, String member) {

765. Long result = null;

766. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

767. if (shardedJedis == null) {

768. return result;

769. }

770. boolean broken = false;

771. try {

772. result = shardedJedis.zrem(key, member);

773. } catch (Exception e) {

774. log.error(e.getMessage(), e);

775. broken = true;

776. } finally {

777. redisDataSource.returnResource(shardedJedis, broken);

778. }

779. return result;

780. }

782. public Double zincrby(String key, double score, String member) {

783. Double result = null;

784. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

785. if (shardedJedis == null) {

786. return result;

787. }

788. boolean broken = false;

789. try {

790. result = shardedJedis.zincrby(key, score, member);

791. } catch (Exception e) {

792. log.error(e.getMessage(), e);

793. broken = true;

794. } finally {

795. redisDataSource.returnResource(shardedJedis, broken);

796. }

797. return result;

798. }

800. public Long zrank(String key, String member) {

801. Long result = null;

802. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

803. if (shardedJedis == null) {

804. return result;

805. }

806. boolean broken = false;

807. try {

808. result = shardedJedis.zrank(key, member);

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

818. public Long zcard(String key) {

819. Long result = null;

820. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

821. if (shardedJedis == null) {

822. return result;

823. }

824. boolean broken = false;

825. try {

826. result = shardedJedis.zcard(key);

827. } catch (Exception e) {

828. log.error(e.getMessage(), e);

829. broken = true;

830. } finally {

831. redisDataSource.returnResource(shardedJedis, broken);

832. }

833. return result;

834. }

836. public Double zscore(String key, String member) {

837. Double result = null;

838. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

839. if (shardedJedis == null) {

840. return result;

841. }

842. boolean broken = false;

843. try {

844. result = shardedJedis.zscore(key, member);

845. } catch (Exception e) {

846. log.error(e.getMessage(), e);

847. broken = true;

848. } finally {

849. redisDataSource.returnResource(shardedJedis, broken);

850. }

851. return result;

852. }

854. public Long zcount(String key, double min, double max) {

855. Long result = null;

856. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

857. if (shardedJedis == null) {

858. return result;

859. }

860. boolean broken = false;

861. try {

862. result = shardedJedis.zcount(key, min, max);

863. } catch (Exception e) {

864. log.error(e.getMessage(), e);

865. broken = true;

866. } finally {

867. redisDataSource.returnResource(shardedJedis, broken);

868. }

869. return result;

870. }

872. public String set(byte[] key, byte[] value) {

873. String result = null;

874. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

875. if (shardedJedis == null) {

876. return result;

877. }

878. boolean broken = false;

879. try {

880. result = shardedJedis.set(key, value);

881. } catch (Exception e) {

882. log.error(e.getMessage(), e);

883. broken = true;

884. } finally {

885. redisDataSource.returnResource(shardedJedis, broken);

886. }

887. return result;

888. }

890. public byte[] get(byte[] key) {

891. byte[] result = null;

892. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

893. if (shardedJedis == null) {

894. return result;

895. }

896. boolean broken = false;

897. try {

898. result = shardedJedis.get(key);

899. } catch (Exception e) {

900. log.error(e.getMessage(), e);

901. broken = true;

902. } finally {

903. redisDataSource.returnResource(shardedJedis, broken);

904. }

905. return result;

906. }

908. public Boolean exists(byte[] key) {

909. Boolean result = false;

910. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

911. if (shardedJedis == null) {

912. return result;

913. }

914. boolean broken = false;

915. try {

916. result = shardedJedis.exists(key);

917. } catch (Exception e) {

918. log.error(e.getMessage(), e);

919. broken = true;

920. } finally {

921. redisDataSource.returnResource(shardedJedis, broken);

922. }

923. return result;

924. }

925. public Long expire(byte[] key, int seconds) {

926. Long result = null;

927. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

928. if (shardedJedis == null) {

929. return result;

930. }

931. boolean broken = false;

932. try {

933. result = shardedJedis.expire(key, seconds);

934. } catch (Exception e) {

935. log.error(e.getMessage(), e);

936. broken = true;

937. } finally {

938. redisDataSource.returnResource(shardedJedis, broken);

939. }

940. return result;

941. }

942. public Long expireAt(byte[] key, long unixTime) {

943. Long result = null;

944. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

945. if (shardedJedis == null) {

946. return result;

947. }

948. boolean broken = false;

949. try {

950. result = shardedJedis.expireAt(key, unixTime);

951. } catch (Exception e) {

952. log.error(e.getMessage(), e);

953. broken = true;

954. } finally {

955. redisDataSource.returnResource(shardedJedis, broken);

956. }

957. return result;

958. }

959. public Long ttl(byte[] key) {

960. Long result = null;

961. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

962. if (shardedJedis == null) {

963. return result;

964. }

965. boolean broken = false;

966. try {

967. result = shardedJedis.ttl(key);

968. } catch (Exception e) {

969. log.error(e.getMessage(), e);

970. broken = true;

971. } finally {

972. redisDataSource.returnResource(shardedJedis, broken);

973. }

974. return result;

975. }

976. public Long append(byte[] key, byte[] value) {

977. Long result = null;

978. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

979. if (shardedJedis == null) {

980. return result;

981. }

982. boolean broken = false;

983. try {

984. result = shardedJedis.append(key, value);

985. } catch (Exception e) {

986. log.error(e.getMessage(), e);

987. broken = true;

988. } finally {

989. redisDataSource.returnResource(shardedJedis, broken);

990. }

991. return result;

992. }

994. public Long hset(byte[] key, byte[] field, byte[] value) {

995. Long result = null;

996. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

997. if (shardedJedis == null) {

998. return result;

999. }

1000. boolean broken = false;

1001. try {

1002. result = shardedJedis.hset(key, field, value);

1003. } catch (Exception e) {

1004. log.error(e.getMessage(), e);

1005. broken = true;

1006. } finally {

1007. redisDataSource.returnResource(shardedJedis, broken);

1008. }

1009. return result;

1010. }

1012. public byte[] hget(byte[] key, byte[] field) {

1013. byte[] result = null;

1014. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1015. if (shardedJedis == null) {

1016. return result;

1017. }

1018. boolean broken = false;

1019. try {

1020. result = shardedJedis.hget(key, field);

1021. } catch (Exception e) {

1022. log.error(e.getMessage(), e);

1023. broken = true;

1024. } finally {

1025. redisDataSource.returnResource(shardedJedis, broken);

1026. }

1027. return result;

1028. }

1029. public String hmset(byte[] key, Map<byte[], byte[]> hash) {

1030. String result = null;

1031. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1032. if (shardedJedis == null) {

1033. return result;

1034. }

1035. boolean broken = false;

1036. try {

1037. result = shardedJedis.hmset(key, hash);

1038. } catch (Exception e) {

1039. log.error(e.getMessage(), e);

1040. broken = true;

1041. } finally {

1042. redisDataSource.returnResource(shardedJedis, broken);

1043. }

1044. return result;

1045. }

1046. public List<byte[]> hmget(byte[] key, byte[]... fields) {

1047. List<byte[]> result = null;

1048. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1049. if (shardedJedis == null) {

1050. return result;

1051. }

1052. boolean broken = false;

1053. try {

1054. result = shardedJedis.hmget(key, fields);

1055. } catch (Exception e) {

1056. log.error(e.getMessage(), e);

1057. broken = true;

1058. } finally {

1059. redisDataSource.returnResource(shardedJedis, broken);

1060. }

1061. return result;

1062. }

1063. public Boolean hexists(byte[] key, byte[] field) {

1064. Boolean result = false;

1065. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1066. if (shardedJedis == null) {

1067. return result;

1068. }

1069. boolean broken = false;

1070. try {

1071. result = shardedJedis.hexists(key, field);

1072. } catch (Exception e) {

1073. log.error(e.getMessage(), e);

1074. broken = true;

1075. } finally {

1076. redisDataSource.returnResource(shardedJedis, broken);

1077. }

1078. return result;

1079. }

1081. public Long hdel(byte[] key, byte[] field) {

1082. Long result = null;

1083. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1084. if (shardedJedis == null) {

1085. return result;

1086. }

1087. boolean broken = false;

1088. try {

1089. result = shardedJedis.hdel(key, field);

1090. } catch (Exception e) {

1091. log.error(e.getMessage(), e);

1092. broken = true;

1093. } finally {

1094. redisDataSource.returnResource(shardedJedis, broken);

1095. }

1096. return result;

1097. }

1098. public Long rpush(byte[] key, byte[] string) {

1099. Long result = null;

1100. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1101. if (shardedJedis == null) {

1102. return result;

1103. }

1104. boolean broken = false;

1105. try {

1106. result = shardedJedis.rpush(key, string);

1107. } catch (Exception e) {

1108. log.error(e.getMessage(), e);

1109. broken = true;

1110. } finally {

1111. redisDataSource.returnResource(shardedJedis, broken);

1112. }

1113. return result;

1114. }

1115. public Long lpush(byte[] key, byte[] string) {

1116. Long result = null;

1117. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1118. if (shardedJedis == null) {

1119. return result;

1120. }

1121. boolean broken = false;

1122. try {

1123. result = shardedJedis.lpush(key, string);

1124. } catch (Exception e) {

1125. log.error(e.getMessage(), e);

1126. broken = true;

1127. } finally {

1128. redisDataSource.returnResource(shardedJedis, broken);

1129. }

1130. return result;

1131. }

1132. public Long llen(byte[] key) {

1133. Long result = null;

1134. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1135. if (shardedJedis == null) {

1136. return result;

1137. }

1138. boolean broken = false;

1139. try {

1140. result = shardedJedis.llen(key);

1141. } catch (Exception e) {

1142. log.error(e.getMessage(), e);

1143. broken = true;

1144. } finally {

1145. redisDataSource.returnResource(shardedJedis, broken);

1146. }

1147. return result;

1148. }

1149. public List<byte[]> lrange(byte[] key, int start, int end) {

1150. List<byte[]> result = null;

1151. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1152. if (shardedJedis == null) {

1153. return result;

1154. }

1155. boolean broken = false;

1156. try {

1157. result = shardedJedis.lrange(key, start, end);

1158. } catch (Exception e) {

1159. log.error(e.getMessage(), e);

1160. broken = true;

1161. } finally {

1162. redisDataSource.returnResource(shardedJedis, broken);

1163. }

1164. return result;

1165. }

1166. public String lset(byte[] key, int index, byte[] value) {

1167. String result = null;

1168. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1169. if (shardedJedis == null) {

1170. return result;

1171. }

1172. boolean broken = false;

1173. try {

1174. result = shardedJedis.lset(key, index, value);

1175. } catch (Exception e) {

1176. log.error(e.getMessage(), e);

1177. broken = true;

1178. } finally {

1179. redisDataSource.returnResource(shardedJedis, broken);

1180. }

1181. return result;

1182. }

1183. public Long lrem(byte[] key, int count, byte[] value) {

1184. Long result = null;

1185. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1186. if (shardedJedis == null) {

1187. return result;

1188. }

1189. boolean broken = false;

1190. try {

1191. result = shardedJedis.lrem(key, count, value);

1192. } catch (Exception e) {

1193. log.error(e.getMessage(), e);

1194. broken = true;

1195. } finally {

1196. redisDataSource.returnResource(shardedJedis, broken);

1197. }

1198. return result;

1199. }

1200. public byte[] lpop(byte[] key) {

1201. byte[] result = null;

1202. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1203. if (shardedJedis == null) {

1204. return result;

1205. }

1206. boolean broken = false;

1207. try {

1208. result = shardedJedis.lpop(key);

1209. } catch (Exception e) {

1210. log.error(e.getMessage(), e);

1211. broken = true;

1212. } finally {

1213. redisDataSource.returnResource(shardedJedis, broken);

1214. }

1215. return result;

1216. }

1217. public byte[] rpop(byte[] key) {

1218. byte[] result = null;

1219. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1220. if (shardedJedis == null) {

1221. return result;

1222. }

1223. boolean broken = false;

1224. try {

1225. result = shardedJedis.rpop(key);

1226. } catch (Exception e) {

1227. log.error(e.getMessage(), e);

1228. broken = true;

1229. } finally {

1230. redisDataSource.returnResource(shardedJedis, broken);

1231. }

1232. return result;

1233. }

1235. public Long sadd(byte[] key, byte[] member) {

1236. Long result = null;

1237. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1238. if (shardedJedis == null) {

1239. return result;

1240. }

1241. boolean broken = false;

1242. try {

1243. result = shardedJedis.sadd(key, member);

1244. } catch (Exception e) {

1245. log.error(e.getMessage(), e);

1246. broken = true;

1247. } finally {

1248. redisDataSource.returnResource(shardedJedis, broken);

1249. }

1250. return result;

1251. }

1252. public Set<byte[]> smembers(byte[] key) {

1253. Set<byte[]> result = null;

1254. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1255. if (shardedJedis == null) {

1256. return result;

1257. }

1258. boolean broken = false;

1259. try {

1260. result = shardedJedis.smembers(key);

1261. } catch (Exception e) {

1262. log.error(e.getMessage(), e);

1263. broken = true;

1264. } finally {

1265. redisDataSource.returnResource(shardedJedis, broken);

1266. }

1267. return result;

1268. }

1269. public Long scard(byte[] key) {

1270. Long result = null;

1271. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1272. if (shardedJedis == null) {

1273. return result;

1274. }

1275. boolean broken = false;

1276. try {

1277. result = shardedJedis.scard(key);

1278. } catch (Exception e) {

1279. log.error(e.getMessage(), e);

1280. broken = true;

1281. } finally {

1282. redisDataSource.returnResource(shardedJedis, broken);

1283. }

1284. return result;

1285. }

1286. public Long zadd(byte[] key, double score, byte[] member) {

1287. Long result = null;

1288. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1289. if (shardedJedis == null) {

1290. return result;

1291. }

1292. boolean broken = false;

1293. try {

1294. result = shardedJedis.zadd(key, score, member);

1295. } catch (Exception e) {

1296. log.error(e.getMessage(), e);

1297. broken = true;

1298. } finally {

1299. redisDataSource.returnResource(shardedJedis, broken);

1300. }

1301. return result;

1302. }

1303. public Long zcard(byte[] key) {

1304. Long result = null;

1305. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1306. if (shardedJedis == null) {

1307. return result;

1308. }

1309. boolean broken = false;

1310. try {

1311. result = shardedJedis.zcard(key);

1312. } catch (Exception e) {

1313. log.error(e.getMessage(), e);

1314. broken = true;

1315. } finally {

1316. redisDataSource.returnResource(shardedJedis, broken);

1317. }

1318. return result;

1319. }

1320. public JedisShardInfo getShardInfo(String key) {

1321. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1322. JedisShardInfo result = null;

1323. if (shardedJedis == null) {

1324. return result;

1325. }

1326. boolean broken = false;

1327. try {

1328. result = shardedJedis.getShardInfo(key);

1329. } catch (Exception e) {

1330. log.error(e.getMessage(), e);

1331. broken = true;

1332. } finally {

1333. redisDataSource.returnResource(shardedJedis, broken);

1334. }

1335. return result;

1336. }

1337. public Collection<JedisShardInfo> getAllShardInfo() {

1338. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1339. Collection<JedisShardInfo> result = null;

1340. if (shardedJedis == null) {

1341. return result;

1342. }

1343. boolean broken = false;

1344. try {

1345. result = shardedJedis.getAllShardInfo();

1346. } catch (Exception e) {

1347. log.error(e.getMessage(), e);

1348. broken = true;

1349. } finally {

1350. redisDataSource.returnResource(shardedJedis, broken);

1351. }

1352. return result;

1353. }

1354. public Collection<Jedis> getAllShards() {

1355. ShardedJedis shardedJedis = redisDataSource.getRedisClient();

1356. Collection<Jedis> result = null;

1357. if (shardedJedis == null) {

1358. return result;

1359. }

1360. boolean broken = false;

1361. try {

1362. result = shardedJedis.getAllShards();

1363. } catch (Exception e) {

1364. log.error(e.getMessage(), e);

1365. broken = true;

1366. } finally {

1367. redisDataSource.returnResource(shardedJedis, broken);

1368. }

1369. return result;

1370. }

1371. }