672 | #
673 | # A client is immediately disconnected once the hard limit is reached, or if
674 | # the soft limit is reached and remains reached for the specified number of
675 | # seconds (continuously).
676 | # So for instance if the hard limit is 32 megabytes and the soft limit is
677 | # 16 megabytes / 10 seconds, the client will get disconnected immediately
678 | # if the size of the output buffers reach 32 megabytes, but will also get
679 | # disconnected if the client reaches 16 megabytes and continuously overcomes
680 | # the limit for 10 seconds.
681 | #
682 | # By default normal clients are not limited because they don't receive data
683 | # without asking (in a push way), but just after a request, so only
684 | # asynchronous clients may create a scenario where data is requested faster
685 | # than it can read.
686 | #
687 | # Instead there is a default limit for pubsub and slave clients, since
688 | # subscribers and slaves receive data in a push fashion.
689 | #
690 | # Both the hard or the soft limit can be disabled by setting them to zero.
691 | client-output-buffer-limit normal 0 0 0
692 | client-output-buffer-limit slave 256mb 64mb 60
693 | client-output-buffer-limit pubsub 32mb 8mb 60
694 |
695 | # Redis calls an internal function to perform many background tasks, like
696 | # closing connections of clients in timeout, purging expired keys that are
697 | # never requested, and so forth.
698 | #
699 | # Not all tasks are performed with the same frequency, but Redis checks for
700 | # tasks to perform accordingly to the specified "hz" value.
701 | #
702 | # By default "hz" is set to 10. Raising the value will use more CPU when
703 | # Redis is idle, but at the same time will make Redis more responsive when
704 | # there are many keys expiring at the same time, and timeouts may be
705 | # handled with more precision.
706 | #
707 | # The range is between 1 and 500, however a value over 100 is usually not
708 | # a good idea. Most users should use the default of 10 and raise this up to
709 | # 100 only in environments where very low latency is required.
710 | hz 10
711 |
712 | # When a child rewrites the AOF file, if the following option is enabled
713 | # the file will be fsync-ed every 32 MB of data generated. This is useful
714 | # in order to commit the file to the disk more incrementally and avoid
715 | # big latency spikes.
716 | aof-rewrite-incremental-fsync yes
717 |
718 |
--------------------------------------------------------------------------------
/RedisCluster/src/main/java/com/rr/redis/client/RedisClusterPoolClient.java:
--------------------------------------------------------------------------------
1 | package com.rr.redis.client;
2 |
3 | import java.util.ArrayList;
4 | import java.util.Collection;
5 | import java.util.HashMap;
6 | import java.util.List;
7 | import java.util.Map;
8 | import java.util.Map.Entry;
9 | import java.util.Set;
10 | import java.util.concurrent.Callable;
11 | import java.util.concurrent.ExecutorService;
12 | import java.util.concurrent.Executors;
13 | import java.util.concurrent.Future;
14 |
15 | import org.apache.commons.logging.Log;
16 | import org.apache.commons.logging.LogFactory;
17 |
18 | import redis.clients.jedis.BinaryClient.LIST_POSITION;
19 | import redis.clients.jedis.Jedis;
20 | import redis.clients.jedis.SortingParams;
21 | import redis.clients.jedis.Tuple;
22 |
23 | import com.rr.redis.client.exception.ClusterOpException;
24 | import com.rr.redis.client.hash.IHashFunc;
25 |
26 | /**
27 | *
28 | * Pool Client for redis cluster.
29 | *
30 | *
31 | * This class is thread safe since we use JedisPool.
32 | *
33 | * USAGE: private RedisClusterPoolClient client; client = new
34 | * RedisClusterPoolClient("testCluster", "10.22.241.233:2181");
35 | * client.set("key", "value"); System.out.println(client.get("key"));
36 | *
37 | *
38 | *
39 | * @author lei.gao
40 | */
41 | public class RedisClusterPoolClient {
42 | private static final Log logger = LogFactory
43 | .getLog(RedisClusterPoolClient.class);
44 | /**
45 | * Number of hash slot(node).
46 | */
47 | private IHashFunc hashFunc;
48 | private String clusterName;
49 | private String zkHost;
50 | private RedisClusterPoolProvider poolsObj;
51 | public static final int DEFAULT_ZK_TIMEOUT = 2000;
52 | public static final int DEFAULT_REDIS_TIMEOUT = 3000;
53 | private int zkTimeout = DEFAULT_ZK_TIMEOUT;
54 | private int redisTimeout = DEFAULT_REDIS_TIMEOUT;
55 |
56 | private int partsLen;
57 |
58 | /**
59 | * RedisClusterPoolClient的默认构造函数，可以满足大多数场景
60 | *
61 | * @param clusterName
62 | * 业务名称
63 | * @param zkHost
64 | * zookeeper地址
65 | */
66 | public RedisClusterPoolClient(String clusterName, String zkHost) {
67 | this.clusterName = clusterName;
68 | this.zkHost = zkHost;
69 | }
70 |
71 | /**
72 | * RedisClusterPoolClient的构造函数，如果你不确定请不要使用
73 | *
74 | * @param clusterName
75 | * @param zkHost
76 | * @param poolMaxActive
77 | * @param poolMaxIdle
78 | * @param poolMaxWait
79 | * maxActive: 1000 the maximum number of objects that can be
80 | * allocated by the pool (checked out to clients, or idle
81 | * awaiting checkout) at a given time. When non-positive, there
82 | * is no limit to the number of objects that can be managed by
83 | * the pool at one time. When maxActive is reached, the pool is
84 | * said to be exhausted. The default setting for this parameter
85 | * is 8. maxIdle: 100 the maximum number of objects that can sit
86 | * idle in the pool at any time. When negative, there is no limit
87 | * to the number of objects that may be idle at one time. The
88 | * default setting for this parameter is 8.
89 | */
90 | public RedisClusterPoolClient(String clusterName, String zkHost,
91 | int poolMaxActive, int poolMaxIdle, int poolMaxWait) {
92 | this.clusterName = clusterName;
93 | this.zkHost = zkHost;
94 | RedisClusterPoolProvider.setJedisPoolConfig(poolMaxActive, poolMaxIdle,
95 | poolMaxWait);
96 | }
97 |
98 | /**
99 | * RedisClusterPoolClient的构造函数
100 | *
101 | * @param clusterName
102 | * @param zkHost
103 | * @param redisTimeout
104 | * 设置redis超时时间，单位:ms
105 | */
106 | public RedisClusterPoolClient(String clusterName, String zkHost,
107 | int redisTimeout) {
108 | this.clusterName = clusterName;
109 | this.zkHost = zkHost;
110 | this.redisTimeout = redisTimeout;
111 | }
112 |
113 | /**
114 | * 初始化过程
115 | */
116 | public void init() {
117 | this.poolsObj = new RedisClusterPoolProvider(clusterName, zkHost,
118 | zkTimeout, redisTimeout);
119 | this.hashFunc = poolsObj.getHashFunc();
120 | this.partsLen = this.poolsObj.getPoolsLen();
121 | }
122 |
123 | /**
124 | * 得到hash算法
125 | *
126 | * @return
127 | */
128 | public IHashFunc getHashFunc() {
129 | return hashFunc;
130 | }
131 |
132 | /**
133 | * 设置key的值为value，永久性
134 | *
135 | * key是string和key是byte[] 不能混用，因为两者的hash值不同
136 | *
137 | * @param key
138 | * @param value
139 | * @return 成功返回 OK
140 | */
141 | public String set(String key, String value) {
142 | try {
143 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
144 | .getPool(hashFunc.hash(key));
145 | Jedis jedis = pool.getResource();
146 | String r = jedis.set(key, value);
147 | pool.returnResource(jedis);
148 | return r;
149 | } catch (Exception e) {
150 | throw new ClusterOpException(e);
151 | }
152 | }
153 |
154 | /**
155 | * 得到key的值
156 | *
157 | * @param key
158 | * @return
159 | */
160 | public String get(String key) {
161 | try {
162 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
163 | .getPool(hashFunc.hash(key));
164 | Jedis jedis = pool.getResource();
165 | String r = jedis.get(key);
166 | pool.returnResource(jedis);
167 | return r;
168 | } catch (Exception e) {
169 | throw new ClusterOpException(e);
170 | }
171 | }
172 |
173 | /**
174 | * 判断值是否存在
175 | *
176 | * @param key
177 | * @return
178 | */
179 | public Boolean exists(String key) {
180 | try {
181 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
182 | .getPool(hashFunc.hash(key));
183 | Jedis jedis = pool.getResource();
184 | Boolean r = jedis.exists(key);
185 | pool.returnResource(jedis);
186 | return r;
187 | } catch (Exception e) {
188 | throw new ClusterOpException(e);
189 | }
190 | }
191 |
192 | /**
193 | * 返回key的类型,不存在则为none
194 | *
195 | * @param key
196 | * @return
197 | */
198 | public String type(String key) {
199 | try {
200 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
201 | .getPool(hashFunc.hash(key));
202 | Jedis jedis = pool.getResource();
203 | String r = jedis.type(key);
204 | pool.returnResource(jedis);
205 | return r;
206 | } catch (Exception e) {
207 | throw new ClusterOpException(e);
208 | }
209 | }
210 |
211 | /**
212 | * 为 key 设置生存时间，过期时间为seconds秒
213 | *
214 | * @param key
215 | * @param seconds
216 | * @return
217 | */
218 | public Long expire(String key, int seconds) {
219 | try {
220 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
221 | .getPool(hashFunc.hash(key));
222 | Jedis jedis = pool.getResource();
223 | Long r = jedis.expire(key, seconds);
224 | pool.returnResource(jedis);
225 | return r;
226 | } catch (Exception e) {
227 | throw new ClusterOpException(e);
228 | }
229 | }
230 |
231 | public Long expire(int seconds, String... keys) {
232 | try {
233 | long result = 0;
234 | for (String key : keys) {
235 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
236 | .getPool(hashFunc.hash(key));
237 | Jedis jedis = pool.getResource();
238 | result += jedis.expire(key, seconds);
239 | pool.returnResource(jedis);
240 | }
241 | return result;
242 | } catch (Exception e) {
243 | throw new ClusterOpException(e);
244 | }
245 | }
246 |
247 | public Long expireBinary(final Set keys, int seconds) {
248 | try {
249 | long result = 0;
250 | for (byte[] key : keys) {
251 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
252 | .getPool(hashFunc.hash(key));
253 | Jedis jedis = pool.getResource();
254 | result += jedis.expire(key, seconds);
255 | pool.returnResource(jedis);
256 | }
257 | return result;
258 | } catch (Exception e) {
259 | throw new ClusterOpException(e);
260 | }
261 | }
262 |
263 | /**
264 | * EXPIREAT 命令接受的时间参数是 UNIX 时间戳
265 | *
266 | * 例如:EXPIREAT cache 1355292000 # 这个 key 将在 2012.12.12 过期
267 | *
268 | * @param key
269 | * @param unixTime
270 | * @return
271 | */
272 | public Long expireAt(String key, long unixTime) {
273 | try {
274 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
275 | .getPool(hashFunc.hash(key));
276 | Jedis jedis = pool.getResource();
277 | Long r = jedis.expireAt(key, unixTime);
278 | pool.returnResource(jedis);
279 | return r;
280 | } catch (Exception e) {
281 | throw new ClusterOpException(e);
282 | }
283 |
284 | }
285 |
286 | /**
287 | * 返回生存时间 如果是永久性则返回-1
288 | *
289 | * @param key
290 | * @return
291 | */
292 | public Long ttl(String key) {
293 | try {
294 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
295 | .getPool(hashFunc.hash(key));
296 | Jedis jedis = pool.getResource();
297 | Long r = jedis.ttl(key);
298 | pool.returnResource(jedis);
299 | return r;
300 | } catch (Exception e) {
301 | throw new ClusterOpException(e);
302 | }
303 |
304 | }
305 |
306 | /**
307 | * 设置或者清空key的value(字符串)在offset处的bit值
308 | *
309 | * http://redis.cn/commands/setbit.html
310 | *
311 | * @param key
312 | * @param offset
313 | * @param value
314 | * @return
315 | */
316 | public boolean setbit(String key, long offset, boolean value) {
317 | try {
318 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
319 | .getPool(hashFunc.hash(key));
320 | Jedis jedis = pool.getResource();
321 | boolean r = jedis.setbit(key, offset, value);
322 | pool.returnResource(jedis);
323 | return r;
324 | } catch (Exception e) {
325 | throw new ClusterOpException(e);
326 | }
327 |
328 | }
329 |
330 | /**
331 | * 返回位的值存储在关键的字符串值的偏移量。
332 | *
333 | * @param key
334 | * @param offset
335 | * @return
336 | */
337 | public boolean getbit(String key, long offset) {
338 | try {
339 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
340 | .getPool(hashFunc.hash(key));
341 | Jedis jedis = pool.getResource();
342 | boolean r = jedis.getbit(key, offset);
343 | pool.returnResource(jedis);
344 | return r;
345 | } catch (Exception e) {
346 | throw new ClusterOpException(e);
347 | }
348 |
349 | }
350 |
351 | /**
352 | * 覆盖key对应的string的一部分，从指定的offset处开始，覆盖value的长度
353 | *
354 | * @param key
355 | * @param offset
356 | * @param value
357 | * @return
358 | */
359 | public long setrange(String key, long offset, String value) {
360 | try {
361 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
362 | .getPool(hashFunc.hash(key));
363 | Jedis jedis = pool.getResource();
364 | long r = jedis.setrange(key, offset, value);
365 | pool.returnResource(jedis);
366 | return r;
367 | } catch (Exception e) {
368 | throw new ClusterOpException(e);
369 | }
370 |
371 | }
372 |
373 | /**
374 | * 获取存储在key上的值的一个子字符串
375 | *
376 | * @param key
377 | * @param startOffset
378 | * @param endOffset
379 | * @return
380 | */
381 | public String getrange(String key, long startOffset, long endOffset) {
382 | try {
383 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
384 | .getPool(hashFunc.hash(key));
385 | Jedis jedis = pool.getResource();
386 | String r = jedis.getrange(key, startOffset, endOffset);
387 | pool.returnResource(jedis);
388 | return r;
389 | } catch (Exception e) {
390 | throw new ClusterOpException(e);
391 | }
392 |
393 | }
394 |
395 | /**
396 | * 自动将key对应到value并且返回原来key对应的value
397 | *
398 | * @param key
399 | * @param value
400 | * @return
401 | */
402 | public String getSet(String key, String value) {
403 | try {
404 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
405 | .getPool(hashFunc.hash(key));
406 | Jedis jedis = pool.getResource();
407 | String r = jedis.getSet(key, value);
408 | pool.returnResource(jedis);
409 | return r;
410 | } catch (Exception e) {
411 | throw new ClusterOpException(e);
412 | }
413 |
414 | }
415 |
416 | /**
417 | * 如果key不存在，就设置key对应字符串value。在这种情况下，该命令和SET一样。当key已经存在时，就不做任何操作。SETNX是
418 | * "SET if Not eXists"。
419 | *
420 | * @param key
421 | * @param value
422 | * @return
423 | */
424 | public Long setnx(String key, String value) {
425 | try {
426 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
427 | .getPool(hashFunc.hash(key));
428 | Jedis jedis = pool.getResource();
429 | Long r = jedis.setnx(key, value);
430 | pool.returnResource(jedis);
431 | return r;
432 | } catch (Exception e) {
433 | throw new ClusterOpException(e);
434 | }
435 |
436 | }
437 |
438 | /**
439 | * 设置key-value并设置过期时间（单位：秒）
440 | *
441 | * @param key
442 | * @param seconds
443 | * @param value
444 | * @return
445 | */
446 | public String setex(String key, int seconds, String value) {
447 | try {
448 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
449 | .getPool(hashFunc.hash(key));
450 | Jedis jedis = pool.getResource();
451 | String r = jedis.setex(key, seconds, value);
452 | pool.returnResource(jedis);
453 | return r;
454 | } catch (Exception e) {
455 | throw new ClusterOpException(e);
456 | }
457 |
458 | }
459 |
460 | /**
461 | * 原子减指定的整数
462 | *
463 | * @param key
464 | * @param integer
465 | * @return
466 | */
467 | public Long decrBy(String key, long integer) {
468 | try {
469 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
470 | .getPool(hashFunc.hash(key));
471 | Jedis jedis = pool.getResource();
472 | Long r = jedis.decrBy(key, integer);
473 | pool.returnResource(jedis);
474 | return r;
475 | } catch (Exception e) {
476 | throw new ClusterOpException(e);
477 | }
478 |
479 | }
480 |
481 | /**
482 | * 整数原子减1
483 | *
484 | * @param key
485 | * @return
486 | */
487 | public Long decr(String key) {
488 | try {
489 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
490 | .getPool(hashFunc.hash(key));
491 | Jedis jedis = pool.getResource();
492 | Long r = jedis.decr(key);
493 | pool.returnResource(jedis);
494 | return r;
495 | } catch (Exception e) {
496 | throw new ClusterOpException(e);
497 | }
498 |
499 | }
500 |
501 | /**
502 | * 执行原子增加一个整数
503 | *
504 | * @param key
505 | * @param integer
506 | * @return
507 | */
508 | public Long incrBy(String key, long integer) {
509 | try {
510 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
511 | .getPool(hashFunc.hash(key));
512 | Jedis jedis = pool.getResource();
513 | Long r = jedis.incrBy(key, integer);
514 | pool.returnResource(jedis);
515 | return r;
516 | } catch (Exception e) {
517 | throw new ClusterOpException(e);
518 | }
519 |
520 | }
521 |
522 | /**
523 | * 执行原子加1操作
524 | *
525 | * @param key
526 | * @return
527 | */
528 | public Long incr(String key) {
529 | try {
530 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
531 | .getPool(hashFunc.hash(key));
532 | Jedis jedis = pool.getResource();
533 | Long r = jedis.incr(key);
534 | pool.returnResource(jedis);
535 | return r;
536 | } catch (Exception e) {
537 | throw new ClusterOpException(e);
538 | }
539 |
540 | }
541 |
542 | /**
543 | * 追加一个值到key上
544 | *
545 | * @param key
546 | * @param value
547 | * @return
548 | */
549 | public Long append(String key, String value) {
550 | try {
551 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
552 | .getPool(hashFunc.hash(key));
553 | Jedis jedis = pool.getResource();
554 | Long r = jedis.append(key, value);
555 | pool.returnResource(jedis);
556 | return r;
557 | } catch (Exception e) {
558 | throw new ClusterOpException(e);
559 | }
560 |
561 | }
562 |
563 | /**
564 | * 设置hash里面一个字段的值
565 | *
566 | * @param key
567 | * @param field
568 | * @param value
569 | * @return
570 | */
571 | public Long hset(String key, String field, String value) {
572 | try {
573 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
574 | .getPool(hashFunc.hash(key));
575 | Jedis jedis = pool.getResource();
576 | Long r = jedis.hset(key, field, value);
577 | pool.returnResource(jedis);
578 | return r;
579 | } catch (Exception e) {
580 | throw new ClusterOpException(e);
581 | }
582 | }
583 |
584 | /**
585 | * 读取哈希域的的值
586 | *
587 | * @param key
588 | * @param field
589 | * @return
590 | */
591 | public String hget(String key, String field) {
592 | try {
593 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
594 | .getPool(hashFunc.hash(key));
595 | Jedis jedis = pool.getResource();
596 | String r = jedis.hget(key, field);
597 | pool.returnResource(jedis);
598 | return r;
599 | } catch (Exception e) {
600 | throw new ClusterOpException(e);
601 | }
602 | }
603 |
604 | /**
605 | * 设置hash的一个字段，只有当这个字段不存在时有效
606 | *
607 | * @param key
608 | * @param field
609 | * @param value
610 | * @return
611 | */
612 | public Long hsetnx(String key, String field, String value) {
613 | try {
614 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
615 | .getPool(hashFunc.hash(key));
616 | Jedis jedis = pool.getResource();
617 | Long r = jedis.hsetnx(key, field, value);
618 | pool.returnResource(jedis);
619 | return r;
620 | } catch (Exception e) {
621 | throw new ClusterOpException(e);
622 | }
623 | }
624 |
625 | /**
626 | * 设置hash字段值
627 | *
628 | * @param key
629 | * @param hash
630 | * @return
631 | */
632 | public String hmset(String key, Map hash) {
633 | if (hash == null || hash.isEmpty())
634 | throw new ClusterOpException("Param cannot be null or empty!");
635 | try {
636 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
637 | .getPool(hashFunc.hash(key));
638 | Jedis jedis = pool.getResource();
639 | String r = jedis.hmset(key, hash);
640 | pool.returnResource(jedis);
641 | return r;
642 | } catch (Exception e) {
643 | throw new ClusterOpException(e);
644 | }
645 | }
646 |
647 | /**
648 | * 获取hash里面指定字段的值
649 | *
650 | * @param key
651 | * @param fields
652 | * @return
653 | */
654 | public List hmget(String key, String... fields) {
655 | try {
656 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
657 | .getPool(hashFunc.hash(key));
658 | Jedis jedis = pool.getResource();
659 | List r = jedis.hmget(key, fields);
660 | pool.returnResource(jedis);
661 | return r;
662 | } catch (Exception e) {
663 | throw new ClusterOpException(e);
664 | }
665 | }
666 |
667 | /**
668 | * 将哈希集中指定域的值增加给定的数字
669 | *
670 | * @param key
671 | * @param field
672 | * @param value
673 | * @return
674 | */
675 | public Long hincrBy(String key, String field, long value) {
676 | try {
677 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
678 | .getPool(hashFunc.hash(key));
679 | Jedis jedis = pool.getResource();
680 | Long r = jedis.hincrBy(key, field, value);
681 | pool.returnResource(jedis);
682 | return r;
683 | } catch (Exception e) {
684 | throw new ClusterOpException(e);
685 | }
686 | }
687 |
688 | /**
689 | * 判断给定域是否存在于哈希集中
690 | *
691 | * @param key
692 | * @param field
693 | * @return
694 | */
695 | public Boolean hexists(String key, String field) {
696 | try {
697 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
698 | .getPool(hashFunc.hash(key));
699 | Jedis jedis = pool.getResource();
700 | Boolean r = jedis.hexists(key, field);
701 | pool.returnResource(jedis);
702 | return r;
703 | } catch (Exception e) {
704 | throw new ClusterOpException(e);
705 | }
706 | }
707 |
708 | /**
709 | * 删除一个或多个哈希域
710 | *
711 | * @param key
712 | * @param fields
713 | * @return
714 | */
715 | public Long hdel(String key, String... fields) {
716 | try {
717 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
718 | .getPool(hashFunc.hash(key));
719 | Jedis jedis = pool.getResource();
720 | Long r = jedis.hdel(key, fields);
721 | pool.returnResource(jedis);
722 | return r;
723 | } catch (Exception e) {
724 | throw new ClusterOpException(e);
725 | }
726 | }
727 |
728 | /**
729 | * 获取hash里所有字段的数量
730 | *
731 | * @param key
732 | * @return
733 | */
734 | public Long hlen(String key) {
735 | try {
736 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
737 | .getPool(hashFunc.hash(key));
738 | Jedis jedis = pool.getResource();
739 | Long r = jedis.hlen(key);
740 | pool.returnResource(jedis);
741 | return r;
742 | } catch (Exception e) {
743 | throw new ClusterOpException(e);
744 | }
745 | }
746 |
747 | /**
748 | * 获取hash的所有字段
749 | *
750 | * @param key
751 | * @return
752 | */
753 | public Set hkeys(String key) {
754 | try {
755 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
756 | .getPool(hashFunc.hash(key));
757 | Jedis jedis = pool.getResource();
758 | Set r = jedis.hkeys(key);
759 | pool.returnResource(jedis);
760 | return r;
761 | } catch (Exception e) {
762 | throw new ClusterOpException(e);
763 | }
764 | }
765 |
766 | /**
767 | * 获得hash的所有值
768 | *
769 | * @param key
770 | * @return
771 | */
772 | public List hvals(String key) {
773 | try {
774 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
775 | .getPool(hashFunc.hash(key));
776 | Jedis jedis = pool.getResource();
777 | List r = jedis.hvals(key);
778 | pool.returnResource(jedis);
779 | return r;
780 | } catch (Exception e) {
781 | throw new ClusterOpException(e);
782 | }
783 | }
784 |
785 | /**
786 | * 从哈希集中读取全部的域和值
787 | *
788 | * @param key
789 | * @return
790 | */
791 | public Map hgetAll(String key) {
792 | try {
793 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
794 | .getPool(hashFunc.hash(key));
795 | Jedis jedis = pool.getResource();
796 | Map r = jedis.hgetAll(key);
797 | pool.returnResource(jedis);
798 | return r;
799 | } catch (Exception e) {
800 | throw new ClusterOpException(e);
801 | }
802 | }
803 |
804 | /**
805 | * 从队列的右边入队一个元素
806 | *
807 | * @param key
808 | * @param strings
809 | * @return
810 | */
811 | public Long rpush(String key, String... strings) {
812 | try {
813 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
814 | .getPool(hashFunc.hash(key));
815 | Jedis jedis = pool.getResource();
816 | Long r = jedis.rpush(key, strings);
817 | pool.returnResource(jedis);
818 | return r;
819 | } catch (Exception e) {
820 | throw new ClusterOpException(e);
821 | }
822 | }
823 |
824 | /**
825 | * 从队列的左边入队一个或多个元素
826 | *
827 | * @param key
828 | * @param strings
829 | * @return
830 | */
831 | public Long lpush(String key, String... strings) {
832 | try {
833 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
834 | .getPool(hashFunc.hash(key));
835 | Jedis jedis = pool.getResource();
836 | Long r = jedis.lpush(key, strings);
837 | pool.returnResource(jedis);
838 | return r;
839 | } catch (Exception e) {
840 | throw new ClusterOpException(e);
841 | }
842 | }
843 |
844 | /**
845 | * 获得队列(List)的长度
846 | *
847 | * @param key
848 | * @return
849 | */
850 | public Long llen(String key) {
851 | try {
852 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
853 | .getPool(hashFunc.hash(key));
854 | Jedis jedis = pool.getResource();
855 | Long r = jedis.llen(key);
856 | pool.returnResource(jedis);
857 | return r;
858 | } catch (Exception e) {
859 | throw new ClusterOpException(e);
860 | }
861 | }
862 |
863 | /**
864 | * 从列表中获取指定返回的元素
865 | *
866 | * @param key
867 | * @param start
868 | * @param end
869 | * @return
870 | */
871 | public List lrange(String key, long start, long end) {
872 | try {
873 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
874 | .getPool(hashFunc.hash(key));
875 | Jedis jedis = pool.getResource();
876 | List r = jedis.lrange(key, start, end);
877 | pool.returnResource(jedis);
878 | return r;
879 | } catch (Exception e) {
880 | throw new ClusterOpException(e);
881 | }
882 | }
883 |
884 | /**
885 | * 修剪(trim)一个已存在的 list，这样 list 就会只包含指定范围的指定元素。start 和 stop 都是由0开始计数的， 这里的 0
886 | * 是列表里的第一个元素（表头），1 是第二个元素，以此类推。 例如： LTRIM foobar 0 2 将会对存储在 foobar
887 | * 的列表进行修剪，只保留列表里的前3个元素。 start 和 end 也可以用负数来表示与表尾的偏移量，比如 -1 表示列表里的最后一个元素， -2
888 | * 表示倒数第二个，等等。 超过范围的下标并不会产生错误：如果 start 超过列表尾部，或者 start > end，结果会是列表变成空表（即该
889 | * key 会被移除）。 如果 end 超过列表尾部，Redis 会将其当作列表的最后一个元素。 LTRIM 的一个常见用法是和 LPUSH /
890 | * RPUSH 一起使用
891 | *
892 | * @param key
893 | * @param start
894 | * @param end
895 | * @return
896 | */
897 | public String ltrim(String key, long start, long end) {
898 | try {
899 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
900 | .getPool(hashFunc.hash(key));
901 | Jedis jedis = pool.getResource();
902 | String r = jedis.ltrim(key, start, end);
903 | pool.returnResource(jedis);
904 | return r;
905 | } catch (Exception e) {
906 | throw new ClusterOpException(e);
907 | }
908 | }
909 |
910 | /**
911 | * 获取一个元素，通过其索引列表
912 | *
913 | * @param key
914 | * @param index
915 | * @return
916 | */
917 | public String lindex(String key, long index) {
918 | try {
919 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
920 | .getPool(hashFunc.hash(key));
921 | Jedis jedis = pool.getResource();
922 | String r = jedis.lindex(key, index);
923 | pool.returnResource(jedis);
924 | return r;
925 | } catch (Exception e) {
926 | throw new ClusterOpException(e);
927 | }
928 | }
929 |
930 | /**
931 | * 设置队列里面一个元素的值
932 | *
933 | * @param key
934 | * @param index
935 | * @param value
936 | * @return
937 | */
938 | public String lset(String key, long index, String value) {
939 | try {
940 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
941 | .getPool(hashFunc.hash(key));
942 | Jedis jedis = pool.getResource();
943 | String r = jedis.lset(key, index, value);
944 | pool.returnResource(jedis);
945 | return r;
946 | } catch (Exception e) {
947 | throw new ClusterOpException(e);
948 | }
949 | }
950 |
951 | /**
952 | * 从列表中删除元素
953 | *
954 | * 从存于 key 的列表里移除前 count 次出现的值为 value 的元素。 这个 count 参数通过下面几种方式影响这个操作： count
955 | * > 0: 从头往尾移除值为 value 的元素。 count < 0: 从尾往头移除值为 value 的元素。 count = 0: 移除所有值为
956 | * value 的元素。
957 | *
958 | * @param key
959 | * @param count
960 | * @param value
961 | * @return
962 | */
963 | public Long lrem(String key, long count, String value) {
964 | try {
965 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
966 | .getPool(hashFunc.hash(key));
967 | Jedis jedis = pool.getResource();
968 | Long r = jedis.lrem(key, count, value);
969 | pool.returnResource(jedis);
970 | return r;
971 | } catch (Exception e) {
972 | throw new ClusterOpException(e);
973 | }
974 | }
975 |
976 | /**
977 | * 删除，并获得该列表中的第一元素，或阻塞，直到有一个可用
978 | *
979 | * BLPOP 是阻塞式列表的弹出原语。 它是命令 LPOP 的阻塞版本，这是因为当给定列表内没有任何元素可供弹出的时候， 连接将被 BLPOP
980 | * 命令阻塞。 当给定多个 key 参数时，按参数 key 的先后顺序依次检查各个列表，弹出第一个非空列表的头元素。 非阻塞行为 当 BLPOP
981 | * 被调用时，如果给定 key 内至少有一个非空列表，那么弹出遇到的第一个非空列表的头元素，并和被弹出元素所属的列表的名字 key
982 | * 一起，组成结果返回给调用者。 当存在多个给定 key 时， BLPOP 按给定 key 参数排列的先后顺序，依次检查各个列表。 我们假设 key
983 | * list1 不存在，而 list2 和 list3 都是非空列表
984 | *
985 | * @param key
986 | * @param timeoutSecs
987 | * @return
988 | */
989 | public String blpop(String key, final int timeoutSecs) {
990 | try {
991 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
992 | .getPool(hashFunc.hash(key));
993 | Jedis jedis = pool.getResource();
994 | List r = jedis.blpop(timeoutSecs, key);
995 | pool.returnResource(jedis);
996 | if (r != null && r.size() == 2) {
997 | return r.get(1);
998 | } else {
999 | return null;
1000 | }
1001 | } catch (Exception e) {
1002 | throw new ClusterOpException(e);
1003 | }
1004 | }
1005 |
1006 | /**
1007 | * 删除，并获得该列表中的最后一个元素，或阻塞，直到有一个可用
1008 | *
1009 | * @param key
1010 | * @param timeoutSecs
1011 | * @return
1012 | */
1013 | public String brpop(String key, final int timeoutSecs) {
1014 | try {
1015 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1016 | .getPool(hashFunc.hash(key));
1017 | Jedis jedis = pool.getResource();
1018 | List r = jedis.brpop(timeoutSecs, key);
1019 | pool.returnResource(jedis);
1020 | if (r != null && r.size() == 2) {
1021 | return r.get(1);
1022 | } else {
1023 | return null;
1024 | }
1025 | } catch (Exception e) {
1026 | throw new ClusterOpException(e);
1027 | }
1028 | }
1029 |
1030 | /**
1031 | * 删除，并获得该列表中的第一元素，或阻塞，直到有一个可用
1032 | *
1033 | * @param key
1034 | * @param timeoutSecs
1035 | * @return
1036 | */
1037 | public byte[] blpop(byte[] key, final int timeoutSecs) {
1038 | try {
1039 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1040 | .getPool(hashFunc.hash(key));
1041 | Jedis jedis = pool.getResource();
1042 | List r = jedis.blpop(timeoutSecs, key);
1043 | pool.returnResource(jedis);
1044 | if (r != null && r.size() == 2) {
1045 | return r.get(1);
1046 | } else {
1047 | return null;
1048 | }
1049 | } catch (Exception e) {
1050 | throw new ClusterOpException(e);
1051 | }
1052 | }
1053 |
1054 | /**
1055 | * 删除，并获得该列表中的第一元素，或阻塞，直到有一个可用
1056 | *
1057 | * @param key
1058 | * @param timeoutSecs
1059 | * @return
1060 | */
1061 | public byte[] brpop(byte[] key, final int timeoutSecs) {
1062 | try {
1063 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1064 | .getPool(hashFunc.hash(key));
1065 | Jedis jedis = pool.getResource();
1066 | List r = jedis.brpop(timeoutSecs, key);
1067 | pool.returnResource(jedis);
1068 | if (r != null && r.size() == 2) {
1069 | return r.get(1);
1070 | } else {
1071 | return null;
1072 | }
1073 | } catch (Exception e) {
1074 | throw new ClusterOpException(e);
1075 | }
1076 | }
1077 |
1078 | /**
1079 | * 从队列的左边出队一个元素
1080 | *
1081 | * @param key
1082 | * @return
1083 | */
1084 | public String lpop(String key) {
1085 | try {
1086 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1087 | .getPool(hashFunc.hash(key));
1088 | Jedis jedis = pool.getResource();
1089 | String r = jedis.lpop(key);
1090 | pool.returnResource(jedis);
1091 | return r;
1092 | } catch (Exception e) {
1093 | throw new ClusterOpException(e);
1094 | }
1095 | }
1096 |
1097 | /**
1098 | * 从队列的右边出队一个元素
1099 | *
1100 | * @param key
1101 | * @return
1102 | */
1103 | public String rpop(String key) {
1104 | try {
1105 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1106 | .getPool(hashFunc.hash(key));
1107 | Jedis jedis = pool.getResource();
1108 | String r = jedis.rpop(key);
1109 | pool.returnResource(jedis);
1110 | return r;
1111 | } catch (Exception e) {
1112 | throw new ClusterOpException(e);
1113 | }
1114 | }
1115 |
1116 | /**
1117 | * 添加一个或者多个元素到集合(set)里
1118 | *
1119 | * @param key
1120 | * @param members
1121 | * @return
1122 | */
1123 | public Long sadd(String key, String... members) {
1124 | try {
1125 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1126 | .getPool(hashFunc.hash(key));
1127 | Jedis jedis = pool.getResource();
1128 | Long r = jedis.sadd(key, members);
1129 | pool.returnResource(jedis);
1130 | return r;
1131 | } catch (Exception e) {
1132 | throw new ClusterOpException(e);
1133 | }
1134 | }
1135 |
1136 | /**
1137 | * 获取集合里面的所有key
1138 | *
1139 | * @param key
1140 | * @return
1141 | */
1142 | public Set smembers(String key) {
1143 | try {
1144 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1145 | .getPool(hashFunc.hash(key));
1146 | Jedis jedis = pool.getResource();
1147 | Set r = jedis.smembers(key);
1148 | pool.returnResource(jedis);
1149 | return r;
1150 | } catch (Exception e) {
1151 | throw new ClusterOpException(e);
1152 | }
1153 | }
1154 |
1155 | /**
1156 | * 从集合里删除一个或多个key
1157 | *
1158 | * @param key
1159 | * @param members
1160 | * @return
1161 | */
1162 | public Long srem(String key, String... members) {
1163 | try {
1164 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1165 | .getPool(hashFunc.hash(key));
1166 | Jedis jedis = pool.getResource();
1167 | Long r = jedis.srem(key, members);
1168 | pool.returnResource(jedis);
1169 | return r;
1170 | } catch (Exception e) {
1171 | throw new ClusterOpException(e);
1172 | }
1173 | }
1174 |
1175 | /**
1176 | * 移除并返回一个集合中的随机元素
1177 | *
1178 | * @param key
1179 | * @return
1180 | */
1181 | public String spop(String key) {
1182 | try {
1183 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1184 | .getPool(hashFunc.hash(key));
1185 | Jedis jedis = pool.getResource();
1186 | String r = jedis.spop(key);
1187 | pool.returnResource(jedis);
1188 | return r;
1189 | } catch (Exception e) {
1190 | throw new ClusterOpException(e);
1191 | }
1192 | }
1193 |
1194 | /**
1195 | * 获取集合里面的元素数量
1196 | *
1197 | * @param key
1198 | * @return
1199 | */
1200 | public Long scard(String key) {
1201 | try {
1202 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1203 | .getPool(hashFunc.hash(key));
1204 | Jedis jedis = pool.getResource();
1205 | Long r = jedis.scard(key);
1206 | pool.returnResource(jedis);
1207 | return r;
1208 | } catch (Exception e) {
1209 | throw new ClusterOpException(e);
1210 | }
1211 | }
1212 |
1213 | /**
1214 | * 确定一个给定的值是一个集合的成员
1215 | *
1216 | * @param key
1217 | * @param member
1218 | * @return
1219 | */
1220 | public Boolean sismember(String key, String member) {
1221 | try {
1222 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1223 | .getPool(hashFunc.hash(key));
1224 | Jedis jedis = pool.getResource();
1225 | Boolean r = jedis.sismember(key, member);
1226 | pool.returnResource(jedis);
1227 | return r;
1228 | } catch (Exception e) {
1229 | throw new ClusterOpException(e);
1230 | }
1231 | }
1232 |
1233 | /**
1234 | * 从集合里面随机获取一个key
1235 | *
1236 | * @param key
1237 | * @return
1238 | */
1239 | public String srandmember(String key) {
1240 | try {
1241 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1242 | .getPool(hashFunc.hash(key));
1243 | Jedis jedis = pool.getResource();
1244 | String r = jedis.srandmember(key);
1245 | pool.returnResource(jedis);
1246 | return r;
1247 | } catch (Exception e) {
1248 | throw new ClusterOpException(e);
1249 | }
1250 | }
1251 |
1252 | /**
1253 | * 添加到有序set的一个或多个成员，或更新的分数，如果它已经存在
1254 | *
1255 | * @param key
1256 | * @param score
1257 | * @param member
1258 | * @return
1259 | */
1260 | public Long zadd(String key, double score, String member) {
1261 | try {
1262 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1263 | .getPool(hashFunc.hash(key));
1264 | Jedis jedis = pool.getResource();
1265 | Long r = jedis.zadd(key, score, member);
1266 | pool.returnResource(jedis);
1267 | return r;
1268 | } catch (Exception e) {
1269 | throw new ClusterOpException(e);
1270 | }
1271 | }
1272 |
1273 | /**
1274 | * 返回有序集key中，指定区间内的成员。其中成员按score值递增(从小到大)来排序。具有相同score值的成员按字典序来排列。
1275 | *
1276 | * @param key
1277 | * @param start
1278 | * @param end
1279 | * @return
1280 | */
1281 | public Set zrange(String key, int start, int end) {
1282 | try {
1283 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1284 | .getPool(hashFunc.hash(key));
1285 | Jedis jedis = pool.getResource();
1286 | Set r = jedis.zrange(key, start, end);
1287 | pool.returnResource(jedis);
1288 | return r;
1289 | } catch (Exception e) {
1290 | throw new ClusterOpException(e);
1291 | }
1292 | }
1293 |
1294 | /**
1295 | * 从排序的集合中删除一个或多个成员
1296 | *
1297 | * @param key
1298 | * @param members
1299 | * @return
1300 | */
1301 | public Long zrem(String key, String... members) {
1302 | try {
1303 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1304 | .getPool(hashFunc.hash(key));
1305 | Jedis jedis = pool.getResource();
1306 | Long r = jedis.zrem(key, members);
1307 | pool.returnResource(jedis);
1308 | return r;
1309 | } catch (Exception e) {
1310 | throw new ClusterOpException(e);
1311 | }
1312 | }
1313 |
1314 | /**
1315 | * 增量的一名成员在排序设置的评分
1316 | *
1317 | * @param key
1318 | * @param score
1319 | * @param member
1320 | * @return
1321 | */
1322 | public Double zincrby(String key, double score, String member) {
1323 | try {
1324 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1325 | .getPool(hashFunc.hash(key));
1326 | Jedis jedis = pool.getResource();
1327 | Double r = jedis.zincrby(key, score, member);
1328 | pool.returnResource(jedis);
1329 | return r;
1330 | } catch (Exception e) {
1331 | throw new ClusterOpException(e);
1332 | }
1333 | }
1334 |
1335 | /**
1336 | * 确定在排序集合成员的索引
1337 | *
1338 | * @param key
1339 | * @param member
1340 | * @return
1341 | */
1342 | public Long zrank(String key, String member) {
1343 | try {
1344 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1345 | .getPool(hashFunc.hash(key));
1346 | Jedis jedis = pool.getResource();
1347 | Long r = jedis.zrank(key, member);
1348 | pool.returnResource(jedis);
1349 | return r;
1350 | } catch (Exception e) {
1351 | throw new ClusterOpException(e);
1352 | }
1353 | }
1354 |
1355 | /**
1356 | * 确定指数在排序集的成员，下令从分数高到低
1357 | *
1358 | * @param key
1359 | * @param member
1360 | * @return
1361 | */
1362 | public Long zrevrank(String key, String member) {
1363 | try {
1364 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1365 | .getPool(hashFunc.hash(key));
1366 | Jedis jedis = pool.getResource();
1367 | Long r = jedis.zrevrank(key, member);
1368 | pool.returnResource(jedis);
1369 | return r;
1370 | } catch (Exception e) {
1371 | throw new ClusterOpException(e);
1372 | }
1373 | }
1374 |
1375 | /**
1376 | *
1377 | * 返回有序集key中，指定区间内的成员。其中成员的位置按score值递减(从大到小)来排列
1378 | *
1379 | * @param key
1380 | * @param start
1381 | * @param end
1382 | * @return
1383 | */
1384 | public Set zrevrange(String key, int start, int end) {
1385 | try {
1386 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1387 | .getPool(hashFunc.hash(key));
1388 | Jedis jedis = pool.getResource();
1389 | Set r = jedis.zrevrange(key, start, end);
1390 | pool.returnResource(jedis);
1391 | return r;
1392 | } catch (Exception e) {
1393 | throw new ClusterOpException(e);
1394 | }
1395 | }
1396 |
1397 | public Set zrangeWithScores(String key, int start, int end) {
1398 | try {
1399 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1400 | .getPool(hashFunc.hash(key));
1401 | Jedis jedis = pool.getResource();
1402 | Set r = jedis.zrangeWithScores(key, start, end);
1403 | pool.returnResource(jedis);
1404 | return r;
1405 | } catch (Exception e) {
1406 | throw new ClusterOpException(e);
1407 | }
1408 | }
1409 |
1410 | public Set zrevrangeWithScores(String key, int start, int end) {
1411 | try {
1412 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1413 | .getPool(hashFunc.hash(key));
1414 | Jedis jedis = pool.getResource();
1415 | Set r = jedis.zrevrangeWithScores(key, start, end);
1416 | pool.returnResource(jedis);
1417 | return r;
1418 | } catch (Exception e) {
1419 | throw new ClusterOpException(e);
1420 | }
1421 | }
1422 |
1423 | /**
1424 | * 获取一个排序的集合中的成员数量
1425 | *
1426 | * @param key
1427 | * @return
1428 | */
1429 | public Long zcard(String key) {
1430 | try {
1431 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1432 | .getPool(hashFunc.hash(key));
1433 | Jedis jedis = pool.getResource();
1434 | Long r = jedis.zcard(key);
1435 | pool.returnResource(jedis);
1436 | return r;
1437 | } catch (Exception e) {
1438 | throw new ClusterOpException(e);
1439 | }
1440 | }
1441 |
1442 | /**
1443 | * 获取成员在排序设置相关的比分
1444 | *
1445 | * @param key
1446 | * @param member
1447 | * @return
1448 | */
1449 | public Double zscore(String key, String member) {
1450 | try {
1451 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1452 | .getPool(hashFunc.hash(key));
1453 | Jedis jedis = pool.getResource();
1454 | Double r = jedis.zscore(key, member);
1455 | pool.returnResource(jedis);
1456 | return r;
1457 | } catch (Exception e) {
1458 | throw new ClusterOpException(e);
1459 | }
1460 | }
1461 |
1462 | /**
1463 | * 对队列、集合、有序集合排序
1464 | *
1465 | * @param key
1466 | * @return
1467 | */
1468 | public List sort(String key) {
1469 | try {
1470 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1471 | .getPool(hashFunc.hash(key));
1472 | Jedis jedis = pool.getResource();
1473 | List r = jedis.sort(key);
1474 | pool.returnResource(jedis);
1475 | return r;
1476 | } catch (Exception e) {
1477 | throw new ClusterOpException(e);
1478 | }
1479 | }
1480 |
1481 | /**
1482 | * 带参数排序 http://blog.csdn.net/yousite1/article/details/8486218
1483 | *
1484 | * @param key
1485 | * @param sortingParameters
1486 | * @return
1487 | */
1488 | public List sort(String key, SortingParams sortingParameters) {
1489 | try {
1490 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1491 | .getPool(hashFunc.hash(key));
1492 | Jedis jedis = pool.getResource();
1493 | List r = jedis.sort(key, sortingParameters);
1494 | pool.returnResource(jedis);
1495 | return r;
1496 | } catch (Exception e) {
1497 | throw new ClusterOpException(e);
1498 | }
1499 | }
1500 |
1501 | /**
1502 | * 返回有序集key中，score值在min和max之间(默认包括score值等于min或max)的成员
1503 | *
1504 | * @param key
1505 | * @param min
1506 | * @param max
1507 | * @return
1508 | */
1509 | public Long zcount(String key, double min, double max) {
1510 | try {
1511 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1512 | .getPool(hashFunc.hash(key));
1513 | Jedis jedis = pool.getResource();
1514 | Long r = jedis.zcount(key, min, max);
1515 | pool.returnResource(jedis);
1516 | return r;
1517 | } catch (Exception e) {
1518 | throw new ClusterOpException(e);
1519 | }
1520 | }
1521 |
1522 | /**
1523 | * 返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素被认为是从低分到高分排序的。
1524 | * 具有相同分数的元素按字典序排列（这个根据redis对有序集合实现的情况而定，并不需要进一步计算）。
1525 | *
1526 | * @param key
1527 | * @param min
1528 | * @param max
1529 | * @return
1530 | */
1531 | public Set zrangeByScore(String key, double min, double max) {
1532 | try {
1533 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1534 | .getPool(hashFunc.hash(key));
1535 | Jedis jedis = pool.getResource();
1536 | Set r = jedis.zrangeByScore(key, min, max);
1537 | pool.returnResource(jedis);
1538 | return r;
1539 | } catch (Exception e) {
1540 | throw new ClusterOpException(e);
1541 | }
1542 | }
1543 |
1544 | public Set zrevrangeByScore(String key, double max, double min) {
1545 | try {
1546 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1547 | .getPool(hashFunc.hash(key));
1548 | Jedis jedis = pool.getResource();
1549 | Set r = jedis.zrevrangeByScore(key, max, min);
1550 | pool.returnResource(jedis);
1551 | return r;
1552 | } catch (Exception e) {
1553 | throw new ClusterOpException(e);
1554 | }
1555 | }
1556 |
1557 | public Set zrangeByScore(String key, double min, double max,
1558 | int offset, int count) {
1559 | try {
1560 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1561 | .getPool(hashFunc.hash(key));
1562 | Jedis jedis = pool.getResource();
1563 | Set r = jedis.zrangeByScore(key, min, max, offset, count);
1564 | pool.returnResource(jedis);
1565 | return r;
1566 | } catch (Exception e) {
1567 | throw new ClusterOpException(e);
1568 | }
1569 | }
1570 |
1571 | public Set zrevrangeByScore(String key, double max, double min,
1572 | int offset, int count) {
1573 | try {
1574 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1575 | .getPool(hashFunc.hash(key));
1576 | Jedis jedis = pool.getResource();
1577 | Set r = jedis
1578 | .zrevrangeByScore(key, max, min, offset, count);
1579 | pool.returnResource(jedis);
1580 | return r;
1581 | } catch (Exception e) {
1582 | throw new ClusterOpException(e);
1583 | }
1584 | }
1585 |
1586 | public Set zrangeByScoreWithScores(String key, double min, double max) {
1587 | try {
1588 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1589 | .getPool(hashFunc.hash(key));
1590 | Jedis jedis = pool.getResource();
1591 | Set r = jedis.zrangeByScoreWithScores(key, min, max);
1592 | pool.returnResource(jedis);
1593 | return r;
1594 | } catch (Exception e) {
1595 | throw new ClusterOpException(e);
1596 | }
1597 | }
1598 |
1599 | public Set zrevrangeByScoreWithScores(String key, double max,
1600 | double min) {
1601 | try {
1602 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1603 | .getPool(hashFunc.hash(key));
1604 | Jedis jedis = pool.getResource();
1605 | Set r = jedis.zrevrangeByScoreWithScores(key, max, min);
1606 | pool.returnResource(jedis);
1607 | return r;
1608 | } catch (Exception e) {
1609 | throw new ClusterOpException(e);
1610 | }
1611 | }
1612 |
1613 | public Set zrangeByScoreWithScores(String key, double min,
1614 | double max, int offset, int count) {
1615 | try {
1616 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1617 | .getPool(hashFunc.hash(key));
1618 | Jedis jedis = pool.getResource();
1619 | Set r = jedis.zrangeByScoreWithScores(key, min, max, offset,
1620 | count);
1621 | pool.returnResource(jedis);
1622 | return r;
1623 | } catch (Exception e) {
1624 | throw new ClusterOpException(e);
1625 | }
1626 | }
1627 |
1628 | public Set zrevrangeByScoreWithScores(String key, double max,
1629 | double min, int offset, int count) {
1630 | try {
1631 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1632 | .getPool(hashFunc.hash(key));
1633 | Jedis jedis = pool.getResource();
1634 | Set r = jedis.zrevrangeByScoreWithScores(key, max, min,
1635 | offset, count);
1636 | pool.returnResource(jedis);
1637 | return r;
1638 | } catch (Exception e) {
1639 | throw new ClusterOpException(e);
1640 | }
1641 | }
1642 |
1643 | public Long zremrangeByRank(String key, int start, int end) {
1644 | try {
1645 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1646 | .getPool(hashFunc.hash(key));
1647 | Jedis jedis = pool.getResource();
1648 | Long r = jedis.zremrangeByRank(key, start, end);
1649 | pool.returnResource(jedis);
1650 | return r;
1651 | } catch (Exception e) {
1652 | throw new ClusterOpException(e);
1653 | }
1654 | }
1655 |
1656 | public Long zremrangeByScore(String key, double start, double end) {
1657 | try {
1658 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1659 | .getPool(hashFunc.hash(key));
1660 | Jedis jedis = pool.getResource();
1661 | Long r = jedis.zremrangeByScore(key, start, end);
1662 | pool.returnResource(jedis);
1663 | return r;
1664 | } catch (Exception e) {
1665 | throw new ClusterOpException(e);
1666 | }
1667 | }
1668 |
1669 | public Long linsert(String key, LIST_POSITION where, String pivot,
1670 | String value) {
1671 | try {
1672 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1673 | .getPool(hashFunc.hash(key));
1674 | Jedis jedis = pool.getResource();
1675 | Long r = jedis.linsert(key, where, pivot, value);
1676 | pool.returnResource(jedis);
1677 | return r;
1678 | } catch (Exception e) {
1679 | throw new ClusterOpException(e);
1680 | }
1681 | }
1682 |
1683 | public String set(byte[] key, byte[] value) {
1684 | try {
1685 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1686 | .getPool(hashFunc.hash(key));
1687 | Jedis jedis = pool.getResource();
1688 | String r = jedis.set(key, value);
1689 | pool.returnResource(jedis);
1690 | return r;
1691 | } catch (Exception e) {
1692 | throw new ClusterOpException(e);
1693 | }
1694 | }
1695 |
1696 | public byte[] get(byte[] key) {
1697 | try {
1698 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1699 | .getPool(hashFunc.hash(key));
1700 | Jedis jedis = pool.getResource();
1701 | byte[] r = jedis.get(key);
1702 | pool.returnResource(jedis);
1703 | return r;
1704 | } catch (Exception e) {
1705 | throw new ClusterOpException(e);
1706 | }
1707 | }
1708 |
1709 | public Boolean exists(byte[] key) {
1710 | try {
1711 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1712 | .getPool(hashFunc.hash(key));
1713 | Jedis jedis = pool.getResource();
1714 | Boolean r = jedis.exists(key);
1715 | pool.returnResource(jedis);
1716 | return r;
1717 | } catch (Exception e) {
1718 | throw new ClusterOpException(e);
1719 | }
1720 | }
1721 |
1722 | public String type(byte[] key) {
1723 | try {
1724 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1725 | .getPool(hashFunc.hash(key));
1726 | Jedis jedis = pool.getResource();
1727 | String r = jedis.type(key);
1728 | pool.returnResource(jedis);
1729 | return r;
1730 | } catch (Exception e) {
1731 | throw new ClusterOpException(e);
1732 | }
1733 | }
1734 |
1735 | public Long expire(byte[] key, int seconds) {
1736 | try {
1737 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1738 | .getPool(hashFunc.hash(key));
1739 | Jedis jedis = pool.getResource();
1740 | Long r = jedis.expire(key, seconds);
1741 | pool.returnResource(jedis);
1742 | return r;
1743 | } catch (Exception e) {
1744 | throw new ClusterOpException(e);
1745 | }
1746 | }
1747 |
1748 | public Long expire(int seconds, byte[]... keys) {
1749 | try {
1750 | long result = 0;
1751 | for (byte[] key : keys) {
1752 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1753 | .getPool(hashFunc.hash(key));
1754 | Jedis jedis = pool.getResource();
1755 | result += jedis.expire(key, seconds);
1756 | pool.returnResource(jedis);
1757 | }
1758 | return result;
1759 | } catch (Exception e) {
1760 | throw new ClusterOpException(e);
1761 | }
1762 | }
1763 |
1764 | public Long expireAt(byte[] key, long unixTime) {
1765 | try {
1766 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1767 | .getPool(hashFunc.hash(key));
1768 | Jedis jedis = pool.getResource();
1769 | Long r = jedis.expireAt(key, unixTime);
1770 | pool.returnResource(jedis);
1771 | return r;
1772 | } catch (Exception e) {
1773 | throw new ClusterOpException(e);
1774 | }
1775 | }
1776 |
1777 | public Long ttl(byte[] key) {
1778 | try {
1779 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1780 | .getPool(hashFunc.hash(key));
1781 | Jedis jedis = pool.getResource();
1782 | Long r = jedis.ttl(key);
1783 | pool.returnResource(jedis);
1784 | return r;
1785 | } catch (Exception e) {
1786 | throw new ClusterOpException(e);
1787 | }
1788 | }
1789 |
1790 | public byte[] getSet(byte[] key, byte[] value) {
1791 | try {
1792 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1793 | .getPool(hashFunc.hash(key));
1794 | Jedis jedis = pool.getResource();
1795 | byte[] r = jedis.getSet(key, value);
1796 | pool.returnResource(jedis);
1797 | return r;
1798 | } catch (Exception e) {
1799 | throw new ClusterOpException(e);
1800 | }
1801 | }
1802 |
1803 | public Long setnx(byte[] key, byte[] value) {
1804 | try {
1805 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1806 | .getPool(hashFunc.hash(key));
1807 | Jedis jedis = pool.getResource();
1808 | Long r = jedis.setnx(key, value);
1809 | pool.returnResource(jedis);
1810 | return r;
1811 | } catch (Exception e) {
1812 | throw new ClusterOpException(e);
1813 | }
1814 | }
1815 |
1816 | public String setex(byte[] key, int seconds, byte[] value) {
1817 | try {
1818 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1819 | .getPool(hashFunc.hash(key));
1820 | Jedis jedis = pool.getResource();
1821 | String r = jedis.setex(key, seconds, value);
1822 | pool.returnResource(jedis);
1823 | return r;
1824 | } catch (Exception e) {
1825 | throw new ClusterOpException(e);
1826 | }
1827 | }
1828 |
1829 | public Long decrBy(byte[] key, long integer) {
1830 | try {
1831 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1832 | .getPool(hashFunc.hash(key));
1833 | Jedis jedis = pool.getResource();
1834 | Long r = jedis.decrBy(key, integer);
1835 | pool.returnResource(jedis);
1836 | return r;
1837 | } catch (Exception e) {
1838 | throw new ClusterOpException(e);
1839 | }
1840 | }
1841 |
1842 | public Long decr(byte[] key) {
1843 | try {
1844 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1845 | .getPool(hashFunc.hash(key));
1846 | Jedis jedis = pool.getResource();
1847 | Long r = jedis.decr(key);
1848 | pool.returnResource(jedis);
1849 | return r;
1850 | } catch (Exception e) {
1851 | throw new ClusterOpException(e);
1852 | }
1853 | }
1854 |
1855 | public Long incrBy(byte[] key, long integer) {
1856 | try {
1857 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1858 | .getPool(hashFunc.hash(key));
1859 | Jedis jedis = pool.getResource();
1860 | Long r = jedis.incrBy(key, integer);
1861 | pool.returnResource(jedis);
1862 | return r;
1863 | } catch (Exception e) {
1864 | throw new ClusterOpException(e);
1865 | }
1866 | }
1867 |
1868 | public Long incr(byte[] key) {
1869 | try {
1870 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1871 | .getPool(hashFunc.hash(key));
1872 | Jedis jedis = pool.getResource();
1873 | Long r = jedis.incr(key);
1874 | pool.returnResource(jedis);
1875 | return r;
1876 | } catch (Exception e) {
1877 | throw new ClusterOpException(e);
1878 | }
1879 | }
1880 |
1881 | public Long append(byte[] key, byte[] value) {
1882 | try {
1883 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1884 | .getPool(hashFunc.hash(key));
1885 | Jedis jedis = pool.getResource();
1886 | Long r = jedis.append(key, value);
1887 | pool.returnResource(jedis);
1888 | return r;
1889 | } catch (Exception e) {
1890 | throw new ClusterOpException(e);
1891 | }
1892 | }
1893 |
1894 | public byte[] substr(byte[] key, int start, int end) {
1895 | try {
1896 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1897 | .getPool(hashFunc.hash(key));
1898 | Jedis jedis = pool.getResource();
1899 | byte[] r = jedis.substr(key, start, end);
1900 | pool.returnResource(jedis);
1901 | return r;
1902 | } catch (Exception e) {
1903 | throw new ClusterOpException(e);
1904 | }
1905 | }
1906 |
1907 | public Long hset(byte[] key, byte[] field, byte[] value) {
1908 | try {
1909 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1910 | .getPool(hashFunc.hash(key));
1911 | Jedis jedis = pool.getResource();
1912 | Long r = jedis.hset(key, field, value);
1913 | pool.returnResource(jedis);
1914 | return r;
1915 | } catch (Exception e) {
1916 | throw new ClusterOpException(e);
1917 | }
1918 | }
1919 |
1920 | public byte[] hget(byte[] key, byte[] field) {
1921 | try {
1922 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1923 | .getPool(hashFunc.hash(key));
1924 | Jedis jedis = pool.getResource();
1925 | byte[] r = jedis.hget(key, field);
1926 | pool.returnResource(jedis);
1927 | return r;
1928 | } catch (Exception e) {
1929 | throw new ClusterOpException(e);
1930 | }
1931 | }
1932 |
1933 | public Long hsetnx(byte[] key, byte[] field, byte[] value) {
1934 | try {
1935 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1936 | .getPool(hashFunc.hash(key));
1937 | Jedis jedis = pool.getResource();
1938 | Long r = jedis.hsetnx(key, field, value);
1939 | pool.returnResource(jedis);
1940 | return r;
1941 | } catch (Exception e) {
1942 | throw new ClusterOpException(e);
1943 | }
1944 | }
1945 |
1946 | public String hmset(byte[] key, Map hash) {
1947 | if (hash == null || hash.isEmpty())
1948 | throw new ClusterOpException("Param cannot be null or empty!");
1949 | try {
1950 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1951 | .getPool(hashFunc.hash(key));
1952 | Jedis jedis = pool.getResource();
1953 | String r = jedis.hmset(key, hash);
1954 | pool.returnResource(jedis);
1955 | return r;
1956 | } catch (Exception e) {
1957 | throw new ClusterOpException(e);
1958 | }
1959 | }
1960 |
1961 | public List hmget(byte[] key, byte[]... fields) {
1962 | try {
1963 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1964 | .getPool(hashFunc.hash(key));
1965 | Jedis jedis = pool.getResource();
1966 | List r = jedis.hmget(key, fields);
1967 | pool.returnResource(jedis);
1968 | return r;
1969 | } catch (Exception e) {
1970 | throw new ClusterOpException(e);
1971 | }
1972 | }
1973 |
1974 | public Long hincrBy(byte[] key, byte[] field, long value) {
1975 | try {
1976 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1977 | .getPool(hashFunc.hash(key));
1978 | Jedis jedis = pool.getResource();
1979 | Long r = jedis.hincrBy(key, field, value);
1980 | pool.returnResource(jedis);
1981 | return r;
1982 | } catch (Exception e) {
1983 | throw new ClusterOpException(e);
1984 | }
1985 | }
1986 |
1987 | public Boolean hexists(byte[] key, byte[] field) {
1988 | try {
1989 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
1990 | .getPool(hashFunc.hash(key));
1991 | Jedis jedis = pool.getResource();
1992 | Boolean r = jedis.hexists(key, field);
1993 | pool.returnResource(jedis);
1994 | return r;
1995 | } catch (Exception e) {
1996 | throw new ClusterOpException(e);
1997 | }
1998 | }
1999 |
2000 | public Long hdel(byte[] key, byte[]... fields) {
2001 | try {
2002 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2003 | .getPool(hashFunc.hash(key));
2004 | Jedis jedis = pool.getResource();
2005 | Long r = jedis.hdel(key, fields);
2006 | pool.returnResource(jedis);
2007 | return r;
2008 | } catch (Exception e) {
2009 | throw new ClusterOpException(e);
2010 | }
2011 | }
2012 |
2013 | public Long hlen(byte[] key) {
2014 | try {
2015 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2016 | .getPool(hashFunc.hash(key));
2017 | Jedis jedis = pool.getResource();
2018 | Long r = jedis.hlen(key);
2019 | pool.returnResource(jedis);
2020 | return r;
2021 | } catch (Exception e) {
2022 | throw new ClusterOpException(e);
2023 | }
2024 | }
2025 |
2026 | public Set hkeys(byte[] key) {
2027 | try {
2028 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2029 | .getPool(hashFunc.hash(key));
2030 | Jedis jedis = pool.getResource();
2031 | Set r = jedis.hkeys(key);
2032 | pool.returnResource(jedis);
2033 | return r;
2034 | } catch (Exception e) {
2035 | throw new ClusterOpException(e);
2036 | }
2037 | }
2038 |
2039 | public Collection hvals(byte[] key) {
2040 | try {
2041 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2042 | .getPool(hashFunc.hash(key));
2043 | Jedis jedis = pool.getResource();
2044 | Collection r = jedis.hvals(key);
2045 | pool.returnResource(jedis);
2046 | return r;
2047 | } catch (Exception e) {
2048 | throw new ClusterOpException(e);
2049 | }
2050 | }
2051 |
2052 | public Map hgetAll(byte[] key) {
2053 | try {
2054 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2055 | .getPool(hashFunc.hash(key));
2056 | Jedis jedis = pool.getResource();
2057 | Map r = jedis.hgetAll(key);
2058 | pool.returnResource(jedis);
2059 | return r;
2060 | } catch (Exception e) {
2061 | throw new ClusterOpException(e);
2062 | }
2063 | }
2064 |
2065 | public Long rpush(byte[] key, byte[]... strings) {
2066 | try {
2067 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2068 | .getPool(hashFunc.hash(key));
2069 | Jedis jedis = pool.getResource();
2070 | Long r = jedis.rpush(key, strings);
2071 | pool.returnResource(jedis);
2072 | return r;
2073 | } catch (Exception e) {
2074 | throw new ClusterOpException(e);
2075 | }
2076 | }
2077 |
2078 | public Long lpush(byte[] key, byte[]... strings) {
2079 | try {
2080 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2081 | .getPool(hashFunc.hash(key));
2082 | Jedis jedis = pool.getResource();
2083 | Long r = jedis.lpush(key, strings);
2084 | pool.returnResource(jedis);
2085 | return r;
2086 | } catch (Exception e) {
2087 | throw new ClusterOpException(e);
2088 | }
2089 | }
2090 |
2091 | public Long llen(byte[] key) {
2092 | try {
2093 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2094 | .getPool(hashFunc.hash(key));
2095 | Jedis jedis = pool.getResource();
2096 | Long r = jedis.llen(key);
2097 | pool.returnResource(jedis);
2098 | return r;
2099 | } catch (Exception e) {
2100 | throw new ClusterOpException(e);
2101 | }
2102 | }
2103 |
2104 | public List lrange(byte[] key, int start, int end) {
2105 | try {
2106 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2107 | .getPool(hashFunc.hash(key));
2108 | Jedis jedis = pool.getResource();
2109 | List r = jedis.lrange(key, start, end);
2110 | pool.returnResource(jedis);
2111 | return r;
2112 | } catch (Exception e) {
2113 | throw new ClusterOpException(e);
2114 | }
2115 | }
2116 |
2117 | public String ltrim(byte[] key, int start, int end) {
2118 | try {
2119 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2120 | .getPool(hashFunc.hash(key));
2121 | Jedis jedis = pool.getResource();
2122 | String r = jedis.ltrim(key, start, end);
2123 | pool.returnResource(jedis);
2124 | return r;
2125 | } catch (Exception e) {
2126 | throw new ClusterOpException(e);
2127 | }
2128 | }
2129 |
2130 | public byte[] lindex(byte[] key, int index) {
2131 | try {
2132 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2133 | .getPool(hashFunc.hash(key));
2134 | Jedis jedis = pool.getResource();
2135 | byte[] r = jedis.lindex(key, index);
2136 | pool.returnResource(jedis);
2137 | return r;
2138 | } catch (Exception e) {
2139 | throw new ClusterOpException(e);
2140 | }
2141 | }
2142 |
2143 | public String lset(byte[] key, int index, byte[] value) {
2144 | try {
2145 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2146 | .getPool(hashFunc.hash(key));
2147 | Jedis jedis = pool.getResource();
2148 | String r = jedis.lset(key, index, value);
2149 | pool.returnResource(jedis);
2150 | return r;
2151 | } catch (Exception e) {
2152 | throw new ClusterOpException(e);
2153 | }
2154 | }
2155 |
2156 | public Long lrem(byte[] key, int count, byte[] value) {
2157 | try {
2158 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2159 | .getPool(hashFunc.hash(key));
2160 | Jedis jedis = pool.getResource();
2161 | Long r = jedis.lrem(key, count, value);
2162 | pool.returnResource(jedis);
2163 | return r;
2164 | } catch (Exception e) {
2165 | throw new ClusterOpException(e);
2166 | }
2167 | }
2168 |
2169 | public byte[] lpop(byte[] key) {
2170 | try {
2171 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2172 | .getPool(hashFunc.hash(key));
2173 | Jedis jedis = pool.getResource();
2174 | byte[] r = jedis.lpop(key);
2175 | pool.returnResource(jedis);
2176 | return r;
2177 | } catch (Exception e) {
2178 | throw new ClusterOpException(e);
2179 | }
2180 | }
2181 |
2182 | public byte[] rpop(byte[] key) {
2183 | try {
2184 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2185 | .getPool(hashFunc.hash(key));
2186 | Jedis jedis = pool.getResource();
2187 | byte[] r = jedis.rpop(key);
2188 | pool.returnResource(jedis);
2189 | return r;
2190 | } catch (Exception e) {
2191 | throw new ClusterOpException(e);
2192 | }
2193 | }
2194 |
2195 | public Long sadd(byte[] key, byte[]... members) {
2196 | try {
2197 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2198 | .getPool(hashFunc.hash(key));
2199 | Jedis jedis = pool.getResource();
2200 | Long r = jedis.sadd(key, members);
2201 | pool.returnResource(jedis);
2202 | return r;
2203 | } catch (Exception e) {
2204 | throw new ClusterOpException(e);
2205 | }
2206 | }
2207 |
2208 | public Set smembers(byte[] key) {
2209 | try {
2210 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2211 | .getPool(hashFunc.hash(key));
2212 | Jedis jedis = pool.getResource();
2213 | Set r = jedis.smembers(key);
2214 | pool.returnResource(jedis);
2215 | return r;
2216 | } catch (Exception e) {
2217 | throw new ClusterOpException(e);
2218 | }
2219 | }
2220 |
2221 | public Long srem(byte[] key, byte[]... members) {
2222 | try {
2223 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2224 | .getPool(hashFunc.hash(key));
2225 | Jedis jedis = pool.getResource();
2226 | Long r = jedis.srem(key, members);
2227 | pool.returnResource(jedis);
2228 | return r;
2229 | } catch (Exception e) {
2230 | throw new ClusterOpException(e);
2231 | }
2232 | }
2233 |
2234 | public byte[] spop(byte[] key) {
2235 | try {
2236 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2237 | .getPool(hashFunc.hash(key));
2238 | Jedis jedis = pool.getResource();
2239 | byte[] r = jedis.spop(key);
2240 | pool.returnResource(jedis);
2241 | return r;
2242 | } catch (Exception e) {
2243 | throw new ClusterOpException(e);
2244 | }
2245 | }
2246 |
2247 | public Long scard(byte[] key) {
2248 | try {
2249 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2250 | .getPool(hashFunc.hash(key));
2251 | Jedis jedis = pool.getResource();
2252 | Long r = jedis.scard(key);
2253 | pool.returnResource(jedis);
2254 | return r;
2255 | } catch (Exception e) {
2256 | throw new ClusterOpException(e);
2257 | }
2258 | }
2259 |
2260 | public Boolean sismember(byte[] key, byte[] member) {
2261 | try {
2262 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2263 | .getPool(hashFunc.hash(key));
2264 | Jedis jedis = pool.getResource();
2265 | Boolean r = jedis.sismember(key, member);
2266 | pool.returnResource(jedis);
2267 | return r;
2268 | } catch (Exception e) {
2269 | throw new ClusterOpException(e);
2270 | }
2271 | }
2272 |
2273 | public byte[] srandmember(byte[] key) {
2274 | try {
2275 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2276 | .getPool(hashFunc.hash(key));
2277 | Jedis jedis = pool.getResource();
2278 | byte[] r = jedis.srandmember(key);
2279 | pool.returnResource(jedis);
2280 | return r;
2281 | } catch (Exception e) {
2282 | throw new ClusterOpException(e);
2283 | }
2284 | }
2285 |
2286 | public Long zadd(byte[] key, double score, byte[] member) {
2287 | try {
2288 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2289 | .getPool(hashFunc.hash(key));
2290 | Jedis jedis = pool.getResource();
2291 | Long r = jedis.zadd(key, score, member);
2292 | pool.returnResource(jedis);
2293 | return r;
2294 | } catch (Exception e) {
2295 | throw new ClusterOpException(e);
2296 | }
2297 | }
2298 |
2299 | public Set zrange(byte[] key, int start, int end) {
2300 | try {
2301 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2302 | .getPool(hashFunc.hash(key));
2303 | Jedis jedis = pool.getResource();
2304 | Set r = jedis.zrange(key, start, end);
2305 | pool.returnResource(jedis);
2306 | return r;
2307 | } catch (Exception e) {
2308 | throw new ClusterOpException(e);
2309 | }
2310 | }
2311 |
2312 | public Long zrem(byte[] key, byte[]... members) {
2313 | try {
2314 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2315 | .getPool(hashFunc.hash(key));
2316 | Jedis jedis = pool.getResource();
2317 | Long r = jedis.zrem(key, members);
2318 | pool.returnResource(jedis);
2319 | return r;
2320 | } catch (Exception e) {
2321 | throw new ClusterOpException(e);
2322 | }
2323 | }
2324 |
2325 | public Double zincrby(byte[] key, double score, byte[] member) {
2326 | try {
2327 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2328 | .getPool(hashFunc.hash(key));
2329 | Jedis jedis = pool.getResource();
2330 | Double r = jedis.zincrby(key, score, member);
2331 | pool.returnResource(jedis);
2332 | return r;
2333 | } catch (Exception e) {
2334 | throw new ClusterOpException(e);
2335 | }
2336 | }
2337 |
2338 | public Long zrank(byte[] key, byte[] member) {
2339 | try {
2340 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2341 | .getPool(hashFunc.hash(key));
2342 | Jedis jedis = pool.getResource();
2343 | Long r = jedis.zrank(key, member);
2344 | pool.returnResource(jedis);
2345 | return r;
2346 | } catch (Exception e) {
2347 | throw new ClusterOpException(e);
2348 | }
2349 | }
2350 |
2351 | public Long zrevrank(byte[] key, byte[] member) {
2352 | try {
2353 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2354 | .getPool(hashFunc.hash(key));
2355 | Jedis jedis = pool.getResource();
2356 | Long r = jedis.zrevrank(key, member);
2357 | pool.returnResource(jedis);
2358 | return r;
2359 | } catch (Exception e) {
2360 | throw new ClusterOpException(e);
2361 | }
2362 | }
2363 |
2364 | public Set zrevrange(byte[] key, int start, int end) {
2365 | try {
2366 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2367 | .getPool(hashFunc.hash(key));
2368 | Jedis jedis = pool.getResource();
2369 | Set r = jedis.zrevrange(key, start, end);
2370 | pool.returnResource(jedis);
2371 | return r;
2372 | } catch (Exception e) {
2373 | throw new ClusterOpException(e);
2374 | }
2375 | }
2376 |
2377 | public Set zrangeWithScores(byte[] key, int start, int end) {
2378 | try {
2379 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2380 | .getPool(hashFunc.hash(key));
2381 | Jedis jedis = pool.getResource();
2382 | Set r = jedis.zrangeWithScores(key, start, end);
2383 | pool.returnResource(jedis);
2384 | return r;
2385 | } catch (Exception e) {
2386 | throw new ClusterOpException(e);
2387 | }
2388 | }
2389 |
2390 | public Set zrevrangeWithScores(byte[] key, int start, int end) {
2391 | try {
2392 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2393 | .getPool(hashFunc.hash(key));
2394 | Jedis jedis = pool.getResource();
2395 | Set r = jedis.zrevrangeWithScores(key, start, end);
2396 | pool.returnResource(jedis);
2397 | return r;
2398 | } catch (Exception e) {
2399 | throw new ClusterOpException(e);
2400 | }
2401 | }
2402 |
2403 | public Long zcard(byte[] key) {
2404 | try {
2405 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2406 | .getPool(hashFunc.hash(key));
2407 | Jedis jedis = pool.getResource();
2408 | Long r = jedis.zcard(key);
2409 | pool.returnResource(jedis);
2410 | return r;
2411 | } catch (Exception e) {
2412 | throw new ClusterOpException(e);
2413 | }
2414 | }
2415 |
2416 | public Double zscore(byte[] key, byte[] member) {
2417 | try {
2418 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2419 | .getPool(hashFunc.hash(key));
2420 | Jedis jedis = pool.getResource();
2421 | Double r = jedis.zscore(key, member);
2422 | pool.returnResource(jedis);
2423 | return r;
2424 | } catch (Exception e) {
2425 | throw new ClusterOpException(e);
2426 | }
2427 | }
2428 |
2429 | public List sort(byte[] key) {
2430 | try {
2431 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2432 | .getPool(hashFunc.hash(key));
2433 | Jedis jedis = pool.getResource();
2434 | List r = jedis.sort(key);
2435 | pool.returnResource(jedis);
2436 | return r;
2437 | } catch (Exception e) {
2438 | throw new ClusterOpException(e);
2439 | }
2440 | }
2441 |
2442 | public List sort(byte[] key, SortingParams sortingParameters) {
2443 | try {
2444 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2445 | .getPool(hashFunc.hash(key));
2446 | Jedis jedis = pool.getResource();
2447 | List r = jedis.sort(key, sortingParameters);
2448 | pool.returnResource(jedis);
2449 | return r;
2450 | } catch (Exception e) {
2451 | throw new ClusterOpException(e);
2452 | }
2453 | }
2454 |
2455 | public Long zcount(byte[] key, double min, double max) {
2456 | try {
2457 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2458 | .getPool(hashFunc.hash(key));
2459 | Jedis jedis = pool.getResource();
2460 | Long r = jedis.zcount(key, min, max);
2461 | pool.returnResource(jedis);
2462 | return r;
2463 | } catch (Exception e) {
2464 | throw new ClusterOpException(e);
2465 | }
2466 | }
2467 |
2468 | public Set zrangeByScore(byte[] key, double min, double max) {
2469 | try {
2470 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2471 | .getPool(hashFunc.hash(key));
2472 | Jedis jedis = pool.getResource();
2473 | Set r = jedis.zrangeByScore(key, min, max);
2474 | pool.returnResource(jedis);
2475 | return r;
2476 | } catch (Exception e) {
2477 | throw new ClusterOpException(e);
2478 | }
2479 | }
2480 |
2481 | public Set zrangeByScore(byte[] key, double min, double max,
2482 | int offset, int count) {
2483 | try {
2484 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2485 | .getPool(hashFunc.hash(key));
2486 | Jedis jedis = pool.getResource();
2487 | Set r = jedis.zrangeByScore(key, min, max, offset, count);
2488 | pool.returnResource(jedis);
2489 | return r;
2490 | } catch (Exception e) {
2491 | throw new ClusterOpException(e);
2492 | }
2493 | }
2494 |
2495 | public Set zrangeByScoreWithScores(byte[] key, double min, double max) {
2496 | try {
2497 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2498 | .getPool(hashFunc.hash(key));
2499 | Jedis jedis = pool.getResource();
2500 | Set r = jedis.zrangeByScoreWithScores(key, min, max);
2501 | pool.returnResource(jedis);
2502 | return r;
2503 | } catch (Exception e) {
2504 | throw new ClusterOpException(e);
2505 | }
2506 | }
2507 |
2508 | public Set zrangeByScoreWithScores(byte[] key, double min,
2509 | double max, int offset, int count) {
2510 | try {
2511 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2512 | .getPool(hashFunc.hash(key));
2513 | Jedis jedis = pool.getResource();
2514 | Set r = jedis.zrangeByScoreWithScores(key, min, max, offset,
2515 | count);
2516 | pool.returnResource(jedis);
2517 | return r;
2518 | } catch (Exception e) {
2519 | throw new ClusterOpException(e);
2520 | }
2521 | }
2522 |
2523 | public Set zrevrangeByScore(byte[] key, double max, double min) {
2524 | try {
2525 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2526 | .getPool(hashFunc.hash(key));
2527 | Jedis jedis = pool.getResource();
2528 | Set r = jedis.zrevrangeByScore(key, max, min);
2529 | pool.returnResource(jedis);
2530 | return r;
2531 | } catch (Exception e) {
2532 | throw new ClusterOpException(e);
2533 | }
2534 | }
2535 |
2536 | public Set zrevrangeByScore(byte[] key, double max, double min,
2537 | int offset, int count) {
2538 | try {
2539 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2540 | .getPool(hashFunc.hash(key));
2541 | Jedis jedis = pool.getResource();
2542 | Set r = jedis
2543 | .zrevrangeByScore(key, max, min, offset, count);
2544 | pool.returnResource(jedis);
2545 | return r;
2546 | } catch (Exception e) {
2547 | throw new ClusterOpException(e);
2548 | }
2549 | }
2550 |
2551 | public Set zrevrangeByScoreWithScores(byte[] key, double max,
2552 | double min) {
2553 | try {
2554 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2555 | .getPool(hashFunc.hash(key));
2556 | Jedis jedis = pool.getResource();
2557 | Set r = jedis.zrevrangeByScoreWithScores(key, max, min);
2558 | pool.returnResource(jedis);
2559 | return r;
2560 | } catch (Exception e) {
2561 | throw new ClusterOpException(e);
2562 | }
2563 | }
2564 |
2565 | public Set zrevrangeByScoreWithScores(byte[] key, double max,
2566 | double min, int offset, int count) {
2567 | try {
2568 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2569 | .getPool(hashFunc.hash(key));
2570 | Jedis jedis = pool.getResource();
2571 | Set r = jedis.zrevrangeByScoreWithScores(key, max, min,
2572 | offset, count);
2573 | pool.returnResource(jedis);
2574 | return r;
2575 | } catch (Exception e) {
2576 | throw new ClusterOpException(e);
2577 | }
2578 | }
2579 |
2580 | public Long zremrangeByRank(byte[] key, int start, int end) {
2581 | try {
2582 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2583 | .getPool(hashFunc.hash(key));
2584 | Jedis jedis = pool.getResource();
2585 | Long r = jedis.zremrangeByRank(key, start, end);
2586 | pool.returnResource(jedis);
2587 | return r;
2588 | } catch (Exception e) {
2589 | throw new ClusterOpException(e);
2590 | }
2591 | }
2592 |
2593 | public Long zremrangeByScore(byte[] key, double start, double end) {
2594 | try {
2595 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2596 | .getPool(hashFunc.hash(key));
2597 | Jedis jedis = pool.getResource();
2598 | Long r = jedis.zremrangeByScore(key, start, end);
2599 | pool.returnResource(jedis);
2600 | return r;
2601 | } catch (Exception e) {
2602 | throw new ClusterOpException(e);
2603 | }
2604 | }
2605 |
2606 | public Long linsert(byte[] key, LIST_POSITION where, byte[] pivot,
2607 | byte[] value) {
2608 | try {
2609 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2610 | .getPool(hashFunc.hash(key));
2611 | Jedis jedis = pool.getResource();
2612 | Long r = jedis.linsert(key, where, pivot, value);
2613 | pool.returnResource(jedis);
2614 | return r;
2615 | } catch (Exception e) {
2616 | throw new ClusterOpException(e);
2617 | }
2618 | }
2619 |
2620 | public Long del(final String key) {
2621 | try {
2622 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2623 | .getPool(hashFunc.hash(key));
2624 | Jedis jedis = pool.getResource();
2625 | Long r = jedis.del(key);
2626 | pool.returnResource(jedis);
2627 | return r;
2628 | } catch (Exception e) {
2629 | throw new ClusterOpException(e);
2630 | }
2631 | }
2632 |
2633 | public Long del(final String... keys) {
2634 |
2635 | try {
2636 | Map> mkeys = new HashMap>();
2637 | for (String key : keys) {
2638 | int part = hashFunc.hash(key);
2639 | List mlist = new ArrayList();
2640 | if (mkeys.containsKey(part)) {
2641 | mlist = mkeys.get(part);
2642 | }
2643 | mlist.add(key);
2644 | mkeys.put(part, mlist);
2645 | }
2646 | Long r = 0l;
2647 | for (int part : mkeys.keySet()) {
2648 | List mlist = mkeys.get(part);
2649 | String[] delKeys = (String[]) mlist.toArray(new String[mlist
2650 | .size()]);
2651 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2652 | .getPool(part);
2653 | Jedis jedis = pool.getResource();
2654 | r += jedis.del(delKeys);
2655 | pool.returnResource(jedis);
2656 | }
2657 | return r;
2658 | } catch (Exception e) {
2659 | throw new ClusterOpException(e);
2660 | }
2661 | }
2662 |
2663 | public Long del(final List keys) {
2664 | String[] keyss = keys.toArray(new String[keys.size()]);
2665 | return del(keyss);
2666 | }
2667 |
2668 | public Long delBinary(final List keys) {
2669 | byte[][] delKeys = (byte[][]) keys.toArray(new byte[keys.size()][]);
2670 | return del(delKeys);
2671 | }
2672 |
2673 | public Long del(final byte[]... keys) {
2674 | try {
2675 | Map> mkeys = new HashMap>();
2676 | for (byte[] key : keys) {
2677 | int part = hashFunc.hash(key);
2678 | List mlist = new ArrayList();
2679 | if (mkeys.containsKey(part)) {
2680 | mlist = mkeys.get(part);
2681 | }
2682 | mlist.add(key);
2683 | mkeys.put(part, mlist);
2684 | }
2685 | Long r = 0l;
2686 | for (int part : mkeys.keySet()) {
2687 | List mlist = mkeys.get(part);
2688 | byte[][] delKeys = (byte[][]) mlist.toArray(new byte[mlist
2689 | .size()][]);
2690 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2691 | .getPool(part);
2692 | Jedis jedis = pool.getResource();
2693 | r += jedis.del(delKeys);
2694 | pool.returnResource(jedis);
2695 | }
2696 | return r;
2697 | } catch (Exception e) {
2698 | throw new ClusterOpException(e);
2699 | }
2700 | }
2701 |
2702 | public List mget(final List keys) {
2703 | String[] keyss = keys.toArray(new String[keys.size()]);
2704 | return mget(keyss);
2705 | }
2706 |
2707 | public List mget(final String... keys) {
2708 | try {
2709 | List ret = new ArrayList(keys.length);
2710 | for (int g = 0; g < keys.length; g++) {
2711 | ret.add(null);
2712 | }
2713 | int[][] shadow = new int[partsLen][keys.length];
2714 | int[] count = new int[partsLen];
2715 | List> mkeys = new ArrayList>(partsLen);
2716 | List> mvals = new ArrayList>(partsLen);
2717 | for (int h = 0; h < partsLen; h++) {
2718 | mkeys.add(new ArrayList(keys.length));
2719 | mvals.add(new ArrayList(keys.length));
2720 | }
2721 | for (int j = 0; j < keys.length; j++) {
2722 | int part = hashFunc.hash(keys[j]);
2723 | mkeys.get(part).add(keys[j]);
2724 | shadow[part][count[part]] = j;
2725 | count[part]++;
2726 | }
2727 | for (int i = 0; i < partsLen; i++) {
2728 | if (!mkeys.get(i).isEmpty()) {
2729 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2730 | .getPool(i);
2731 | Jedis jedis = pool.getResource();
2732 | String[] mgkeys = mkeys.get(i).toArray(
2733 | new String[mkeys.get(i).size()]);
2734 | mvals.set(i, jedis.mget(mgkeys));
2735 | pool.returnResource(jedis);
2736 | }
2737 | }
2738 | for (int k = 0; k < partsLen; k++) {
2739 | for (int m = 0; m < count[k]; m++) {
2740 | ret.set(shadow[k][m], mvals.get(k).get(m));
2741 | }
2742 | }
2743 | return ret;
2744 | } catch (Exception e) {
2745 | throw new ClusterOpException(e);
2746 | }
2747 | }
2748 |
2749 | public List mgetBinary(final List keys) {
2750 | byte[][] mgkeys = (byte[][]) keys.toArray(new byte[keys.size()][]);
2751 | return mget(mgkeys);
2752 | }
2753 |
2754 | public List mget(final byte[]... keys) {
2755 | try {
2756 | List ret = new ArrayList(keys.length);
2757 | for (int g = 0; g < keys.length; g++) {
2758 | ret.add(null);
2759 | }
2760 | int[][] shadow = new int[partsLen][keys.length];
2761 | int[] count = new int[partsLen];
2762 | List> mkeys = new ArrayList>(partsLen);
2763 | List> mvals = new ArrayList>(partsLen);
2764 | for (int h = 0; h < partsLen; h++) {
2765 | mkeys.add(new ArrayList(keys.length));
2766 | mvals.add(new ArrayList(keys.length));
2767 | }
2768 | for (int j = 0; j < keys.length; j++) {
2769 | int part = hashFunc.hash(keys[j]);
2770 | mkeys.get(part).add(keys[j]);
2771 | shadow[part][count[part]] = j;
2772 | count[part]++;
2773 | }
2774 | for (int i = 0; i < partsLen; i++) {
2775 | if (!mkeys.get(i).isEmpty()) {
2776 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2777 | .getPool(i);
2778 | Jedis jedis = pool.getResource();
2779 | byte[][] mgkeys = (byte[][]) mkeys.get(i).toArray(
2780 | new byte[mkeys.get(i).size()][]);
2781 | mvals.set(i, jedis.mget(mgkeys));
2782 | pool.returnResource(jedis);
2783 | }
2784 | }
2785 | for (int k = 0; k < partsLen; k++) {
2786 | for (int m = 0; m < count[k]; m++) {
2787 | ret.set(shadow[k][m], mvals.get(k).get(m));
2788 | }
2789 | }
2790 | return ret;
2791 | } catch (Exception e) {
2792 | throw new ClusterOpException(e);
2793 | }
2794 | }
2795 |
2796 | public Long mset(final Map keysvalues) {
2797 | try {
2798 | Long ret = 0L;
2799 | List> mkeysvalues = new ArrayList>(
2800 | partsLen);
2801 | for (int h = 0; h < partsLen; h++) {
2802 | mkeysvalues.add(new HashMap(keysvalues.size()));
2803 | }
2804 | for (Entry keyvalue : keysvalues.entrySet()) {
2805 | int part = hashFunc.hash(keyvalue.getKey());
2806 | mkeysvalues.get(part).put(keyvalue.getKey(),
2807 | keyvalue.getValue());
2808 | }
2809 | for (int i = 0; i < partsLen; i++) {
2810 | Map mkeyvalue = mkeysvalues.get(i);
2811 | if (!mkeyvalue.isEmpty()) {
2812 | String[] mskeyvalue = new String[mkeyvalue.size() * 2];
2813 | int ct = -1;
2814 | for (String key : mkeyvalue.keySet()) {
2815 | mskeyvalue[++ct] = key;
2816 | mskeyvalue[++ct] = mkeyvalue.get(key);
2817 | }
2818 |
2819 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2820 | .getPool(i);
2821 | Jedis jedis = pool.getResource();
2822 | ret += jedis.mset(mskeyvalue).equals("OK") ? mkeyvalue
2823 | .size() : 0;
2824 | pool.returnResource(jedis);
2825 | }
2826 | }
2827 | return ret;
2828 | } catch (Exception e) {
2829 | throw new ClusterOpException(e);
2830 | }
2831 | }
2832 |
2833 | public Long msetnx(final Map keysvalues) {
2834 | try {
2835 | Long ret = 0L;
2836 | List> mkeysvalues = new ArrayList>(
2837 | partsLen);
2838 | for (int h = 0; h < partsLen; h++) {
2839 | mkeysvalues.add(new HashMap(keysvalues.size()));
2840 | }
2841 | for (Entry keyvalue : keysvalues.entrySet()) {
2842 | int part = hashFunc.hash(keyvalue.getKey());
2843 | mkeysvalues.get(part).put(keyvalue.getKey(),
2844 | keyvalue.getValue());
2845 | }
2846 | for (int i = 0; i < partsLen; i++) {
2847 | Map mkeyvalue = mkeysvalues.get(i);
2848 | if (!mkeyvalue.isEmpty()) {
2849 | String[] mskeyvalue = new String[mkeyvalue.size() * 2];
2850 | int ct = -1;
2851 | for (String key : mkeyvalue.keySet()) {
2852 | mskeyvalue[++ct] = key;
2853 | mskeyvalue[++ct] = mkeyvalue.get(key);
2854 | }
2855 |
2856 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2857 | .getPool(i);
2858 | Jedis jedis = pool.getResource();
2859 | ret += jedis.msetnx(mskeyvalue).equals("OK") ? mkeyvalue
2860 | .size() : 0;
2861 | pool.returnResource(jedis);
2862 | }
2863 | }
2864 | return ret;
2865 | } catch (Exception e) {
2866 | throw new ClusterOpException(e);
2867 | }
2868 | }
2869 |
2870 | public Long msetBinary(final Map keysvalues) {
2871 | try {
2872 | Long ret = 0L;
2873 | List> mkeysvalues = new ArrayList>(
2874 | partsLen);
2875 | for (int h = 0; h < partsLen; h++) {
2876 | mkeysvalues.add(new HashMap(keysvalues.size()));
2877 | }
2878 | for (Entry keyvalue : keysvalues.entrySet()) {
2879 | int part = hashFunc.hash(keyvalue.getKey());
2880 | mkeysvalues.get(part).put(keyvalue.getKey(),
2881 | keyvalue.getValue());
2882 | }
2883 | for (int i = 0; i < partsLen; i++) {
2884 | Map mkeyvalue = mkeysvalues.get(i);
2885 | if (!mkeyvalue.isEmpty()) {
2886 | byte[][] mskeyvalue = new byte[mkeyvalue.size() * 2][];
2887 | int ct = -1;
2888 | for (byte[] key : mkeyvalue.keySet()) {
2889 | mskeyvalue[++ct] = key;
2890 | mskeyvalue[++ct] = mkeyvalue.get(key);
2891 | }
2892 |
2893 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2894 | .getPool(i);
2895 | Jedis jedis = pool.getResource();
2896 | ret += jedis.mset(mskeyvalue).equals("OK") ? mkeyvalue
2897 | .size() : 0;
2898 | pool.returnResource(jedis);
2899 | }
2900 | }
2901 | return ret;
2902 | } catch (Exception e) {
2903 | throw new ClusterOpException(e);
2904 | }
2905 | }
2906 |
2907 | /**
2908 | * 清空整个 Redis 服务器的数据(删除所有数据库的所有 key )。
2909 | */
2910 | public void flushAll() {
2911 | try {
2912 | for (int i = 0; i < partsLen; i++) {
2913 | RedisClusterPool pool = (RedisClusterPool) this.poolsObj
2914 | .getPool(i);
2915 | Jedis jedis = pool.getResource();
2916 | jedis.flushAll();
2917 | pool.returnResource(jedis);
2918 | }
2919 | } catch (Exception e) {
2920 | throw new ClusterOpException(e);
2921 | }
2922 | }
2923 |
2924 | }
2925 |
--------------------------------------------------------------------------------