springboot 整合redis ，jedis

SpringBoot2.0笔记

（一）SpringBoot基本操作——环境搭建及项目创建（有demo）

（二）SpringBoot基本操作——使用IDEA打war包发布及测试

（三）SpringBoot基本操作——SpringBoot整合SpringDataJpa（有demo）

（四）SpringBoot基本操作——SpringBoot使用RedisTemplate整合Redis（有demo）

（五）SpringBoot基本操作——SpringBoot使用Jedis整合Redis（有demo）

（六）SpringBoot基本操作——SpringBoot使用Junit4单元测试（有demo）

（七）SpringBoot基本操作——SpringBoot整合Shiro权限管理（完整demo+界面）

 

本篇基于Springboot2.0 + Redis实现数据缓存及分库存储，上一篇主要使用官方推荐的RedisTemplate实现，这篇我主要以Jedis的方式来实现Redis的操作。这里再重复一遍，两种方式都可以实现对Redis的操作，RedisTemplate是对Jedis做了封装，官方推荐使用Redistemplate方式。

本文使用idea工具构建Springboot+SpringMvc+Thymeleaf+SpringDataJPA+MySql+Redis项目

GitHub地址：https://github.com/jwwam/springbootRedis2.git

一、Redis基本配置及工具类

还是来样子先看下项目demo的目录结构，基本的目录结构和上篇没什么差别。文末会给出pom包配置。

1.创建redis.properties配置文件

  1. #redis配置开始
  2. # Redis数据库索引（默认为0）
  3. spring.redis.database=0
  4. # Redis服务器地址
  5. spring.redis.host=localhost
  6. # Redis服务器连接端口
  7. spring.redis.port=6379
  8. # Redis服务器连接密码（默认为空）
  9. spring.redis.password=123456
  10. # 连接池最大连接数（使用负值表示没有限制）
  11. spring.redis.jedis.pool.max-active=1024
  12. # 连接池最大阻塞等待时间（使用负值表示没有限制）
  13. spring.redis.jedis.pool.max-wait=10000
  14. # 连接池中的最大空闲连接
  15. spring.redis.jedis.pool.max-idle=200
  16. # 连接池中的最小空闲连接
  17. spring.redis.jedis.pool.min-idle=0
  18. # 连接超时时间（毫秒）
  19. spring.redis.timeout=10000
  20. #redis配置结束
  21. spring.redis.block-when-exhausted=true

这里我们要注意max-active，max-wait，max-idle，min-idle这几个参数版本不同写法也不一样，我这里由于引入了最新的Jedis包所以写法如上，请注意。

2.添加配置类RedisConfig.java

  1. package com.springboot.demo.base.config;
  2.  
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.springframework.beans.factory.annotation.Value;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.context.annotation.PropertySource;
  8. import redis.clients.jedis.JedisPool;
  9. import redis.clients.jedis.JedisPoolConfig;
  10.  
  11. @Configuration
  12. @PropertySource("classpath:redis.properties")
  13. @Slf4j
  14. public class RedisConfig {
  15.  
  16.     @Value("${spring.redis.host}")
  17.     private String host;
  18.  
  19.     @Value("${spring.redis.port}")
  20.     private int port;
  21.  
  22.     @Value("${spring.redis.timeout}")
  23.     private int timeout;
  24.  
  25.     @Value("${spring.redis.jedis.pool.max-idle}")
  26.     private int maxIdle;
  27.  
  28.     @Value("${spring.redis.jedis.pool.max-wait}")
  29.     private long maxWaitMillis;
  30.  
  31.     @Value("${spring.redis.password}")
  32.     private String password;
  33.  
  34.     @Value("${spring.redis.block-when-exhausted}")
  35.     private boolean  blockWhenExhausted;
  36.  
  37.     @Bean
  38.     public JedisPool redisPoolFactory()  throws Exception{
  39.         log.info("JedisPool注入成功！！");
  40.         log.info("redis地址：" + host + ":" + port);
  41.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
  42.         jedisPoolConfig.setMaxIdle(maxIdle);
  43.         jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
  44.         // 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
  45.         jedisPoolConfig.setBlockWhenExhausted(blockWhenExhausted);
  46.         // 是否启用pool的jmx管理功能, 默认true
  47.         jedisPoolConfig.setJmxEnabled(true);
  48.         JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);
  49.         return jedisPool;
  50.     }
  51.  
  52. }

3.创建RedisUtil.java工具类，注意，这是一个非常完整的Jedis操作redis的工具类，里面多数方法我都加入了分库操作，使用时注意规范就好。

  1. package com.springboot.demo.base.utils;
  2.  
  3. import java.io.ByteArrayInputStream;
  4. import java.io.ByteArrayOutputStream;
  5. import java.io.ObjectInputStream;
  6. import java.io.ObjectOutputStream;
  7. import java.util.List;
  8. import java.util.Map;
  9. import java.util.Set;
  10.  
  11. import lombok.extern.slf4j.Slf4j;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.stereotype.Component;
  14.  
  15. import redis.clients.jedis.BinaryClient.LIST_POSITION;
  16. import redis.clients.jedis.Jedis;
  17. import redis.clients.jedis.JedisPool;
  18. import redis.clients.jedis.SortingParams;
  19.  
  20. @Component
  21. @Slf4j
  22. public class RedisUtil{
  23.  
  24. 	@Autowired
  25. 	private JedisPool jedisPool;
  26.  
  27. 	/**
  28. 	 * <p>
  29. 	 * 通过key获取储存在redis中的value
  30. 	 * </p>
  31. 	 * <p>
  32. 	 * 并释放连接
  33. 	 * </p>
  34. 	 *
  35. 	 * @param key
  36. 	 * @param indexdb 选择redis库 0-15
  37. 	 * @return 成功返回value 失败返回null
  38. 	 */
  39. 	public String get(String key,int indexdb) {
  40. 		Jedis jedis = null;
  41. 		String value = null;
  42. 		try {
  43. 			jedis = jedisPool.getResource();
  44. 			jedis.select(indexdb);
  45. 			value = jedis.get(key);
  46. 			log.info(value);
  47. 		} catch (Exception e) {
  48.  
  49. 			log.error(e.getMessage());
  50. 		} finally {
  51. 			returnResource(jedisPool, jedis);
  52. 		}
  53. 		return value;
  54. 	}
  55.  
  56. 	/**
  57. 	 * <p>
  58. 	 * 通过key获取储存在redis中的value
  59. 	 * </p>
  60. 	 * <p>
  61. 	 * 并释放连接
  62. 	 * </p>
  63. 	 *
  64. 	 * @param key
  65. 	 * @param indexdb 选择redis库 0-15
  66. 	 * @return 成功返回value 失败返回null
  67. 	 */
  68. 	public byte[] get(byte[] key,int indexdb) {
  69. 		Jedis jedis = null;
  70. 		byte[] value = null;
  71. 		try {
  72. 			jedis = jedisPool.getResource();
  73. 			jedis.select(indexdb);
  74. 			value = jedis.get(key);
  75. 		} catch (Exception e) {
  76.  
  77. 			log.error(e.getMessage());
  78. 		} finally {
  79. 			returnResource(jedisPool, jedis);
  80. 		}
  81. 		return value;
  82. 	}
  83. 	/**
  84. 	 * <p>
  85. 	 * 向redis存入key和value,并释放连接资源
  86. 	 * </p>
  87. 	 * <p>
  88. 	 * 如果key已经存在 则覆盖
  89. 	 * </p>
  90. 	 *
  91. 	 * @param key
  92. 	 * @param value
  93. 	 * @param indexdb 选择redis库 0-15
  94. 	 * @return 成功 返回OK 失败返回 0
  95. 	 */
  96. 	public String set(String key, String value,int indexdb) {
  97. 		Jedis jedis = null;
  98. 		try {
  99. 			jedis = jedisPool.getResource();
  100. 			jedis.select(indexdb);
  101. 			return jedis.set(key, value);
  102. 		} catch (Exception e) {
  103.  
  104. 			log.error(e.getMessage());
  105. 			return "0";
  106. 		} finally {
  107. 			returnResource(jedisPool, jedis);
  108. 		}
  109. 	}
  110. 	/**
  111. 	 * <p>
  112. 	 * 向redis存入key和value,并释放连接资源
  113. 	 * </p>
  114. 	 * <p>
  115. 	 * 如果key已经存在 则覆盖
  116. 	 * </p>
  117. 	 *
  118. 	 * @param key
  119. 	 * @param value
  120. 	 * @param indexdb 选择redis库 0-15
  121. 	 * @return 成功 返回OK 失败返回 0
  122. 	 */
  123. 	public String set(byte[] key, byte[] value,int indexdb) {
  124. 		Jedis jedis = null;
  125. 		try {
  126. 			jedis = jedisPool.getResource();
  127. 			jedis.select(indexdb);
  128. 			return jedis.set(key, value);
  129. 		} catch (Exception e) {
  130.  
  131. 			log.error(e.getMessage());
  132. 			return "0";
  133. 		} finally {
  134. 			returnResource(jedisPool, jedis);
  135. 		}
  136. 	}
  137. 	/**
  138. 	 * <p>
  139. 	 * 删除指定的key,也可以传入一个包含key的数组
  140. 	 * </p>
  141. 	 *
  142. 	 * @param keys 一个key 也可以使 string 数组
  143. 	 * @return 返回删除成功的个数
  144. 	 */
  145. 	public Long del(String... keys) {
  146. 		Jedis jedis = null;
  147. 		try {
  148. 			jedis = jedisPool.getResource();
  149. 			return jedis.del(keys);
  150. 		} catch (Exception e) {
  151.  
  152. 			log.error(e.getMessage());
  153. 			return 0L;
  154. 		} finally {
  155. 			returnResource(jedisPool, jedis);
  156. 		}
  157. 	}
  158. 	/**
  159. 	 * <p>
  160. 	 * 删除指定的key,也可以传入一个包含key的数组
  161. 	 * </p>
  162. 	 * @param indexdb 选择redis库 0-15
  163. 	 * @param keys 一个key 也可以使 string 数组
  164. 	 * @return 返回删除成功的个数
  165. 	 */
  166. 	public Long del(int indexdb,String... keys) {
  167. 		Jedis jedis = null;
  168. 		try {
  169. 			jedis = jedisPool.getResource();
  170. 			jedis.select(indexdb);
  171. 			return jedis.del(keys);
  172. 		} catch (Exception e) {
  173.  
  174. 			log.error(e.getMessage());
  175. 			return 0L;
  176. 		} finally {
  177. 			returnResource(jedisPool, jedis);
  178. 		}
  179. 	}
  180. 	/**
  181. 	 * <p>
  182. 	 * 删除指定的key,也可以传入一个包含key的数组
  183. 	 * </p>
  184. 	 * @param indexdb 选择redis库 0-15
  185. 	 * @param keys 一个key 也可以使 string 数组
  186. 	 * @return 返回删除成功的个数
  187. 	 */
  188. 	public Long del(int indexdb,byte[]... keys) {
  189. 		Jedis jedis = null;
  190. 		try {
  191. 			jedis = jedisPool.getResource();
  192. 			jedis.select(indexdb);
  193. 			return jedis.del(keys);
  194. 		} catch (Exception e) {
  195.  
  196. 			log.error(e.getMessage());
  197. 			return 0L;
  198. 		} finally {
  199. 			returnResource(jedisPool, jedis);
  200. 		}
  201. 	}
  202. 	/**
  203. 	 * <p>
  204. 	 * 通过key向指定的value值追加值
  205. 	 * </p>
  206. 	 *
  207. 	 * @param key
  208. 	 * @param str
  209. 	 * @return 成功返回 添加后value的长度 失败 返回 添加的 value 的长度 异常返回0L
  210. 	 */
  211. 	public Long append(String key, String str) {
  212. 		Jedis jedis = null;
  213. 		Long res = null;
  214. 		try {
  215. 			jedis = jedisPool.getResource();
  216. 			res = jedis.append(key, str);
  217. 		} catch (Exception e) {
  218.  
  219. 			log.error(e.getMessage());
  220. 			return 0L;
  221. 		} finally {
  222. 			returnResource(jedisPool, jedis);
  223. 		}
  224. 		return res;
  225. 	}
  226.  
  227. 	/**
  228. 	 * <p>
  229. 	 * 判断key是否存在
  230. 	 * </p>
  231. 	 *
  232. 	 * @param key
  233. 	 * @return true OR false
  234. 	 */
  235. 	public Boolean exists(String key) {
  236. 		Jedis jedis = null;
  237. 		try {
  238. 			jedis = jedisPool.getResource();
  239. 			return jedis.exists(key);
  240. 		} catch (Exception e) {
  241.  
  242. 			log.error(e.getMessage());
  243. 			return false;
  244. 		} finally {
  245. 			returnResource(jedisPool, jedis);
  246. 		}
  247. 	}
  248.  
  249. 	/**
  250. 	 * <p>
  251. 	 * 清空当前数据库中的所有 key,此命令从不失败。
  252. 	 * </p>
  253. 	 *
  254. 	 * @return 总是返回 OK
  255. 	 */
  256. 	public String flushDB() {
  257. 		Jedis jedis = null;
  258. 		try {
  259. 			jedis = jedisPool.getResource();
  260. 			return jedis.flushDB();
  261. 		} catch (Exception e) {
  262. 			log.error(e.getMessage());
  263. 		} finally {
  264. 			returnResource(jedisPool, jedis);
  265. 		}
  266. 		return null;
  267. 	}
  268.  
  269. 	/**
  270. 	 * <p>
  271. 	 * 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
  272. 	 * </p>
  273. 	 *
  274. 	 * @param key
  275. 	 * @param value
  276. 	 *            过期时间，单位：秒
  277. 	 * @return 成功返回1 如果存在 和 发生异常 返回 0
  278. 	 */
  279. 	public Long expire(String key, int value, int indexdb) {
  280. 		Jedis jedis = null;
  281. 		try {
  282. 			jedis = jedisPool.getResource();
  283. 			jedis.select(indexdb);
  284. 			return jedis.expire(key, value);
  285. 		} catch (Exception e) {
  286. 			log.error(e.getMessage());
  287. 			return 0L;
  288. 		} finally {
  289. 			returnResource(jedisPool, jedis);
  290. 		}
  291. 	}
  292.  
  293. 	/**
  294. 	 * <p>
  295. 	 * 以秒为单位，返回给定 key 的剩余生存时间
  296. 	 * </p>
  297. 	 *
  298. 	 * @param key
  299. 	 * @return 当 key 不存在时，返回 -2 。当 key 存在但没有设置剩余生存时间时，返回 -1 。否则，以秒为单位，返回 key
  300. 	 *         的剩余生存时间。 发生异常 返回 0
  301. 	 */
  302. 	public Long ttl(String key,int indexdb) {
  303. 		Jedis jedis = null;
  304. 		try {
  305. 			jedis = jedisPool.getResource();
  306. 			jedis.select(indexdb);
  307. 			return jedis.ttl(key);
  308. 		} catch (Exception e) {
  309.  
  310. 			log.error(e.getMessage());
  311. 			return 0L;
  312. 		} finally {
  313. 			returnResource(jedisPool, jedis);
  314. 		}
  315. 	}
  316.  
  317. 	/**
  318. 	 * <p>
  319. 	 * 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )
  320. 	 * </p>
  321. 	 *
  322. 	 * @param key
  323. 	 * @return 当生存时间移除成功时，返回 1 .如果 key 不存在或 key 没有设置生存时间，返回 0 ， 发生异常 返回 -1
  324. 	 */
  325. 	public Long persist(String key) {
  326. 		Jedis jedis = null;
  327. 		try {
  328. 			jedis = jedisPool.getResource();
  329. 			return jedis.persist(key);
  330. 		} catch (Exception e) {
  331.  
  332. 			log.error(e.getMessage());
  333. 			return -1L;
  334. 		} finally {
  335. 			returnResource(jedisPool, jedis);
  336. 		}
  337. 	}
  338.  
  339. 	/**
  340. 	 * <p>
  341. 	 * 新增key,并将 key 的生存时间 (以秒为单位)
  342. 	 * </p>
  343. 	 *
  344. 	 * @param key
  345. 	 * @param seconds
  346. 	 *            生存时间 单位：秒
  347. 	 * @param value
  348. 	 * @return 设置成功时返回 OK 。当 seconds 参数不合法时，返回一个错误。
  349. 	 */
  350. 	public String setex(String key, int seconds, String value) {
  351. 		Jedis jedis = null;
  352. 		try {
  353. 			jedis = jedisPool.getResource();
  354. 			return jedis.setex(key, seconds, value);
  355. 		} catch (Exception e) {
  356.  
  357. 			log.error(e.getMessage());
  358. 		} finally {
  359. 			returnResource(jedisPool, jedis);
  360. 		}
  361. 		return null;
  362. 	}
  363.  
  364. 	/**
  365. 	 * <p>
  366. 	 * 设置key value,如果key已经存在则返回0,nx==> not exist
  367. 	 * </p>
  368. 	 *
  369. 	 * @param key
  370. 	 * @param value
  371. 	 * @return 成功返回1 如果存在 和 发生异常 返回 0
  372. 	 */
  373. 	public Long setnx(String key, String value) {
  374. 		Jedis jedis = null;
  375. 		try {
  376. 			jedis = jedisPool.getResource();
  377. 			return jedis.setnx(key, value);
  378. 		} catch (Exception e) {
  379.  
  380. 			log.error(e.getMessage());
  381. 			return 0L;
  382. 		} finally {
  383. 			returnResource(jedisPool, jedis);
  384. 		}
  385. 	}
  386.  
  387. 	/**
  388. 	 * <p>
  389. 	 * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。
  390. 	 * </p>
  391. 	 * <p>
  392. 	 * 当 key 存在但不是字符串类型时，返回一个错误。
  393. 	 * </p>
  394. 	 *
  395. 	 * @param key
  396. 	 * @param value
  397. 	 * @return 返回给定 key 的旧值。当 key 没有旧值时，也即是， key 不存在时，返回 nil
  398. 	 */
  399. 	public String getSet(String key, String value) {
  400. 		Jedis jedis = null;
  401. 		try {
  402. 			jedis = jedisPool.getResource();
  403. 			return jedis.getSet(key, value);
  404. 		} catch (Exception e) {
  405.  
  406. 			log.error(e.getMessage());
  407. 		} finally {
  408. 			returnResource(jedisPool, jedis);
  409. 		}
  410. 		return null;
  411. 	}
  412.  
  413. 	/**
  414. 	 * <p>
  415. 	 * 设置key value并制定这个键值的有效期
  416. 	 * </p>
  417. 	 *
  418. 	 * @param key
  419. 	 * @param value
  420. 	 * @param seconds
  421. 	 *            单位:秒
  422. 	 * @return 成功返回OK 失败和异常返回null
  423. 	 */
  424. 	public String setex(String key, String value, int seconds) {
  425. 		Jedis jedis = null;
  426. 		String res = null;
  427. 		try {
  428. 			jedis = jedisPool.getResource();
  429. 			res = jedis.setex(key, seconds, value);
  430. 		} catch (Exception e) {
  431.  
  432. 			log.error(e.getMessage());
  433. 		} finally {
  434. 			returnResource(jedisPool, jedis);
  435. 		}
  436. 		return res;
  437. 	}
  438.  
  439. 	/**
  440. 	 * <p>
  441. 	 * 通过key 和offset 从指定的位置开始将原先value替换
  442. 	 * </p>
  443. 	 * <p>
  444. 	 * 下标从0开始,offset表示从offset下标开始替换
  445. 	 * </p>
  446. 	 * <p>
  447. 	 * 如果替换的字符串长度过小则会这样
  448. 	 * </p>
  449. 	 * <p>
  450. 	 * example:
  451. 	 * </p>
  452. 	 * <p>
  453. 	 * value : bigsea@zto.cn
  454. 	 * </p>
  455. 	 * <p>
  456. 	 * str : abc
  457. 	 * </p>
  458. 	 * <P>
  459. 	 * 从下标7开始替换 则结果为
  460. 	 * </p>
  461. 	 * <p>
  462. 	 * RES : bigsea.abc.cn
  463. 	 * </p>
  464. 	 *
  465. 	 * @param key
  466. 	 * @param str
  467. 	 * @param offset
  468. 	 *            下标位置
  469. 	 * @return 返回替换后 value 的长度
  470. 	 */
  471. 	public Long setrange(String key, String str, int offset) {
  472. 		Jedis jedis = null;
  473. 		try {
  474. 			jedis = jedisPool.getResource();
  475. 			return jedis.setrange(key, offset, str);
  476. 		} catch (Exception e) {
  477.  
  478. 			log.error(e.getMessage());
  479. 			return 0L;
  480. 		} finally {
  481. 			returnResource(jedisPool, jedis);
  482. 		}
  483. 	}
  484.  
  485. 	/**
  486. 	 * <p>
  487. 	 * 通过批量的key获取批量的value
  488. 	 * </p>
  489. 	 *
  490. 	 * @param keys
  491. 	 *            string数组 也可以是一个key
  492. 	 * @return 成功返回value的集合, 失败返回null的集合 ,异常返回空
  493. 	 */
  494. 	public List<String> mget(String... keys) {
  495. 		Jedis jedis = null;
  496. 		List<String> values = null;
  497. 		try {
  498. 			jedis = jedisPool.getResource();
  499. 			values = jedis.mget(keys);
  500. 		} catch (Exception e) {
  501.  
  502. 			log.error(e.getMessage());
  503. 		} finally {
  504. 			returnResource(jedisPool, jedis);
  505. 		}
  506. 		return values;
  507. 	}
  508.  
  509. 	/**
  510. 	 * <p>
  511. 	 * 批量的设置key:value,可以一个
  512. 	 * </p>
  513. 	 * <p>
  514. 	 * example:
  515. 	 * </p>
  516. 	 * <p>
  517. 	 * obj.mset(new String[]{"key2","value1","key2","value2"})
  518. 	 * </p>
  519. 	 *
  520. 	 * @param keysvalues
  521. 	 * @return 成功返回OK 失败 异常 返回 null
  522. 	 *
  523. 	 */
  524. 	public String mset(String... keysvalues) {
  525. 		Jedis jedis = null;
  526. 		String res = null;
  527. 		try {
  528. 			jedis = jedisPool.getResource();
  529. 			res = jedis.mset(keysvalues);
  530. 		} catch (Exception e) {
  531.  
  532. 			log.error(e.getMessage());
  533. 		} finally {
  534. 			returnResource(jedisPool, jedis);
  535. 		}
  536. 		return res;
  537. 	}
  538.  
  539. 	/**
  540. 	 * <p>
  541. 	 * 批量的设置key:value,可以一个,如果key已经存在则会失败,操作会回滚
  542. 	 * </p>
  543. 	 * <p>
  544. 	 * example:
  545. 	 * </p>
  546. 	 * <p>
  547. 	 * obj.msetnx(new String[]{"key2","value1","key2","value2"})
  548. 	 * </p>
  549. 	 *
  550. 	 * @param keysvalues
  551. 	 * @return 成功返回1 失败返回0
  552. 	 */
  553. 	public Long msetnx(String... keysvalues) {
  554. 		Jedis jedis = null;
  555. 		Long res = 0L;
  556. 		try {
  557. 			jedis = jedisPool.getResource();
  558. 			res = jedis.msetnx(keysvalues);
  559. 		} catch (Exception e) {
  560.  
  561. 			log.error(e.getMessage());
  562. 		} finally {
  563. 			returnResource(jedisPool, jedis);
  564. 		}
  565. 		return res;
  566. 	}
  567.  
  568. 	/**
  569. 	 * <p>
  570. 	 * 设置key的值,并返回一个旧值
  571. 	 * </p>
  572. 	 *
  573. 	 * @param key
  574. 	 * @param value
  575. 	 * @return 旧值 如果key不存在 则返回null
  576. 	 */
  577. 	public String getset(String key, String value) {
  578. 		Jedis jedis = null;
  579. 		String res = null;
  580. 		try {
  581. 			jedis = jedisPool.getResource();
  582. 			res = jedis.getSet(key, value);
  583. 		} catch (Exception e) {
  584.  
  585. 			log.error(e.getMessage());
  586. 		} finally {
  587. 			returnResource(jedisPool, jedis);
  588. 		}
  589. 		return res;
  590. 	}
  591.  
  592. 	/**
  593. 	 * <p>
  594. 	 * 通过下标 和key 获取指定下标位置的 value
  595. 	 * </p>
  596. 	 *
  597. 	 * @param key
  598. 	 * @param startOffset
  599. 	 *            开始位置 从0 开始 负数表示从右边开始截取
  600. 	 * @param endOffset
  601. 	 * @return 如果没有返回null
  602. 	 */
  603. 	public String getrange(String key, int startOffset, int endOffset) {
  604. 		Jedis jedis = null;
  605. 		String res = null;
  606. 		try {
  607. 			jedis = jedisPool.getResource();
  608. 			res = jedis.getrange(key, startOffset, endOffset);
  609. 		} catch (Exception e) {
  610.  
  611. 			log.error(e.getMessage());
  612. 		} finally {
  613. 			returnResource(jedisPool, jedis);
  614. 		}
  615. 		return res;
  616. 	}
  617.  
  618. 	/**
  619. 	 * <p>
  620. 	 * 通过key 对value进行加值+1操作,当value不是int类型时会返回错误,当key不存在是则value为1
  621. 	 * </p>
  622. 	 *
  623. 	 * @param key
  624. 	 * @return 加值后的结果
  625. 	 */
  626. 	public Long incr(String key) {
  627. 		Jedis jedis = null;
  628. 		Long res = null;
  629. 		try {
  630. 			jedis = jedisPool.getResource();
  631. 			res = jedis.incr(key);
  632. 		} catch (Exception e) {
  633.  
  634. 			log.error(e.getMessage());
  635. 		} finally {
  636. 			returnResource(jedisPool, jedis);
  637. 		}
  638. 		return res;
  639. 	}
  640.  
  641. 	/**
  642. 	 * <p>
  643. 	 * 通过key给指定的value加值,如果key不存在,则这是value为该值
  644. 	 * </p>
  645. 	 *
  646. 	 * @param key
  647. 	 * @param integer
  648. 	 * @return
  649. 	 */
  650. 	public Long incrBy(String key, Long integer) {
  651. 		Jedis jedis = null;
  652. 		Long res = null;
  653. 		try {
  654. 			jedis = jedisPool.getResource();
  655. 			res = jedis.incrBy(key, integer);
  656. 		} catch (Exception e) {
  657.  
  658. 			log.error(e.getMessage());
  659. 		} finally {
  660. 			returnResource(jedisPool, jedis);
  661. 		}
  662. 		return res;
  663. 	}
  664.  
  665. 	/**
  666. 	 * <p>
  667. 	 * 对key的值做减减操作,如果key不存在,则设置key为-1
  668. 	 * </p>
  669. 	 *
  670. 	 * @param key
  671. 	 * @return
  672. 	 */
  673. 	public Long decr(String key) {
  674. 		Jedis jedis = null;
  675. 		Long res = null;
  676. 		try {
  677. 			jedis = jedisPool.getResource();
  678. 			res = jedis.decr(key);
  679. 		} catch (Exception e) {
  680.  
  681. 			log.error(e.getMessage());
  682. 		} finally {
  683. 			returnResource(jedisPool, jedis);
  684. 		}
  685. 		return res;
  686. 	}
  687.  
  688. 	/**
  689. 	 * <p>
  690. 	 * 减去指定的值
  691. 	 * </p>
  692. 	 *
  693. 	 * @param key
  694. 	 * @param integer
  695. 	 * @return
  696. 	 */
  697. 	public Long decrBy(String key, Long integer) {
  698. 		Jedis jedis = null;
  699. 		Long res = null;
  700. 		try {
  701. 			jedis = jedisPool.getResource();
  702. 			res = jedis.decrBy(key, integer);
  703. 		} catch (Exception e) {
  704.  
  705. 			log.error(e.getMessage());
  706. 		} finally {
  707. 			returnResource(jedisPool, jedis);
  708. 		}
  709. 		return res;
  710. 	}
  711.  
  712. 	/**
  713. 	 * <p>
  714. 	 * 通过key获取value值的长度
  715. 	 * </p>
  716. 	 *
  717. 	 * @param key
  718. 	 * @return 失败返回null
  719. 	 */
  720. 	public Long serlen(String key) {
  721. 		Jedis jedis = null;
  722. 		Long res = null;
  723. 		try {
  724. 			jedis = jedisPool.getResource();
  725. 			res = jedis.strlen(key);
  726. 		} catch (Exception e) {
  727.  
  728. 			log.error(e.getMessage());
  729. 		} finally {
  730. 			returnResource(jedisPool, jedis);
  731. 		}
  732. 		return res;
  733. 	}
  734.  
  735. 	/**
  736. 	 * <p>
  737. 	 * 通过key给field设置指定的值,如果key不存在,则先创建
  738. 	 * </p>
  739. 	 *
  740. 	 * @param key
  741. 	 * @param field
  742. 	 *            字段
  743. 	 * @param value
  744. 	 * @return 如果存在返回0 异常返回null
  745. 	 */
  746. 	public Long hset(String key, String field, String value) {
  747. 		Jedis jedis = null;
  748. 		Long res = null;
  749. 		try {
  750. 			jedis = jedisPool.getResource();
  751. 			res = jedis.hset(key, field, value);
  752. 		} catch (Exception e) {
  753.  
  754. 			log.error(e.getMessage());
  755. 		} finally {
  756. 			returnResource(jedisPool, jedis);
  757. 		}
  758. 		return res;
  759. 	}
  760.  
  761. 	/**
  762. 	 * <p>
  763. 	 * 通过key给field设置指定的值,如果key不存在则先创建,如果field已经存在,返回0
  764. 	 * </p>
  765. 	 *
  766. 	 * @param key
  767. 	 * @param field
  768. 	 * @param value
  769. 	 * @return
  770. 	 */
  771. 	public Long hsetnx(String key, String field, String value) {
  772. 		Jedis jedis = null;
  773. 		Long res = null;
  774. 		try {
  775. 			jedis = jedisPool.getResource();
  776. 			res = jedis.hsetnx(key, field, value);
  777. 		} catch (Exception e) {
  778.  
  779. 			log.error(e.getMessage());
  780. 		} finally {
  781. 			returnResource(jedisPool, jedis);
  782. 		}
  783. 		return res;
  784. 	}
  785.  
  786. 	/**
  787. 	 * <p>
  788. 	 * 通过key同时设置 hash的多个field
  789. 	 * </p>
  790. 	 *
  791. 	 * @param key
  792. 	 * @param hash
  793. 	 * @return 返回OK 异常返回null
  794. 	 */
  795. 	public String hmset(String key, Map<String, String> hash, int indexdb) {
  796. 		Jedis jedis = null;
  797. 		String res = null;
  798. 		try {
  799. 			jedis = jedisPool.getResource();
  800. 			jedis.select(indexdb);
  801. 			res = jedis.hmset(key, hash);
  802. 		} catch (Exception e) {
  803.  
  804. 			log.error(e.getMessage());
  805. 		} finally {
  806. 			returnResource(jedisPool, jedis);
  807. 		}
  808. 		return res;
  809. 	}
  810.  
  811. 	/**
  812. 	 * <p>
  813. 	 * 通过key 和 field 获取指定的 value
  814. 	 * </p>
  815. 	 *
  816. 	 * @param key
  817. 	 * @param field
  818. 	 * @return 没有返回null
  819. 	 */
  820. 	public String hget(String key, String field) {
  821. 		Jedis jedis = null;
  822. 		String res = null;
  823. 		try {
  824. 			jedis = jedisPool.getResource();
  825. 			res = jedis.hget(key, field);
  826. 		} catch (Exception e) {
  827.  
  828. 			log.error(e.getMessage());
  829. 		} finally {
  830. 			returnResource(jedisPool, jedis);
  831. 		}
  832. 		return res;
  833. 	}
  834.  
  835. 	/**
  836. 	 * <p>
  837. 	 * 通过key 和 fields 获取指定的value 如果没有对应的value则返回null
  838. 	 * </p>
  839. 	 *
  840. 	 * @param key
  841. 	 * @param fields
  842. 	 *            可以使 一个String 也可以是 String数组
  843. 	 * @return
  844. 	 */
  845. 	public List<String> hmget(String key, int indexdb, String... fields) {
  846. 		Jedis jedis = null;
  847. 		List<String> res = null;
  848. 		try {
  849. 			jedis = jedisPool.getResource();
  850. 			jedis.select(indexdb);
  851. 			res = jedis.hmget(key, fields);
  852. 		} catch (Exception e) {
  853.  
  854. 			log.error(e.getMessage());
  855. 		} finally {
  856. 			returnResource(jedisPool, jedis);
  857. 		}
  858. 		return res;
  859. 	}
  860.  
  861. 	/**
  862. 	 * <p>
  863. 	 * 通过key给指定的field的value加上给定的值
  864. 	 * </p>
  865. 	 *
  866. 	 * @param key
  867. 	 * @param field
  868. 	 * @param value
  869. 	 * @return
  870. 	 */
  871. 	public Long hincrby(String key, String field, Long value) {
  872. 		Jedis jedis = null;
  873. 		Long res = null;
  874. 		try {
  875. 			jedis = jedisPool.getResource();
  876. 			res = jedis.hincrBy(key, field, value);
  877. 		} catch (Exception e) {
  878.  
  879. 			log.error(e.getMessage());
  880. 		} finally {
  881. 			returnResource(jedisPool, jedis);
  882. 		}
  883. 		return res;
  884. 	}
  885.  
  886. 	/**
  887. 	 * <p>
  888. 	 * 通过key和field判断是否有指定的value存在
  889. 	 * </p>
  890. 	 *
  891. 	 * @param key
  892. 	 * @param field
  893. 	 * @return
  894. 	 */
  895. 	public Boolean hexists(String key, String field) {
  896. 		Jedis jedis = null;
  897. 		Boolean res = false;
  898. 		try {
  899. 			jedis = jedisPool.getResource();
  900. 			res = jedis.hexists(key, field);
  901. 		} catch (Exception e) {
  902.  
  903. 			log.error(e.getMessage());
  904. 		} finally {
  905. 			returnResource(jedisPool, jedis);
  906. 		}
  907. 		return res;
  908. 	}
  909.  
  910. 	/**
  911. 	 * <p>
  912. 	 * 通过key返回field的数量
  913. 	 * </p>
  914. 	 *
  915. 	 * @param key
  916. 	 * @return
  917. 	 */
  918. 	public Long hlen(String key) {
  919. 		Jedis jedis = null;
  920. 		Long res = null;
  921. 		try {
  922. 			jedis = jedisPool.getResource();
  923. 			res = jedis.hlen(key);
  924. 		} catch (Exception e) {
  925.  
  926. 			log.error(e.getMessage());
  927. 		} finally {
  928. 			returnResource(jedisPool, jedis);
  929. 		}
  930. 		return res;
  931.  
  932. 	}
  933.  
  934. 	/**
  935. 	 * <p>
  936. 	 * 通过key 删除指定的 field
  937. 	 * </p>
  938. 	 *
  939. 	 * @param key
  940. 	 * @param fields
  941. 	 *            可以是 一个 field 也可以是 一个数组
  942. 	 * @return
  943. 	 */
  944. 	public Long hdel(String key, String... fields) {
  945. 		Jedis jedis = null;
  946. 		Long res = null;
  947. 		try {
  948. 			jedis = jedisPool.getResource();
  949. 			res = jedis.hdel(key, fields);
  950. 		} catch (Exception e) {
  951.  
  952. 			log.error(e.getMessage());
  953. 		} finally {
  954. 			returnResource(jedisPool, jedis);
  955. 		}
  956. 		return res;
  957. 	}
  958.  
  959. 	/**
  960. 	 * <p>
  961. 	 * 通过key返回所有的field
  962. 	 * </p>
  963. 	 *
  964. 	 * @param key
  965. 	 * @return
  966. 	 */
  967. 	public Set<String> hkeys(String key) {
  968. 		Jedis jedis = null;
  969. 		Set<String> res = null;
  970. 		try {
  971. 			jedis = jedisPool.getResource();
  972. 			res = jedis.hkeys(key);
  973. 		} catch (Exception e) {
  974.  
  975. 			log.error(e.getMessage());
  976. 		} finally {
  977. 			returnResource(jedisPool, jedis);
  978. 		}
  979. 		return res;
  980. 	}
  981.  
  982. 	/**
  983. 	 * <p>
  984. 	 * 通过key返回所有和key有关的value
  985. 	 * </p>
  986. 	 *
  987. 	 * @param key
  988. 	 * @return
  989. 	 */
  990. 	public List<String> hvals(String key) {
  991. 		Jedis jedis = null;
  992. 		List<String> res = null;
  993. 		try {
  994. 			jedis = jedisPool.getResource();
  995. 			res = jedis.hvals(key);
  996. 		} catch (Exception e) {
  997.  
  998. 			log.error(e.getMessage());
  999. 		} finally {
  1000. 			returnResource(jedisPool, jedis);
  1001. 		}
  1002. 		return res;
  1003. 	}
  1004.  
  1005. 	/**
  1006. 	 * <p>
  1007. 	 * 通过key获取所有的field和value
  1008. 	 * </p>
  1009. 	 *
  1010. 	 * @param key
  1011. 	 * @return
  1012. 	 */
  1013. 	public Map<String, String> hgetall(String key, int indexdb) {
  1014. 		Jedis jedis = null;
  1015. 		Map<String, String> res = null;
  1016. 		try {
  1017. 			jedis = jedisPool.getResource();
  1018. 			jedis.select(indexdb);
  1019. 			res = jedis.hgetAll(key);
  1020. 		} catch (Exception e) {
  1021. 			log.error(e.getMessage());
  1022. 		} finally {
  1023. 			returnResource(jedisPool, jedis);
  1024. 		}
  1025. 		return res;
  1026. 	}
  1027.  
  1028. 	/**
  1029. 	 * <p>
  1030. 	 * 通过key向list头部添加字符串
  1031. 	 * </p>
  1032. 	 *
  1033. 	 * @param key
  1034. 	 * @param strs
  1035. 	 *            可以使一个string 也可以使string数组
  1036. 	 * @return 返回list的value个数
  1037. 	 */
  1038. 	public Long lpush(int indexdb, String key, String... strs) {
  1039. 		Jedis jedis = null;
  1040. 		Long res = null;
  1041. 		try {
  1042. 			jedis = jedisPool.getResource();
  1043. 			jedis.select(indexdb);
  1044. 			res = jedis.lpush(key, strs);
  1045. 		} catch (Exception e) {
  1046.  
  1047. 			log.error(e.getMessage());
  1048. 		} finally {
  1049. 			returnResource(jedisPool, jedis);
  1050. 		}
  1051. 		return res;
  1052. 	}
  1053.  
  1054. 	/**
  1055. 	 * <p>
  1056. 	 * 通过key向list尾部添加字符串
  1057. 	 * </p>
  1058. 	 *
  1059. 	 * @param key
  1060. 	 * @param strs
  1061. 	 *            可以使一个string 也可以使string数组
  1062. 	 * @return 返回list的value个数
  1063. 	 */
  1064. 	public Long rpush(String key, String... strs) {
  1065. 		Jedis jedis = null;
  1066. 		Long res = null;
  1067. 		try {
  1068. 			jedis = jedisPool.getResource();
  1069. 			res = jedis.rpush(key, strs);
  1070. 		} catch (Exception e) {
  1071.  
  1072. 			log.error(e.getMessage());
  1073. 		} finally {
  1074. 			returnResource(jedisPool, jedis);
  1075. 		}
  1076. 		return res;
  1077. 	}
  1078.  
  1079. 	/**
  1080. 	 * <p>
  1081. 	 * 通过key在list指定的位置之前或者之后 添加字符串元素
  1082. 	 * </p>
  1083. 	 *
  1084. 	 * @param key
  1085. 	 * @param where
  1086. 	 *            LIST_POSITION枚举类型
  1087. 	 * @param pivot
  1088. 	 *            list里面的value
  1089. 	 * @param value
  1090. 	 *            添加的value
  1091. 	 * @return
  1092. 	 */
  1093. 	public Long linsert(String key, LIST_POSITION where, String pivot,
  1094. 						String value) {
  1095. 		Jedis jedis = null;
  1096. 		Long res = null;
  1097. 		try {
  1098. 			jedis = jedisPool.getResource();
  1099. 			res = jedis.linsert(key, where, pivot, value);
  1100. 		} catch (Exception e) {
  1101.  
  1102. 			log.error(e.getMessage());
  1103. 		} finally {
  1104. 			returnResource(jedisPool, jedis);
  1105. 		}
  1106. 		return res;
  1107. 	}
  1108.  
  1109. 	/**
  1110. 	 * <p>
  1111. 	 * 通过key设置list指定下标位置的value
  1112. 	 * </p>
  1113. 	 * <p>
  1114. 	 * 如果下标超过list里面value的个数则报错
  1115. 	 * </p>
  1116. 	 *
  1117. 	 * @param key
  1118. 	 * @param index
  1119. 	 *            从0开始
  1120. 	 * @param value
  1121. 	 * @return 成功返回OK
  1122. 	 */
  1123. 	public String lset(String key, Long index, String value) {
  1124. 		Jedis jedis = null;
  1125. 		String res = null;
  1126. 		try {
  1127. 			jedis = jedisPool.getResource();
  1128. 			res = jedis.lset(key, index, value);
  1129. 		} catch (Exception e) {
  1130.  
  1131. 			log.error(e.getMessage());
  1132. 		} finally {
  1133. 			returnResource(jedisPool, jedis);
  1134. 		}
  1135. 		return res;
  1136. 	}
  1137.  
  1138. 	/**
  1139. 	 * <p>
  1140. 	 * 通过key从对应的list中删除指定的count个 和 value相同的元素
  1141. 	 * </p>
  1142. 	 *
  1143. 	 * @param key
  1144. 	 * @param count
  1145. 	 *            当count为0时删除全部
  1146. 	 * @param value
  1147. 	 * @return 返回被删除的个数
  1148. 	 */
  1149. 	public Long lrem(String key, long count, String value) {
  1150. 		Jedis jedis = null;
  1151. 		Long res = null;
  1152. 		try {
  1153. 			jedis = jedisPool.getResource();
  1154. 			res = jedis.lrem(key, count, value);
  1155. 		} catch (Exception e) {
  1156.  
  1157. 			log.error(e.getMessage());
  1158. 		} finally {
  1159. 			returnResource(jedisPool, jedis);
  1160. 		}
  1161. 		return res;
  1162. 	}
  1163.  
  1164. 	/**
  1165. 	 * <p>
  1166. 	 * 通过key保留list中从strat下标开始到end下标结束的value值
  1167. 	 * </p>
  1168. 	 *
  1169. 	 * @param key
  1170. 	 * @param start
  1171. 	 * @param end
  1172. 	 * @return 成功返回OK
  1173. 	 */
  1174. 	public String ltrim(String key, long start, long end) {
  1175. 		Jedis jedis = null;
  1176. 		String res = null;
  1177. 		try {
  1178. 			jedis = jedisPool.getResource();
  1179. 			res = jedis.ltrim(key, start, end);
  1180. 		} catch (Exception e) {
  1181.  
  1182. 			log.error(e.getMessage());
  1183. 		} finally {
  1184. 			returnResource(jedisPool, jedis);
  1185. 		}
  1186. 		return res;
  1187. 	}
  1188.  
  1189. 	/**
  1190. 	 * <p>
  1191. 	 * 通过key从list的头部删除一个value,并返回该value
  1192. 	 * </p>
  1193. 	 *
  1194. 	 * @param key
  1195. 	 * @return
  1196. 	 */
  1197. 	synchronized public String lpop(String key) {
  1198. 		Jedis jedis = null;
  1199. 		String res = null;
  1200. 		try {
  1201. 			jedis = jedisPool.getResource();
  1202. 			res = jedis.lpop(key);
  1203. 		} catch (Exception e) {
  1204.  
  1205. 			log.error(e.getMessage());
  1206. 		} finally {
  1207. 			returnResource(jedisPool, jedis);
  1208. 		}
  1209. 		return res;
  1210. 	}
  1211.  
  1212. 	/**
  1213. 	 * <p>
  1214. 	 * 通过key从list尾部删除一个value,并返回该元素
  1215. 	 * </p>
  1216. 	 *
  1217. 	 * @param key
  1218. 	 * @return
  1219. 	 */
  1220. 	synchronized public String rpop(String key, int indexdb) {
  1221. 		Jedis jedis = null;
  1222. 		String res = null;
  1223. 		try {
  1224. 			jedis = jedisPool.getResource();
  1225. 			jedis.select(indexdb);
  1226. 			res = jedis.rpop(key);
  1227. 		} catch (Exception e) {
  1228.  
  1229. 			log.error(e.getMessage());
  1230. 		} finally {
  1231. 			returnResource(jedisPool, jedis);
  1232. 		}
  1233. 		return res;
  1234. 	}
  1235.  
  1236. 	/**
  1237. 	 * <p>
  1238. 	 * 通过key从一个list的尾部删除一个value并添加到另一个list的头部,并返回该value
  1239. 	 * </p>
  1240. 	 * <p>
  1241. 	 * 如果第一个list为空或者不存在则返回null
  1242. 	 * </p>
  1243. 	 *
  1244. 	 * @param srckey
  1245. 	 * @param dstkey
  1246. 	 * @return
  1247. 	 */
  1248. 	public String rpoplpush(String srckey, String dstkey, int indexdb) {
  1249. 		Jedis jedis = null;
  1250. 		String res = null;
  1251. 		try {
  1252. 			jedis = jedisPool.getResource();
  1253. 			jedis.select(indexdb);
  1254. 			res = jedis.rpoplpush(srckey, dstkey);
  1255. 		} catch (Exception e) {
  1256.  
  1257. 			log.error(e.getMessage());
  1258. 		} finally {
  1259. 			returnResource(jedisPool, jedis);
  1260. 		}
  1261. 		return res;
  1262. 	}
  1263.  
  1264. 	/**
  1265. 	 * <p>
  1266. 	 * 通过key获取list中指定下标位置的value
  1267. 	 * </p>
  1268. 	 *
  1269. 	 * @param key
  1270. 	 * @param index
  1271. 	 * @return 如果没有返回null
  1272. 	 */
  1273. 	public String lindex(String key, long index) {
  1274. 		Jedis jedis = null;
  1275. 		String res = null;
  1276. 		try {
  1277. 			jedis = jedisPool.getResource();
  1278. 			res = jedis.lindex(key, index);
  1279. 		} catch (Exception e) {
  1280.  
  1281. 			log.error(e.getMessage());
  1282. 		} finally {
  1283. 			returnResource(jedisPool, jedis);
  1284. 		}
  1285. 		return res;
  1286. 	}
  1287.  
  1288. 	/**
  1289. 	 * <p>
  1290. 	 * 通过key返回list的长度
  1291. 	 * </p>
  1292. 	 *
  1293. 	 * @param key
  1294. 	 * @return
  1295. 	 */
  1296. 	public Long llen(String key) {
  1297. 		Jedis jedis = null;
  1298. 		Long res = null;
  1299. 		try {
  1300. 			jedis = jedisPool.getResource();
  1301. 			res = jedis.llen(key);
  1302. 		} catch (Exception e) {
  1303.  
  1304. 			log.error(e.getMessage());
  1305. 		} finally {
  1306. 			returnResource(jedisPool, jedis);
  1307. 		}
  1308. 		return res;
  1309. 	}
  1310.  
  1311. 	/**
  1312. 	 * <p>
  1313. 	 * 通过key获取list指定下标位置的value
  1314. 	 * </p>
  1315. 	 * <p>
  1316. 	 * 如果start 为 0 end 为 -1 则返回全部的list中的value
  1317. 	 * </p>
  1318. 	 *
  1319. 	 * @param key
  1320. 	 * @param start
  1321. 	 * @param end
  1322. 	 * @return
  1323. 	 */
  1324. 	public List<String> lrange(String key, long start, long end, int indexdb) {
  1325. 		Jedis jedis = null;
  1326. 		List<String> res = null;
  1327. 		try {
  1328. 			jedis = jedisPool.getResource();
  1329. 			jedis.select(indexdb);
  1330. 			res = jedis.lrange(key, start, end);
  1331. 		} catch (Exception e) {
  1332.  
  1333. 			log.error(e.getMessage());
  1334. 		} finally {
  1335. 			returnResource(jedisPool, jedis);
  1336. 		}
  1337. 		return res;
  1338. 	}
  1339.  
  1340. 	/**
  1341. 	 * <p>
  1342. 	 * 将列表 key 下标为 index 的元素的值设置为 value
  1343. 	 * </p>
  1344. 	 *
  1345. 	 * @param key
  1346. 	 * @param index
  1347. 	 * @param value
  1348. 	 * @return 操作成功返回 ok ，否则返回错误信息
  1349. 	 */
  1350. 	public String lset(String key, long index, String value) {
  1351. 		Jedis jedis = null;
  1352. 		try {
  1353. 			jedis = jedisPool.getResource();
  1354. 			return jedis.lset(key, index, value);
  1355. 		} catch (Exception e) {
  1356.  
  1357. 			log.error(e.getMessage());
  1358. 		} finally {
  1359. 			returnResource(jedisPool, jedis);
  1360. 		}
  1361. 		return null;
  1362. 	}
  1363.  
  1364. 	/**
  1365. 	 * <p>
  1366. 	 * 返回给定排序后的结果
  1367. 	 * </p>
  1368. 	 *
  1369. 	 * @param key
  1370. 	 * @param sortingParameters
  1371. 	 * @return 返回列表形式的排序结果
  1372. 	 */
  1373. 	public List<String> sort(String key, SortingParams sortingParameters) {
  1374. 		Jedis jedis = null;
  1375. 		try {
  1376. 			jedis = jedisPool.getResource();
  1377. 			return jedis.sort(key, sortingParameters);
  1378. 		} catch (Exception e) {
  1379.  
  1380. 			log.error(e.getMessage());
  1381. 		} finally {
  1382. 			returnResource(jedisPool, jedis);
  1383. 		}
  1384. 		return null;
  1385. 	}
  1386.  
  1387. 	/**
  1388. 	 * <p>
  1389. 	 * 返回排序后的结果，排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较。
  1390. 	 * </p>
  1391. 	 *
  1392. 	 * @param key
  1393. 	 * @return 返回列表形式的排序结果
  1394. 	 */
  1395. 	public List<String> sort(String key) {
  1396. 		Jedis jedis = null;
  1397. 		try {
  1398. 			jedis = jedisPool.getResource();
  1399. 			return jedis.sort(key);
  1400. 		} catch (Exception e) {
  1401.  
  1402. 			log.error(e.getMessage());
  1403. 		} finally {
  1404. 			returnResource(jedisPool, jedis);
  1405. 		}
  1406. 		return null;
  1407. 	}
  1408.  
  1409. 	/**
  1410. 	 * <p>
  1411. 	 * 通过key向指定的set中添加value
  1412. 	 * </p>
  1413. 	 *
  1414. 	 * @param key
  1415. 	 * @param members
  1416. 	 *            可以是一个String 也可以是一个String数组
  1417. 	 * @return 添加成功的个数
  1418. 	 */
  1419. 	public Long sadd(String key, String... members) {
  1420. 		Jedis jedis = null;
  1421. 		Long res = null;
  1422. 		try {
  1423. 			jedis = jedisPool.getResource();
  1424. 			res = jedis.sadd(key, members);
  1425. 		} catch (Exception e) {
  1426.  
  1427. 			log.error(e.getMessage());
  1428. 		} finally {
  1429. 			returnResource(jedisPool, jedis);
  1430. 		}
  1431. 		return res;
  1432. 	}
  1433.  
  1434. 	/**
  1435. 	 * <p>
  1436. 	 * 通过key删除set中对应的value值
  1437. 	 * </p>
  1438. 	 *
  1439. 	 * @param key
  1440. 	 * @param members
  1441. 	 *            可以是一个String 也可以是一个String数组
  1442. 	 * @return 删除的个数
  1443. 	 */
  1444. 	public Long srem(String key, String... members) {
  1445. 		Jedis jedis = null;
  1446. 		Long res = null;
  1447. 		try {
  1448. 			jedis = jedisPool.getResource();
  1449. 			res = jedis.srem(key, members);
  1450. 		} catch (Exception e) {
  1451.  
  1452. 			log.error(e.getMessage());
  1453. 		} finally {
  1454. 			returnResource(jedisPool, jedis);
  1455. 		}
  1456. 		return res;
  1457. 	}
  1458.  
  1459. 	/**
  1460. 	 * <p>
  1461. 	 * 通过key随机删除一个set中的value并返回该值
  1462. 	 * </p>
  1463. 	 *
  1464. 	 * @param key
  1465. 	 * @return
  1466. 	 */
  1467. 	public String spop(String key) {
  1468. 		Jedis jedis = null;
  1469. 		String res = null;
  1470. 		try {
  1471. 			jedis = jedisPool.getResource();
  1472. 			res = jedis.spop(key);
  1473. 		} catch (Exception e) {
  1474.  
  1475. 			log.error(e.getMessage());
  1476. 		} finally {
  1477. 			returnResource(jedisPool, jedis);
  1478. 		}
  1479. 		return res;
  1480. 	}
  1481.  
  1482. 	/**
  1483. 	 * <p>
  1484. 	 * 通过key获取set中的差集
  1485. 	 * </p>
  1486. 	 * <p>
  1487. 	 * 以第一个set为标准
  1488. 	 * </p>
  1489. 	 *
  1490. 	 * @param keys
  1491. 	 *            可以使一个string 则返回set中所有的value 也可以是string数组
  1492. 	 * @return
  1493. 	 */
  1494. 	public Set<String> sdiff(String... keys) {
  1495. 		Jedis jedis = null;
  1496. 		Set<String> res = null;
  1497. 		try {
  1498. 			jedis = jedisPool.getResource();
  1499. 			res = jedis.sdiff(keys);
  1500. 		} catch (Exception e) {
  1501.  
  1502. 			log.error(e.getMessage());
  1503. 		} finally {
  1504. 			returnResource(jedisPool, jedis);
  1505. 		}
  1506. 		return res;
  1507. 	}
  1508.  
  1509. 	/**
  1510. 	 * <p>
  1511. 	 * 通过key获取set中的差集并存入到另一个key中
  1512. 	 * </p>
  1513. 	 * <p>
  1514. 	 * 以第一个set为标准
  1515. 	 * </p>
  1516. 	 *
  1517. 	 * @param dstkey
  1518. 	 *            差集存入的key
  1519. 	 * @param keys
  1520. 	 *            可以使一个string 则返回set中所有的value 也可以是string数组
  1521. 	 * @return
  1522. 	 */
  1523. 	public Long sdiffstore(String dstkey, String... keys) {
  1524. 		Jedis jedis = null;
  1525. 		Long res = null;
  1526. 		try {
  1527. 			jedis = jedisPool.getResource();
  1528. 			res = jedis.sdiffstore(dstkey, keys);
  1529. 		} catch (Exception e) {
  1530.  
  1531. 			log.error(e.getMessage());
  1532. 		} finally {
  1533. 			returnResource(jedisPool, jedis);
  1534. 		}
  1535. 		return res;
  1536. 	}
  1537.  
  1538. 	/**
  1539. 	 * <p>
  1540. 	 * 通过key获取指定set中的交集
  1541. 	 * </p>
  1542. 	 *
  1543. 	 * @param keys
  1544. 	 *            可以使一个string 也可以是一个string数组
  1545. 	 * @return
  1546. 	 */
  1547. 	public Set<String> sinter(String... keys) {
  1548. 		Jedis jedis = null;
  1549. 		Set<String> res = null;
  1550. 		try {
  1551. 			jedis = jedisPool.getResource();
  1552. 			res = jedis.sinter(keys);
  1553. 		} catch (Exception e) {
  1554.  
  1555. 			log.error(e.getMessage());
  1556. 		} finally {
  1557. 			returnResource(jedisPool, jedis);
  1558. 		}
  1559. 		return res;
  1560. 	}
  1561.  
  1562. 	/**
  1563. 	 * <p>
  1564. 	 * 通过key获取指定set中的交集 并将结果存入新的set中
  1565. 	 * </p>
  1566. 	 *
  1567. 	 * @param dstkey
  1568. 	 * @param keys
  1569. 	 *            可以使一个string 也可以是一个string数组
  1570. 	 * @return
  1571. 	 */
  1572. 	public Long sinterstore(String dstkey, String... keys) {
  1573. 		Jedis jedis = null;
  1574. 		Long res = null;
  1575. 		try {
  1576. 			jedis = jedisPool.getResource();
  1577. 			res = jedis.sinterstore(dstkey, keys);
  1578. 		} catch (Exception e) {
  1579.  
  1580. 			log.error(e.getMessage());
  1581. 		} finally {
  1582. 			returnResource(jedisPool, jedis);
  1583. 		}
  1584. 		return res;
  1585. 	}
  1586.  
  1587. 	/**
  1588. 	 * <p>
  1589. 	 * 通过key返回所有set的并集
  1590. 	 * </p>
  1591. 	 *
  1592. 	 * @param keys
  1593. 	 *            可以使一个string 也可以是一个string数组
  1594. 	 * @return
  1595. 	 */
  1596. 	public Set<String> sunion(String... keys) {
  1597. 		Jedis jedis = null;
  1598. 		Set<String> res = null;
  1599. 		try {
  1600. 			jedis = jedisPool.getResource();
  1601. 			res = jedis.sunion(keys);
  1602. 		} catch (Exception e) {
  1603.  
  1604. 			log.error(e.getMessage());
  1605. 		} finally {
  1606. 			returnResource(jedisPool, jedis);
  1607. 		}
  1608. 		return res;
  1609. 	}
  1610.  
  1611. 	/**
  1612. 	 * <p>
  1613. 	 * 通过key返回所有set的并集,并存入到新的set中
  1614. 	 * </p>
  1615. 	 *
  1616. 	 * @param dstkey
  1617. 	 * @param keys
  1618. 	 *            可以使一个string 也可以是一个string数组
  1619. 	 * @return
  1620. 	 */
  1621. 	public Long sunionstore(String dstkey, String... keys) {
  1622. 		Jedis jedis = null;
  1623. 		Long res = null;
  1624. 		try {
  1625. 			jedis = jedisPool.getResource();
  1626. 			res = jedis.sunionstore(dstkey, keys);
  1627. 		} catch (Exception e) {
  1628.  
  1629. 			log.error(e.getMessage());
  1630. 		} finally {
  1631. 			returnResource(jedisPool, jedis);
  1632. 		}
  1633. 		return res;
  1634. 	}
  1635.  
  1636. 	/**
  1637. 	 * <p>
  1638. 	 * 通过key将set中的value移除并添加到第二个set中
  1639. 	 * </p>
  1640. 	 *
  1641. 	 * @param srckey
  1642. 	 *            需要移除的
  1643. 	 * @param dstkey
  1644. 	 *            添加的
  1645. 	 * @param member
  1646. 	 *            set中的value
  1647. 	 * @return
  1648. 	 */
  1649. 	public Long smove(String srckey, String dstkey, String member) {
  1650. 		Jedis jedis = null;
  1651. 		Long res = null;
  1652. 		try {
  1653. 			jedis = jedisPool.getResource();
  1654. 			res = jedis.smove(srckey, dstkey, member);
  1655. 		} catch (Exception e) {
  1656.  
  1657. 			log.error(e.getMessage());
  1658. 		} finally {
  1659. 			returnResource(jedisPool, jedis);
  1660. 		}
  1661. 		return res;
  1662. 	}
  1663.  
  1664. 	/**
  1665. 	 * <p>
  1666. 	 * 通过key获取set中value的个数
  1667. 	 * </p>
  1668. 	 *
  1669. 	 * @param key
  1670. 	 * @return
  1671. 	 */
  1672. 	public Long scard(String key) {
  1673. 		Jedis jedis = null;
  1674. 		Long res = null;
  1675. 		try {
  1676. 			jedis = jedisPool.getResource();
  1677. 			res = jedis.scard(key);
  1678. 		} catch (Exception e) {
  1679.  
  1680. 			log.error(e.getMessage());
  1681. 		} finally {
  1682. 			returnResource(jedisPool, jedis);
  1683. 		}
  1684. 		return res;
  1685. 	}
  1686.  
  1687. 	/**
  1688. 	 * <p>
  1689. 	 * 通过key判断value是否是set中的元素
  1690. 	 * </p>
  1691. 	 *
  1692. 	 * @param key
  1693. 	 * @param member
  1694. 	 * @return
  1695. 	 */
  1696. 	public Boolean sismember(String key, String member) {
  1697. 		Jedis jedis = null;
  1698. 		Boolean res = null;
  1699. 		try {
  1700. 			jedis = jedisPool.getResource();
  1701. 			res = jedis.sismember(key, member);
  1702. 		} catch (Exception e) {
  1703.  
  1704. 			log.error(e.getMessage());
  1705. 		} finally {
  1706. 			returnResource(jedisPool, jedis);
  1707. 		}
  1708. 		return res;
  1709. 	}
  1710.  
  1711. 	/**
  1712. 	 * <p>
  1713. 	 * 通过key获取set中随机的value,不删除元素
  1714. 	 * </p>
  1715. 	 *
  1716. 	 * @param key
  1717. 	 * @return
  1718. 	 */
  1719. 	public String srandmember(String key) {
  1720. 		Jedis jedis = null;
  1721. 		String res = null;
  1722. 		try {
  1723. 			jedis = jedisPool.getResource();
  1724. 			res = jedis.srandmember(key);
  1725. 		} catch (Exception e) {
  1726.  
  1727. 			log.error(e.getMessage());
  1728. 		} finally {
  1729. 			returnResource(jedisPool, jedis);
  1730. 		}
  1731. 		return res;
  1732. 	}
  1733.  
  1734. 	/**
  1735. 	 * <p>
  1736. 	 * 通过key获取set中所有的value
  1737. 	 * </p>
  1738. 	 *
  1739. 	 * @param key
  1740. 	 * @return
  1741. 	 */
  1742. 	public Set<String> smembers(String key) {
  1743. 		Jedis jedis = null;
  1744. 		Set<String> res = null;
  1745. 		try {
  1746. 			jedis = jedisPool.getResource();
  1747. 			res = jedis.smembers(key);
  1748. 		} catch (Exception e) {
  1749.  
  1750. 			log.error(e.getMessage());
  1751. 		} finally {
  1752. 			returnResource(jedisPool, jedis);
  1753. 		}
  1754. 		return res;
  1755. 	}
  1756.  
  1757. 	/**
  1758. 	 * <p>
  1759. 	 * 通过key向zset中添加value,score,其中score就是用来排序的
  1760. 	 * </p>
  1761. 	 * <p>
  1762. 	 * 如果该value已经存在则根据score更新元素
  1763. 	 * </p>
  1764. 	 *
  1765. 	 * @param key
  1766. 	 * @param score
  1767. 	 * @param member
  1768. 	 * @return
  1769. 	 */
  1770. 	public Long zadd(String key, double score, String member) {
  1771. 		Jedis jedis = null;
  1772. 		Long res = null;
  1773. 		try {
  1774. 			jedis = jedisPool.getResource();
  1775. 			res = jedis.zadd(key, score, member);
  1776. 		} catch (Exception e) {
  1777.  
  1778. 			log.error(e.getMessage());
  1779. 		} finally {
  1780. 			returnResource(jedisPool, jedis);
  1781. 		}
  1782. 		return res;
  1783. 	}
  1784.  
  1785. 	/**
  1786. 	 * <p>
  1787. 	 * 返回有序集 key 中，指定区间内的成员。min=0,max=-1代表所有元素
  1788. 	 * </p>
  1789. 	 *
  1790. 	 * @param key
  1791. 	 * @param min
  1792. 	 * @param max
  1793. 	 * @return 指定区间内的有序集成员的列表。
  1794. 	 */
  1795. 	public Set<String> zrange(String key, long min, long max) {
  1796. 		Jedis jedis = null;
  1797. 		try {
  1798. 			jedis = jedisPool.getResource();
  1799. 			return jedis.zrange(key, min, max);
  1800. 		} catch (Exception e) {
  1801.  
  1802. 			log.error(e.getMessage());
  1803. 		} finally {
  1804. 			returnResource(jedisPool, jedis);
  1805. 		}
  1806. 		return null;
  1807. 	}
  1808.  
  1809. 	/**
  1810. 	 * <p>
  1811. 	 * 统计有序集 key 中,值在 min 和 max 之间的成员的数量
  1812. 	 * </p>
  1813. 	 *
  1814. 	 * @param key
  1815. 	 * @param min
  1816. 	 * @param max
  1817. 	 * @return 值在 min 和 max 之间的成员的数量。异常返回0
  1818. 	 */
  1819. 	public Long zcount(String key, double min, double max) {
  1820. 		Jedis jedis = null;
  1821. 		try {
  1822. 			jedis = jedisPool.getResource();
  1823. 			return jedis.zcount(key, min, max);
  1824. 		} catch (Exception e) {
  1825.  
  1826. 			log.error(e.getMessage());
  1827. 			return 0L;
  1828. 		} finally {
  1829. 			returnResource(jedisPool, jedis);
  1830. 		}
  1831.  
  1832. 	}
  1833.  
  1834. 	/**
  1835. 	 * <p>
  1836. 	 * 为哈希表 key 中的域 field 的值加上增量 increment 。增量也可以为负数，相当于对给定域进行减法操作。 如果 key
  1837. 	 * 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。如果域 field 不存在，那么在执行命令前，域的值被初始化为 0 。
  1838. 	 * 对一个储存字符串值的域 field 执行 HINCRBY 命令将造成一个错误。本操作的值被限制在 64 位(bit)有符号数字表示之内。
  1839. 	 * </p>
  1840. 	 * <p>
  1841. 	 * 将名称为key的hash中field的value增加integer
  1842. 	 * </p>
  1843. 	 *
  1844. 	 * @param key
  1845. 	 * @param value
  1846. 	 * @param increment
  1847. 	 * @return 执行 HINCRBY 命令之后，哈希表 key 中域 field的值。异常返回0
  1848. 	 */
  1849. 	public Long hincrBy(String key, String value, long increment) {
  1850. 		Jedis jedis = null;
  1851. 		try {
  1852. 			jedis = jedisPool.getResource();
  1853. 			return jedis.hincrBy(key, value, increment);
  1854. 		} catch (Exception e) {
  1855. 			log.error(e.getMessage());
  1856. 			return 0L;
  1857. 		} finally {
  1858. 			returnResource(jedisPool, jedis);
  1859. 		}
  1860.  
  1861. 	}
  1862.  
  1863. 	/**
  1864. 	 * <p>
  1865. 	 * 通过key删除在zset中指定的value
  1866. 	 * </p>
  1867. 	 *
  1868. 	 * @param key
  1869. 	 * @param members
  1870. 	 *            可以使一个string 也可以是一个string数组
  1871. 	 * @return
  1872. 	 */
  1873. 	public Long zrem(String key, String... members) {
  1874. 		Jedis jedis = null;
  1875. 		Long res = null;
  1876. 		try {
  1877. 			jedis = jedisPool.getResource();
  1878. 			res = jedis.zrem(key, members);
  1879. 		} catch (Exception e) {
  1880.  
  1881. 			log.error(e.getMessage());
  1882. 		} finally {
  1883. 			returnResource(jedisPool, jedis);
  1884. 		}
  1885. 		return res;
  1886. 	}
  1887.  
  1888. 	/**
  1889. 	 * <p>
  1890. 	 * 通过key增加该zset中value的score的值
  1891. 	 * </p>
  1892. 	 *
  1893. 	 * @param key
  1894. 	 * @param score
  1895. 	 * @param member
  1896. 	 * @return
  1897. 	 */
  1898. 	public Double zincrby(String key, double score, String member) {
  1899. 		Jedis jedis = null;
  1900. 		Double res = null;
  1901. 		try {
  1902. 			jedis = jedisPool.getResource();
  1903. 			res = jedis.zincrby(key, score, member);
  1904. 		} catch (Exception e) {
  1905.  
  1906. 			log.error(e.getMessage());
  1907. 		} finally {
  1908. 			returnResource(jedisPool, jedis);
  1909. 		}
  1910. 		return res;
  1911. 	}
  1912.  
  1913. 	/**
  1914. 	 * <p>
  1915. 	 * 通过key返回zset中value的排名
  1916. 	 * </p>
  1917. 	 * <p>
  1918. 	 * 下标从小到大排序
  1919. 	 * </p>
  1920. 	 *
  1921. 	 * @param key
  1922. 	 * @param member
  1923. 	 * @return
  1924. 	 */
  1925. 	public Long zrank(String key, String member) {
  1926. 		Jedis jedis = null;
  1927. 		Long res = null;
  1928. 		try {
  1929. 			jedis = jedisPool.getResource();
  1930. 			res = jedis.zrank(key, member);
  1931. 		} catch (Exception e) {
  1932.  
  1933. 			log.error(e.getMessage());
  1934. 		} finally {
  1935. 			returnResource(jedisPool, jedis);
  1936. 		}
  1937. 		return res;
  1938. 	}
  1939.  
  1940. 	/**
  1941. 	 * <p>
  1942. 	 * 通过key返回zset中value的排名
  1943. 	 * </p>
  1944. 	 * <p>
  1945. 	 * 下标从大到小排序
  1946. 	 * </p>
  1947. 	 *
  1948. 	 * @param key
  1949. 	 * @param member
  1950. 	 * @return
  1951. 	 */
  1952. 	public Long zrevrank(String key, String member) {
  1953. 		Jedis jedis = null;
  1954. 		Long res = null;
  1955. 		try {
  1956. 			jedis = jedisPool.getResource();
  1957. 			res = jedis.zrevrank(key, member);
  1958. 		} catch (Exception e) {
  1959.  
  1960. 			log.error(e.getMessage());
  1961. 		} finally {
  1962. 			returnResource(jedisPool, jedis);
  1963. 		}
  1964. 		return res;
  1965. 	}
  1966.  
  1967. 	/**
  1968. 	 * <p>
  1969. 	 * 通过key将获取score从start到end中zset的value
  1970. 	 * </p>
  1971. 	 * <p>
  1972. 	 * socre从大到小排序
  1973. 	 * </p>
  1974. 	 * <p>
  1975. 	 * 当start为0 end为-1时返回全部
  1976. 	 * </p>
  1977. 	 *
  1978. 	 * @param key
  1979. 	 * @param start
  1980. 	 * @param end
  1981. 	 * @return
  1982. 	 */
  1983. 	public Set<String> zrevrange(String key, long start, long end) {
  1984. 		Jedis jedis = null;
  1985. 		Set<String> res = null;
  1986. 		try {
  1987. 			jedis = jedisPool.getResource();
  1988. 			res = jedis.zrevrange(key, start, end);
  1989. 		} catch (Exception e) {
  1990.  
  1991. 			log.error(e.getMessage());
  1992. 		} finally {
  1993. 			returnResource(jedisPool, jedis);
  1994. 		}
  1995. 		return res;
  1996. 	}
  1997.  
  1998. 	/**
  1999. 	 * <p>
  2000. 	 * 通过key返回指定score内zset中的value
  2001. 	 * </p>
  2002. 	 *
  2003. 	 * @param key
  2004. 	 * @param max
  2005. 	 * @param min
  2006. 	 * @return
  2007. 	 */
  2008. 	public Set<String> zrangebyscore(String key, String max, String min) {
  2009. 		Jedis jedis = null;
  2010. 		Set<String> res = null;
  2011. 		try {
  2012. 			jedis = jedisPool.getResource();
  2013. 			res = jedis.zrevrangeByScore(key, max, min);
  2014. 		} catch (Exception e) {
  2015.  
  2016. 			log.error(e.getMessage());
  2017. 		} finally {
  2018. 			returnResource(jedisPool, jedis);
  2019. 		}
  2020. 		return res;
  2021. 	}
  2022.  
  2023. 	/**
  2024. 	 * <p>
  2025. 	 * 通过key返回指定score内zset中的value
  2026. 	 * </p>
  2027. 	 *
  2028. 	 * @param key
  2029. 	 * @param max
  2030. 	 * @param min
  2031. 	 * @return
  2032. 	 */
  2033. 	public Set<String> zrangeByScore(String key, double max, double min) {
  2034. 		Jedis jedis = null;
  2035. 		Set<String> res = null;
  2036. 		try {
  2037. 			jedis = jedisPool.getResource();
  2038. 			res = jedis.zrevrangeByScore(key, max, min);
  2039. 		} catch (Exception e) {
  2040.  
  2041. 			log.error(e.getMessage());
  2042. 		} finally {
  2043. 			returnResource(jedisPool, jedis);
  2044. 		}
  2045. 		return res;
  2046. 	}
  2047.  
  2048. 	/**
  2049. 	 * <p>
  2050. 	 * 返回指定区间内zset中value的数量
  2051. 	 * </p>
  2052. 	 *
  2053. 	 * @param key
  2054. 	 * @param min
  2055. 	 * @param max
  2056. 	 * @return
  2057. 	 */
  2058. 	public Long zcount(String key, String min, String max) {
  2059. 		Jedis jedis = null;
  2060. 		Long res = null;
  2061. 		try {
  2062. 			jedis = jedisPool.getResource();
  2063. 			res = jedis.zcount(key, min, max);
  2064. 		} catch (Exception e) {
  2065.  
  2066. 			log.error(e.getMessage());
  2067. 		} finally {
  2068. 			returnResource(jedisPool, jedis);
  2069. 		}
  2070. 		return res;
  2071. 	}
  2072.  
  2073. 	/**
  2074. 	 * <p>
  2075. 	 * 通过key返回zset中的value个数
  2076. 	 * </p>
  2077. 	 *
  2078. 	 * @param key
  2079. 	 * @return
  2080. 	 */
  2081. 	public Long zcard(String key) {
  2082. 		Jedis jedis = null;
  2083. 		Long res = null;
  2084. 		try {
  2085. 			jedis = jedisPool.getResource();
  2086. 			res = jedis.zcard(key);
  2087. 		} catch (Exception e) {
  2088.  
  2089. 			log.error(e.getMessage());
  2090. 		} finally {
  2091. 			returnResource(jedisPool, jedis);
  2092. 		}
  2093. 		return res;
  2094. 	}
  2095.  
  2096. 	/**
  2097. 	 * <p>
  2098. 	 * 通过key获取zset中value的score值
  2099. 	 * </p>
  2100. 	 *
  2101. 	 * @param key
  2102. 	 * @param member
  2103. 	 * @return
  2104. 	 */
  2105. 	public Double zscore(String key, String member) {
  2106. 		Jedis jedis = null;
  2107. 		Double res = null;
  2108. 		try {
  2109. 			jedis = jedisPool.getResource();
  2110. 			res = jedis.zscore(key, member);
  2111. 		} catch (Exception e) {
  2112.  
  2113. 			log.error(e.getMessage());
  2114. 		} finally {
  2115. 			returnResource(jedisPool, jedis);
  2116. 		}
  2117. 		return res;
  2118. 	}
  2119.  
  2120. 	/**
  2121. 	 * <p>
  2122. 	 * 通过key删除给定区间内的元素
  2123. 	 * </p>
  2124. 	 *
  2125. 	 * @param key
  2126. 	 * @param start
  2127. 	 * @param end
  2128. 	 * @return
  2129. 	 */
  2130. 	public Long zremrangeByRank(String key, long start, long end) {
  2131. 		Jedis jedis = null;
  2132. 		Long res = null;
  2133. 		try {
  2134. 			jedis = jedisPool.getResource();
  2135. 			res = jedis.zremrangeByRank(key, start, end);
  2136. 		} catch (Exception e) {
  2137.  
  2138. 			log.error(e.getMessage());
  2139. 		} finally {
  2140. 			returnResource(jedisPool, jedis);
  2141. 		}
  2142. 		return res;
  2143. 	}
  2144.  
  2145. 	/**
  2146. 	 * <p>
  2147. 	 * 通过key删除指定score内的元素
  2148. 	 * </p>
  2149. 	 *
  2150. 	 * @param key
  2151. 	 * @param start
  2152. 	 * @param end
  2153. 	 * @return
  2154. 	 */
  2155. 	public Long zremrangeByScore(String key, double start, double end) {
  2156. 		Jedis jedis = null;
  2157. 		Long res = null;
  2158. 		try {
  2159. 			jedis = jedisPool.getResource();
  2160. 			res = jedis.zremrangeByScore(key, start, end);
  2161. 		} catch (Exception e) {
  2162.  
  2163. 			log.error(e.getMessage());
  2164. 		} finally {
  2165. 			returnResource(jedisPool, jedis);
  2166. 		}
  2167. 		return res;
  2168. 	}
  2169.  
  2170. 	/**
  2171. 	 * <p>
  2172. 	 * 返回满足pattern表达式的所有key
  2173. 	 * </p>
  2174. 	 * <p>
  2175. 	 * keys(*)
  2176. 	 * </p>
  2177. 	 * <p>
  2178. 	 * 返回所有的key
  2179. 	 * </p>
  2180. 	 *
  2181. 	 * @param pattern
  2182. 	 * @return
  2183. 	 */
  2184. 	public Set<String> keys(String pattern) {
  2185. 		Jedis jedis = null;
  2186. 		Set<String> res = null;
  2187. 		try {
  2188. 			jedis = jedisPool.getResource();
  2189. 			res = jedis.keys(pattern);
  2190. 		} catch (Exception e) {
  2191.  
  2192. 			log.error(e.getMessage());
  2193. 		} finally {
  2194. 			returnResource(jedisPool, jedis);
  2195. 		}
  2196. 		return res;
  2197. 	}
  2198.  
  2199. 	public Set<String> keysBySelect(String pattern,int database) {
  2200. 		Jedis jedis = null;
  2201. 		Set<String> res = null;
  2202. 		try {
  2203. 			jedis = jedisPool.getResource();
  2204. 			jedis.select(database);
  2205. 			res = jedis.keys(pattern);
  2206. 		} catch (Exception e) {
  2207.  
  2208. 			log.error(e.getMessage());
  2209. 		} finally {
  2210. 			returnResource(jedisPool, jedis);
  2211. 		}
  2212. 		return res;
  2213. 	}
  2214.  
  2215.  
  2216. 	/**
  2217. 	 * <p>
  2218. 	 * 通过key判断值得类型
  2219. 	 * </p>
  2220. 	 *
  2221. 	 * @param key
  2222. 	 * @return
  2223. 	 */
  2224. 	public String type(String key) {
  2225. 		Jedis jedis = null;
  2226. 		String res = null;
  2227. 		try {
  2228. 			jedis = jedisPool.getResource();
  2229. 			res = jedis.type(key);
  2230. 		} catch (Exception e) {
  2231.  
  2232. 			log.error(e.getMessage());
  2233. 		} finally {
  2234. 			returnResource(jedisPool, jedis);
  2235. 		}
  2236. 		return res;
  2237. 	}
  2238.  
  2239. 	/**
  2240. 	 * 序列化对象
  2241. 	 * @param obj
  2242. 	 * @return
  2243. 	 * 对象需实现Serializable接口
  2244. 	 */
  2245. 	public static byte[] ObjTOSerialize(Object obj) {
  2246. 		ObjectOutputStream oos = null;
  2247. 		ByteArrayOutputStream byteOut = null;
  2248. 		try {
  2249. 			byteOut = new ByteArrayOutputStream();
  2250. 			oos = new ObjectOutputStream(byteOut);
  2251. 			oos.writeObject(obj);
  2252. 			byte[] bytes = byteOut.toByteArray();
  2253. 			return bytes;
  2254. 		} catch (Exception e) {
  2255. 		}
  2256. 		return null;
  2257. 	}
  2258.  
  2259. 	/**
  2260. 	 * 反序列化对象
  2261. 	 * @param bytes
  2262. 	 * @return
  2263. 	 * 对象需实现Serializable接口
  2264. 	 */
  2265. 	public static Object unserialize(byte[] bytes) {
  2266. 		ByteArrayInputStream bais = null;
  2267. 		try {
  2268. 			//反序列化
  2269. 			bais = new ByteArrayInputStream(bytes);
  2270. 			ObjectInputStream ois = new ObjectInputStream(bais);
  2271. 			return ois.readObject();
  2272. 		} catch (Exception e) {
  2273. 		}
  2274. 		return null;
  2275. 	}
  2276.  
  2277. 	/**
  2278. 	 * 返还到连接池
  2279. 	 *
  2280. 	 * @param jedisPool
  2281. 	 * @param jedis
  2282. 	 */
  2283. 	public static void returnResource(JedisPool jedisPool, Jedis jedis) {
  2284. 		if (jedis != null) {
  2285. 			jedisPool.returnResource(jedis);
  2286. 		}
  2287. 	}
  2288.  
  2289. 	// public static RedisUtil getRu() {
  2290. 	// return ru;
  2291. 	// }
  2292. 	//
  2293. 	// public static void setRu(RedisUtil ru) {
  2294. 	// RedisUtil.ru = ru;
  2295. 	// }
  2296.  
  2297. 	public static void main(String[] args) {
  2298. 		/*JedisPool jedisPool = new JedisPool(null,"localhost",6379,100,"123456");
  2299. 		Jedis jedis = jedisPool.getResource();
  2300. 		//r.get("", RedisConstants.datebase4);
  2301. 		jedis.select(RedisConstants.datebase4);
  2302. 		Set<String> str =  jedis.keys("*");
  2303. 		for (String string : str) {
  2304. 			System.out.println(string);
  2305. 		}*/
  2306. 	}
  2307. }

4.示例说明，同样的，我拿出最基本的set方法，indexdb参数为需要自定义的redis库编码，finally中我们回收此连接放入连接池。

  1. 	public String set(String key, String value,int indexdb) {
  2. 		Jedis jedis = null;
  3. 		try {
  4. 			jedis = jedisPool.getResource();
  5. 			jedis.select(indexdb);
  6. 			return jedis.set(key, value);
  7. 		} catch (Exception e) {
  8.  
  9. 			log.error(e.getMessage());
  10. 			return "0";
  11. 		} finally {
  12. 			returnResource(jedisPool, jedis);
  13. 		}
  14. 	}

二、实际操作示例

还是一样，这里新建Controller进行测试操作

RedisController.java

  1. package com.springboot.demo.controller;
  2.  
  3. import com.springboot.demo.base.controller.BaseController;
  4. import com.springboot.demo.base.utils.RedisConstants;
  5. import com.springboot.demo.base.utils.RedisUtil;
  6. import com.springboot.demo.base.utils.StateParameter;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.stereotype.Controller;
  9. import org.springframework.ui.ModelMap;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11. import org.springframework.web.bind.annotation.RequestMethod;
  12. import org.springframework.web.bind.annotation.ResponseBody;
  13.  
  14. /**
  15.  * @ClassName: RedisController
  16.  * @Auther: zhangyingqi
  17.  * @Date: 2018/8/29 16:15
  18.  * @Description:
  19.  */
  20. @Controller
  21. @RequestMapping(value="/redis")
  22. public class RedisController extends BaseController {
  23.     @Autowired
  24.     RedisUtil redisUtil;
  25.  
  26.     /**
  27.      * @auther: zhangyingqi
  28.      * @date: 16:23 2018/8/29
  29.      * @param: []
  30.      * @return: org.springframework.ui.ModelMap
  31.      * @Description: 执行redis写/读/生命周期
  32.      */
  33.     @RequestMapping(value = "getRedis",method = RequestMethod.POST)
  34.     @ResponseBody
  35.     public ModelMap getRedis(){
  36.         redisUtil.set("20182018","这是一条测试数据", RedisConstants.datebase1);
  37.         Long resExpire = redisUtil.expire("20182018", 60, RedisConstants.datebase1);//设置key过期时间
  38.         logger.info("resExpire="+resExpire);
  39.         String res = redisUtil.get("20182018", RedisConstants.datebase1);
  40.         return getModelMap(StateParameter.SUCCESS, res, "执行成功");
  41.     }
  42.  
  43. }

使用@Autowired注入RedisUtil

使用以下语句存储缓存值

redisUtil.set("20182018","这是一条测试数据", RedisConstants.datebase1);

使用以下语句设置该值的生命周期即有效期，单位是秒

Long resExpire = redisUtil.expire("20182018", 60, RedisConstants.datebase1);//设置key过期时间

启动项目请求地址：http://localhost:8080/redis/getRedis，返回成功，打开redis客户端工具，可以看到在db1中存入了该数据，并且设置了有效时间为60秒，截图时还剩余54秒。

 最后给出pom包

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4. 	<modelVersion>4.0.0</modelVersion>
  5.  
  6. 	<groupId>com.springboot</groupId>
  7. 	<artifactId>springbootRedis2</artifactId>
  8. 	<version>0.0.1-SNAPSHOT</version>
  9. 	<packaging>war</packaging>
  10.  
  11. 	<name>springbootRedis2</name>
  12. 	<description>Demo project for Spring Boot</description>
  13.  
  14. 	<parent>
  15. 		<groupId>org.springframework.boot</groupId>
  16. 		<artifactId>spring-boot-starter-parent</artifactId>
  17. 		<version>2.0.4.RELEASE</version>
  18. 		<relativePath/> <!-- lookup parent from repository -->
  19. 	</parent>
  20.  
  21. 	<properties>
  22. 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  23. 		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  24. 		<java.version>1.8</java.version>
  25. 	</properties>
  26.  
  27. 	<dependencies>
  28. 		<dependency>
  29. 			<groupId>org.springframework.boot</groupId>
  30. 			<artifactId>spring-boot-starter-tomcat</artifactId>
  31. 			<!--<scope>provided</scope>-->
  32. 		</dependency>
  33. 		<dependency>
  34. 			<groupId>org.springframework.boot</groupId>
  35. 			<artifactId>spring-boot-starter-data-jpa</artifactId>
  36. 			<exclusions>
  37. 				<exclusion>
  38. 					<groupId>org.hibernate</groupId>
  39. 					<artifactId>hibernate-entitymanager</artifactId>
  40. 				</exclusion>
  41. 				<exclusion>
  42. 					<groupId>org.hibernate</groupId>
  43. 					<artifactId>hibernate-core</artifactId>
  44. 				</exclusion>
  45. 			</exclusions>
  46. 		</dependency>
  47. 		<dependency>
  48. 			<groupId>org.hibernate</groupId>
  49. 			<artifactId>hibernate-core</artifactId>
  50. 			<version>5.2.10.Final</version>
  51. 		</dependency>
  52. 		<dependency>
  53. 			<groupId>org.springframework.boot</groupId>
  54. 			<artifactId>spring-boot-starter-data-redis</artifactId>
  55. 		</dependency>
  56. 		<dependency>
  57. 			<groupId>org.springframework.boot</groupId>
  58. 			<artifactId>spring-boot-starter-mail</artifactId>
  59. 		</dependency>
  60. 		<dependency>
  61. 			<groupId>org.springframework.boot</groupId>
  62. 			<artifactId>spring-boot-starter-thymeleaf</artifactId>
  63. 		</dependency>
  64. 		<dependency>
  65. 			<groupId>org.springframework.boot</groupId>
  66. 			<artifactId>spring-boot-starter-web</artifactId>
  67. 		</dependency>
  68.  
  69. 		<dependency>
  70. 			<groupId>mysql</groupId>
  71. 			<artifactId>mysql-connector-java</artifactId>
  72. 			<scope>runtime</scope>
  73. 		</dependency>
  74. 		<dependency>
  75. 			<groupId>org.projectlombok</groupId>
  76. 			<artifactId>lombok</artifactId>
  77. 			<optional>true</optional>
  78. 		</dependency>
  79. 		<dependency>
  80. 			<groupId>org.springframework.boot</groupId>
  81. 			<artifactId>spring-boot-starter-test</artifactId>
  82. 			<scope>test</scope>
  83. 		</dependency>
  84. 		<dependency>
  85. 			<groupId>org.springframework.boot</groupId>
  86. 			<!--<artifactId>spring-boot-starter-redis</artifactId>-->
  87. 			<artifactId>spring-boot-starter-data-redis</artifactId>
  88. 		</dependency>
  89. 		<dependency>
  90. 			<groupId>redis.clients</groupId>
  91. 			<artifactId>jedis</artifactId>
  92. 			<version>2.9.0</version>
  93. 		</dependency>
  94. 	</dependencies>
  95.  
  96. 	<build>
  97. 		<plugins>
  98. 			<plugin>
  99. 				<groupId>org.springframework.boot</groupId>
  100. 				<artifactId>spring-boot-maven-plugin</artifactId>
  101. 			</plugin>
  102. 		</plugins>
  103. 	</build>
  104.  
  105.  
  106. </project>

实际上只需引入以下两个依赖即可，注意由于springboot的版本不同，引入redis的配置写法略有不同。我注释掉的是旧版本的springboot引入redis方式，请留意。

  1. 		<dependency>
  2. 			<groupId>org.springframework.boot</groupId>
  3. 			<!--<artifactId>spring-boot-starter-redis</artifactId>-->
  4. 			<artifactId>spring-boot-starter-data-redis</artifactId>
  5. 		</dependency>
  6. 		<dependency>
  7. 			<groupId>redis.clients</groupId>
  8. 			<artifactId>jedis</artifactId>
  9. 			<version>2.9.0</version>
  10. 		</dependency>

花了一些时间对这两种在springboot中引入Redis的方式进行了一个小结，实际使用中发现两者并无太大差异，所以任选一个即可。

写博文不易，转载请注明出处。

全文完，2018/8/29

posted @ 2019-02-25 10:45  tangblog  阅读(10007)  评论(0)  编辑  收藏  举报