Redis客户端之Spring整合Jedis

 

1.下载相关jar包，并引入工程：

jedis-2.4.2.jar

commons-pool2-2.0.jar

2.将以下XML配置引入spring

1. <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
2. <constructor-arg index="0" ref="jedisPoolConfig"/>
3. <constructor-arg index="1">
4. <list>
5. <bean name="slaver" class="redis.clients.jedis.JedisShardInfo">
6. <constructor-arg index="0" value="${redis.slaver.host}"/>
7. <constructor-arg index="1" value="${redis.slaver.port}" type="int"/>
8. </bean>
9. <bean name="master" class="redis.clients.jedis.JedisShardInfo">
10. <constructor-arg index="0" value="${redis.master.host}"/>
11. <constructor-arg index="1" value="${redis.master.port}" type="int"/>
12. </bean>
13. </list>
14. </constructor-arg>
15. </bean>
16. <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
17. <property name="maxTotal" value="2048" />
18. <property name="maxIdle" value="200" />
19. <property name="numTestsPerEvictionRun" value="1024"/>
20. <property name="timeBetweenEvictionRunsMillis" value="30000" />
21. <property name="minEvictableIdleTimeMillis" value="-1" />
22. <property name="softMinEvictableIdleTimeMillis" value="10000" />
23. <property name="maxWaitMillis" value="1500"/>
24. <property name="testOnBorrow" value="true" />
25. <property name="testWhileIdle" value="true"/>
26. <property name="testOnReturn" value="false"/>
27. <property name="jmxEnabled" value="true"/>
28. <property name="jmxNamePrefix" value="youyuan"/>
29. <property name="blockWhenExhausted" value="false"/>
30. </bean>

3.将shardedJedisPool注入相关的类中即可使用

1. @Resource
2. private ShardedJedisPool shardedJedisPool;
3. /**
4. * 设置一个key的过期时间（单位：秒）
5. * @param key key值
6. * @param seconds 多少秒后过期
7. * @return 1：设置了过期时间  0：没有设置过期时间/不能设置过期时间
8. */
9. public long expire(String key, int seconds) {
10. if (key==null || key.equals("")) {
11. return 0;
12. }
13. ShardedJedis shardedJedis = null;
14. try {
15. shardedJedis = shardedJedisPool.getResource();
16. return shardedJedis.expire(key, seconds);
17. } catch (Exception ex) {
18. logger.error("EXPIRE error[key=" + key + " seconds=" + seconds + "]" + ex.getMessage(), ex);
19. returnBrokenResource(shardedJedis);
20. } finally {
21. returnResource(shardedJedis);
22. }
23. return 0;
24. }
25. /**
26. * 设置一个key在某个时间点过期
27. * @param key key值
28. * @param unixTimestamp unix时间戳，从1970-01-01 00:00:00开始到现在的秒数
29. * @return 1：设置了过期时间  0：没有设置过期时间/不能设置过期时间
30. */
31. public long expireAt(String key, int unixTimestamp) {
32. if (key==null || key.equals("")) {
33. return 0;
34. }
35. ShardedJedis shardedJedis = null;
36. try {
37. shardedJedis = shardedJedisPool.getResource();
38. return shardedJedis.expireAt(key, unixTimestamp);
39. } catch (Exception ex) {
40. logger.error("EXPIRE error[key=" + key + " unixTimestamp=" + unixTimestamp + "]" + ex.getMessage(), ex);
41. returnBrokenResource(shardedJedis);
42. } finally {
43. returnResource(shardedJedis);
44. }
45. return 0;
46. }
47. /**
48. * 截断一个List
49. * @param key 列表key
50. * @param start 开始位置 从0开始
51. * @param end 结束位置
52. * @return 状态码
53. */
54. public String trimList(String key, long start, long end) {
55. if (key == null || key.equals("")) {
56. return "-";
57. }
58. ShardedJedis shardedJedis = null;
59. try {
60. shardedJedis = shardedJedisPool.getResource();
61. return shardedJedis.ltrim(key, start, end);
62. } catch (Exception ex) {
63. logger.error("LTRIM 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);
64. returnBrokenResource(shardedJedis);
65. } finally {
66. returnResource(shardedJedis);
67. }
68. return "-";
69. }
70. /**
71. * 检查Set长度
72. * @param key
73. * @return
74. */
75. public long countSet(String key){
76. if(key == null ){
77. return 0;
78. }
79. ShardedJedis shardedJedis = null;
80. try {
81. shardedJedis = shardedJedisPool.getResource();
82. return shardedJedis.scard(key);
83. } catch (Exception ex) {
84. logger.error("countSet error.", ex);
85. returnBrokenResource(shardedJedis);
86. } finally {
87. returnResource(shardedJedis);
88. }
89. return 0;
90. }
91. /**
92. * 添加到Set中（同时设置过期时间）
93. * @param key key值
94. * @param seconds 过期时间 单位s
95. * @param value
96. * @return
97. */
98. public boolean addSet(String key,int seconds, String... value) {
99. boolean result = addSet(key, value);
100. if(result){
101. long i = expire(key, seconds);
102. return i==1;
103. }
104. return false;
105. }
106. /**
107. * 添加到Set中
108. * @param key
109. * @param value
110. * @return
111. */
112. public boolean addSet(String key, String... value) {
113. if(key == null || value == null){
114. return false;
115. }
116. ShardedJedis shardedJedis = null;
117. try {
118. shardedJedis = shardedJedisPool.getResource();
119. shardedJedis.sadd(key, value);
120. return true;
121. } catch (Exception ex) {
122. logger.error("setList error.", ex);
123. returnBrokenResource(shardedJedis);
124. } finally {
125. returnResource(shardedJedis);
126. }
127. return false;
128. }
129. /**
130. * @param key
131. * @param value
132. * @return 判断值是否包含在set中
133. */
134. public boolean containsInSet(String key, String value) {
135. if(key == null || value == null){
136. return false;
137. }
138. ShardedJedis shardedJedis = null;
139. try {
140. shardedJedis = shardedJedisPool.getResource();
141. return shardedJedis.sismember(key, value);
142. } catch (Exception ex) {
143. logger.error("setList error.", ex);
144. returnBrokenResource(shardedJedis);
145. } finally {
146. returnResource(shardedJedis);
147. }
148. return false;
149. }
150. /**
151. * 获取Set
152. * @param key
153. * @return
154. */
155. public  Set<String> getSet(String key){
156. ShardedJedis shardedJedis = null;
157. try {
158. shardedJedis = shardedJedisPool.getResource();
159. return shardedJedis.smembers(key);
160. } catch (Exception ex) {
161. logger.error("getList error.", ex);
162. returnBrokenResource(shardedJedis);
163. } finally {
164. returnResource(shardedJedis);
165. }
166. return null;
167. }
168. /**
169. * 从set中删除value
170. * @param key
171. * @return
172. */
173. public  boolean removeSetValue(String key,String... value){
174. ShardedJedis shardedJedis = null;
175. try {
176. shardedJedis = shardedJedisPool.getResource();
177. shardedJedis.srem(key, value);
178. return true;
179. } catch (Exception ex) {
180. logger.error("getList error.", ex);
181. returnBrokenResource(shardedJedis);
182. } finally {
183. returnResource(shardedJedis);
184. }
185. return false;
186. }
187. /**
188. * 从list中删除value 默认count 1
189. * @param key
190. * @param values 值list
191. * @return
192. */
193. public  int removeListValue(String key,List<String> values){
194. return removeListValue(key, 1, values);
195. }
196. /**
197. * 从list中删除value
198. * @param key
199. * @param count
200. * @param values 值list
201. * @return
202. */
203. public  int removeListValue(String key,long count,List<String> values){
204. int result = 0;
205. if(values != null && values.size()>0){
206. for(String value : values){
207. if(removeListValue(key, count, value)){
208. result++;
209. }
210. }
211. }
212. return result;
213. }
214. /**
215. *  从list中删除value
216. * @param key
217. * @param count 要删除个数
218. * @param value
219. * @return
220. */
221. public  boolean removeListValue(String key,long count,String value){
222. ShardedJedis shardedJedis = null;
223. try {
224. shardedJedis = shardedJedisPool.getResource();
225. shardedJedis.lrem(key, count, value);
226. return true;
227. } catch (Exception ex) {
228. logger.error("getList error.", ex);
229. returnBrokenResource(shardedJedis);
230. } finally {
231. returnResource(shardedJedis);
232. }
233. return false;
234. }
235. /**
236. * 截取List
237. * @param key
238. * @param start 起始位置
239. * @param end 结束位置
240. * @return
241. */
242. public List<String> rangeList(String key, long start, long end) {
243. if (key == null || key.equals("")) {
244. return null;
245. }
246. ShardedJedis shardedJedis = null;
247. try {
248. shardedJedis = shardedJedisPool.getResource();
249. return shardedJedis.lrange(key, start, end);
250. } catch (Exception ex) {
251. logger.error("rangeList 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);
252. returnBrokenResource(shardedJedis);
253. } finally {
254. returnResource(shardedJedis);
255. }
256. return null;
257. }
258. /**
259. * 检查List长度
260. * @param key
261. * @return
262. */
263. public long countList(String key){
264. if(key == null ){
265. return 0;
266. }
267. ShardedJedis shardedJedis = null;
268. try {
269. shardedJedis = shardedJedisPool.getResource();
270. return shardedJedis.llen(key);
271. } catch (Exception ex) {
272. logger.error("countList error.", ex);
273. returnBrokenResource(shardedJedis);
274. } finally {
275. returnResource(shardedJedis);
276. }
277. return 0;
278. }
279. /**
280. * 添加到List中（同时设置过期时间）
281. * @param key key值
282. * @param seconds 过期时间 单位s
283. * @param value
284. * @return
285. */
286. public boolean addList(String key,int seconds, String... value){
287. boolean result = addList(key, value);
288. if(result){
289. long i = expire(key, seconds);
290. return i==1;
291. }
292. return false;
293. }
294. /**
295. * 添加到List
296. * @param key
297. * @param value
298. * @return
299. */
300. public boolean addList(String key, String... value) {
301. if(key == null || value == null){
302. return false;
303. }
304. ShardedJedis shardedJedis = null;
305. try {
306. shardedJedis = shardedJedisPool.getResource();
307. shardedJedis.lpush(key, value);
308. return true;
309. } catch (Exception ex) {
310. logger.error("setList error.", ex);
311. returnBrokenResource(shardedJedis);
312. } finally {
313. returnResource(shardedJedis);
314. }
315. return false;
316. }
317. /**
318. * 添加到List(只新增)
319. * @param key
320. * @param value
321. * @return
322. */
323. public boolean addList(String key, List<String> list) {
324. if(key == null || list == null || list.size() == 0){
325. return false;
326. }
327. for(String value : list){
328. addList(key, value);
329. }
330. return true;
331. }
332. /**
333. * 获取List
334. * @param key
335. * @return
336. */
337. public  List<String> getList(String key){
338. ShardedJedis shardedJedis = null;
339. try {
340. shardedJedis = shardedJedisPool.getResource();
341. return shardedJedis.lrange(key, 0, -1);
342. } catch (Exception ex) {
343. logger.error("getList error.", ex);
344. returnBrokenResource(shardedJedis);
345. } finally {
346. returnResource(shardedJedis);
347. }
348. return null;
349. }
350. /**
351. * 设置HashSet对象
352. *
353. * @param domain 域名
354. * @param key    键值
355. * @param value  Json String or String value
356. * @return
357. */
358. public boolean setHSet(String domain, String key, String value) {
359. if (value == null) return false;
360. ShardedJedis shardedJedis = null;
361. try {
362. shardedJedis = shardedJedisPool.getResource();
363. shardedJedis.hset(domain, key, value);
364. return true;
365. } catch (Exception ex) {
366. logger.error("setHSet error.", ex);
367. returnBrokenResource(shardedJedis);
368. } finally {
369. returnResource(shardedJedis);
370. }
371. return false;
372. }
373. /**
374. * 获得HashSet对象
375. *
376. * @param domain 域名
377. * @param key    键值
378. * @return Json String or String value
379. */
380. public String getHSet(String domain, String key) {
381. ShardedJedis shardedJedis = null;
382. try {
383. shardedJedis = shardedJedisPool.getResource();
384. return shardedJedis.hget(domain, key);
385. } catch (Exception ex) {
386. logger.error("getHSet error.", ex);
387. returnBrokenResource(shardedJedis);
388. } finally {
389. returnResource(shardedJedis);
390. }
391. return null;
392. }
393. /**
394. * 删除HashSet对象
395. *
396. * @param domain 域名
397. * @param key    键值
398. * @return 删除的记录数
399. */
400. public long delHSet(String domain, String key) {
401. ShardedJedis shardedJedis = null;
402. long count = 0;
403. try {
404. shardedJedis = shardedJedisPool.getResource();
405. count = shardedJedis.hdel(domain, key);
406. } catch (Exception ex) {
407. logger.error("delHSet error.", ex);
408. returnBrokenResource(shardedJedis);
409. } finally {
410. returnResource(shardedJedis);
411. }
412. return count;
413. }
414. /**
415. * 删除HashSet对象
416. *
417. * @param domain 域名
418. * @param key    键值
419. * @return 删除的记录数
420. */
421. public long delHSet(String domain, String... key) {
422. ShardedJedis shardedJedis = null;
423. long count = 0;
424. try {
425. shardedJedis = shardedJedisPool.getResource();
426. count = shardedJedis.hdel(domain, key);
427. } catch (Exception ex) {
428. logger.error("delHSet error.", ex);
429. returnBrokenResource(shardedJedis);
430. } finally {
431. returnResource(shardedJedis);
432. }
433. return count;
434. }
435. /**
436. * 判断key是否存在
437. *
438. * @param domain 域名
439. * @param key    键值
440. * @return
441. */
442. public boolean existsHSet(String domain, String key) {
443. ShardedJedis shardedJedis = null;
444. boolean isExist = false;
445. try {
446. shardedJedis = shardedJedisPool.getResource();
447. isExist = shardedJedis.hexists(domain, key);
448. } catch (Exception ex) {
449. logger.error("existsHSet error.", ex);
450. returnBrokenResource(shardedJedis);
451. } finally {
452. returnResource(shardedJedis);
453. }
454. return isExist;
455. }
456. /**
457. * 全局扫描hset
458. *
459. * @param match field匹配模式
460. * @return
461. */
462. public List<Map.Entry<String, String>> scanHSet(String domain, String match) {
463. ShardedJedis shardedJedis = null;
464. try {
465. int cursor = 0;
466. shardedJedis = shardedJedisPool.getResource();
467. ScanParams scanParams = new ScanParams();
468. scanParams.match(match);
469. Jedis jedis = shardedJedis.getShard(domain);
470. ScanResult<Map.Entry<String, String>> scanResult;
471. List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>();
472. do {
473. scanResult = jedis.hscan(domain, String.valueOf(cursor), scanParams);
474. list.addAll(scanResult.getResult());
475. cursor = Integer.parseInt(scanResult.getStringCursor());
476. } while (cursor > 0);
477. return list;
478. } catch (Exception ex) {
479. logger.error("scanHSet error.", ex);
480. returnBrokenResource(shardedJedis);
481. } finally {
482. returnResource(shardedJedis);
483. }
484. return null;
485. }
486. /**
487. * 返回 domain 指定的哈希集中所有字段的value值
488. *
489. * @param domain
490. * @return
491. */
492. public List<String> hvals(String domain) {
493. ShardedJedis shardedJedis = null;
494. List<String> retList = null;
495. try {
496. shardedJedis = shardedJedisPool.getResource();
497. retList = shardedJedis.hvals(domain);
498. } catch (Exception ex) {
499. logger.error("hvals error.", ex);
500. returnBrokenResource(shardedJedis);
501. } finally {
502. returnResource(shardedJedis);
503. }
504. return retList;
505. }
506. /**
507. * 返回 domain 指定的哈希集中所有字段的key值
508. *
509. * @param domain
510. * @return
511. */
512. public Set<String> hkeys(String domain) {
513. ShardedJedis shardedJedis = null;
514. Set<String> retList = null;
515. try {
516. shardedJedis = shardedJedisPool.getResource();
517. retList = shardedJedis.hkeys(domain);
518. } catch (Exception ex) {
519. logger.error("hkeys error.", ex);
520. returnBrokenResource(shardedJedis);
521. } finally {
522. returnResource(shardedJedis);
523. }
524. return retList;
525. }
526. /**
527. * 返回 domain 指定的哈希key值总数
528. *
529. * @param domain
530. * @return
531. */
532. public long lenHset(String domain) {
533. ShardedJedis shardedJedis = null;
534. long retList = 0;
535. try {
536. shardedJedis = shardedJedisPool.getResource();
537. retList = shardedJedis.hlen(domain);
538. } catch (Exception ex) {
539. logger.error("hkeys error.", ex);
540. returnBrokenResource(shardedJedis);
541. } finally {
542. returnResource(shardedJedis);
543. }
544. return retList;
545. }
546. /**
547. * 设置排序集合
548. *
549. * @param key
550. * @param score
551. * @param value
552. * @return
553. */
554. public boolean setSortedSet(String key, long score, String value) {
555. ShardedJedis shardedJedis = null;
556. try {
557. shardedJedis = shardedJedisPool.getResource();
558. shardedJedis.zadd(key, score, value);
559. return true;
560. } catch (Exception ex) {
561. logger.error("setSortedSet error.", ex);
562. returnBrokenResource(shardedJedis);
563. } finally {
564. returnResource(shardedJedis);
565. }
566. return false;
567. }
568. /**
569. * 获得排序集合
570. *
571. * @param key
572. * @param startScore
573. * @param endScore
574. * @param orderByDesc
575. * @return
576. */
577. public Set<String> getSoredSet(String key, long startScore, long endScore, boolean orderByDesc) {
578. ShardedJedis shardedJedis = null;
579. try {
580. shardedJedis = shardedJedisPool.getResource();
581. if (orderByDesc) {
582. return shardedJedis.zrevrangeByScore(key, endScore, startScore);
583. } else {
584. return shardedJedis.zrangeByScore(key, startScore, endScore);
585. }
586. } catch (Exception ex) {
587. logger.error("getSoredSet error.", ex);
588. returnBrokenResource(shardedJedis);
589. } finally {
590. returnResource(shardedJedis);
591. }
592. return null;
593. }
594. /**
595. * 计算排序长度
596. *
597. * @param key
598. * @param startScore
599. * @param endScore
600. * @return
601. */
602. public long countSoredSet(String key, long startScore, long endScore) {
603. ShardedJedis shardedJedis = null;
604. try {
605. shardedJedis = shardedJedisPool.getResource();
606. Long count = shardedJedis.zcount(key, startScore, endScore);
607. return count == null ? 0L : count;
608. } catch (Exception ex) {
609. logger.error("countSoredSet error.", ex);
610. returnBrokenResource(shardedJedis);
611. } finally {
612. returnResource(shardedJedis);
613. }
614. return 0L;
615. }
616. /**
617. * 删除排序集合
618. *
619. * @param key
620. * @param value
621. * @return
622. */
623. public boolean delSortedSet(String key, String value) {
624. ShardedJedis shardedJedis = null;
625. try {
626. shardedJedis = shardedJedisPool.getResource();
627. long count = shardedJedis.zrem(key, value);
628. return count > 0;
629. } catch (Exception ex) {
630. logger.error("delSortedSet error.", ex);
631. returnBrokenResource(shardedJedis);
632. } finally {
633. returnResource(shardedJedis);
634. }
635. return false;
636. }
637. /**
638. * 获得排序集合
639. *
640. * @param key
641. * @param startRange
642. * @param endRange
643. * @param orderByDesc
644. * @return
645. */
646. public Set<String> getSoredSetByRange(String key, int startRange, int endRange, boolean orderByDesc) {
647. ShardedJedis shardedJedis = null;
648. try {
649. shardedJedis = shardedJedisPool.getResource();
650. if (orderByDesc) {
651. return shardedJedis.zrevrange(key, startRange, endRange);
652. } else {
653. return shardedJedis.zrange(key, startRange, endRange);
654. }
655. } catch (Exception ex) {
656. logger.error("getSoredSetByRange error.", ex);
657. returnBrokenResource(shardedJedis);
658. } finally {
659. returnResource(shardedJedis);
660. }
661. return null;
662. }
663. /**
664. * 获得排序打分
665. *
666. * @param key
667. * @return
668. */
669. public Double getScore(String key, String member) {
670. ShardedJedis shardedJedis = null;
671. try {
672. shardedJedis = shardedJedisPool.getResource();
673. return shardedJedis.zscore(key, member);
674. } catch (Exception ex) {
675. logger.error("getSoredSet error.", ex);
676. returnBrokenResource(shardedJedis);
677. } finally {
678. returnResource(shardedJedis);
679. }
680. return null;
681. }
682. public boolean set(String key, String value, int second) {
683. ShardedJedis shardedJedis = null;
684. try {
685. shardedJedis = shardedJedisPool.getResource();
686. shardedJedis.setex(key, second, value);
687. return true;
688. } catch (Exception ex) {
689. logger.error("set error.", ex);
690. returnBrokenResource(shardedJedis);
691. } finally {
692. returnResource(shardedJedis);
693. }
694. return false;
695. }
696. public boolean set(String key, String value) {
697. ShardedJedis shardedJedis = null;
698. try {
699. shardedJedis = shardedJedisPool.getResource();
700. shardedJedis.set(key, value);
701. return true;
702. } catch (Exception ex) {
703. logger.error("set error.", ex);
704. returnBrokenResource(shardedJedis);
705. } finally {
706. returnResource(shardedJedis);
707. }
708. return false;
709. }
710. public String get(String key, String defaultValue) {
711. ShardedJedis shardedJedis = null;
712. try {
713. shardedJedis = shardedJedisPool.getResource();
714. return shardedJedis.get(key) == null?defaultValue:shardedJedis.get(key);
715. } catch (Exception ex) {
716. logger.error("get error.", ex);
717. returnBrokenResource(shardedJedis);
718. } finally {
719. returnResource(shardedJedis);
720. }
721. return defaultValue;
722. }
723. public boolean del(String key) {
724. ShardedJedis shardedJedis = null;
725. try {
726. shardedJedis = shardedJedisPool.getResource();
727. shardedJedis.del(key);
728. return true;
729. } catch (Exception ex) {
730. logger.error("del error.", ex);
731. returnBrokenResource(shardedJedis);
732. } finally {
733. returnResource(shardedJedis);
734. }
735. return false;
736. }
737. public long incr(String key) {
738. ShardedJedis shardedJedis = null;
739. try {
740. shardedJedis = shardedJedisPool.getResource();
741. return shardedJedis.incr(key);
742. } catch (Exception ex) {
743. logger.error("incr error.", ex);
744. returnBrokenResource(shardedJedis);
745. } finally {
746. returnResource(shardedJedis);
747. }
748. return 0;
749. }
750. public long decr(String key) {
751. ShardedJedis shardedJedis = null;
752. try {
753. shardedJedis = shardedJedisPool.getResource();
754. return shardedJedis.decr(key);
755. } catch (Exception ex) {
756. logger.error("incr error.", ex);
757. returnBrokenResource(shardedJedis);
758. } finally {
759. returnResource(shardedJedis);
760. }
761. return 0;
762. }
763. private void returnBrokenResource(ShardedJedis shardedJedis) {
764. try {
765. shardedJedisPool.returnBrokenResource(shardedJedis);
766. } catch (Exception e) {
767. logger.error("returnBrokenResource error.", e);
768. }
769. }
770. private void returnResource(ShardedJedis shardedJedis) {
771. try {
772. shardedJedisPool.returnResource(shardedJedis);
773. } catch (Exception e) {
774. logger.error("returnResource error.", e);
775. }
776. }