动态代理模式_应用(Redis工具类)
程序员文章站
2022-06-27 21:34:31
本次使用动态代理的初衷是学习Redis，使用Java操作Redis时用到Jedis的JedisPool，而后对Jedis的方法进一步封装完善成为一个工具类。因为直接使用Jedis对象时，为了保证性能，总会需要手动的获取到连接池中的连接，使用完成后还需要手动的释放连接，都是完全重复的操作。所以想要使用 ......
本次使用动态代理的初衷是学习redis，使用java操作redis时用到jedis的jedispool，而后对jedis的方法进一步封装完善成为一个工具类。
因为直接使用jedis对象时，为了保证性能，总会需要手动的获取到连接池中的连接，使用完成后还需要手动的释放连接，都是完全重复的操作。
所以想要使用一些方法来抽取出这些重复操作，初时想到的是使用模板方法或是动态代理，但考虑到到模板方法会使用到大量的类，似乎与主旨不符，遂使用动态代理进行加强。
实现动态代理可使用jdk对应的方法，或是cglib。由于工具类本身不会去定义接口，所以选择cglib。本身是在springboot项目中进行，所以没有额外导入cglib的包(spring的面向切面就使用到了cglib与jdk自带的动态 代理)。
具体的思路就是使用动态代理来增强工具类对象，使得工具类在调用方法前后对应的进行获取连接及释放连接操作。在获得到增强工具类后只需要进行相关操作即可。
使用了maven来管理项目，代码所需的依赖如下
1 <!-- jedis --> 2 <dependency> 3 <groupid>com.redislabs</groupid> 4 <artifactid>jredisearch-jedis</artifactid> 5 <version>3.0.0-20180508</version> 6 </dependency>
此外还需要自己电脑安装redis，或有对应的服务器
代码如下
redis连接池代码
1 package com;
2
3 import org.apache.logging.log4j.logger;
4
5 import redis.clients.jedis.jedis;
6 import redis.clients.jedis.jedispool;
7 import redis.clients.jedis.jedispoolconfig;
8 /**
9 * jedis连接池
10 *
11 * @author zaizouggg
12 *
13 */
14 public class redispool {
15
16 private logger logger = logutil.get(jedisutil.class);
17 private static sysconfigutil sysconfigutil = sysconfigutil.getsysconfigutil("redis.properties");
18
19 //声明成static的原因：保证jedis连接池在tomcat启动时就加载出来
20 //jedis连接池
21 private static jedispool pool;
22 //与redis连接池连接的最大连接数
23 private static integer maxtotal = sysconfigutil.getint("redis.maxtotal");
24 //在jedis连接池中最大的idle状态（空闲的）的jedis实例的个数
25 private static integer maxidle = sysconfigutil.getint("redis.maxidle");
26 //在jedis连接池中最小的idle状态（空闲的）的jedis实例的个数
27 private static integer minidle = sysconfigutil.getint("redis.minidle");
28 //在borrow一个jedis实例的时候，是否要进行验证操作，如果赋值为true，则得到的jedis实例肯定是可用的
29 private static boolean testonborrow = sysconfigutil.getboolean("redis.testonborrow");
30 //在return一个jedis实例的时候，是否要进行验证操作，如果赋值为true，则返回jedis连接池的jedis实例肯定是可用的
31 private static boolean testonreturn = sysconfigutil.getboolean("redis.testonreturn");
32 private static string redisip = sysconfigutil.getstring("redis.host");
33 private static integer redisport = sysconfigutil.getint("redis.port");
34 private static string password = sysconfigutil.getstring("redis.password");
35
36 //初始化连接池，只会调用一次
37 private static void initpool() {
38 jedispoolconfig config = new jedispoolconfig();
39
40 config.setmaxtotal(maxtotal);
41 config.setmaxidle(maxidle);
42 config.setminidle(minidle);
43
44 config.settestonborrow(testonborrow);
45 config.settestonreturn(testonreturn);
46
47 //连接池耗尽的时候，是否阻塞，false会抛出异常，true阻塞直到超时，会抛出超时异常，默认为true
48 config.setblockwhenexhausted(true);
49
50 //这里超时时间是2s
51 if (password != null && !"".equals(password)) {
52 // redis 设置了密码
53 pool = new jedispool(config, redisip, redisport, 1000*2, password);
54 } else {
55 // redis 未设置密码
56 pool = new jedispool(config, redisip, redisport, 1000*2);
57 };
58
59
60 }
61
62 static {
63 initpool();
64 }
65
66 //从连接池中拿取一个实例
67 public static jedis getjedis() {
68 return pool.getresource();
69 }
70
71 //返还jedis
72 public static void returnjedis(jedis jedis) {
73 jedis.close();
74 }
75
76 //被使用的连接数
77 public static int getnumactive() {
78 return pool.getnumactive();
79 }
80
81 //被阻塞的连接数？
82 public static int getnumwaiters() {
83 return pool.getnumwaiters();
84 }
85
86 //空闲的连接数
87 public static int getnumidle() {
88 return pool.getnumidle();
89 }
90 }
读取.properties配置文件的工具类
用于读取配置在.properties中的参数
1 package com; 2 3 import java.io.bufferedinputstream; 4 import java.io.fileinputstream; 5 import java.io.ioexception; 6 import java.io.inputstream; 7 import java.util.properties; 8 9 import org.apache.logging.log4j.logger; 10 11 /** 12 * 获取自定义配置文件参数的共用方法 13 * 14 * @author zaizouggg
15 * 16 */ 17 public class sysconfigutil { 18 19 private static logger logger = logutil.get(sysconfigutil.class); 20 private properties properties = null; 21 22 public sysconfigutil() { 23 24 } 25 26 public sysconfigutil(properties p) { 27 properties = p; 28 } 29 30 31 public static sysconfigutil getsysconfigutil(string url) { 32 try(inputstream in = new bufferedinputstream(new fileinputstream(url));) { 33 properties p = new properties(); 34 p.load(in); 35 //return p.getproperty("jdbc.type"); 36 return new sysconfigutil(p); 37 } catch (ioexception e) { 38 // todo auto-generated catch block 39 logger.error("jedis工具类初始化失败,读取配置文件 "+url+" 出错"); 40 e.printstacktrace(); 41 return null; 42 } 43 44 } 45 46 public string getstring(string key) { 47 return properties.getproperty(key); 48 } 49 50 public int getint(string key) { 51 int result = integer.parseint(properties.getproperty(key)); 52 return result; 53 } 54 55 public boolean getboolean(string key) { 56 boolean result = boolean.parseboolean(properties.getproperty(key)); 57 return result; 58 } 59 60 public long getlong(string key) { 61 long result = long.parselong(properties.getproperty(key)); 62 return result; 63 } 64 }
redis配置文件
此处的配置是我从网上找的，普通的使用没有问题，要应用请慎重
redis.host=localhost redis.port=6379 redis.password=root #在指定时刻通过pool能够获取到的最大的连接的jedis个数 redis.maxtotal=8 #最大能够保持idle的数量，控制一个pool最多有多少个状态为idle的jedis实例 redis.maxidle=8 #最小能够保持idle的数量，控制一个pool最多有多少个状态为idle的jedis实例 redis.minidle=2 #在borrow一个jedis实例的时候，是否要进行验证操作，如果赋值为true，则得到的jedis实例肯定是可用的 redis.testonborrow=true #在return一个jedis实例的时候，是否要进行验证操作，如果赋值为true，则返回jedis连接池的jedis实例肯定是可用的 redis.testonreturn=false #当连接池内的连接耗尽时，getblockwhenexhausted为true时，连接会阻塞，超过了阻塞的时间（设定的maxwaitmillis，单位毫秒）时会报错 redis.maxwaitmillis=3000 #在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；默认是false redis.testonborrow=false
jedis的工具类
1 package com;
2
3 import java.io.ioexception;
4 import java.util.list;
5 import java.util.map;
6 import java.util.set;
7
8 import org.apache.logging.log4j.logger;
9
10 import redis.clients.jedis.jedis;
11 import redis.clients.jedis.jedispool;
12 import redis.clients.jedis.jedispoolconfig;
13 import redis.clients.jedis.listposition;
14
15 /**
16 * jedis 通用工具类
17 * @author zaizouggg
18 *
19 */
20 public class jedisutil {
21
22 private logger logger = logutil.get(jedisutil.class);
23 private jedis jedis = null;
24
25 public jedis getjedis() {
26 return jedis;
27 }
28
29 public void setjedis(jedis jedis) {
30 this.jedis = jedis;
31 }
32
33 /**
34 * 获取指定key的值,如果key不存在返回null，如果该key存储的不是字符串，会抛出一个错误
35 *
36 * @param key
37 * @return
38 */
39 public string get(string key) {
40 string value = jedis.get(key);
41 return value;
42 }
43
44 /**
45 * 设置key的值为value
46 *
47 * @param key
48 * @param value
49 * @return
50 */
51 public string set(string key, string value) {
52 string result = jedis.set(key, value);
53 return result;
54 }
55
56 /**
57 * 删除指定的key,也可以传入一个包含key的数组
58 *
59 * @param keys
60 * @return
61 */
62 public long del(string... keys) {
63
64 return jedis.del(keys);
65 }
66
67 /**
68 * 通过key向指定的value值追加值
69 *
70 * @param key
71 * @param str
72 * @return
73 */
74 public long append(string key, string str) {
75
76 return jedis.append(key, str);
77 }
78
79 /**
80 * 判断key是否存在
81 *
82 * @param key
83 * @return
84 */
85 public boolean exists(string key) {
86
87 return jedis.exists(key);
88 }
89
90 /**
91 * 设置key value,如果key已经存在则返回0
92 *
93 * @param key
94 * @param value
95 * @return
96 */
97 public long setnx(string key, string value) {
98
99 return jedis.setnx(key, value);
100 }
101
102 /**
103 * 设置key value并指定这个键值的有效期
104 *
105 * @param key
106 * @param seconds
107 * @param value
108 * @return
109 */
110 public string setex(string key, string value, int seconds) {
111 string result = jedis.setex(key, seconds, value);
112 return result;
113 }
114
115 /**
116 * 通过key 和offset 从指定的位置开始将原先value替换
117 *
118 * @param key
119 * @param offset
120 * @param str
121 * @return
122 */
123 public long setrange(string key, int offset, string str) {
124
125 return jedis.setrange(key, offset, str);
126 }
127
128 /**
129 * 通过批量的key获取批量的value
130 *
131 * @param keys
132 * @return
133 */
134 public list<string> mget(string... keys) {
135
136 return jedis.mget(keys);
137 }
138
139 /**
140 * 批量的设置key:value,也可以一个
141 *
142 * @param keysvalues
143 * @return
144 */
145 public string mset(string... keysvalues) {
146
147 return jedis.mset(keysvalues);
148 }
149
150 /**
151 * 批量的设置key:value,可以一个,如果key已经存在则会失败,操作会回滚
152 *
153 * @param keysvalues
154 * @return
155 */
156 public long msetnx(string... keysvalues) {
157
158 return jedis.msetnx(keysvalues);
159 }
160
161 /**
162 * 设置key的值,并返回一个旧值
163 *
164 * @param key
165 * @param value
166 * @return
167 */
168 public string getset(string key, string value) {
169
170 return jedis.getset(key, value);
171 }
172
173 /**
174 * 通过下标 和key 获取指定下标位置的 value
175 *
176 * @param key
177 * @param startoffset
178 * @param endoffset
179 * @return
180 */
181 public string getrange(string key, int startoffset, int endoffset) {
182
183 return jedis.getrange(key, startoffset, endoffset);
184 }
185
186 /**
187 * 通过key 对value进行加值+1操作,当value不是int类型时会返回错误,当key不存在是则value为1
188 *
189 * @param key
190 * @return
191 */
192 public long incr(string key) {
193
194 return jedis.incr(key);
195 }
196
197 /**
198 * 通过key给指定的value加值,如果key不存在,则这是value为该值
199 *
200 * @param key
201 * @param integer
202 * @return
203 */
204 public long incrby(string key, long integer) {
205
206 return jedis.incrby(key, integer);
207 }
208
209 /**
210 * 对key的值做减减操作,如果key不存在,则设置key为-1
211 *
212 * @param key
213 * @return
214 */
215 public long decr(string key) {
216
217 return jedis.decr(key);
218 }
219
220 /**
221 * 减去指定的值
222 *
223 * @param key
224 * @param integer
225 * @return
226 */
227 public long decrby(string key, long integer) {
228
229 return jedis.decrby(key, integer);
230 }
231
232 /**
233 * 通过key获取value值的长度
234 *
235 * @param key
236 * @return
237 */
238 public long strlen(string key) {
239
240 return jedis.strlen(key);
241 }
242
243 /**
244 * 通过key给field设置指定的值,如果key不存在则先创建,如果field已经存在,返回0
245 *
246 * @param key
247 * @param field
248 * @param value
249 * @return
250 */
251 public long hsetnx(string key, string field, string value) {
252
253 return jedis.hsetnx(key, field, value);
254 }
255
256 /**
257 * 通过key给field设置指定的值,如果key不存在,则先创建
258 *
259 * @param key
260 * @param field
261 * @param value
262 * @return
263 */
264 public long hset(string key, string field, string value) {
265
266 return jedis.hset(key, field, value);
267 }
268
269 /**
270 * 通过key同时设置 hash的多个field
271 *
272 * @param key
273 * @param hash
274 * @return
275 */
276 public string hmset(string key, map<string, string> hash) {
277
278 return jedis.hmset(key, hash);
279 }
280
281 /**
282 * 通过key 和 field 获取指定的 value
283 *
284 * @param key
285 * @param failed
286 * @return
287 */
288 public string hget(string key, string failed) {
289
290 return jedis.hget(key, failed);
291 }
292
293 /**
294 * 设置key的超时时间为seconds
295 *
296 * @param key
297 * @param seconds
298 * @return
299 */
300 public long expire(string key, int seconds) {
301
302 return jedis.expire(key, seconds);
303 }
304
305 /**
306 * 通过key 和 fields 获取指定的value 如果没有对应的value则返回null
307 *
308 * @param key
309 * @param fields 可以是 一个string 也可以是 string数组
310 * @return
311 */
312 public list<string> hmget(string key, string... fields) {
313
314 return jedis.hmget(key, fields);
315 }
316
317 /**
318 * 通过key给指定的field的value加上给定的值
319 *
320 * @param key
321 * @param field
322 * @param value
323 * @return
324 */
325 public long hincrby(string key, string field, long value) {
326
327 return jedis.hincrby(key, field, value);
328 }
329
330 /**
331 * 通过key和field判断是否有指定的value存在
332 *
333 * @param key
334 * @param field
335 * @return
336 */
337 public boolean hexists(string key, string field) {
338
339 return jedis.hexists(key, field);
340 }
341
342 /**
343 * 通过key返回field的数量
344 *
345 * @param key
346 * @return
347 */
348 public long hlen(string key) {
349
350 return jedis.hlen(key);
351 }
352
353 /**
354 * 通过key 删除指定的 field
355 *
356 * @param key
357 * @param fields 可以是 一个 field 也可以是 一个数组
358 * @return
359 */
360 public long hdel(string key, string... fields) {
361
362 return jedis.hdel(key, fields);
363 }
364
365 /**
366 * 通过key返回所有的field
367 *
368 * @param key
369 * @return
370 */
371 public set<string> hkeys(string key) {
372
373 return jedis.hkeys(key);
374 }
375
376 /**
377 * 通过key返回所有和key有关的value
378 *
379 * @param key
380 * @return
381 */
382 public list<string> hvals(string key) {
383
384 return jedis.hvals(key);
385 }
386
387 /**
388 * 通过key获取所有的field和value
389 *
390 * @param key
391 * @return
392 */
393 public map<string, string> hgetall(string key) {
394
395 return jedis.hgetall(key);
396 }
397
398 /**
399 * 通过key向list头部添加字符串
400 *
401 * @param key
402 * @param strs 可以是一个string 也可以是string数组
403 * @return 返回list的value个数
404 */
405 public long lpush(string key, string... strs) {
406
407 return jedis.lpush(key, strs);
408 }
409
410 /**
411 * 通过key向list尾部添加字符串
412 *
413 * @param key
414 * @param strs 可以是一个string 也可以是string数组
415 * @return 返回list的value个数
416 */
417 public long rpush(string key, string... strs) {
418
419 return jedis.rpush(key, strs);
420 }
421
422 /**
423 * 通过key在list指定的位置之前或者之后 添加字符串元素
424 *
425 * @param key
426 * @param where list_position枚举类型
427 * @param pivot list里面的value
428 * @param value 添加的value
429 * @return
430 */
431 public long linsert(string key, listposition where,
432 string pivot, string value) {
433
434 return jedis.linsert(key, where, pivot, value);
435 }
436
437 /**
438 * 通过key设置list指定下标位置的value
439 * 如果下标超过list里面value的个数则报错
440 *
441 * @param key
442 * @param index 从0开始
443 * @param value
444 * @return 成功返回ok
445 */
446 public string lset(string key, long index, string value) {
447
448 return jedis.lset(key, index, value);
449 }
450
451 /**
452 * 通过key从对应的list中删除指定的count个 和 value相同的元素
453 *
454 * @param key
455 * @param count 当count为0时删除全部
456 * @param value
457 * @return 返回被删除的个数
458 */
459 public long lrem(string key, long count, string value) {
460
461 return jedis.lrem(key, count, value);
462 }
463
464 /**
465 * 通过key保留list中从strat下标开始到end下标结束的value值
466 *
467 * @param key
468 * @param start
469 * @param end
470 * @return 成功返回ok
471 */
472 public string ltrim(string key, long start, long end) {
473
474 return jedis.ltrim(key, start, end);
475 }
476
477 /**
478 * 通过key从list的头部删除一个value,并返回该value
479 *
480 * @param key
481 * @return
482 */
483 public synchronized string lpop(string key) {
484
485
486 return jedis.lpop(key);
487 }
488
489 /**
490 * 通过key从list尾部删除一个value,并返回该元素
491 *
492 * @param key
493 * @return
494 */
495 synchronized public string rpop(string key) {
496
497 return jedis.rpop(key);
498 }
499
500 /**
501 * 通过key从一个list的尾部删除一个value并添加到另一个list的头部,并返回该value
502 * 如果第一个list为空或者不存在则返回null
503 *
504 * @param srckey
505 * @param dstkey
506 * @return
507 */
508 public string rpoplpush(string srckey, string dstkey) {
509
510 return jedis.rpoplpush(srckey, dstkey);
511 }
512
513 /**
514 * 通过key获取list中指定下标位置的value
515 *
516 * @param key
517 * @param index
518 * @return 如果没有返回null
519 */
520 public string lindex(string key, long index) {
521
522 return jedis.lindex(key, index);
523 }
524
525 /**
526 * 通过key返回list的长度
527 *
528 * @param key
529 * @return
530 */
531 public long llen(string key) {
532
533 return jedis.llen(key);
534 }
535
536 /**
537 * 通过key获取list指定下标位置的value
538 * 如果start 为 0 end 为 -1 则返回全部的list中的value
539 *
540 * @param key
541 * @param start
542 * @param end
543 * @return
544 */
545 public list<string> lrange(string key, long start, long end) {
546
547 return jedis.lrange(key, start, end);
548 }
549
550 /**
551 * 通过key向指定的set中添加value
552 *
553 * @param key
554 * @param members 可以是一个string 也可以是一个string数组
555 * @return 添加成功的个数
556 */
557 public long sadd(string key, string... members) {
558
559 return jedis.sadd(key, members);
560 }
561
562 /**
563 * 通过key删除set中对应的value值
564 *
565 * @param key
566 * @param members 可以是一个string 也可以是一个string数组
567 * @return 删除的个数
568 */
569 public long srem(string key, string... members) {
570
571 return jedis.srem(key, members);
572 }
573
574 /**
575 * 通过key随机删除一个set中的value并返回该值
576 *
577 * @param key
578 * @return
579 */
580 public string spop(string key) {
581
582 return jedis.spop(key);
583 }
584
585 /**
586 * 通过key获取set中的差集
587 * 以第一个set为标准
588 *
589 * @param keys 可以 是一个string 则返回set中所有的value 也可以是string数组
590 * @return
591 */
592 public set<string> sdiff(string... keys) {
593
594 return jedis.sdiff(keys);
595 }
596
597 /**
598 * 通过key获取set中的差集并存入到另一个key中
599 * 以第一个set为标准
600 *
601 * @param dstkey 差集存入的key
602 * @param keys 可以 是一个string 则返回set中所有的value 也可以是string数组
603 * @return
604 */
605 public long sdiffstore(string dstkey, string... keys) {
606
607 return jedis.sdiffstore(dstkey, keys);
608 }
609
610 /**
611 * 通过key获取指定set中的交集
612 *
613 * @param keys 可以 是一个string 也可以是一个string数组
614 * @return
615 */
616 public set<string> sinter(string... keys) {
617
618 return jedis.sinter(keys);
619 }
620
621 /**
622 * 通过key获取指定set中的交集 并将结果存入新的set中
623 *
624 * @param dstkey
625 * @param keys 可以 是一个string 也可以是一个string数组
626 * @return
627 */
628 public long sinterstore(string dstkey, string... keys) {
629
630 return jedis.sinterstore(dstkey, keys);
631 }
632
633 /**
634 * 通过key返回所有set的并集
635 *
636 * @param keys 可以 是一个string 也可以是一个string数组
637 * @return
638 */
639 public set<string> sunion(string... keys) {
640
641 return jedis.sunion(keys);
642 }
643
644 /**
645 * 通过key返回所有set的并集,并存入到新的set中
646 *
647 * @param dstkey
648 * @param keys 可以 是一个string 也可以是一个string数组
649 * @return
650 */
651 public long sunionstore(string dstkey, string... keys) {
652
653 return jedis.sunionstore(dstkey, keys);
654 }
655
656 /**
657 * 通过key将set中的value移除并添加到第二个set中
658 *
659 * @param srckey 需要移除的
660 * @param dstkey 添加的
661 * @param member set中的value
662 * @return
663 */
664 public long smove(string srckey, string dstkey, string member) {
665
666 return jedis.smove(srckey, dstkey, member);
667 }
668
669 /**
670 * 通过key获取set中value的个数
671 *
672 * @param key
673 * @return
674 */
675 public long scard(string key) {
676
677 return jedis.scard(key);
678 }
679
680 /**
681 * 通过key判断value是否是set中的元素
682 *
683 * @param key
684 * @param member
685 * @return
686 */
687 public boolean sismember(string key, string member) {
688
689 return jedis.sismember(key, member);
690 }
691
692 /**
693 * 通过key获取set中随机的value,不删除元素
694 *
695 * @param key
696 * @return
697 */
698 public string srandmember(string key) {
699
700 return jedis.srandmember(key);
701 }
702
703 /**
704 * 通过key获取set中所有的value
705 *
706 * @param key
707 * @return
708 */
709 public set<string> smembers(string key) {
710
711 return jedis.smembers(key);
712 }
713
714
715 /**
716 * 通过key向zset中添加value,score,其中score就是用来排序的
717 * 如果该value已经存在则根据score更新元素
718 *
719 * @param key
720 * @param score
721 * @param member
722 * @return
723 */
724 public long zadd(string key, double score, string member) {
725
726 return jedis.zadd(key, score, member);
727 }
728
729 /**
730 * 通过key删除在zset中指定的value
731 *
732 * @param key
733 * @param members 可以 是一个string 也可以是一个string数组
734 * @return
735 */
736 public long zrem(string key, string... members) {
737
738 return jedis.zrem(key, members);
739 }
740
741 /**
742 * 通过key增加该zset中value的score的值
743 *
744 * @param key
745 * @param score
746 * @param member
747 * @return
748 */
749 public double zincrby(string key, double score, string member) {
750
751 return jedis.zincrby(key, score, member);
752 }
753
754 /**
755 * 通过key返回zset中value的排名
756 * 下标从小到大排序
757 *
758 * @param key
759 * @param member
760 * @return
761 */
762 public long zrank(string key, string member) {
763
764 return jedis.zrank(key, member);
765 }
766
767 /**
768 * 通过key返回zset中value的排名
769 * 下标从大到小排序
770 *
771 * @param key
772 * @param member
773 * @return
774 */
775 public long zrevrank(string key, string member) {
776
777 return jedis.zrevrank(key, member);
778 }
779
780 /**
781 * 通过key将获取score从start到end中zset的value
782 * socre从大到小排序
783 * 当start为0 end为-1时返回全部
784 *
785 * @param key
786 * @param start
787 * @param end
788 * @return
789 */
790 public set<string> zrevrange(string key, long start, long end) {
791
792 return jedis.zrevrange(key, start, end);
793 }
794
795 /**
796 * 通过key返回指定score内zset中的value
797 *
798 * @param key
799 * @param max
800 * @param min
801 * @return
802 */
803 public set<string> zrangebyscore(string key, string max, string min) {
804
805 return jedis.zrevrangebyscore(key, max, min);
806 }
807
808 /**
809 * 通过key返回指定score内zset中的value
810 *
811 * @param key
812 * @param max
813 * @param min
814 * @return
815 */
816 public set<string> zrangebyscore(string key, double max, double min) {
817
818 return jedis.zrevrangebyscore(key, max, min);
819 }
820
821 /**
822 * 返回指定区间内zset中value的数量
823 *
824 * @param key
825 * @param min
826 * @param max
827 * @return
828 */
829 public long zcount(string key, string min, string max) {
830
831 return jedis.zcount(key, min, max);
832 }
833
834 /**
835 * 通过key返回zset中的value个数
836 *
837 * @param key
838 * @return
839 */
840 public long zcard(string key) {
841
842 return jedis.zcard(key);
843 }
844
845 /**
846 * 通过key获取zset中value的score值
847 *
848 * @param key
849 * @param member
850 * @return
851 */
852 public double zscore(string key, string member) {
853
854 return jedis.zscore(key, member);
855 }
856
857 /**
858 * 通过key删除给定区间内的元素
859 *
860 * @param key
861 * @param start
862 * @param end
863 * @return
864 */
865 public long zremrangebyrank(string key, long start, long end) {
866
867 return jedis.zremrangebyrank(key, start, end);
868 }
869
870 /**
871 * 通过key删除指定score内的元素
872 *
873 * @param key
874 * @param start
875 * @param end
876 * @return
877 */
878 public long zremrangebyscore(string key, double start, double end) {
879
880 return jedis.zremrangebyscore(key, start, end);
881 }
882
883 /**
884 * 返回满足pattern表达式的所有key
885 * keys(*)
886 * 返回所有的key
887 *
888 * @param pattern
889 * @return
890 */
891 public set<string> keys(string pattern) {
892
893 return jedis.keys(pattern);
894 }
895
896 /**
897 * 通过key判断值得类型
898 *
899 * @param key
900 * @return
901 */
902 public string type(string key) {
903
904 return jedis.type(key);
905 }
906
907
908 /**
909 * 返回一个cglib增强的工具类对象
910 * @return
911 */
912 public static jedisutil getjedisutil() {
913 redisinterceptor redisinterceptor = new redisinterceptor();
914 jedisutil jedisutil = (jedisutil) redisinterceptor.getinstance(new jedisutil());
915 return jedisutil;
916 }
917
918 }
jedis工具类的动态代理类
1 package com; 2 3 import java.lang.reflect.method; 4 5 import org.apache.logging.log4j.logger; 6 import org.springframework.cglib.proxy.enhancer; 7 import org.springframework.cglib.proxy.methodinterceptor; 8 import org.springframework.cglib.proxy.methodproxy; 9 10 /** 11 * jedis工具类的动态代理 12 * 自动获取连接及归还连接 13 * @author zaizouggg
14 * 15 */ 16 public class redisinterceptor implements methodinterceptor { 17 18 private logger logger = logutil.get(redisinterceptor.class); 19 private jedisutil targetobject; 20 // 这里的目标类型为object，则可以接受任意一种参数作为被代理类，实现了动态代理 21 public object getinstance(jedisutil target) { 22 // 设置需要创建子类的类 23 this.targetobject = target; 24 enhancer enhancer = new enhancer(); 25 enhancer.setsuperclass(target.getclass()); 26 enhancer.setcallback(this); 27 return enhancer.create(); 28 } 29 30 @override 31 public object intercept(object obj, method method, object[] args, methodproxy proxy) throws throwable { 32 // todo auto-generated method stub 33 targetobject.setjedis(redispool.getjedis()); 34 logger.info("获取连接后连接池状态"+redispool.getnumactive() + "-" + redispool.getnumidle() + "-" + redispool.getnumwaiters()); 35 object result = proxy.invoke(targetobject, args); 36 redispool.returnjedis(targetobject.getjedis()); 37 logger.info("归还连接后连接池状态"+redispool.getnumactive() + "-" + redispool.getnumidle() + "-" + redispool.getnumwaiters()); 38 return result; 39 } 40 41 }
操作代码
public static void main(string[] args){
//实例化一个增强的工具类
jedisutil jedisutil = jedisutil.getjedisutil();
//进行相关操作即可
value = jedisutil.get(key);
}