服务器之家:专注于服务器技术及软件下载分享
分类导航

Mysql|Sql Server|Oracle|Redis|MongoDB|PostgreSQL|Sqlite|DB2|mariadb|Access|数据库技术|

服务器之家 - 数据库 - Redis - Redis实战之百度首页新闻热榜的实现代码

Redis实战之百度首页新闻热榜的实现代码

2021-07-25 22:05山前留名 Redis

这篇文章主要介绍了Redis实战之百度首页新闻热榜的实现代码,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下

目标

利用Redis实现类似百度首页新闻热榜功能。

功能

新闻排行榜以热度为指标降序排序,这里假设热度就是评论数量且统计的热度时间范围以当天为准;根据新闻的时效性,这里假设每15分钟刷新一次新闻榜单。

Redis实战之百度首页新闻热榜的实现代码



分析 Zset数据类型:一个有序集合最多 Redis实战之百度首页新闻热榜的实现代码 个元素,集合元素有序不可重复,每个元素都会关联一个double类型的分数。元素根据分数从小到大的排序,分数可以重复。zscore命令可以对分数实现增量,且如果该Zset中没有该元素,则会创建该条数据。可以将模块名+当天的时间作为Zset的键,用户评论量作为分数,新闻标题作为值,每当用户评论一次新闻,分数则相应地加1。每隔15分钟提取新闻统计中的前30名(包含第30名)榜单,放入到新闻热榜的Zset中。

 


代码实现

控制层

  1. package com.shoppingcart.controller;
  2.  
  3. import com.shoppingcart.service.NewsTopServer;
  4. import org.springframework.web.bind.annotation.*;
  5. import javax.annotation.Resource;
  6. import java.util.List;
  7. import java.util.Map;
  8.  
  9. /**
  10. * 新闻排行榜
  11. */
  12. @RestController
  13. @RequestMapping("/newsTop")
  14. public class NewsTopController {
  15. @Resource
  16. public NewsTopServer newsTopServer;
  17.  
  18. /**
  19. * http://localhost:8099/newsTop/zscoreNews?newTitle=《欢乐喜剧人7》全新赛制养成新人&score=434000
  20. * 创建新闻统计&实时统计新闻热度
  21. * @param newTitle 新闻标题 (根据业务也可以写成新闻ID)
  22. * @param score 热度增量
  23. * @return 给新闻一个增量以后,返回新闻的当前分数。
  24. */
  25. @GetMapping("/zscoreNews")
  26. public Map<String, Object> zscoreNews(
  27. @RequestParam(value = "newTitle", required = true) String newTitle,
  28. @RequestParam(value = "score", defaultValue = "1") double score
  29. ) {
  30. Map<String, Object> map = newsTopServer.incrementScore(newTitle, score);
  31. return map;
  32. }
  33.  
  34. /**
  35. * http://localhost:8099/newsTop/findNewByNewTitle?newTitle=《欢乐喜剧人7》全新赛制养成新人
  36. * 查询某条新闻的热度
  37. * @param newTitle
  38. * @return
  39. */
  40. @GetMapping("/findNewByNewTitle")
  41. public Map<String, Object> findNewByNewTitle(
  42. @RequestParam(value = "newTitle", required = true) String newTitle
  43. ) {
  44. Map<String, Object> map = newsTopServer.findNewByNewTitle(newTitle);
  45. return map;
  46. }
  47.  
  48. /**
  49. * http://localhost:8099/newsTop/createNewsTop?startPage=0&endPage=29
  50. * 对统计的新闻数据降序排序,并将[29,0]之间的数据放入新闻排行榜。(这个方法可以设置成定时任务。)
  51. * @param startPage 开始下标
  52. * @param endPage 结束下标
  53. * @return
  54. */
  55. @GetMapping("/createNewsTop")
  56. public Map<String, Object> createNewsTop(
  57. @RequestParam(value = "startPage", defaultValue = "0") int startPage,
  58. @RequestParam(value = "endPage", defaultValue = "29") int endPage
  59. ) {
  60. Map<String, Object> map = newsTopServer.createNewsTop(startPage, endPage);
  61. return map;
  62. }
  63.  
  64. /**
  65. * http://localhost:8099/newsTop/newsTop?startPage=20&endPage=29
  66. * 对统计的新闻数据降序排序,并将[29,0]之间的数据放入新闻排行榜。(这个方法可以设置成定时任务。)
  67. *
  68. * @param startPage 开始下标
  69. * @param endPage 结束下标
  70. * @return
  71. */
  72. @GetMapping("/newsTop")
  73. public Map<String, Object> newsTop(
  74. @RequestParam(value = "startPage", defaultValue = "0") int startPage,
  75. @RequestParam(value = "endPage", defaultValue = "9") int endPage
  76. ) {
  77. Map<String, Object> map = newsTopServer.newsTop(startPage, endPage);
  78. return map;
  79. }
  80.  
  81. /**
  82. * http://localhost:8099/newsTop/addTestData
  83. * 批量增加测试数据(新闻统计)
  84. */
  85. @PostMapping("/addTestData")
  86. public void addTestData(@RequestBody List<Map<String, Object>> list) {
  87. for (int i = 0; i < list.size(); i++) {
  88. System.out.println(list.get(i).get("value").toString());
  89. System.out.println(Double.parseDouble(list.get(i).get("score").toString()));
  90. zscoreNews(list.get(i).get("value").toString(), Double.parseDouble(list.get(i).get("score").toString()));
  91. }
  92. }
  93. /**新增测试数据:
  94. [
  95. {
  96. "score": 2356428.0,
  97. "value": "《蒙面唱将猜猜猜》第五季收官"
  98. },
  99. {
  100. "score": 2335456.0,
  101. "value": "《欢乐喜剧人7》全新赛制养成新人"
  102. },
  103. {
  104. "score": 987655.0,
  105. "value": "《星光大道》2020年度总决赛"
  106. },
  107. {
  108. "score": 954566.0,
  109. "value": "网易北京:重构梦幻西游项目"
  110. },
  111. {
  112. "score": 943665.0,
  113. "value": "神武惊现靓号:44488888"
  114. },
  115. {
  116. "score": 876653.0,
  117. "value": "小米手机:红米"
  118. },
  119. {
  120. "score": 875444.0,
  121. "value": "英特尔扩大外包"
  122. },
  123. {
  124. "score": 755656.0,
  125. "value": "多益广州举办神武4手游比赛"
  126. },
  127. {
  128. "score": 687466.0,
  129. "value": "亮剑重播超记录"
  130. },
  131. {
  132. "score": 567645.0,
  133. "value": "春节快到了"
  134. },
  135. {
  136. "score": 554342.0,
  137. "value": "购票狂潮"
  138. },
  139. {
  140. "score": 466654.0,
  141. "value": "达摩院旗下拥有20多位世界级的科学家"
  142. },
  143. {
  144. "score": 456666.0,
  145. "value": "NBA MVP候选人"
  146. },
  147. {
  148. "score": 435654.0,
  149. "value": "CBA最佳新秀"
  150. },
  151. {
  152. "score": 392875.0,
  153. "value": "数字货币新时代"
  154. },
  155. {
  156. "score": 300454.0,
  157. "value": "网易新手游即将发布"
  158. },
  159. {
  160. "score": 277654.0,
  161. "value": "CBA12强排名:四强格局已定"
  162. },
  163. {
  164. "score": 265656.0,
  165. "value": "用黑科技悄悄改变大众生活"
  166. },
  167. {
  168. "score": 234665.0,
  169. "value": "玉溪:致力打造全省数字经济第一城"
  170. },
  171. {
  172. "score": 234665.0,
  173. "value": "广西培育消费新业态新模式"
  174. },
  175. {
  176. "score": 234656.0,
  177. "value": "互联网产品是顺从用户?还是教育用户?"
  178. },
  179. {
  180. "score": 234564.0,
  181. "value": "蒋军:企业做强,做大跟产品的关系是什么?"
  182. },
  183. {
  184. "score": 234564.0,
  185. "value": "热搜第一!微信又有重大更新,这次有点炸"
  186. },
  187. {
  188. "score": 234555.0,
  189. "value": "成功的人,往往都读这“6”种书"
  190. },
  191. {
  192. "score": 134566.0,
  193. "value": "外地职工留苏州过年 落户加15分"
  194. },
  195. {
  196. "score": 133455.0,
  197. "value": "蒋军:成功创业的7种思维!创业者必读!"
  198. },
  199. {
  200. "score": 98554.0,
  201. "value": "阿里平头哥:首个RISC - V版安卓10系统顺畅运行"
  202. },
  203. {
  204. "score": 87654.0,
  205. "value": "不断增强人民群众就医获得感"
  206. },
  207. {
  208. "score": 54347.0,
  209. "value": "《星光大道》年度总冠军出炉"
  210. },
  211. {
  212. "score": 43335.0,
  213. "value": "流量应是榜样,榜样应成力量"
  214. },
  215. {
  216. "score": 23555.0,
  217. "value": "《山海情》:主旋律可以这样好看"
  218. },
  219. {
  220. "score": 23456.0,
  221. "value": "2021艺考新动向"
  222. }
  223. ]
  224. */
  225. }

业务层

  1. package com.shoppingcart.service;
  2.  
  3. import java.util.Map;
  4.  
  5. public interface NewsTopServer {
  6. Map<String, Object> incrementScore(String newTitle,double zscore);
  7. Map<String, Object> findNewByNewTitle(String newTitle);
  8. Map<String, Object> createNewsTop(int startPage, int endPage);
  9. Map<String, Object> newsTop(int startPage, int endPage);
  10. }
  1. package com.shoppingcart.service.impl;
  2.  
  3. import com.shoppingcart.service.NewsTopServer;
  4. import com.shoppingcart.utils.RedisService;
  5. import org.springframework.data.redis.core.ZSetOperations;
  6. import org.springframework.stereotype.Service;
  7. import javax.annotation.Resource;
  8. import java.util.*;
  9.  
  10. @Service
  11. public class NewsTopServerImpl implements NewsTopServer {
  12. @Resource
  13. private RedisService redisService;
  14.  
  15. @Override
  16. public Map<String, Object> incrementScore(String newTitle, double score) {
  17. Map<String, Object> map = new HashMap<>();
  18. //String key= "newsSta:"+DateUtils.dateToString(new Date(),"yyyyMMdd");
  19. String key = "newsSta:" + "20210123";
  20. Double d = redisService.incrementScore(key, newTitle, score);
  21. Map<String, Object> m = new HashMap<String, Object>() {
  22. {
  23. put("key", key);
  24. put("newTitle", newTitle);
  25. put("score", d);
  26. }
  27. };
  28. map.put("data", m);
  29. map.put("code", 0);
  30. return map;
  31. }
  32.  
  33. @Override
  34. public Map<String, Object> findNewByNewTitle(String newTitle) {
  35. //String key= "newsSta:"+DateUtils.dateToString(new Date(),"yyyyMMdd");
  36. String key = "newsSta:" + "20210123";
  37. Double d = redisService.score(key, newTitle);
  38. Map<String, Object> map = new HashMap<>();
  39. Map<String, Object> m = new HashMap<String, Object>() {
  40. {
  41. put("key", key);
  42. put("newTitle", newTitle);
  43. put("score", d);
  44. }
  45. };
  46. map.put("data", m);
  47. map.put("code", 0);
  48. return map;
  49. }
  50.  
  51. /**
  52. * @param startPage
  53. * @param endPage
  54. * @return
  55. */
  56. @Override
  57. public Map<String, Object> createNewsTop(int startPage, int endPage) {
  58. Map<String, Object> map = new HashMap<>();
  59. //新闻统计键
  60. //String newsStaKey= "newsSta:"+DateUtils.dateToString(new Date(),"yyyyMMdd");
  61. String newsStaKey = "newsSta:" + "20210123";
  62. //新闻前30排名键
  63. //String newsTopKey= "newsSta:"+DateUtils.dateToString(new Date(),"yyyyMMdd");
  64. String newsTopKey = "newsTop:" + "20210123";
  65. //查询前30的信息(Interface Comparable<T> :该接口对实现它的每个类的对象强加一个整体排序。)
  66. Set<ZSetOperations.TypedTuple<Object>> set = redisService.reverseRangeWithScores(newsStaKey, startPage, endPage);
  67. if (set == null || set.size() == 0) {
  68. map.put("data", null);
  69. map.put("code", 1);
  70. return map;
  71. }
  72. //删除旧的新闻排行榜
  73. redisService.del(newsTopKey);
  74. //添加新闻排行榜数据
  75. Long zsetSize = redisService.zsetAdd(newsTopKey, set);
  76. Map<String, Object> m = new HashMap<String, Object>() {
  77. {
  78. put("data", set);
  79. put("size", zsetSize);
  80. }
  81. };
  82. map.put("data", m);
  83. map.put("code", 0);
  84. return map;
  85. }
  86.  
  87. /**
  88. * 查看新闻热榜(TOP30)
  89. *
  90. * @param startPage
  91. * @param endPage
  92. * @return
  93. */
  94. @Override
  95. public Map<String, Object> newsTop(int startPage, int endPage) {
  96. //新闻统计键
  97. //String newsStaKey= "newsSta:"+DateUtils.dateToString(new Date(),"yyyyMMdd");
  98. String newsStaKey = "newsSta:" + "20210123";
  99. //新闻前30排名键
  100. //String newsTopKey= "newsSta:"+DateUtils.dateToString(new Date(),"yyyyMMdd");
  101. String newsTopKey = "newsTop:" + "20210123";
  102. Set<ZSetOperations.TypedTuple<Object>> set = redisService.reverseRangeWithScores(newsTopKey, startPage, endPage);
  103. Map<String, Object> m = new HashMap<String, Object>();
  104. m.put("data", set);
  105. m.put("size", set.size());
  106. //新闻排行榜为空,也许现在正在添加数据,先查询新闻统计键。
  107. if (set == null || set.size() == 0) {
  108. //查询前30的信息(Interface Comparable<T> :该接口对实现它的每个类的对象强加一个整体排序。)
  109. Set<ZSetOperations.TypedTuple<Object>> set2 = redisService.reverseRangeWithScores(newsStaKey, startPage, endPage);
  110. m.put("data", set);
  111. m.put("size", set.size());
  112. }
  113. Map<String, Object> map = new HashMap<>();
  114. map.put("data", m);
  115. map.put("code", 0);
  116. return map;
  117. }
  118. }

工具类

  1. package com.shoppingcart.utils;
  2.  
  3. import java.text.SimpleDateFormat;
  4. import java.util.Date;
  5.  
  6. public class DateUtils {
  7. // 日期转字符串,返回指定的格式
  8. public static String dateToString(Date date, String dateFormat) {
  9. SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
  10. return sdf.format(date);
  11. }
  12. }
  1. package com.shoppingcart.utils;
  2.  
  3. import com.alibaba.fastjson.JSONObject;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.data.redis.connection.RedisZSetCommands;
  6. import org.springframework.data.redis.connection.SortParameters;
  7. import org.springframework.data.redis.core.DefaultTypedTuple;
  8. import org.springframework.data.redis.core.RedisTemplate;
  9. import org.springframework.data.redis.core.ZSetOperations;
  10. import org.springframework.stereotype.Service;
  11. import org.springframework.util.CollectionUtils;
  12. import org.w3c.dom.ranges.Range;
  13.  
  14. import java.util.*;
  15. import java.util.concurrent.TimeUnit;
  16. import java.util.stream.Collectors;
  17.  
  18. @Service
  19. public class RedisService {
  20.  
  21. @Autowired
  22. private RedisTemplate<String, Object> redisTemplate;
  23.  
  24. // =============================common============================
  25.  
  26. /**
  27. * 指定缓存失效时间
  28. *
  29. * @param key 键
  30. * @param time 时间(秒)
  31. * @return
  32. */
  33. public boolean expire(String key, long time) {
  34. try {
  35. if (time > 0) {
  36. redisTemplate.expire(key, time, TimeUnit.SECONDS);
  37. }
  38. return true;
  39. } catch (Exception e) {
  40. e.printStackTrace();
  41. return false;
  42. }
  43. }
  44.  
  45. /**
  46. * 根据key 获取过期时间
  47. *
  48. * @param key 键 不能为null
  49. * @return 时间(秒) 返回0代表为永久有效
  50. */
  51. public long getExpire(String key) {
  52. return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  53. }
  54.  
  55. /**
  56. * 判断key是否存在
  57. *
  58. * @param key 键
  59. * @return true 存在 false不存在
  60. */
  61. public boolean hasKey(String key) {
  62. try {
  63. return redisTemplate.hasKey(key);
  64. } catch (Exception e) {
  65. e.printStackTrace();
  66. return false;
  67. }
  68. }
  69.  
  70. /**
  71. * 删除缓存
  72. *
  73. * @param key 可以传一个值 或多个
  74. */
  75. @SuppressWarnings("unchecked")
  76. public void del(String... key) {
  77. if (key != null && key.length > 0) {
  78. if (key.length == 1) {
  79. redisTemplate.delete(key[0]);
  80. } else {
  81. List<String> list = new ArrayList<>(Arrays.asList(key));
  82. redisTemplate.delete(list);
  83. }
  84. }
  85. }
  86.  
  87. /**
  88. * 删除缓存
  89. *
  90. * @param keys 可以传一个值 或多个
  91. */
  92. @SuppressWarnings("unchecked")
  93. public void del(Collection keys) {
  94. if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(keys)) {
  95. redisTemplate.delete(keys);
  96. }
  97. }
  98.  
  99. // ============================String=============================
  100.  
  101. /**
  102. * 普通缓存获取
  103. *
  104. * @param key 键
  105. * @return 值
  106. */
  107. public Object get(String key) {
  108. return key == null ? null : redisTemplate.opsForValue().get(key);
  109. }
  110.  
  111. /**
  112. * 普通缓存放入
  113. *
  114. * @param key 键
  115. * @param value 值
  116. * @return true成功 false失败
  117. */
  118. public boolean set(String key, Object value) {
  119. try {
  120. redisTemplate.opsForValue().set(key, value);
  121. return true;
  122. } catch (Exception e) {
  123. e.printStackTrace();
  124. return false;
  125. }
  126. }
  127.  
  128. /**
  129. * 普通缓存放入并设置时间
  130. *
  131. * @param key 键
  132. * @param value 值
  133. * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
  134. * @return true成功 false 失败
  135. */
  136. public boolean set(String key, Object value, long time) {
  137. try {
  138. if (time > 0) {
  139. redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  140. } else {
  141. set(key, value);
  142. }
  143. return true;
  144. } catch (Exception e) {
  145. e.printStackTrace();
  146. return false;
  147. }
  148. }
  149.  
  150. /**
  151. * 递增
  152. *
  153. * @param key 键
  154. * @param delta 要增加几(大于0)
  155. * @return
  156. */
  157. public long incr(String key, long delta) {
  158. if (delta < 0) {
  159. throw new RuntimeException("递增因子必须大于0");
  160. }
  161. return redisTemplate.opsForValue().increment(key, delta);
  162. }
  163.  
  164. /**
  165. * 递减
  166. *
  167. * @param key 键
  168. * @param delta 要减少几(小于0)
  169. * @return
  170. */
  171. public long decr(String key, long delta) {
  172. if (delta < 0) {
  173. throw new RuntimeException("递减因子必须大于0");
  174. }
  175. return redisTemplate.opsForValue().increment(key, -delta);
  176. }
  177.  
  178. // ================================Hash=================================
  179.  
  180. /**
  181. * HashGet
  182. *
  183. * @param key 键 不能为null
  184. * @param item 项 不能为null
  185. * @return 值
  186. */
  187. public Object hget(String key, String item) {
  188. return redisTemplate.opsForHash().get(key, item);
  189. }
  190.  
  191. /**
  192. * 获取hashKey对应的所有键值
  193. *
  194. * @param key 键
  195. * @return 对应的多个键值
  196. */
  197. public Map<Object, Object> hmget(String key) {
  198. Map<Object, Object> entries = redisTemplate.opsForHash().entries(key);
  199. return entries;
  200. }
  201.  
  202. /**
  203. * HashSet
  204. *
  205. * @param key 键
  206. * @param map 对应多个键值
  207. * @return true 成功 false 失败
  208. */
  209. public boolean hmset(String key, Map<String, Object> map) {
  210. try {
  211. redisTemplate.opsForHash().putAll(key, map);
  212. return true;
  213. } catch (Exception e) {
  214. e.printStackTrace();
  215. return false;
  216. }
  217. }
  218.  
  219. /**
  220. * HashSet 并设置时间
  221. *
  222. * @param key 键
  223. * @param map 对应多个键值
  224. * @param time 时间(秒)
  225. * @return true成功 false失败
  226. */
  227. public boolean hmset(String key, Map<String, Object> map, long time) {
  228. try {
  229. redisTemplate.opsForHash().putAll(key, map);
  230. if (time > 0) {
  231. expire(key, time);
  232. }
  233. return true;
  234. } catch (Exception e) {
  235. e.printStackTrace();
  236. return false;
  237. }
  238. }
  239.  
  240. /**
  241. * 向一张hash表中放入数据,如果不存在则不添加。
  242. * @param key 键
  243. * @param item 项
  244. * @param value 值
  245. * @return true 成功 false失败
  246. */
  247. public boolean hsetnx(String key, String item, Object value) {
  248. try {
  249. Boolean success = redisTemplate.opsForHash().putIfAbsent(key, item, value);
  250. return success;
  251. } catch (Exception e) {
  252. e.printStackTrace();
  253. return false;
  254. }
  255. }
  256.  
  257. /**
  258. * 向一张hash表中放入数据,如果存在就覆盖原来的值。
  259. *
  260. * @param key 键
  261. * @param item 项
  262. * @param value 值
  263. * @return true 成功 false失败
  264. */
  265. public boolean hset(String key, String item, Object value) {
  266. try {
  267. redisTemplate.opsForHash().put(key, item, value);
  268. return true;
  269. } catch (Exception e) {
  270. e.printStackTrace();
  271. return false;
  272. }
  273. }
  274.  
  275. /**
  276. * 向一张hash表中放入数据,如果存在就覆盖原来的值。
  277. *
  278. * @param key 键
  279. * @param item 项
  280. * @param value 值
  281. * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  282. * @return true 成功 false失败
  283. */
  284. public boolean hset(String key, String item, Object value, long time) {
  285. try {
  286. redisTemplate.opsForHash().put(key, item, value);
  287. if (time > 0) {
  288. expire(key, time);
  289. }
  290. return true;
  291. } catch (Exception e) {
  292. e.printStackTrace();
  293. return false;
  294. }
  295. }
  296.  
  297. /**
  298. * 删除hash表中的值
  299. *
  300. * @param key 键 不能为null
  301. * @param item 项 可以使多个 不能为null
  302. * 返回被删除的数量
  303. */
  304. public Long hdel(String key, Object... item) {
  305. return redisTemplate.opsForHash().delete(key, item);
  306. }
  307.  
  308. /**
  309. * 删除hash表中的值
  310. *
  311. * @param key 键 不能为null
  312. * @param items 项 可以使多个 不能为null
  313. */
  314. public void hdel(String key, Collection items) {
  315. redisTemplate.opsForHash().delete(key, items.toArray());
  316. }
  317.  
  318. /**
  319. * 判断hash表中是否有该项的值
  320. *
  321. * @param key 键 不能为null
  322. * @param item 项 不能为null
  323. * @return true 存在 false不存在
  324. */
  325. public boolean hHasKey(String key, String item) {
  326. return redisTemplate.opsForHash().hasKey(key, item);
  327. }
  328.  
  329. /**
  330. * hash数据类型:给元素一个增量 如果不存在,就会创建一个 并把新增后的值返回
  331. *
  332. * @param key 键
  333. * @param item 项
  334. * @param delta 要增加几(大于0)
  335. * @return
  336. */
  337. public double hincr(String key, String item, double delta) {
  338. return redisTemplate.opsForHash().increment(key, item, delta);
  339. }
  340. // ============================set=============================
  341.  
  342. /**
  343. * 根据key获取Set中的所有值
  344. *
  345. * @param key 键
  346. * @return
  347. */
  348. public Set<Object> sGet(String key) {
  349. try {
  350. return redisTemplate.opsForSet().members(key);
  351. } catch (Exception e) {
  352. e.printStackTrace();
  353. return null;
  354. }
  355. }
  356.  
  357. /**
  358. * 根据value从一个set中查询,是否存在
  359. *
  360. * @param key 键
  361. * @param value 值
  362. * @return true 存在 false不存在
  363. */
  364. public boolean sHasKey(String key, Object value) {
  365. try {
  366. return redisTemplate.opsForSet().isMember(key, value);
  367. } catch (Exception e) {
  368. e.printStackTrace();
  369. return false;
  370. }
  371. }
  372.  
  373. /**
  374. * 将数据放入set缓存
  375. *
  376. * @param key 键
  377. * @param values 值 可以是多个
  378. * @return 成功个数
  379. */
  380. public long sSet(String key, Object... values) {
  381. try {
  382. return redisTemplate.opsForSet().add(key, values);
  383. } catch (Exception e) {
  384. e.printStackTrace();
  385. return 0;
  386. }
  387. }
  388.  
  389. /**
  390. * 将数据放入set缓存
  391. *
  392. * @param key 键
  393. * @param values 值 可以是多个
  394. * @return 成功个数
  395. */
  396. public long sSet(String key, Collection values) {
  397. try {
  398. return redisTemplate.opsForSet().add(key, values.toArray());
  399. } catch (Exception e) {
  400. e.printStackTrace();
  401. return 0;
  402. }
  403. }
  404.  
  405. /**
  406. * 将set数据放入缓存
  407. *
  408. * @param key 键
  409. * @param time 时间(秒)
  410. * @param values 值 可以是多个
  411. * @return 成功个数
  412. */
  413. public long sSetAndTime(String key, long time, Object... values) {
  414. try {
  415. Long count = redisTemplate.opsForSet().add(key, values);
  416. if (time > 0)
  417. expire(key, time);
  418. return count;
  419. } catch (Exception e) {
  420. e.printStackTrace();
  421. return 0;
  422. }
  423. }
  424.  
  425. /**
  426. * 获取set缓存的长度
  427. *
  428. * @param key 键
  429. * @return
  430. */
  431. public long sGetSetSize(String key) {
  432. try {
  433. return redisTemplate.opsForSet().size(key);
  434. } catch (Exception e) {
  435. e.printStackTrace();
  436. return 0;
  437. }
  438. }
  439.  
  440. /**
  441. * 移除值为value的
  442. *
  443. * @param key 键
  444. * @param values 值 可以是多个
  445. * @return 移除的个数
  446. */
  447. public long setRemove(String key, Object... values) {
  448. try {
  449. Long count = redisTemplate.opsForSet().remove(key, values);
  450. return count;
  451. } catch (Exception e) {
  452. e.printStackTrace();
  453. return 0;
  454. }
  455. }
  456.  
  457. // ===============================list=================================
  458.  
  459. /**
  460. * 获取list缓存的内容
  461. *
  462. * @param key 键
  463. * @param start 开始
  464. * @param end 结束 0 到 -1代表所有值
  465. * @return
  466. */
  467. public List<Object> lGet(String key, long start, long end) {
  468. try {
  469. return redisTemplate.opsForList().range(key, start, end);
  470. } catch (Exception e) {
  471. e.printStackTrace();
  472. return null;
  473. }
  474. }
  475.  
  476. /**
  477. * 获取list缓存的长度
  478. *
  479. * @param key 键
  480. * @return
  481. */
  482. public long lGetListSize(String key) {
  483. try {
  484. return redisTemplate.opsForList().size(key);
  485. } catch (Exception e) {
  486. e.printStackTrace();
  487. return 0;
  488. }
  489. }
  490.  
  491. /**
  492. * 通过索引 获取list中的值
  493. *
  494. * @param key 键
  495. * @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
  496. * @return
  497. */
  498. public Object lGetIndex(String key, long index) {
  499. try {
  500. return redisTemplate.opsForList().index(key, index);
  501. } catch (Exception e) {
  502. e.printStackTrace();
  503. return null;
  504. }
  505. }
  506.  
  507. /**
  508. * 将list放入缓存
  509. *
  510. * @param key 键
  511. * @param value 值
  512. * @return
  513. */
  514. public boolean lSet(String key, Object value) {
  515. try {
  516. redisTemplate.opsForList().rightPush(key, value);
  517. return true;
  518. } catch (Exception e) {
  519. e.printStackTrace();
  520. return false;
  521. }
  522. }
  523.  
  524. /**
  525. * 将list放入缓存
  526. *
  527. * @param key 键
  528. * @param value 值
  529. * @param time 时间(秒)
  530. * @return
  531. */
  532. public boolean lSet(String key, Object value, long time) {
  533. try {
  534. redisTemplate.opsForList().rightPush(key, value);
  535. if (time > 0)
  536. expire(key, time);
  537. return true;
  538. } catch (Exception e) {
  539. e.printStackTrace();
  540. return false;
  541. }
  542. }
  543.  
  544. /**
  545. * 将list放入缓存
  546. *
  547. * @param key 键
  548. * @param value 值
  549. * @return
  550. */
  551. public boolean lSet(String key, List<Object> value) {
  552. try {
  553. redisTemplate.opsForList().rightPushAll(key, value);
  554. return true;
  555. } catch (Exception e) {
  556. e.printStackTrace();
  557. return false;
  558. }
  559. }
  560.  
  561. /**
  562. * 将list放入缓存
  563. *
  564. * @param key 键
  565. * @param value 值
  566. * @param time 时间(秒)
  567. * @return
  568. */
  569. public boolean lSet(String key, List<Object> value, long time) {
  570. try {
  571. redisTemplate.opsForList().rightPushAll(key, value);
  572. if (time > 0)
  573. expire(key, time);
  574. return true;
  575. } catch (Exception e) {
  576. e.printStackTrace();
  577. return false;
  578. }
  579. }
  580.  
  581. /**
  582. * 根据索引修改list中的某条数据
  583. *
  584. * @param key 键
  585. * @param index 索引
  586. * @param value 值
  587. * @return
  588. */
  589. public boolean lUpdateIndex(String key, long index, Object value) {
  590. try {
  591. redisTemplate.opsForList().set(key, index, value);
  592. return true;
  593. } catch (Exception e) {
  594. e.printStackTrace();
  595. return false;
  596. }
  597. }
  598.  
  599. /**
  600. * 移除N个值为value
  601. *
  602. * @param key 键
  603. * @param count 移除多少个
  604. * @param value 值
  605. * @return 移除的个数
  606. */
  607. public long lRemove(String key, long count, Object value) {
  608. try {
  609. Long remove = redisTemplate.opsForList().remove(key, count, value);
  610. return remove;
  611. } catch (Exception e) {
  612. e.printStackTrace();
  613. return 0;
  614. }
  615. }
  616. // ===============================Zset=================================
  617.  
  618. /**
  619. * 给key键的value增加value分数,没有则会创建。
  620. *
  621. * @param key 键
  622. * @param value 值
  623. * @param score 分数
  624. */
  625. public Double incrementScore(String key, String value, double score) {
  626. //Boolean add = redisTemplate.boundZSetOps(key).add(value, score);
  627. Double add = redisTemplate.boundZSetOps(key).incrementScore(value, score);
  628. return add;
  629. }
  630.  
  631. /**
  632. * 获得指定Zset元素的分数
  633. *
  634. * @param key
  635. * @param value
  636. * @return
  637. */
  638. public Double score(String key, String value) {
  639. Double score = redisTemplate.boundZSetOps(key).score(value);
  640. return score;
  641. }
  642.  
  643. /**
  644. * 升序查询key集合内[endTop,startTop]如果是负数表示倒数
  645. * endTop=-1,startTop=0表示获取所有数据。
  646. *
  647. * @param key
  648. * @param startPage
  649. * @param endPage
  650. */
  651. public Set<ZSetOperations.TypedTuple<Object>> rangeWithScores(String key, int startPage, int endPage) {
  652. Set<ZSetOperations.TypedTuple<Object>> set = redisTemplate.boundZSetOps(key).rangeWithScores(startPage, endPage);
  653. return set;
  654. }
  655.  
  656. /**
  657. * 降序查询key集合内[endTop,startTop],如果是负数表示倒数
  658. * endTop=-1,startTop=0表示获取所有数据。
  659. *
  660. * @param key
  661. * @param startPage
  662. * @param endPage
  663. */
  664. public Set<ZSetOperations.TypedTuple<Object>> reverseRangeWithScores(String key, int startPage, int endPage) {
  665. Set<ZSetOperations.TypedTuple<Object>> set = redisTemplate.boundZSetOps(key).reverseRangeWithScores(startPage, endPage);
  666. return set;
  667. }
  668.  
  669. /**
  670. * 批量新增数据
  671. *
  672. * @param key
  673. * @param set
  674. * @return
  675. */
  676. public Long zsetAdd(String key, Set set) {
  677. Long add = redisTemplate.boundZSetOps(key).add(set);
  678. return add;
  679. }
  680.  
  681. /**
  682. * 删除指定键的指定下标范围数据
  683. *
  684. * @param key
  685. * @param startPage
  686. * @param endPage
  687. */
  688. public Long zsetRemoveRange(String key, int startPage, int endPage) {
  689. Long l = redisTemplate.boundZSetOps(key).removeRange(startPage, endPage);
  690. return l;
  691. }
  692. /**
  693. * 删除指定键的指定值
  694. *
  695. * @param key
  696. * @param value
  697. */
  698. public Long zsetRemove(String key, String value) {
  699. Long remove = redisTemplate.boundZSetOps(key).remove(value);
  700. return remove;
  701. }
  702. }

到此这篇关于Redis实战之百度首页新闻热榜的文章就介绍到这了,更多相关Redis百度首页新闻热榜内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

延伸 · 阅读

精彩推荐
  • Redisredis缓存存储Session原理机制

    redis缓存存储Session原理机制

    这篇文章主要为大家介绍了redis缓存存储Session原理机制详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪...

    程序媛张小妍9252021-11-25
  • RedisRedis Template实现分布式锁的实例代码

    Redis Template实现分布式锁的实例代码

    这篇文章主要介绍了Redis Template实现分布式锁,需要的朋友可以参考下 ...

    晴天小哥哥2592019-11-18
  • RedisRedis 6.X Cluster 集群搭建

    Redis 6.X Cluster 集群搭建

    码哥带大家完成在 CentOS 7 中安装 Redis 6.x 教程。在学习 Redis Cluster 集群之前,我们需要先搭建一套集群环境。机器有限,实现目标是一台机器上搭建 6 个节...

    码哥字节15752021-04-07
  • RedisRedis集群的5种使用方式,各自优缺点分析

    Redis集群的5种使用方式,各自优缺点分析

    Redis 多副本,采用主从(replication)部署结构,相较于单副本而言最大的特点就是主从实例间数据实时同步,并且提供数据持久化和备份策略。...

    优知学院4082021-08-10
  • Redis关于Redis数据库入门详细介绍

    关于Redis数据库入门详细介绍

    大家好,本篇文章主要讲的是关于Redis数据库入门详细介绍,感兴趣的同学赶快来看一看吧,对你有帮助的话记得收藏一下,方便下次浏览...

    沃尔码6982022-01-24
  • Redis《面试八股文》之 Redis十六卷

    《面试八股文》之 Redis十六卷

    redis 作为我们最常用的内存数据库,很多地方你都能够发现它的身影,比如说登录信息的存储,分布式锁的使用,其经常被我们当做缓存去使用。...

    moon聊技术8182021-07-26
  • Redis详解三分钟快速搭建分布式高可用的Redis集群

    详解三分钟快速搭建分布式高可用的Redis集群

    这篇文章主要介绍了详解三分钟快速搭建分布式高可用的Redis集群,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,...

    万猫学社4502021-07-25
  • Redis如何使用Redis锁处理并发问题详解

    如何使用Redis锁处理并发问题详解

    这篇文章主要给大家介绍了关于如何使用Redis锁处理并发问题的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用Redis具有一定的参考学习...

    haofly4522019-11-26