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. }
时间： 2024-10-06 00:10:49

Redis客户端之Spring整合Jedis的相关文章

用BIO手写实现Redis客户端的探究(拒绝Jedis)

在Redis的使用过程中,大多数人都是使用现成的客户端,如Jedis,Redisson,Lettuce.因此本文研究用BIO的方式手写Redis客户端尝试,对遇到的问题进行探究及总结. 1.手写BIO调用类 使用BIO的方式进行Redis客户端的编写,首先定义一个Connection,Connection类包含了建立BIO连接的远程地址host,端口port,套接字Socket以及输入输出流. 此类一个Connection的构造方法,一个Connection的初始化方法,以及请求发送方法. pu

Redis客户端开发包：Jedis学习-高级应用

事务 Jedis中事务的写法是将redis操作写在事物代码块中,如下所示,multi与exec之间为具体的事务. jedis.watch (key1, key2, ...); Transaction t = jedis.multi(); t.set("foo", "bar"); t.exec(); 另外,在事务内部,是不能通过Jedis对象去获取值的,不过可以通过Transaction对象去获取,如下写法: package cn.edu.hdu.jedisdemo;

spring整合redis客户端及缓存接口设计（转）

一.写在前面 缓存作为系统性能优化的一大杀手锏,几乎在每个系统或多或少的用到缓存.有的使用本地内存作为缓存,有的使用本地硬盘作为缓存,有的使用缓存服务器.但是无论使用哪种缓存,接口中的方法都是差不多.笔者最近的项目使用的是memcached作为缓存服务器,由于memcached的一些限制,现在想换redis作为缓存服务器.思路就是把memached的客户端换成redis客户端,接口依然是原来的接口,这样对系统可以无损替换,接口不变,功能不变,只是客户端变了.本文不介绍缓存的用法,不介绍redis

spring整合redis客户端及缓存接口设计

一.写在前面 缓存作为系统性能优化的一大杀手锏,几乎在每个系统或多或少的用到缓存.有的使用本地内存作为缓存,有的使用本地硬盘作为缓存,有的使用缓存服务器.但是无论使用哪种缓存,接口中的方法都是差不多.笔者最近的项目使用的是memcached作为缓存服务器,由于memcached的一些限制,现在想换redis作为缓存服务器.思路就是把memached的客户端换成redis客户端,接口依然是原来的接口,这样对系统可以无损替换,接口不变,功能不变,只是客户端变了.本文不介绍缓存的用法,不介绍redis

spring 集成redis客户端jedis(java)

jedis是redis的java客户端,spring将redis连接池作为一个bean配置. "redis.clients.jedis.JedisPool",这是单机环境适用的redis连接池. 1.maven导入相关包: <!-- redis依赖包 --> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> &l

Spring整合Redis做数据缓存（Windows环境）

当我们一个项目的数据量很大的时候,就需要做一些缓存机制来减轻数据库的压力,提升应用程序的性能,对于java项目来说,最常用的缓存组件有Redis.Ehcache和Memcached. Ehcache是用java开发的缓存组件,和java结合良好,直接在jvm虚拟机中运行,不需要额外安装什么东西,效率也很高:但是由于和java结合的太紧密了,导致缓存共享麻烦,分布式集群应用不方便,所以比较适合单个部署的应用. Redis需要额外单独安装,是通过socket访问到缓存服务,效率比Ehcache低,但

redis集群、单击版本与spring整合步骤

1.搭建集群,关闭虚拟机防火墙,或者iptables参数,允许redis集群端口通过 service iptables stop 或者 vim /etc/sysconfig/iptables 2.测试集群(不整合spring) @Test public void testJedisCluster(){ HashSet<HostAndPort> nodes = new HashSet<HostAndPort>(); nodes.add(new HostAndPort("19

springMVC整合jedis+redis

http://www.cnblogs.com/zhengbn/p/4140549.html 前两天写过 springMVC+memcached 的整合,我从这个基础上改造一下,把redis和springmvc整合到一起. 和memcached一样,redis也有java专用的客户端,官网推荐使用的是:jedis. 看了一部分资料,大家推荐使用 spring-data-redis (spring在jedis的基础上又包装了一层),但是实际中感觉写起来有点麻烦,不如原生态的jedis好用. 所以我利

Jedis与Spring整合

Redis是一个开源的.K-V型数据库,用于提供高性能的分布式缓存. Jedis是Redis首选的Java客户端开发包. 其中,Jedis与Spring整合配置如下: <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"> <property name="maxTotal" value="30"/> </bea