把redis路径添加到系统路径里 redis怎么用到项目里

转载

doscommand 2024-07-01 11:16:39

文章标签 把redis路径添加到系统路径里 redis java jar包 文章分类 Redis 数据库

一.准备要使用的的jar包,我使用了以下jar包，关于json的jar包是方便存储和转换redis用到的值;

把redis路径添加到系统路径里 redis怎么用到项目里_redis

二.编写加载redis是要用到的实例类

1. package com.redis;    
2.     
3. import redis.clients.jedis.ShardedJedis;    
4.     
5. /**   
6.  * @Title: RedisDataSource.java 
7.  * @copyright  
8.  * @Package com.cy.redis 
9.  * @Description: 该接口用于获取redis客户端实例，通过该实例操作redis数据源 
10.  * @author  
11.  * @date 2016-10-21 下午04:22:41 
12.  */    
13. public interface RedisDataSource {    
14.         
15. public abstract ShardedJedis getRedisClient();    
16.         
17. public void returnResource(ShardedJedis shardedJedis);    
18.         
19. public void returnResource(ShardedJedis shardedJedis,boolean broken);    
20.     
21. }

[java] view plain copy

1. package com.redis;    
2.     
3. import org.slf4j.LoggerFactory;    
4. import org.springframework.beans.factory.annotation.Autowired;    
5.     
6. import redis.clients.jedis.ShardedJedis;    
7. import redis.clients.jedis.ShardedJedisPool;    
8.     
9. /**   
10.  * @Title: RedisDataSourceImpl.java 
11.  * @copyright  
12.  * @Package com.cy.redis 
13.  * @Description: 获取redis客户端实例，通过该实例操作redis数据源 
14.  * @author  
15.  * @date 2016-10-21 下午04:22:54 
16.  */    
17. public class RedisDataSourceImpl implements RedisDataSource{    
18.     
19. private static final org.slf4j.Logger log = LoggerFactory.getLogger(RedisDataSourceImpl.class);    
20.         
21. @Autowired    
22. private ShardedJedisPool shardedJedisPool;    
23.         
24. public ShardedJedisPool getShardedJedisPool() {    
25. return shardedJedisPool;    
26.     }    
27.     
28. public void setShardedJedisPool(ShardedJedisPool shardedJedisPool) {    
29. this.shardedJedisPool = shardedJedisPool;    
30.     }    
31.     
32. /** 
33.      * 获取redis客户端 
34.      */    
35. public ShardedJedis getRedisClient() {    
36. try {    
37.             ShardedJedis shardedJedis=shardedJedisPool.getResource();    
38. return shardedJedis;    
39. catch (Exception e) {    
40. "getRedisClient ,error",e);    
41.             e.printStackTrace();    
42.         }    
43. return null;    
44.     }    
45.     
46. /** 
47.      * 将资源返还给pool 
48.      */    
49. @SuppressWarnings("deprecation")    
50. public void returnResource(ShardedJedis shardedJedis) {    
51.         shardedJedisPool.returnResource(shardedJedis);    
52.             
53.     }    
54.     
55. /** 
56.      * 出现异常后返回资源给pool 
57.      */    
58. @SuppressWarnings("deprecation")    
59. public void returnResource(ShardedJedis shardedJedis, boolean broken) {    
60. if(broken){    
61.             shardedJedisPool.returnBrokenResource(shardedJedis);    
62. else{    
63.             shardedJedisPool.returnResource(shardedJedis);    
64.         }    
65.             
66.     }    
67.     
68. }

[java] view plain copy

1. package com.redis;    
2.     
3. import org.slf4j.LoggerFactory;    
4. import org.springframework.beans.factory.annotation.Autowired;    
5.     
6. import redis.clients.jedis.Jedis;    
7. import redis.clients.jedis.JedisShardInfo;    
8. import redis.clients.jedis.ShardedJedis;    
9.     
10. /**   
11.  * @Title: RedisClientTemplate.java 
12.  * @copyright  
13.  * @Package com.cy.redis 
14.  * @Description: 用于操作redis取值、存值操作的工具类 
15.  * @author  
16.  * @date 2016-10-21 下午04:21:59 
17.  */    
18. public class RedisClientTemplate {    
19.         
20. private static final org.slf4j.Logger log=LoggerFactory.getLogger(RedisClientTemplate.class);    
21.         
22. @Autowired    
23. private RedisDataSource redisDataSource;    
24.     
25. public RedisDataSource getRedisDataSource() {    
26. return redisDataSource;    
27.     }    
28.     
29. public void setRedisDataSource(RedisDataSource redisDataSource) {    
30. this.redisDataSource = redisDataSource;    
31.     }    
32.         
33. public void disconnect(){    
34.         ShardedJedis shardedJedis=redisDataSource.getRedisClient();    
35.         shardedJedis.disconnect();    
36.     }    
37.         
38. /** 
39.     * @Description: 在redis里设置单个值 
40.     * @author Mr.chen 
41.     * @date 2016-10-21 下午04:37:06 
42.      */    
43. public String set(String key, String value){    
44. null;    
45.         ShardedJedis shardedJedis=redisDataSource.getRedisClient();    
46. if(shardedJedis==null){    
47. return result;    
48.         }    
49. boolean broken=false;    
50. try {    
51.             result=shardedJedis.set(key, value);    
52. catch (Exception e) {    
53. true;    
54.             e.printStackTrace();    
55. finally{    
56.             redisDataSource.returnResource(shardedJedis, broken);    
57.         }    
58.             
59. return result;    
60.     }    
61.         
62. /** 
63.     * @Description: 获取redis单个值  
64.     * @author Mr.chen 
65.     * @date 2016-10-21 下午04:40:57 
66.      */    
67. public String get(String key) {    
68. null;    
69.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
70. if (shardedJedis == null) {    
71. return result;    
72.         }    
73. boolean broken = false;    
74. try {    
75.             result = shardedJedis.get(key);    
76.     
77. catch (Exception e) {    
78.             log.error(e.getMessage(), e);    
79. true;    
80. finally {    
81.             redisDataSource.returnResource(shardedJedis, broken);    
82.         }    
83. return result;    
84.     }    
85.         
86. /** 
87.     * @Description: 判断redis是否存在key 
88.     * @author Mr.chen 
89.     * @date 2016-10-21 下午04:41:39 
90.      */    
91. public Boolean exists(String key) {    
92. false;    
93.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
94. if (shardedJedis == null) {    
95. return result;    
96.         }    
97. boolean broken = false;    
98. try {    
99.             result = shardedJedis.exists(key);    
100. catch (Exception e) {    
101.             log.error(e.getMessage(), e);    
102. true;    
103. finally {    
104.             redisDataSource.returnResource(shardedJedis, broken);    
105.         }    
106. return result;    
107.     }    
108.         
109. /** 
110.     * @Description: 获取key返回存储值的类型  
111.     * @author Mr.chen 
112.     * @date 2016-10-21 下午04:42:08 
113.      */    
114. public String type(String key) {    
115. null;    
116.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
117. if (shardedJedis == null) {    
118. return result;    
119.         }    
120. boolean broken = false;    
121. try {    
122.             result = shardedJedis.type(key);    
123.     
124. catch (Exception e) {    
125.             log.error(e.getMessage(), e);    
126. true;    
127. finally {    
128.             redisDataSource.returnResource(shardedJedis, broken);    
129.         }    
130. return result;    
131.     }    
132.         
133. /** 
134.     * @Description: 在某段时间后实现 
135.     * @author Mr.chen 
136.     * @date 2016-10-21 下午04:43:25 
137.      */    
138. public Long expire(String key, int seconds) {    
139. null;    
140.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
141. if (shardedJedis == null) {    
142. return result;    
143.         }    
144. boolean broken = false;    
145. try {    
146.             result = shardedJedis.expire(key, seconds);    
147.     
148. catch (Exception e) {    
149.             log.error(e.getMessage(), e);    
150. true;    
151. finally {    
152.             redisDataSource.returnResource(shardedJedis, broken);    
153.         }    
154. return result;    
155.     }    
156.     
157. /** 
158.     * @Description: 在某个时间点失效  
159.     * @author Mr.chen 
160.     * @date 2016-10-21 下午04:43:40 
161.      */    
162. public Long expireAt(String key, long unixTime) {    
163. null;    
164.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
165. if (shardedJedis == null) {    
166. return result;    
167.         }    
168. boolean broken = false;    
169. try {    
170.             result = shardedJedis.expireAt(key, unixTime);    
171.     
172. catch (Exception e) {    
173.             log.error(e.getMessage(), e);    
174. true;    
175. finally {    
176.             redisDataSource.returnResource(shardedJedis, broken);    
177.         }    
178. return result;    
179.     }    
180.     
181. /** 
182.     * @Description: 以秒为单位，返回给定 key 的剩余生存时间 
183.     * @author Mr.chen 
184.     * @date 2016-10-21 下午04:44:00 
185.      */    
186. public Long ttl(String key) {    
187. null;    
188.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
189. if (shardedJedis == null) {    
190. return result;    
191.         }    
192. boolean broken = false;    
193. try {    
194.             result = shardedJedis.ttl(key);    
195.     
196. catch (Exception e) {    
197.             log.error(e.getMessage(), e);    
198. true;    
199. finally {    
200.             redisDataSource.returnResource(shardedJedis, broken);    
201.         }    
202. return result;    
203.     }    
204.     
205. /** 
206.     * @Description: 将 key 的值设为 value ，当且仅当 key 不存在 
207.     * @author Mr.chen 
208.     * @date 2016-10-21 下午04:44:17 
209.      */    
210. public Long setnx(String key, String value) {    
211. null;    
212.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
213. if (shardedJedis == null) {    
214. return result;    
215.         }    
216. boolean broken = false;    
217. try {    
218.             result = shardedJedis.setnx(key, value);    
219. catch (Exception e) {    
220.             log.error(e.getMessage(), e);    
221. true;    
222. finally {    
223.             redisDataSource.returnResource(shardedJedis, broken);    
224.         }    
225. return result;    
226.     }    
227. /** 
228.      * 将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位) 
229.      * @param key 
230.      * @param seconds 
231.      * @param value 
232.      * @return 
233.      */    
234. public String setex(String key, int seconds, String value) {    
235. null;    
236.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
237. if (shardedJedis == null) {    
238. return result;    
239.         }    
240. boolean broken = false;    
241. try {    
242.             result = shardedJedis.setex(key, seconds, value);    
243.     
244. catch (Exception e) {    
245.             log.error(e.getMessage(), e);    
246. true;    
247. finally {    
248.             redisDataSource.returnResource(shardedJedis, broken);    
249.         }    
250. return result;    
251.     }    
252. /** 
253.      * 将 key 所储存的值减去减量 integer  
254.      * @param key 
255.      * @param integer 
256.      * @return 
257.      */    
258. public Long decrBy(String key, long integer) {    
259. null;    
260.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
261. if (shardedJedis == null) {    
262. return result;    
263.         }    
264. boolean broken = false;    
265. try {    
266.             result = shardedJedis.decrBy(key, integer);    
267.     
268. catch (Exception e) {    
269.             log.error(e.getMessage(), e);    
270. true;    
271. finally {    
272.             redisDataSource.returnResource(shardedJedis, broken);    
273.         }    
274. return result;    
275.     }    
276. /** 
277.      * 将 key 中储存的数字值减一。 
278.      * @param key 
279.      * @return 
280.      */    
281. public Long decr(String key) {    
282. null;    
283.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
284. if (shardedJedis == null) {    
285. return result;    
286.         }    
287. boolean broken = false;    
288. try {    
289.             result = shardedJedis.decr(key);    
290.     
291. catch (Exception e) {    
292.             log.error(e.getMessage(), e);    
293. true;    
294. finally {    
295.             redisDataSource.returnResource(shardedJedis, broken);    
296.         }    
297. return result;    
298.     }    
299. /** 
300.      * 将 key 所储存的值加上增量 integer  
301.      * @param key 
302.      * @param integer 
303.      * @return 
304.      */    
305. public Long incrBy(String key, long integer) {    
306. null;    
307.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
308. if (shardedJedis == null) {    
309. return result;    
310.         }    
311. boolean broken = false;    
312. try {    
313.             result = shardedJedis.incrBy(key, integer);    
314.     
315. catch (Exception e) {    
316.             log.error(e.getMessage(), e);    
317. true;    
318. finally {    
319.             redisDataSource.returnResource(shardedJedis, broken);    
320.         }    
321. return result;    
322.     }    
323. /** 
324.      * 将 key 中储存的数字值增一 
325.      * @param key 
326.      * @return 
327.      */    
328. public Long incr(String key) {    
329. null;    
330.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
331. if (shardedJedis == null) {    
332. return result;    
333.         }    
334. boolean broken = false;    
335. try {    
336.             result = shardedJedis.incr(key);    
337.     
338. catch (Exception e) {    
339.             log.error(e.getMessage(), e);    
340. true;    
341. finally {    
342.             redisDataSource.returnResource(shardedJedis, broken);    
343.         }    
344. return result;    
345.     }    
346. /** 
347.      * 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。 
348.      * 如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。 
349.      * @param key 
350.      * @param value 
351.      * @return 
352.      */    
353. public Long append(String key, String value) {    
354. null;    
355.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
356. if (shardedJedis == null) {    
357. return result;    
358.         }    
359. boolean broken = false;    
360. try {    
361.             result = shardedJedis.append(key, value);    
362.     
363. catch (Exception e) {    
364.             log.error(e.getMessage(), e);    
365. true;    
366. finally {    
367.             redisDataSource.returnResource(shardedJedis, broken);    
368.         }    
369. return result;    
370.     }    
371. /** 
372.      * 返回名称为key的string的value的子串 
373.      * @param key 
374.      * @param start 
375.      * @param end 
376.      * @return 
377.      */    
378. public String substr(String key, int start, int end) {    
379. null;    
380.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
381. if (shardedJedis == null) {    
382. return result;    
383.         }    
384. boolean broken = false;    
385. try {    
386.             result = shardedJedis.substr(key, start, end);    
387.     
388. catch (Exception e) {    
389.             log.error(e.getMessage(), e);    
390. true;    
391. finally {    
392.             redisDataSource.returnResource(shardedJedis, broken);    
393.         }    
394. return result;    
395.     }    
396. /** 
397.      * 将哈希表 key 中的域 field 的值设为 value  
398.      * @param key 
399.      * @param field 
400.      * @param value 
401.      * @return 
402.      */    
403. public Long hset(String key, String field, String value) {    
404. null;    
405.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
406. if (shardedJedis == null) {    
407. return result;    
408.         }    
409. boolean broken = false;    
410. try {    
411.             result = shardedJedis.hset(key, field, value);    
412.     
413. catch (Exception e) {    
414.             log.error(e.getMessage(), e);    
415. true;    
416. finally {    
417.             redisDataSource.returnResource(shardedJedis, broken);    
418.         }    
419. return result;    
420.     }    
421. /** 
422.      * 返回哈希表 key 中给定域 field 的值 
423.      * @param key 
424.      * @param field 
425.      * @return 
426.      */    
427. public String hget(String key, String field) {    
428. null;    
429.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
430. if (shardedJedis == null) {    
431. return result;    
432.         }    
433. boolean broken = false;    
434. try {    
435.             result = shardedJedis.hget(key, field);    
436.     
437. catch (Exception e) {    
438.             log.error(e.getMessage(), e);    
439. true;    
440. finally {    
441.             redisDataSource.returnResource(shardedJedis, broken);    
442.         }    
443. return result;    
444.     }    
445. /** 
446.      * 同时将多个 field-value (域-值)对设置到哈希表 key 中。 
447.      * @param key 
448.      * @param hash 
449.      * @return 
450.      */    
451. public String hmset(String key, Map<String, String> hash) {    
452. null;    
453.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
454. if (shardedJedis == null) {    
455. return result;    
456.         }    
457. boolean broken = false;    
458. try {    
459.             result = shardedJedis.hmset(key, hash);    
460.     
461. catch (Exception e) {    
462.             log.error(e.getMessage(), e);    
463. true;    
464. finally {    
465.             redisDataSource.returnResource(shardedJedis, broken);    
466.         }    
467. return result;    
468.     }    
469. /** 
470.      * 返回哈希表 key 中，一个或多个给定域的值 
471.      * @param key 
472.      * @param fields 
473.      * @return 
474.      */    
475. public List<String> hmget(String key, String... fields) {    
476. null;    
477.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
478. if (shardedJedis == null) {    
479. return result;    
480.         }    
481. boolean broken = false;    
482. try {    
483.             result = shardedJedis.hmget(key, fields);    
484.     
485. catch (Exception e) {    
486.             log.error(e.getMessage(), e);    
487. true;    
488. finally {    
489.             redisDataSource.returnResource(shardedJedis, broken);    
490.         }    
491. return result;    
492.     }    
493. /** 
494.      * 为哈希表 key 中的域 field 的值加上增量 value 
495.      * @param key 
496.      * @param field 
497.      * @param value 
498.      * @return 
499.      */    
500. public Long hincrBy(String key, String field, long value) {    
501. null;    
502.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
503. if (shardedJedis == null) {    
504. return result;    
505.         }    
506. boolean broken = false;    
507. try {    
508.             result = shardedJedis.hincrBy(key, field, value);    
509.     
510. catch (Exception e) {    
511.             log.error(e.getMessage(), e);    
512. true;    
513. finally {    
514.             redisDataSource.returnResource(shardedJedis, broken);    
515.         }    
516. return result;    
517.     }    
518. /** 
519.      * 查看哈希表 key 中，给定域 field 是否存在。 
520.      * @param key 
521.      * @param field 
522.      * @return 
523.      */    
524. public Boolean hexists(String key, String field) {    
525. false;    
526.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
527. if (shardedJedis == null) {    
528. return result;    
529.         }    
530. boolean broken = false;    
531. try {    
532.             result = shardedJedis.hexists(key, field);    
533.     
534. catch (Exception e) {    
535.             log.error(e.getMessage(), e);    
536. true;    
537. finally {    
538.             redisDataSource.returnResource(shardedJedis, broken);    
539.         }    
540. return result;    
541.     }    
542. /** 
543.      * 删除key 
544.      * @param key 
545.      * @return 
546.      */    
547. public Long del(String key) {    
548. null;    
549.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
550. if (shardedJedis == null) {    
551. return result;    
552.         }    
553. boolean broken = false;    
554. try {    
555.             result = shardedJedis.del(key);    
556.     
557. catch (Exception e) {    
558.             log.error(e.getMessage(), e);    
559. true;    
560. finally {    
561.             redisDataSource.returnResource(shardedJedis, broken);    
562.         }    
563. return result;    
564.     }    
565. /** 
566.      * 删除哈希表 key 中的一个或多个指定域。 
567.      * @param key 
568.      * @param field 
569.      * @return 
570.      */    
571. public Long hdel(String key, String field) {    
572. null;    
573.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
574. if (shardedJedis == null) {    
575. return result;    
576.         }    
577. boolean broken = false;    
578. try {    
579.             result = shardedJedis.hdel(key, field);    
580.     
581. catch (Exception e) {    
582.             log.error(e.getMessage(), e);    
583. true;    
584. finally {    
585.             redisDataSource.returnResource(shardedJedis, broken);    
586.         }    
587. return result;    
588.     }    
589. /** 
590.      * 返回哈希表 key 中域的数量。 
591.      * @param key 
592.      * @return 
593.      */    
594. public Long hlen(String key) {    
595. null;    
596.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
597. if (shardedJedis == null) {    
598. return result;    
599.         }    
600. boolean broken = false;    
601. try {    
602.             result = shardedJedis.hlen(key);    
603.     
604. catch (Exception e) {    
605.             log.error(e.getMessage(), e);    
606. true;    
607. finally {    
608.             redisDataSource.returnResource(shardedJedis, broken);    
609.         }    
610. return result;    
611.     }    
612. /** 
613.      * 返回哈希表 key 中的所有域。 
614.      * @param key 
615.      * @return 
616.      */    
617. public Set<String> hkeys(String key) {    
618. null;    
619.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
620. if (shardedJedis == null) {    
621. return result;    
622.         }    
623. boolean broken = false;    
624. try {    
625.             result = shardedJedis.hkeys(key);    
626.     
627. catch (Exception e) {    
628.             log.error(e.getMessage(), e);    
629. true;    
630. finally {    
631.             redisDataSource.returnResource(shardedJedis, broken);    
632.         }    
633. return result;    
634.     }    
635. /** 
636.      * 返回哈希表 key 中所有域的值。 
637.      * @param key 
638.      * @return 
639.      */    
640. public List<String> hvals(String key) {    
641. null;    
642.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
643. if (shardedJedis == null) {    
644. return result;    
645.         }    
646. boolean broken = false;    
647. try {    
648.             result = shardedJedis.hvals(key);    
649.     
650. catch (Exception e) {    
651.             log.error(e.getMessage(), e);    
652. true;    
653. finally {    
654.             redisDataSource.returnResource(shardedJedis, broken);    
655.         }    
656. return result;    
657.     }    
658. /** 
659.       * 返回哈希表 key 中，所有的域和值。 
660.       * @param key 
661.       * @return 
662.       */    
663. public Map<String, String> hgetAll(String key) {    
664. null;    
665.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
666. if (shardedJedis == null) {    
667. return result;    
668.         }    
669. boolean broken = false;    
670. try {    
671.             result = shardedJedis.hgetAll(key);    
672.     
673. catch (Exception e) {    
674.             log.error(e.getMessage(), e);    
675. true;    
676. finally {    
677.             redisDataSource.returnResource(shardedJedis, broken);    
678.         }    
679. return result;    
680.     }    
681.     
682. // ================list ====== l表示 list或 left, r表示right====================    
683. /** 
684.      * 将一个或多个值 value 插入到列表 key 的表尾(最右边) 
685.      * @param key 
686.      * @param string 
687.      * @return 
688.      */    
689. public Long rpush(String key, String string) {    
690. null;    
691.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
692. if (shardedJedis == null) {    
693. return result;    
694.         }    
695. boolean broken = false;    
696. try {    
697.             result = shardedJedis.rpush(key, string);    
698.     
699. catch (Exception e) {    
700.             log.error(e.getMessage(), e);    
701. true;    
702. finally {    
703.             redisDataSource.returnResource(shardedJedis, broken);    
704.         }    
705. return result;    
706.     }    
707. /** 
708.      * 将一个或多个值 value 插入到列表 key 的表头 
709.      * @param key 
710.      * @param string 
711.      * @return 
712.      */    
713. public Long lpush(String key, String string) {    
714. null;    
715.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
716. if (shardedJedis == null) {    
717. return result;    
718.         }    
719. boolean broken = false;    
720. try {    
721.             result = shardedJedis.lpush(key, string);    
722.     
723. catch (Exception e) {    
724.             log.error(e.getMessage(), e);    
725. true;    
726. finally {    
727.             redisDataSource.returnResource(shardedJedis, broken);    
728.         }    
729. return result;    
730.     }    
731. /** 
732.      * 返回列表 key 的长度。 
733.      * @param key 
734.      * @return 
735.      */    
736. public Long llen(String key) {    
737. null;    
738.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
739. if (shardedJedis == null) {    
740. return result;    
741.         }    
742. boolean broken = false;    
743. try {    
744.             result = shardedJedis.llen(key);    
745.     
746. catch (Exception e) {    
747.             log.error(e.getMessage(), e);    
748. true;    
749. finally {    
750.             redisDataSource.returnResource(shardedJedis, broken);    
751.         }    
752. return result;    
753.     }    
754. /** 
755.       * 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定 
756.       * @param key 
757.       * @param start 
758.       * @param end 
759.       * @return 
760.       */    
761. public List<String> lrange(String key, long start, long end) {    
762. null;    
763.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
764. if (shardedJedis == null) {    
765. return result;    
766.         }    
767. boolean broken = false;    
768. try {    
769.             result = shardedJedis.lrange(key, start, end);    
770.     
771. catch (Exception e) {    
772.             log.error(e.getMessage(), e);    
773. true;    
774. finally {    
775.             redisDataSource.returnResource(shardedJedis, broken);    
776.         }    
777. return result;    
778.     }    
779. /** 
780.      * 只保留指定区间内的元素，不在指定区间之内的元素都将被删除 
781.      * @param key 
782.      * @param start 
783.      * @param end 
784.      * @return 
785.      */    
786. public String ltrim(String key, long start, long end) {    
787. null;    
788.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
789. if (shardedJedis == null) {    
790. return result;    
791.         }    
792. boolean broken = false;    
793. try {    
794.             result = shardedJedis.ltrim(key, start, end);    
795.     
796. catch (Exception e) {    
797.             log.error(e.getMessage(), e);    
798. true;    
799. finally {    
800.             redisDataSource.returnResource(shardedJedis, broken);    
801.         }    
802. return result;    
803.     }    
804. /** 
805.      * 返回列表 key 中，下标为 index 的元素。 
806.      * @param key 
807.      * @param index 
808.      * @return 
809.      */    
810. public String lindex(String key, long index) {    
811. null;    
812.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
813. if (shardedJedis == null) {    
814. return result;    
815.         }    
816. boolean broken = false;    
817. try {    
818.             result = shardedJedis.lindex(key, index);    
819.     
820. catch (Exception e) {    
821.             log.error(e.getMessage(), e);    
822. true;    
823. finally {    
824.             redisDataSource.returnResource(shardedJedis, broken);    
825.         }    
826. return result;    
827.     }    
828. /** 
829.      * 将列表 key 下标为 index 的元素的值设置为 value 
830.      * @param key 
831.      * @param index 
832.      * @param value 
833.      * @return 
834.      */    
835. public String lset(String key, long index, String value) {    
836. null;    
837.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
838. if (shardedJedis == null) {    
839. return result;    
840.         }    
841. boolean broken = false;    
842. try {    
843.             result = shardedJedis.lset(key, index, value);    
844.     
845. catch (Exception e) {    
846.             log.error(e.getMessage(), e);    
847. true;    
848. finally {    
849.             redisDataSource.returnResource(shardedJedis, broken);    
850.         }    
851. return result;    
852.     }    
853.     
854. /** 
855.    * 移除并返回列表 key 的头元素 
856.    * @param key 
857.    * @return 
858.    */    
859. public String lpop(String key) {    
860. null;    
861.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
862. if (shardedJedis == null) {    
863. return result;    
864.         }    
865. boolean broken = false;    
866. try {    
867.             result = shardedJedis.lpop(key);    
868.     
869. catch (Exception e) {    
870.             log.error(e.getMessage(), e);    
871. true;    
872. finally {    
873.             redisDataSource.returnResource(shardedJedis, broken);    
874.         }    
875. return result;    
876.     }    
877. /** 
878.      * 移除并返回列表 key 的尾元素。 
879.      * @param key 
880.      * @return 
881.      */    
882. public String rpop(String key) {    
883. null;    
884.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
885. if (shardedJedis == null) {    
886. return result;    
887.         }    
888. boolean broken = false;    
889. try {    
890.             result = shardedJedis.rpop(key);    
891.     
892. catch (Exception e) {    
893.             log.error(e.getMessage(), e);    
894. true;    
895. finally {    
896.             redisDataSource.returnResource(shardedJedis, broken);    
897.         }    
898. return result;    
899.     }    
900.     
901. //return 1 add a not exist value ,    
902. //return 0 add a exist value    
903. /** 
904.      * 将一个或多个 member 元素加入到集合 key 当中 
905.      * @param key 
906.      * @param member 
907.      * @return 
908.      */    
909. public Long sadd(String key, String member) {    
910. null;    
911.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
912. if (shardedJedis == null) {    
913. return result;    
914.         }    
915. boolean broken = false;    
916. try {    
917.             result = shardedJedis.sadd(key, member);    
918.     
919. catch (Exception e) {    
920.             log.error(e.getMessage(), e);    
921. true;    
922. finally {    
923.             redisDataSource.returnResource(shardedJedis, broken);    
924.         }    
925. return result;    
926.     }    
927. /** 
928.      * 返回集合 key 中的所有成员。 
929.      * @param key 
930.      * @return 
931.      */    
932. public Set<String> smembers(String key) {    
933. null;    
934.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
935. if (shardedJedis == null) {    
936. return result;    
937.         }    
938. boolean broken = false;    
939. try {    
940.             result = shardedJedis.smembers(key);    
941.     
942. catch (Exception e) {    
943.             log.error(e.getMessage(), e);    
944. true;    
945. finally {    
946.             redisDataSource.returnResource(shardedJedis, broken);    
947.         }    
948. return result;    
949.     }    
950.     
951. /** 
952.      * 返回集合 key 的基数(集合中元素的数量) 
953.      * @param key 
954.      * @return 
955.      */    
956. public Long scard(String key) {    
957.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
958. null;    
959. if (shardedJedis == null) {    
960. return result;    
961.         }    
962. boolean broken = false;    
963. try {    
964.             result = shardedJedis.scard(key);    
965.     
966. catch (Exception e) {    
967.             log.error(e.getMessage(), e);    
968. true;    
969. finally {    
970.             redisDataSource.returnResource(shardedJedis, broken);    
971.         }    
972. return result;    
973.     }    
974. /** 
975.      * 将一个或多个 member 元素及其 score 值加入到有序集 key 当中 
976.      * @param key 
977.      * @param score 
978.      * @param member 
979.      * @return 
980.      */    
981. public Long zadd(String key, double score, String member) {    
982. null;    
983.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
984. if (shardedJedis == null) {    
985. return result;    
986.         }    
987. boolean broken = false;    
988. try {    
989.             result = shardedJedis.zadd(key, score, member);    
990. catch (Exception e) {    
991.             log.error(e.getMessage(), e);    
992. true;    
993. finally {    
994.             redisDataSource.returnResource(shardedJedis, broken);    
995.         }    
996. return result;    
997.     }    
998. /** 
999.      * 返回有序集 key 中，指定区间内的成员 
1000.      * @param key 
1001.      * @param start 
1002.      * @param end 
1003.      * @return 
1004.      */    
1005. public Set<String> zrange(String key, int start, int end) {    
1006. null;    
1007.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1008. if (shardedJedis == null) {    
1009. return result;    
1010.         }    
1011. boolean broken = false;    
1012. try {    
1013.             result = shardedJedis.zrange(key, start, end);    
1014. catch (Exception e) {    
1015.             log.error(e.getMessage(), e);    
1016. true;    
1017. finally {    
1018.             redisDataSource.returnResource(shardedJedis, broken);    
1019.         }    
1020. return result;    
1021.     }    
1022. /** 
1023.      * 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略 
1024.      * @param key 
1025.      * @param member 
1026.      * @return 
1027.      */    
1028. public Long zrem(String key, String member) {    
1029. null;    
1030.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1031. if (shardedJedis == null) {    
1032. return result;    
1033.         }    
1034. boolean broken = false;    
1035. try {    
1036.             result = shardedJedis.zrem(key, member);    
1037. catch (Exception e) {    
1038.             log.error(e.getMessage(), e);    
1039. true;    
1040. finally {    
1041.             redisDataSource.returnResource(shardedJedis, broken);    
1042.         }    
1043. return result;    
1044.     }    
1045. /** 
1046.      * 为有序集 key 的成员 member 的 score 值加上增量 member 。 
1047.      * @param key 
1048.      * @param score 
1049.      * @param member 
1050.      * @return 
1051.      */    
1052. public Double zincrby(String key, double score, String member) {    
1053. null;    
1054.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1055. if (shardedJedis == null) {    
1056. return result;    
1057.         }    
1058. boolean broken = false;    
1059. try {    
1060.     
1061.             result = shardedJedis.zincrby(key, score, member);    
1062.     
1063. catch (Exception e) {    
1064.             log.error(e.getMessage(), e);    
1065. true;    
1066. finally {    
1067.             redisDataSource.returnResource(shardedJedis, broken);    
1068.         }    
1069. return result;    
1070.     }    
1071. /** 
1072.      * 回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列 
1073.      * @param key 
1074.      * @param member 
1075.      * @return 
1076.      */    
1077. public Long zrank(String key, String member) {    
1078. null;    
1079.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1080. if (shardedJedis == null) {    
1081. return result;    
1082.         }    
1083. boolean broken = false;    
1084. try {    
1085.     
1086.             result = shardedJedis.zrank(key, member);    
1087.     
1088. catch (Exception e) {    
1089.             log.error(e.getMessage(), e);    
1090. true;    
1091. finally {    
1092.             redisDataSource.returnResource(shardedJedis, broken);    
1093.         }    
1094. return result;    
1095.     }    
1096. /** 
1097.      * 返回有序集 key 的基数 
1098.      * @param key 
1099.      * @return 
1100.      */    
1101. public Long zcard(String key) {    
1102. null;    
1103.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1104. if (shardedJedis == null) {    
1105. return result;    
1106.         }    
1107. boolean broken = false;    
1108. try {    
1109.     
1110.             result = shardedJedis.zcard(key);    
1111.     
1112. catch (Exception e) {    
1113.             log.error(e.getMessage(), e);    
1114. true;    
1115. finally {    
1116.             redisDataSource.returnResource(shardedJedis, broken);    
1117.         }    
1118. return result;    
1119.     }    
1120. /** 
1121.      * 返回有序集 key 中，成员 member 的 score 值。 
1122.      * @param key 
1123.      * @param member 
1124.      * @return 
1125.      */    
1126. public Double zscore(String key, String member) {    
1127. null;    
1128.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1129. if (shardedJedis == null) {    
1130. return result;    
1131.         }    
1132. boolean broken = false;    
1133. try {    
1134.     
1135.             result = shardedJedis.zscore(key, member);    
1136.     
1137. catch (Exception e) {    
1138.             log.error(e.getMessage(), e);    
1139. true;    
1140. finally {    
1141.             redisDataSource.returnResource(shardedJedis, broken);    
1142.         }    
1143. return result;    
1144.     }    
1145.     
1146. /** 
1147.     * 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量 
1148.     * @param key 
1149.     * @param min 
1150.     * @param max 
1151.     * @return 
1152.     */    
1153. public Long zcount(String key, double min, double max) {    
1154. null;    
1155.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1156. if (shardedJedis == null) {    
1157. return result;    
1158.         }    
1159. boolean broken = false;    
1160. try {    
1161.     
1162.             result = shardedJedis.zcount(key, min, max);    
1163.     
1164. catch (Exception e) {    
1165.             log.error(e.getMessage(), e);    
1166. true;    
1167. finally {    
1168.             redisDataSource.returnResource(shardedJedis, broken);    
1169.         }    
1170. return result;    
1171.     }    
1172.     
1173. /** 
1174.      * 批量存储 
1175.      * @param key 
1176.      * @param value 
1177.      * @return 
1178.      */    
1179. public String set(byte[] key, byte[] value) {    
1180. null;    
1181.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1182. if (shardedJedis == null) {    
1183. return result;    
1184.         }    
1185. boolean broken = false;    
1186. try {    
1187.     
1188.             result = shardedJedis.set(key, value);    
1189.     
1190. catch (Exception e) {    
1191.             log.error(e.getMessage(), e);    
1192. true;    
1193. finally {    
1194.             redisDataSource.returnResource(shardedJedis, broken);    
1195.         }    
1196. return result;    
1197.     }    
1198. /** 
1199.      * 获取多个key的值 
1200.      * @param key 
1201.      * @return 
1202.      */    
1203. public byte[] get(byte[] key) {    
1204. byte[] result = null;    
1205.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1206. if (shardedJedis == null) {    
1207. return result;    
1208.         }    
1209. boolean broken = false;    
1210. try {    
1211.     
1212.             result = shardedJedis.get(key);    
1213.     
1214. catch (Exception e) {    
1215.             log.error(e.getMessage(), e);    
1216. true;    
1217. finally {    
1218.             redisDataSource.returnResource(shardedJedis, broken);    
1219.         }    
1220. return result;    
1221.     }    
1222. /** 
1223.      * 判断多个key存在 
1224.      * @param key 
1225.      * @return 
1226.      */    
1227. public Boolean exists(byte[] key) {    
1228. false;    
1229.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1230. if (shardedJedis == null) {    
1231. return result;    
1232.         }    
1233. boolean broken = false;    
1234. try {    
1235.     
1236.             result = shardedJedis.exists(key);    
1237.     
1238. catch (Exception e) {    
1239.             log.error(e.getMessage(), e);    
1240. true;    
1241. finally {    
1242.             redisDataSource.returnResource(shardedJedis, broken);    
1243.         }    
1244. return result;    
1245.     }    
1246.     
1247. public Long expire(byte[] key, int seconds) {    
1248. null;    
1249.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1250. if (shardedJedis == null) {    
1251. return result;    
1252.         }    
1253. boolean broken = false;    
1254. try {    
1255.     
1256.             result = shardedJedis.expire(key, seconds);    
1257.     
1258. catch (Exception e) {    
1259.             log.error(e.getMessage(), e);    
1260. true;    
1261. finally {    
1262.             redisDataSource.returnResource(shardedJedis, broken);    
1263.         }    
1264. return result;    
1265.     }    
1266.     
1267. public Long expireAt(byte[] key, long unixTime) {    
1268. null;    
1269.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1270. if (shardedJedis == null) {    
1271. return result;    
1272.         }    
1273. boolean broken = false;    
1274. try {    
1275.     
1276.             result = shardedJedis.expireAt(key, unixTime);    
1277.     
1278. catch (Exception e) {    
1279.             log.error(e.getMessage(), e);    
1280. true;    
1281. finally {    
1282.             redisDataSource.returnResource(shardedJedis, broken);    
1283.         }    
1284. return result;    
1285.     }    
1286.     
1287. public Long ttl(byte[] key) {    
1288. null;    
1289.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1290. if (shardedJedis == null) {    
1291. return result;    
1292.         }    
1293. boolean broken = false;    
1294. try {    
1295.     
1296.             result = shardedJedis.ttl(key);    
1297.     
1298. catch (Exception e) {    
1299.             log.error(e.getMessage(), e);    
1300. true;    
1301. finally {    
1302.             redisDataSource.returnResource(shardedJedis, broken);    
1303.         }    
1304. return result;    
1305.     }    
1306.     
1307. public Long append(byte[] key, byte[] value) {    
1308. null;    
1309.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1310. if (shardedJedis == null) {    
1311. return result;    
1312.         }    
1313. boolean broken = false;    
1314. try {    
1315.     
1316.             result = shardedJedis.append(key, value);    
1317.     
1318. catch (Exception e) {    
1319.             log.error(e.getMessage(), e);    
1320. true;    
1321. finally {    
1322.             redisDataSource.returnResource(shardedJedis, broken);    
1323.         }    
1324. return result;    
1325.     }    
1326.     
1327. /** 
1328.     * 批量增加到hash 
1329.     * @param key 
1330.     * @param field 
1331.     * @param value 
1332.     * @return 
1333.     */    
1334. public Long hset(byte[] key, byte[] field, byte[] value) {    
1335. null;    
1336.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1337. if (shardedJedis == null) {    
1338. return result;    
1339.         }    
1340. boolean broken = false;    
1341. try {    
1342.     
1343.             result = shardedJedis.hset(key, field, value);    
1344.     
1345. catch (Exception e) {    
1346.             log.error(e.getMessage(), e);    
1347. true;    
1348. finally {    
1349.             redisDataSource.returnResource(shardedJedis, broken);    
1350.         }    
1351. return result;    
1352.     }    
1353. /** 
1354.      * 批量获取field域值 
1355.      * @param key 
1356.      * @param field 
1357.      * @return 
1358.      */    
1359. public byte[] hget(byte[] key, byte[] field) {    
1360. byte[] result = null;    
1361.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1362. if (shardedJedis == null) {    
1363. return result;    
1364.         }    
1365. boolean broken = false;    
1366. try {    
1367.     
1368.             result = shardedJedis.hget(key, field);    
1369.     
1370. catch (Exception e) {    
1371.             log.error(e.getMessage(), e);    
1372. true;    
1373. finally {    
1374.             redisDataSource.returnResource(shardedJedis, broken);    
1375.         }    
1376. return result;    
1377.     }    
1378.     
1379. public String hmset(byte[] key, Map<byte[], byte[]> hash) {    
1380. null;    
1381.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1382. if (shardedJedis == null) {    
1383. return result;    
1384.         }    
1385. boolean broken = false;    
1386. try {    
1387.     
1388.             result = shardedJedis.hmset(key, hash);    
1389.     
1390. catch (Exception e) {    
1391.     
1392.             log.error(e.getMessage(), e);    
1393. true;    
1394. finally {    
1395.             redisDataSource.returnResource(shardedJedis, broken);    
1396.         }    
1397. return result;    
1398.     }    
1399.     
1400. public List<byte[]> hmget(byte[] key, byte[]... fields) {    
1401. byte[]> result = null;    
1402.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1403. if (shardedJedis == null) {    
1404. return result;    
1405.         }    
1406. boolean broken = false;    
1407. try {    
1408.     
1409.             result = shardedJedis.hmget(key, fields);    
1410.     
1411. catch (Exception e) {    
1412.     
1413.             log.error(e.getMessage(), e);    
1414. true;    
1415. finally {    
1416.             redisDataSource.returnResource(shardedJedis, broken);    
1417.         }    
1418. return result;    
1419.     }    
1420.     
1421.         
1422. public Boolean hexists(byte[] key, byte[] field) {    
1423. false;    
1424.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1425. if (shardedJedis == null) {    
1426. return result;    
1427.         }    
1428. boolean broken = false;    
1429. try {    
1430.     
1431.             result = shardedJedis.hexists(key, field);    
1432.     
1433. catch (Exception e) {    
1434.     
1435.             log.error(e.getMessage(), e);    
1436. true;    
1437. finally {    
1438.             redisDataSource.returnResource(shardedJedis, broken);    
1439.         }    
1440. return result;    
1441.     }    
1442. /** 
1443.      * 批量删除hash的key 
1444.      * @param key 
1445.      * @param field 
1446.      * @return 
1447.      */    
1448. public Long hdel(byte[] key, byte[] field) {    
1449. null;    
1450.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1451. if (shardedJedis == null) {    
1452. return result;    
1453.         }    
1454. boolean broken = false;    
1455. try {    
1456.     
1457.             result = shardedJedis.hdel(key, field);    
1458.     
1459. catch (Exception e) {    
1460.     
1461.             log.error(e.getMessage(), e);    
1462. true;    
1463. finally {    
1464.             redisDataSource.returnResource(shardedJedis, broken);    
1465.         }    
1466. return result;    
1467.     }    
1468. public Long rpush(byte[] key, byte[] string) {    
1469. null;    
1470.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1471. if (shardedJedis == null) {    
1472. return result;    
1473.         }    
1474. boolean broken = false;    
1475. try {    
1476.     
1477.             result = shardedJedis.rpush(key, string);    
1478.     
1479. catch (Exception e) {    
1480.     
1481.             log.error(e.getMessage(), e);    
1482. true;    
1483. finally {    
1484.             redisDataSource.returnResource(shardedJedis, broken);    
1485.         }    
1486. return result;    
1487.     }    
1488.     
1489. public Long lpush(byte[] key, byte[] string) {    
1490. null;    
1491.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1492. if (shardedJedis == null) {    
1493. return result;    
1494.         }    
1495. boolean broken = false;    
1496. try {    
1497.     
1498.             result = shardedJedis.lpush(key, string);    
1499.     
1500. catch (Exception e) {    
1501.     
1502.             log.error(e.getMessage(), e);    
1503. true;    
1504. finally {    
1505.             redisDataSource.returnResource(shardedJedis, broken);    
1506.         }    
1507. return result;    
1508.     }    
1509.     
1510. public Long llen(byte[] key) {    
1511. null;    
1512.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1513. if (shardedJedis == null) {    
1514. return result;    
1515.         }    
1516. boolean broken = false;    
1517. try {    
1518.     
1519.             result = shardedJedis.llen(key);    
1520.     
1521. catch (Exception e) {    
1522.     
1523.             log.error(e.getMessage(), e);    
1524. true;    
1525. finally {    
1526.             redisDataSource.returnResource(shardedJedis, broken);    
1527.         }    
1528. return result;    
1529.     }    
1530.     
1531. public List<byte[]> lrange(byte[] key, int start, int end) {    
1532. byte[]> result = null;    
1533.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1534. if (shardedJedis == null) {    
1535. return result;    
1536.         }    
1537. boolean broken = false;    
1538. try {    
1539.     
1540.             result = shardedJedis.lrange(key, start, end);    
1541.     
1542. catch (Exception e) {    
1543.     
1544.             log.error(e.getMessage(), e);    
1545. true;    
1546. finally {    
1547.             redisDataSource.returnResource(shardedJedis, broken);    
1548.         }    
1549. return result;    
1550.     }    
1551.     
1552.        
1553. public String lset(byte[] key, int index, byte[] value) {    
1554. null;    
1555.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1556. if (shardedJedis == null) {    
1557. return result;    
1558.         }    
1559. boolean broken = false;    
1560. try {    
1561.     
1562.             result = shardedJedis.lset(key, index, value);    
1563.     
1564. catch (Exception e) {    
1565.     
1566.             log.error(e.getMessage(), e);    
1567. true;    
1568. finally {    
1569.             redisDataSource.returnResource(shardedJedis, broken);    
1570.         }    
1571. return result;    
1572.     }    
1573. public Long lrem(byte[] key, int count, byte[] value) {    
1574. null;    
1575.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1576. if (shardedJedis == null) {    
1577. return result;    
1578.         }    
1579. boolean broken = false;    
1580. try {    
1581.     
1582.             result = shardedJedis.lrem(key, count, value);    
1583.     
1584. catch (Exception e) {    
1585.     
1586.             log.error(e.getMessage(), e);    
1587. true;    
1588. finally {    
1589.             redisDataSource.returnResource(shardedJedis, broken);    
1590.         }    
1591. return result;    
1592.     }    
1593.     
1594. public byte[] lpop(byte[] key) {    
1595. byte[] result = null;    
1596.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1597. if (shardedJedis == null) {    
1598. return result;    
1599.         }    
1600. boolean broken = false;    
1601. try {    
1602.     
1603.             result = shardedJedis.lpop(key);    
1604.     
1605. catch (Exception e) {    
1606.     
1607.             log.error(e.getMessage(), e);    
1608. true;    
1609. finally {    
1610.             redisDataSource.returnResource(shardedJedis, broken);    
1611.         }    
1612. return result;    
1613.     }    
1614.     
1615. public byte[] rpop(byte[] key) {    
1616. byte[] result = null;    
1617.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1618. if (shardedJedis == null) {    
1619. return result;    
1620.         }    
1621. boolean broken = false;    
1622. try {    
1623.     
1624.             result = shardedJedis.rpop(key);    
1625.     
1626. catch (Exception e) {    
1627.     
1628.             log.error(e.getMessage(), e);    
1629. true;    
1630. finally {    
1631.             redisDataSource.returnResource(shardedJedis, broken);    
1632.         }    
1633. return result;    
1634.     }    
1635. /** 
1636.    *   批量增加到set 
1637.    * @param key 
1638.    * @param member 
1639.    * @return 
1640.    */    
1641. public Long sadd(byte[] key, byte[] member) {    
1642. null;    
1643.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1644. if (shardedJedis == null) {    
1645. return result;    
1646.         }    
1647. boolean broken = false;    
1648. try {    
1649.     
1650.             result = shardedJedis.sadd(key, member);    
1651.     
1652. catch (Exception e) {    
1653.     
1654.             log.error(e.getMessage(), e);    
1655. true;    
1656. finally {    
1657.             redisDataSource.returnResource(shardedJedis, broken);    
1658.         }    
1659. return result;    
1660.     }    
1661.     
1662. public Set<byte[]> smembers(byte[] key) {    
1663. byte[]> result = null;    
1664.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1665. if (shardedJedis == null) {    
1666. return result;    
1667.         }    
1668. boolean broken = false;    
1669. try {    
1670.     
1671.             result = shardedJedis.smembers(key);    
1672.     
1673. catch (Exception e) {    
1674.     
1675.             log.error(e.getMessage(), e);    
1676. true;    
1677. finally {    
1678.             redisDataSource.returnResource(shardedJedis, broken);    
1679.         }    
1680. return result;    
1681.     }    
1682.     
1683. public Long scard(byte[] key) {    
1684. null;    
1685.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1686. if (shardedJedis == null) {    
1687. return result;    
1688.         }    
1689. boolean broken = false;    
1690. try {    
1691.     
1692.             result = shardedJedis.scard(key);    
1693.     
1694. catch (Exception e) {    
1695.     
1696.             log.error(e.getMessage(), e);    
1697. true;    
1698. finally {    
1699.             redisDataSource.returnResource(shardedJedis, broken);    
1700.         }    
1701. return result;    
1702.     }    
1703.     
1704. public Long zadd(byte[] key, double score, byte[] member) {    
1705. null;    
1706.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1707. if (shardedJedis == null) {    
1708. return result;    
1709.         }    
1710. boolean broken = false;    
1711. try {    
1712.     
1713.             result = shardedJedis.zadd(key, score, member);    
1714.     
1715. catch (Exception e) {    
1716.     
1717.             log.error(e.getMessage(), e);    
1718. true;    
1719. finally {    
1720.             redisDataSource.returnResource(shardedJedis, broken);    
1721.         }    
1722. return result;    
1723.     }    
1724.     
1725.        
1726. public Long zcard(byte[] key) {    
1727. null;    
1728.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1729. if (shardedJedis == null) {    
1730. return result;    
1731.         }    
1732. boolean broken = false;    
1733. try {    
1734.     
1735.             result = shardedJedis.zcard(key);    
1736.     
1737. catch (Exception e) {    
1738.     
1739.             log.error(e.getMessage(), e);    
1740. true;    
1741. finally {    
1742.             redisDataSource.returnResource(shardedJedis, broken);    
1743.         }    
1744. return result;    
1745.     }    
1746.     
1747. public JedisShardInfo getShardInfo(String key) {    
1748.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1749. null;    
1750. if (shardedJedis == null) {    
1751. return result;    
1752.         }    
1753. boolean broken = false;    
1754. try {    
1755.             result = shardedJedis.getShardInfo(key);    
1756. catch (Exception e) {    
1757.             log.error(e.getMessage(), e);    
1758. true;    
1759. finally {    
1760.             redisDataSource.returnResource(shardedJedis, broken);    
1761.         }    
1762. return result;    
1763.     }    
1764.     
1765. public Collection<JedisShardInfo> getAllShardInfo() {    
1766.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1767. null;    
1768. if (shardedJedis == null) {    
1769. return result;    
1770.         }    
1771. boolean broken = false;    
1772. try {    
1773.             result = shardedJedis.getAllShardInfo();    
1774.     
1775. catch (Exception e) {    
1776.             log.error(e.getMessage(), e);    
1777. true;    
1778. finally {    
1779.             redisDataSource.returnResource(shardedJedis, broken);    
1780.         }    
1781. return result;    
1782.     }    
1783.     
1784. public Collection<Jedis> getAllShards() {    
1785.         ShardedJedis shardedJedis = redisDataSource.getRedisClient();    
1786. null;    
1787. if (shardedJedis == null) {    
1788. return result;    
1789.         }    
1790. boolean broken = false;    
1791. try {    
1792.             result = shardedJedis.getAllShards();    
1793.     
1794. catch (Exception e) {    
1795.             log.error(e.getMessage(), e);    
1796. true;    
1797. finally {    
1798.             redisDataSource.returnResource(shardedJedis, broken);    
1799.         }    
1800. return result;    
1801.     }    
1802.     
1803. }

三.配置spring xml文件

[java] view plain copy

1. <beans xmlns="http://www.springframework.org/schema/beans"    
2. "http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"    
3. "http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"    
4.     xsi:schemaLocation="    
5. //www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd    
6. //www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd    
7. //www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">    
8.       
9.         
10. "jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">    
11. "maxTotal" value="2048" />      
12. "maxIdle" value="200" />      
13. "numTestsPerEvictionRun" value="1024"/>      
14. "timeBetweenEvictionRunsMillis" value="30000" />      
15. "minEvictableIdleTimeMillis" value="-1" />      
16. "softMinEvictableIdleTimeMillis" value="10000" />      
17. "maxWaitMillis" value="1500"/>      
18. "testOnBorrow" value="true" />      
19. "testWhileIdle" value="true"/>      
20. "testOnReturn" value="false"/>      
21. "jmxEnabled" value="true"/>      
22. "blockWhenExhausted" value="false"/>     
23.     </bean>    
24.     
25. "shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">    
26. "0" ref="jedisPoolConfig" />    
27. "1">    
28.             <list>    
29. class="redis.clients.jedis.JedisShardInfo">    
30. "host" value="127.0.0.1" />    
31. "port" value="6379" />    
32. "timeout" value="10000" />    
33.                 </bean>    
34.             </list>    
35.         </constructor-arg>    
36.     </bean>    
37. "redisDataSource" class="redis.dao.RedisDataSourceImpl">    
38. "shardedJedisPool" ref="shardedJedisPool"></property>    
39.     </bean>    
40. "redisClientTemplate" class="redis.dao.RedisClientTemplate">    
41. "redisDataSource" ref="redisDataSource"></property>    
42.     </bean>    
43. </beans>

四.代码中的使用，原则就是在执行service时，先通过key到redis里检测是否存在，如果存在则在

redis里去数据,如果没有则到数据库去数据,然后存到redis里

[java] view plain copy

1. public class StudentinfoServiceImpl implements StudentinfoService{    
2.         
3. private StudentinfoDao studentinfoDao;    
4.         
5. private RedisClientTemplate redisClientTemplate;    
6.         
7. private static final ObjectMapper mapper=new ObjectMapper();    
8.         
9. public List<Studentinfo> getStudentinfoByStu(Studentinfo stu) {    
10. "getStudentinfoByStu:usernumber:"+stu.getUsernumber()+":name:"+stu.getName()+":idnumber:"+stu.getIdnumber();    
11. try {    
12. boolean flag=redisClientTemplate.exists(key);    
13. if(flag){    
14.                 String stuJsonStr=redisClientTemplate.get(key);    
15. new TypeReference<List<Studentinfo>>() {});    
16. return list;    
17.             }    
18. catch (Exception e) {    
19.             e.printStackTrace();    
20.         }    
21. "from Studentinfo where 1=1";    
22. if(stu!=null){    
23. if(stu.getUsernumber()!=null){    
24. " and usernumber like '%"+stu.getUsernumber()+"%' ";    
25.             }    
26.         }    
27.         List<Studentinfo> list = studentinfoDao.getStudentinfoByStu(hql);    
28. try {    
29.             String stuJsonStr=mapper.writeValueAsString(list);    
30. 60, stuJsonStr);    
31. catch (Exception e) {    
32.             e.printStackTrace();    
33.         }    
34. return list;    
35.     }    
36.         
37.     
38. public StudentinfoDao getStudentinfoDao() {    
39. return studentinfoDao;    
40.             
41.     }    
42.     
43. public void setStudentinfoDao(StudentinfoDao studentinfoDao) {    
44. this.studentinfoDao = studentinfoDao;    
45.     }    
46.     
47. public RedisClientTemplate getRedisClientTemplate() {    
48. return redisClientTemplate;    
49.     }    
50.     
51. public void setRedisClientTemplate(RedisClientTemplate redisClientTemplate) {    
52. this.redisClientTemplate = redisClientTemplate;    
53.     }    
54.     
55. }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。