JedisClient(示例)

 

拷贝

  1 import java.io.IOException;
  2 import java.util.HashSet;
  3 import java.util.Map;
  4 import java.util.Set;
  5 import org.apache.commons.lang.StringUtils;
  6 import redis.clients.jedis.Jedis;
  7 import redis.clients.jedis.JedisCluster;
  8 import redis.clients.jedis.JedisPool;
  9 import com.alibaba.fastjson.JSON;
 10 import com.alibaba.fastjson.TypeReference;
 11 
 12 
 13 public class JedisClient{
 14     
 15     private JedisCluster pool;
 16     
 17     public String get(String key) {
 18         return get(-1,key, new TypeReference<String>(){});
 19     }
 20     
 21     public String get(int db, String key) {
 22         return get(db, key, new TypeReference<String>(){});
 23     }
 24     
 25     public <T> T get(String key, TypeReference<T> tr) {
 26         return get(-1, key, tr);
 27     }
 28     
 29     public <T> T get(int db, String key, TypeReference<T> tr) {
 30         
 31         if(StringUtils.isBlank(key)){
 32             return null;
 33         }
 34         
 35         T result = null;
 36         
 37         JedisCluster redis = null;
 38         
 39         boolean borrowOrOprSuccess = true;
 40         
 41         try {
 42             redis = pool;
 43             
 44 //            if(db >= 0){
 45 //                redis.select(db);
 46 //            }else {
 47 //                redis.select(0);
 48 //            }
 49 
 50             String value = redis.get(key);
 51             
 52             if(StringUtils.isBlank(value)){
 53                 return null;
 54             }
 55             
 56             return (T) JSON.parseObject(value, tr);
 57                 
 58         } catch (Exception e) {
 59             borrowOrOprSuccess = false;
 60         } finally {
 61 //            try {
 62 //                pool.close();
 63 //            } catch (IOException e) {
 64 //                // TODO Auto-generated catch block
 65 //                e.printStackTrace();
 66 //            }
 67                 
 68         }
 69         
 70         return result;
 71     }
 72     
 73     
 74     public <T> boolean set(String key, T value) {
 75         return set(key, 0, value);
 76     }
 77 
 78     public <T> boolean set(String key, int TTL, T value) {
 79         return set(-1, key, TTL, value);
 80     }
 81     
 82     
 83     public <T> boolean set(int db, String key, int TTL, T value) {
 84         
 85         if(value == null){
 86             return false;
 87         }
 88         
 89         JedisCluster redis = null;
 90         
 91         boolean borrowOrOprSuccess = true;
 92         
 93         try {
 94             redis = pool;
 95             
 96 //            if(db >= 0){
 97 //                redis.select(db);
 98 //            }else {
 99 //                redis.select(0);
100 //            }
101             
102             if(TTL == 0){
103                 redis.set(key, JSON.toJSONString(value));
104             }else {
105                 redis.setex(key, TTL, JSON.toJSONString(value));
106             }
107             
108         } catch (Exception e) {
109             borrowOrOprSuccess = false;
110 //            try {
111 //                pool.close();
112 //            } catch (IOException e1) {
113 //                // TODO Auto-generated catch block
114 //                e1.printStackTrace();
115 //            }
116             
117             return false;
118  
119         } finally {
120 //            try {
121 //                pool.close();
122 //            } catch (IOException e) {
123 //                // TODO Auto-generated catch block
124 //                e.printStackTrace();
125 //            }
126         }
127         
128         return true;
129     }
130 
131     public boolean delete(String key) {
132         return delete(-1,key);
133     }
134     
135     public boolean delete(int db, String key) {
136         
137         if(StringUtils.isBlank(key)){
138             return false;
139         }
140         
141         JedisCluster redis = null;
142         
143         boolean borrowOrOprSuccess = true;
144         
145         try {
146             redis = pool;
147 //            if(db >= 0){
148 //                redis.select(db);
149 //            }else {
150 //                redis.select(0);
151 //            }
152             redis.del(key);
153             
154         } catch (Exception e) {
155             borrowOrOprSuccess = false;
156 //            try {
157 //                pool.close();
158 //            } catch (IOException e1) {
159 //                // TODO Auto-generated catch block
160 //                e1.printStackTrace();
161 //            }
162             
163             return false;
164  
165         } finally {
166 //            try {
167 //                pool.close();
168 //            } catch (IOException e) {
169 //                // TODO Auto-generated catch block
170 //                e.printStackTrace();
171 //            }
172         }
173         
174         return true;
175         
176     }
177 
178     public boolean expire(String key, int TTL) {
179         return expire(-1, key, TTL);
180     }
181     
182     public boolean expire(int db,String key, int TTL) {
183         JedisCluster redis = null;
184         
185         boolean borrowOrOprSuccess = true;
186         
187         try {
188             redis = pool;
189 //            if(db >= 0){
190 //                redis.select(db);
191 //            }else {
192 //                redis.select(0);
193 //            }
194             redis.expire(key, TTL);
195             
196         } catch (Exception e) {
197             borrowOrOprSuccess = false;
198 //            try {
199 //                pool.close();
200 //            } catch (IOException e1) {
201 //                // TODO Auto-generated catch block
202 //                e1.printStackTrace();
203 //            }
204         } finally {
205 //            try {
206 //                pool.close();
207 //            } catch (IOException e) {
208 //                // TODO Auto-generated catch block
209 //                e.printStackTrace();
210 //            }
211         }
212         
213         return true;
214     }
215     
216     public String hget(int db,String key, String field) {
217 
218         if (StringUtils.isBlank(key) || StringUtils.isBlank(field)) {
219             return null;
220         }
221 
222         String result = null;
223 
224         JedisCluster redis = null;
225 
226         boolean borrowOrOprSuccess = true;
227 
228         try {
229             redis = pool;
230             
231 //            if(db >= 0){
232 //                redis.select(db);
233 //            }else {
234 //                redis.select(0);
235 //            }
236 
237             return redis.hget(key, field);
238 
239         } catch (Exception e) {
240             borrowOrOprSuccess = false;
241 //            try {
242 //                pool.close();
243 //            } catch (IOException e1) {
244 //                // TODO Auto-generated catch block
245 //                e1.printStackTrace();
246 //            }
247 
248         } finally {
249 //            try {
250 //                pool.close();
251 //            } catch (IOException e) {
252 //                // TODO Auto-generated catch block
253 //                e.printStackTrace();
254 //            }
255         }
256 
257         return result;
258     }
259     
260     public String hget(String key, String field) {
261         return hget(-1, key,field);
262     }
263     
264     public byte[] hget(int db, byte[] key, byte[] field) {
265 
266         if (key == null || key.length == 0 || field == null || field.length == 0) {
267             return null;
268         }
269 
270         JedisCluster redis = null;
271 
272         boolean borrowOrOprSuccess = true;
273 
274         try {
275             redis = pool;
276             
277 //            if(db >= 0){
278 //                redis.select(db);
279 //            }else {
280 //                redis.select(0);
281 //            }
282 
283             return redis.hget(key, field);
284 
285         } catch (Exception e) {
286             borrowOrOprSuccess = false;
287 //            try {
288 //                pool.close();
289 //            } catch (IOException e1) {
290 //                // TODO Auto-generated catch block
291 //                e1.printStackTrace();
292 //            }
293 
294         } finally {
295 //            try {
296 //                pool.close();
297 //            } catch (IOException e) {
298 //                // TODO Auto-generated catch block
299 //                e.printStackTrace();
300 //            }
301         }
302 
303         return null;
304     }
305     
306     public byte[] hget(byte[] key, byte[] field) {
307         return hget(-1, key, field);
308     }
309     
310     public int hsetnx(int db,String key, String field, String value) {
311 
312         if (StringUtils.isBlank(key) || StringUtils.isBlank(field)) {
313             return 0;
314         }
315 
316         JedisCluster redis = null;
317 
318         boolean borrowOrOprSuccess = true;
319 
320         try {
321             redis = pool;
322             
323 //            if(db >= 0){
324 //                redis.select(db);
325 //            }else {
326 //                redis.select(0);
327 //            }
328 
329             return redis.hsetnx(key, field, value).intValue();
330 
331         } catch (Exception e) {
332             borrowOrOprSuccess = false;
333 //            try {
334 //                pool.close();
335 //            } catch (IOException e1) {
336 //                // TODO Auto-generated catch block
337 //                e1.printStackTrace();
338 //            }
339         } finally {
340 //            try {
341 //                pool.close();
342 //            } catch (IOException e) {
343 //                // TODO Auto-generated catch block
344 //                e.printStackTrace();
345 //            }
346         }
347 
348         return 0;
349     }
350     
351     public int hsetnx(String key, String field, String value) {
352         return hsetnx(-1, key, field, value);
353     }
354     
355     public int hset(int db, byte[] key, byte[] field, byte[] value) {
356 
357         if (key == null || key.length ==0 || field == null || field.length == 0 || value == null || value.length == 0) {
358             return -1;
359         }
360 
361         JedisCluster redis = null;
362 
363         boolean borrowOrOprSuccess = true;
364 
365         try {
366             redis = pool;
367 //            if(db >= 0){
368 //                redis.select(db);
369 //            }else {
370 //                redis.select(0);
371 //            }
372 
373             return redis.hset(key, field, value).intValue();
374 
375         } catch (Exception e) {
376             borrowOrOprSuccess = false;
377 //            try {
378 //                pool.close();
379 //            } catch (IOException e1) {
380 //                // TODO Auto-generated catch block
381 //                e1.printStackTrace();
382 //            }
383         } finally {
384 //            try {
385 //                pool.close();
386 //            } catch (IOException e) {
387 //                // TODO Auto-generated catch block
388 //                e.printStackTrace();
389 //            }
390         }
391 
392         return -1;
393     }
394     
395     public int hset(byte[] key, byte[] field, byte[] value) {
396         return hset(-1, key, field, value);
397     }
398     
399     public Map<String, String> hgetAll(String key) {
400 
401         return hgetAll(-1, key);
402     }
403     
404     public Map<String, String> hgetAll(int db,String key) {
405 
406         if (StringUtils.isBlank(key)) {
407             return null;
408         }
409 
410         JedisCluster redis = null;
411 
412         boolean borrowOrOprSuccess = true;
413 
414         try {
415             redis = pool;
416             
417 //            if(db >= 0){
418 //                redis.select(db);
419 //            }else {
420 //                redis.select(0);
421 //            }
422 
423             return redis.hgetAll(key);
424 
425         } catch (Exception e) {
426             borrowOrOprSuccess = false;
427 //            try {
428 //                pool.close();
429 //            } catch (IOException e1) {
430 //                // TODO Auto-generated catch block
431 //                e1.printStackTrace();
432 //            }
433         } finally {
434 //            try {
435 //                pool.close();
436 //            } catch (IOException e) {
437 //                // TODO Auto-generated catch block
438 //                e.printStackTrace();
439 //            }
440                 
441         }
442 
443         return null;
444     }
445     
446     public Map<byte[],byte[]> hgetAll(int db,byte[] key) {
447 
448         if (key == null || key.length == 0) {
449             return null;
450         }
451 
452         JedisCluster redis = null;
453 
454         boolean borrowOrOprSuccess = true;
455 
456         try {
457             redis = pool;
458             
459 //            if(db >= 0){
460 //                redis.select(db);
461 //            }else {
462 //                redis.select(0);
463 //            }
464 
465             return redis.hgetAll(key);
466 
467         } catch (Exception e) {
468             borrowOrOprSuccess = false;
469 //            try {
470 //                pool.close();
471 //            } catch (IOException e1) {
472 //                // TODO Auto-generated catch block
473 //                e1.printStackTrace();
474 //            }
475         } finally {
476 //            try {
477 //                pool.close();
478 //            } catch (IOException e) {
479 //                // TODO Auto-generated catch block
480 //                e.printStackTrace();
481 //            }
482         }
483 
484         return null;
485     }
486     
487     public Map<byte[],byte[]> hgetAll(byte[] key) {
488 
489         return hgetAll(-1, key);
490     }
491 
492     public int hset(String key, String field, String value) {
493         return hset(-1, key, field, value);
494     }
495     
496     public int hset(int db,String key, String field, String value) {
497 
498         if (StringUtils.isBlank(key) || StringUtils.isBlank(field)
499                 || StringUtils.isBlank(value)) {
500             return -1;
501         }
502 
503         JedisCluster redis = null;
504 
505         boolean borrowOrOprSuccess = true;
506 
507         try {
508             redis = pool;
509 //            if(db >= 0){
510 //                redis.select(db);
511 //            }else {
512 //                redis.select(0);
513 //            }
514             return redis.hset(key, field, value).intValue();
515         } catch (Exception e) {
516             borrowOrOprSuccess = false;
517 //            try {
518 //                pool.close();
519 //            } catch (IOException e1) {
520 //                // TODO Auto-generated catch block
521 //                e1.printStackTrace();
522 //            }
523             return -1;
524 
525         } finally {
526 //            try {
527 //                pool.close();
528 //            } catch (IOException e) {
529 //                // TODO Auto-generated catch block
530 //                e.printStackTrace();
531 //            }
532         }
533     }
534     
535     public Set<String> hkeys(String key) {
536         return hkeys(-1,key);
537     }
538     
539     public Set<String> hkeys(int db,String key) {
540 
541         if (StringUtils.isBlank(key)) {
542             return new HashSet<String>();
543         }
544 
545         JedisCluster redis = null;
546 
547         boolean borrowOrOprSuccess = true;
548 
549         try {
550             redis = pool;
551 //            if(db >= 0){
552 //                redis.select(db);
553 //            }else {
554 //                redis.select(0);
555 //            }
556             return redis.hkeys(key);
557         } catch (Exception e) {
558             borrowOrOprSuccess = false;
559 //            try {
560 //                pool.close();
561 //            } catch (IOException e1) {
562 //                // TODO Auto-generated catch block
563 //                e1.printStackTrace();
564 //            }
565             return new HashSet<String>();
566 
567         } finally {
568 //            try {
569 //                pool.close();
570 //            } catch (IOException e) {
571 //                // TODO Auto-generated catch block
572 //                e.printStackTrace();
573 //            }
574         }
575     }
576 
577     public boolean hdel(int db,String key, String field) {
578 
579         if (StringUtils.isBlank(key) || StringUtils.isBlank(field)) {
580             return false;
581         }
582 
583         JedisCluster redis = null;
584 
585         boolean borrowOrOprSuccess = true;
586 
587         try {
588             redis = pool;
589 //            if(db >= 0){
590 //                redis.select(db);
591 //            }else {
592 //                redis.select(0);
593 //            }
594             redis.hdel(key, field);
595 
596         } catch (Exception e) {
597             borrowOrOprSuccess = false;
598 //            try {
599 //                pool.close();
600 //            } catch (IOException e1) {
601 //                // TODO Auto-generated catch block
602 //                e1.printStackTrace();
603 //            }
604             return false;
605 
606         } finally {
607 //            try {
608 //                pool.close();
609 //            } catch (IOException e) {
610 //                // TODO Auto-generated catch block
611 //                e.printStackTrace();
612 //            }
613         }
614 
615         return true;
616 
617     }
618     
619     public boolean hdel(String key, String field) {
620         return hdel(-1, key, field);
621     }
622     
623     public boolean hexists(String key, String field) {
624         return hexists(-1, key, field);
625     }
626     
627     public boolean hexists(int db,String key, String field) {
628 
629         if (StringUtils.isBlank(key) || StringUtils.isBlank(field)) {
630             return false;
631         }
632 
633         JedisCluster redis = null;
634 
635         boolean borrowOrOprSuccess = true;
636 
637         try {
638             redis = pool;
639 //            if(db >= 0){
640 //                redis.select(db);
641 //            }else {
642 //                redis.select(0);
643 //            }
644             return redis.hexists(key, field);
645 
646         } catch (Exception e) {
647             borrowOrOprSuccess = false;
648 //            try {
649 //                pool.close();
650 //            } catch (IOException e1) {
651 //                // TODO Auto-generated catch block
652 //                e1.printStackTrace();
653 //            }
654             return false;
655 
656         } finally {
657             if (borrowOrOprSuccess){
658 //                try {
659 //                    pool.close();
660 //                } catch (IOException e) {
661 //                    // TODO Auto-generated catch block
662 //                    e.printStackTrace();
663 //                }
664             }
665         }
666     }
667     
668     public int setnx(String key, String value) {
669         return setnx(-1, key, value);
670     }
671     
672     public int setnx(int db,String key, String value) {
673 
674         if (StringUtils.isBlank(key) || StringUtils.isBlank(value)) {
675             return -1;
676         }
677 
678         JedisCluster redis = null;
679 
680         boolean borrowOrOprSuccess = true;
681 
682         try {
683             redis = pool;
684 //            if(db >= 0){
685 //                redis.select(db);
686 //            }else {
687 //                redis.select(0);
688 //            }
689             return redis.setnx(key, value).intValue();
690 
691         } catch (Exception e) {
692             borrowOrOprSuccess = false;
693 //            try {
694 //                pool.close();
695 //            } catch (IOException e1) {
696 //                // TODO Auto-generated catch block
697 //                e1.printStackTrace();
698 //            }
699 
700             return 0;
701 
702         } finally {
703             if (borrowOrOprSuccess){
704 //                try {
705 //                    pool.close();
706 //                } catch (IOException e) {
707 //                    // TODO Auto-generated catch block
708 //                    e.printStackTrace();
709 //                }
710             }
711         }
712     }
713     
714     public Set<String> keys(String pattern) {
715         return keys(-1, pattern);
716     }
717     
718     public Set<String> keys(int db,String pattern) {
719         JedisCluster redis = null;
720         Set<String> keysSet = new HashSet<String>();
721         
722         boolean borrowOrOprSuccess = true;
723         
724         try {
725             redis = pool;
726 //            if(db >= 0){
727 //                redis.select(db);
728 //            }else {
729 //                redis.select(0);
730 //            }
731             Map<String, JedisPool> clusterNodes = redis.getClusterNodes();  
732             for(String k : clusterNodes.keySet()){  
733                 JedisPool jp = clusterNodes.get(k);  
734                 Jedis connection = jp.getResource();  
735                 try {  
736                     keysSet.addAll(connection.keys(pattern));  
737                 } catch(Exception e){  
738                 } finally{  
739                     connection.close();//用完一定要close这个链接！！！  
740                 }  
741             }  
742             
743         } catch (Exception e) {
744             borrowOrOprSuccess = false;
745 //            try {
746 //                pool.close();
747 //            } catch (IOException e1) {
748 //                // TODO Auto-generated catch block
749 //                e1.printStackTrace();
750 //            }
751         } finally {
752             if (borrowOrOprSuccess){
753 //                try {
754 //                    pool.close();
755 //                } catch (IOException e) {
756 //                    // TODO Auto-generated catch block
757 //                    e.printStackTrace();
758 //                }
759             }
760         }
761         
762         return keysSet;
763     }
764     
765 //    public long publish(String channel, String message){
766 //        Jedis redis = null;
767 //        
768 //        boolean borrowOrOprSuccess = true;
769 //        
770 //        try {
771 //            redis = pool.getResource();
772 //            return redis.publish(channel, message);
773 //            
774 //        } catch (Exception e) {
775 //            borrowOrOprSuccess = false;
776 //            if (redis != null)
777 //                pool.returnBrokenResource(redis);
778 //        } finally {
779 //            if (borrowOrOprSuccess)
780 //                pool.returnResource(redis);
781 //        }
782 //        
783 //        return -1;
784 //    }
785 //    
786 //    public void subscribe(JedisPubSub pubSub, String... channel){
787 //        Jedis redis = null;
788 //        
789 //        boolean borrowOrOprSuccess = true;
790 //        
791 //        try {
792 //            redis = pool.getResource();
793 //            redis.subscribe(pubSub, channel);
794 //        } catch (Exception e) {
795 //            borrowOrOprSuccess = false;
796 //            if (redis != null)
797 //                pool.returnBrokenResource(redis);
798 //        } finally {
799 //            if (borrowOrOprSuccess)
800 //                pool.returnResource(redis);
801 //        }
802 //    }
803 //    
804 //    public void psubscribe(JedisPubSub pubSub, String... patterns){
805 //        Jedis redis = null;
806 //        
807 //        boolean borrowOrOprSuccess = true;
808 //        
809 //        try {
810 //            redis = pool.getResource();
811 //            redis.psubscribe(pubSub, patterns);
812 //        } catch (Exception e) {
813 //            borrowOrOprSuccess = false;
814 //            if (redis != null)
815 //                pool.returnBrokenResource(redis);
816 //        } finally {
817 //            if (borrowOrOprSuccess)
818 //                pool.returnResource(redis);
819 //        }
820 //    }
821     
822     public long ttl(int db, String key) {
823         if(StringUtils.isBlank(key)){
824             return 0;
825         }
826         
827         JedisCluster redis = null;
828         
829         boolean borrowOrOprSuccess = true;
830         
831         try {
832             redis = pool;
833 //            if(db >= 0){
834 //                redis.select(db);
835 //            }else {
836 //                redis.select(0);
837 //            }
838             return redis.ttl(key.getBytes());
839             
840         } catch (Exception e) {
841             borrowOrOprSuccess = false;
842 //            if (redis != null)
843 //                try {
844 //                    pool.close();
845 //                } catch (IOException e1) {
846 //                    // TODO Auto-generated catch block
847 //                    e1.printStackTrace();
848 //                }
849             
850             return 0;
851  
852         } finally {
853 //            if (borrowOrOprSuccess)
854 //                try {
855 //                    pool.close();
856 //                } catch (IOException e) {
857 //                    // TODO Auto-generated catch block
858 //                    e.printStackTrace();
859 //                }
860         }
861     }
862 
863     public void setPool(RedisPool pool) {
864         this.pool = pool.getCluster();
865     }
866 }

View Code