JedisClient(示例)

最新推荐文章于 2024-01-10 13:13:49 发布
最新推荐文章于 2024-01-10 13:13:49 发布
阅读量3.9k 收藏 1
点赞数
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/lydong_/article/details/79812630
版权

 

拷贝

  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

 

习惯沉淀
关注
redis基础学习(三)之Jedis操作CRUD
weixin_53998054的博客
06-25 334
redis学习(三)之Jedis操作CRUD
Jedis客户端操作redis缓存命令详解
liuweixiao520的博客
10-11 2455
jedis操作命令： 1.对value操作的命令      exists(key)：确认一个key是否存在      del(key)：删除一个key      type(key)：返回值的类型      keys(pattern)：返回满足给定pattern的所有key      randomkey：随机返回key空间的一个key      rename
jedisClient
03-31
jedis单机版和集群版封装的实现类, 共用一个接口, 面向接口开发, 代码无需改动, 只用切换实现类, 就可以切换jedis单机或者集群
Intro to Jedis – the Java Redis Client Library
weixin_33912453的博客
08-17 209
转自：http://www.baeldung.com/jedis-java-redis-client-library 1. Overview This article is an introduction to Jedis, a client library in Java for Redis – the popular in-memory data structure store that ca...
封装JedisClient.提供API实现对redis的操作
weixin_34168700的博客
08-05 363
需要导包,jedis-2.8.1.jar和博主的序列化工具类SerializeUtils package com.demo.redis; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.u...
JedisClient代码
xiaomage0077的博客
03-28 453
JedisClient代码
Java客户端利用Jedis操作redis缓存示例代码
08-30
在Java开发中，Redis作为一个高性能的键值存储系统，常被用作数据缓存，以提高应用程序的响应速度。Jedis是Redis官方推荐的Java客户端，提供了丰富的API用于操作Redis数据库。本文将深入探讨如何使用Jedis进行Redis...
java操作Redis缓存设置过期时间的方法
08-19
下面是一个使用 Jedis 设置过期时间的示例代码： ```java jedisClient.set(REDIS_USER_SESSION_KEY + ":" + token, JsonUtils.objectToJson(user)); jedisClient.expire(REDIS_USER_SESSION_KEY + ":" + token, ...
无涯教程-Redis - BLPOP命令函数
最新发布
无涯教程
01-10 718
RedisBLPOP命令用于删除并获取列表中的第一个元素，或者阻塞直到一个可用，BLPOP命令仅返回第一个元素(如果有)，或者在特定时间内阻止客户端执行任何命令。
RedisClient
12-06
RedisClient Redis客户端工具
RedisClient和jedis-2.8.1.jar
09-11
内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。 Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。
第三章阅读 jedis 源码之 Client 类
tobeng的博客
03-31 896
1、
redis java客户端封装_redis的java客户端Jedis简单封装
weixin_32446549的博客
02-16 233
经过我们团队的一番讨论，最终决定使用redis来进行我们的业务缓存。redis会将数据缓存到内存中，运行效率会很快。同时异步将数据写入到磁盘中，进行持久化。且redis支持主从同步，支持分布式部署，支持N多数据结构，这对于我们有着莫大的吸引力。我们团队讨论的焦点是在于redis的灾备恢复问题。由于redis的持久化是异步的，总会有一点时间内存中数据和磁盘数据不同步的情况(当然可以设置成完全同步，那...
系统中Jedis的应用，通过JedisClient来进行数据的交流
weixin_34254823的博客
04-19 265
2019独角兽企业重金招聘Python工程师标准>>> ...
JedisClient连接单机版和集群
weixin_37647123的博客
02-24 699
所以就是接口和实现类的模式 public interface JedisClient { String set(String key, String value); String get(String key); Boolean exists(String key); Long expire(String key, int seconds); Long ttl(String key);...
Redis Java Client Jedis 源码分析
jimgreat的专栏
07-13 287
 由于项目中使用Redis，所以使用它的Java客户端Jedis也有大半年的时间（后续会分享经验）。  最近看了一下源码，源码清晰、流畅、简洁，学到了不少东西，在此分享一下。 （源码地址：https://github.com/xetorthio/jedis）   协议   和Redis Server通信的协议规则都在redis.clients.jedis.Protocol这个类...
Redis客户端操作之Jedis
qq_30984561的博客
05-09 218
Jedis Jedis Client是Redis官网推荐的一个面向java客户端，库文件实现了对redis各类API进行封装调用,通过这些API我们会非常方便的操作我们的Redis数据库。 redis配置文件地修改 1.注释掉绑定地信息 在redis.conf的配置文件中bind配置的信息表示的是redis服务可以接收外部访问的地址，这个主要还是为了提高安全性，我们在学习阶段可以将这个信息直接注释...
JedisClient操作redis 单机版和集群版
mytimelife的博客
08-25 308
往期回顾1.快速了解缓存穿透与缓存雪崩 2.springBoot注解大全3.springBoot之Thymeleaf4.redis常用命令手册大全5.redis面试题集锦（含答案）一、在...
Oracle数据库操作示例：查询与自增技巧
"Oracle数据库示例包括了数据查询、集合操作以及表空间、用户权限管理、表的创建与删除，以及编号自增长的处理。" 在Oracle数据库中，集合操作是数据查询的重要组成部分。`UNION`用于合并两个查询的结果，并去除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值