打开APP
userphoto
未登录

开通VIP，畅享免费电子书等14项超值服

开通VIP

首页

好书

留言交流

下载APP

联系客服
redis实现高并发投票网站
userphoto
昵称10087950  >《JAVA》

2022.10.03 江苏

关注

注：原始资料来自于享学课堂，加上自己的理解和修改

目录

1、基本逻辑分析

1.1 文章投票功能模块需求

1.2 数据库设计

​1.3 使用到的数据类型和相关指令

1.4 key设计思路

1.5、记录已投票用户，防重投

1.6 记录文章分数

1.7、Redis缓存设计实战

1.8、缓存数据变化

2、代码实现

2.1文章处理相关接口

2.2 具体接口实现

2.3 redis的工具类

1、基本逻辑分析

1.1 文章投票功能模块需求

  • 用户可以发表文章,发表时默认给自己的文章投了一票
  • 用户在查看网站时可以按评分进行排列查看 （想到排序就是zset）
  • 用户也可以按照文章发布时间进行排序 （想到排序就是zset）
  • 为节约内存，一篇文章发表后，7天内可以投票,7天过后就不能再投票了 （这里就是加上过期时间）
  • 为防止同一用户多次投票，用户只能给一篇文章投一次票（重复就想到set）

1.2 数据库设计

文章基本信息表 article

 

文章票数与分值表 vote_data

文章投票详表 vote_details


1.3 使用到的数据类型和相关指令

指令如下：

  • HASH：hset  hincrBy  hgetAll   expire
  • SET：sadd  smembers
  • ZSET：zadd   zscore  zincrby  zrevrange

1.4 key设计思路

key的设计一般使用数据库名+主键,这样就能够保证key的唯一性

比如：set user:1 123

1.5、记录已投票用户，防重投

  • set：无序不重复
  • zset：有序不重复

防止重复首先就想到set，zset类型数据，由于没有排行等需求，使用更加简单的set就能满足需求

1.6 记录文章分数

由于涉及到分数的排行和文章发布时间的排行，首先想到的就是使用zset保存数据（默认分数从小到大升序排序）

1.7、Redis缓存设计实战

1.8、缓存数据变化

2、代码实现

2.1文章处理相关接口

  1. /**
  2.  *  RedisArticleService
  3.  *  
  4.  * @author: honry.guan
  5.  * @date: 2021/4/12 17:36
  6.  */
  7. public interface RedisArticleService {
  8.     /**
  9.      * 文章发布,这里只是做个演示，一般存在数据库中
  10.      *
  11.      * @param title   标题
  12.      * @param content 内容
  13.      * @param link    链接
  14.      * @param userId  用户ID
  15.      * @return 文章的ID
  16.      */
  17.     String postArticle(String title, String content, String link, String userId);
  19.     /**
  20.      * 获取key所有数据
  21.      *
  22.      * @param key redis的key
  23.      * @return 数据集
  24.      */
  25.     Map<String, String> hgetAll(String key);
  27.     /**
  28.      * 文章投票
  29.      *
  30.      * @param userId    用户id
  31.      * @param articleId 文章id
  32.      */
  33.     void articleVote(String userId, String articleId);
  35.     /**
  36.      * 获取文章某个字段的值
  37.      *
  38.      * @param key   redis的key
  39.      * @param votes 字段field
  40.      * @return 返回值
  41.      */
  42.     String hget(String key, String votes);
  44.     /**
  45.      * 文章列表查询（分页）
  46.      *
  47.      * @param page key
  48.      * @return redis查询结果
  49.      */
  50.     List<Map<String, String>> getArticles(int page, String order);
  51. }

2.2 具体接口实现

代码key说明：

文章1的投票人，不能重复投，使用set：jedis.sadd("voted:1" , userId);

文章对象信息，使用hash保存：jedis.hmset(article, articleData);

分数排行，看着排行，就想到zset：jedis.zadd("score:info", now + Constants.VOTE_SCORE, article);

时间排行，看着排行，就想到zset：jedis.zadd("time:", now, article);

  1. @Service
  2. public class RedisArticleServiceImpl implements RedisArticleService {
  4.     @Resource
  5.     private JedisUtils jedis;
  7.     /**
  8.      * 文章提交发布
  9.      *
  10.      * @param title   标题
  11.      * @param content 内容
  12.      * @param link    链接
  13.      * @param userId  用户ID
  14.      * @return 文章的ID
  15.      */
  16.     @Override
  17.     public String postArticle(String title, String content, String link, String userId) {
  19.         //article:001// articleId=1
  20.         String articleId = String.valueOf(jedis.incr("article:"));
  22.         //投票键： voted:
  23.         String voted = "voted:" + articleId;
  25.         //自己先给自己投一票
  26.         jedis.sadd(voted, userId);
  27.         jedis.expire(voted, Constants.ONE_WEEK_IN_SECONDS);
  29.         long now = System.currentTimeMillis() / 1000;
  31.         String article = "article:" + articleId;
  33.         HashMap<String, String> articleData = new HashMap<String, String>(5);
  34.         articleData.put("title", title);
  35.         articleData.put("link", link);
  36.         articleData.put("user", userId);
  37.         articleData.put("now", String.valueOf(now));
  38.         articleData.put("votes", "1");
  40.         //添加一篇文章
  41.         jedis.hmset(article, articleData);
  42.         //增加分数排行，随机初始化了一个分数now + Constants.VOTE_SCORE
  43.         jedis.zadd("score:info", now + Constants.VOTE_SCORE, article);
  44.         //增加时间排行
  45.         jedis.zadd("time:", now, article);
  47.         return articleId;
  48.     }
  51.     /**
  52.      * 文章投票
  53.      *
  54.      * @param userId  用户ID
  55.      * @param article 文章ID（article:001）
  56.      */
  57.     @Override
  58.     public void articleVote(String userId, String article) {
  61.         //计算投票截止时间
  62.         long cutoff = (System.currentTimeMillis() / 1000) - Constants.ONE_WEEK_IN_SECONDS;
  63.         //检查是否还可以对文章进行投票,如果该文章的发布时间比截止时间小，则已过期，不能进行投票
  64.         if (jedis.zscore("time:", article) < cutoff) {
  65.             return;
  66.         }
  67.         //获取文章主键idarticle:1    1
  68.         String articleId = article.substring(article.indexOf(':') + 1);
  71.         //添加投票人，投票人添加成功，才增加分数和投票数
  72.         if (jedis.sadd("voted:" + articleId, userId) == 1) {
  73.             //分值加400
  74.             jedis.zincrby("score:info", Constants.VOTE_SCORE, article);
  75.             //投票数加1
  76.             jedis.hincrBy(article, "votes", 1L);
  77.         }
  78.     }
  81.     /**
  82.      * 文章列表查询（分页）
  83.      *
  84.      * @param page key
  85.      * @return redis查询结果
  86.      */
  87.     @Override
  88.     public List<Map<String, String>> getArticles(int page, String key) {
  89.         int start = (page - 1) * Constants.ARTICLES_PER_PAGE;
  90.         int end = start + Constants.ARTICLES_PER_PAGE - 1;
  91.         //倒序查询出投票数最高的文章，zset有序集合，分值递减
  92.         Set<String> ids = jedis.zrevrange(key, start, end);
  93.         List<Map<String, String>> articles = new ArrayList<>();
  94.         for (String id : ids) {
  95.             Map<String, String> articleData = jedis.hgetAll(id);
  96.             articleData.put("id", id);
  97.             articles.add(articleData);
  98.         }
  99.         return articles;
  100.     }
  103.     @Override
  104.     public String hget(String key, String feild) {
  105.         return jedis.hget(key, feild);
  106.     }
  108.     @Override
  109.     public Map<String, String> hgetAll(String key) {
  110.         return jedis.hgetAll(key);
  111.     }
  112. }

2.3 redis的工具类

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

 

 

 

 

 

 

 

 

 

 

 

 

本站仅提供存储服务，所有内容均由用户发布，如发现有害或侵权内容，请点击举报。
打开APP，阅读全文并永久保存 查看更多类似文章
猜你喜欢
类似文章
【热】打开小程序，算一算2024你的财运
redis缓存和mysql数据库同步
springboot使用redis指南
使用 pipeline 提升 Redis 的访问性能
Jedis对redis的操作详解
缓存对事务的支持
什么是分布式锁及正确使用redis实现分布式锁
更多类似文章 >>
生活服务
热点新闻
留言交流
回顶部
联系我们
分享 收藏 导长图 关注 下载文章
绑定账号成功
后续可登录账号畅享VIP特权！
如果VIP功能使用有故障，
可点击这里联系客服！

联系客服