zoukankan      html  css  js  c++  java

  • 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
  • 相关阅读:
    【数据相关】如何进行数据标注（1）
    【机器视觉硬件】机器视觉硬件学习笔记3——镜头
    【机器视觉硬件】工业相机的分类
    【机器视觉硬件】工业相机的主要参数
    【机器视觉硬件】工业相机的主要接口类型
    【机器视觉硬件】机器视觉硬件学习笔记2——工业相机
    【知识相关】机器学习之独热编码（One-Hot）详解（代码解释）
    【机器视觉硬件】硬件学习笔记1——光源
    学习笔记分享之汇编---3. 堆栈&标志寄存器
    学习笔记分享之汇编---1. 通用寄存器
  • 原文地址：https://www.cnblogs.com/tanghaoran-blog/p/10429607.html
Copyright © 2011-2022 走看看