做每周热议，应该用缓存来做，如果直接查库的话，会对数据库造成压力。用缓存做的话，用Redis 来做缓存的话比较合适一点。d8c1da9c34db0fd9058016a3a350830f.png

  1. # 利用Redsi 添加 数据命令
  2. # day:1 指的是在1号的时候 post:1 第一篇文章添加了 10 条评论。
  3. #后面 6 post:2 指的是 在1号第二篇添加了6条评论
  4. zadd day:1 10 post:1 6 post:2
  5. zadd day:2 10 post:1 6 post:2
  6. zadd day:3 10 post:1 6 post:2
  7. ....
  8. zadd day:8 10 post:1 6 post:2
  9. #这样就完成了7天的记录

上面的命令可以帮我们记录一下7天的所有的评论数。但是还没有帮我们计算出来谁是评论最高的。看Redis 的sorted set有序集合有个命令就可以帮我们实现这个功能。
这个命令可以帮助我们实现并集，我们只需要把7天的评论给做个并集就可以求出来，
e0ce7f157be1291d7c8cd87d101bab41.png

  1. # Redis 命令
  2. #意思是并集把这7天的 放到一个新的集合里面 新的集合是 week:rank 这样这个新的集合里面就有了我们的
  3. #7天的记录了
  4. union week:rank 7 day:1...day:8

Redis 命令实践一下看看

本地命令行测试
228f658c607db31d39b6e161507579ae.png

  1. 127.0.0.1:6379> ping
  2. PONG
  3. 127.0.0.1:6379> zadd day:1 10 post:1
  4. (integer) 1
  5. 127.0.0.1:6379> zadd day:2 10 post:1
  6. (integer) 1
  7. 127.0.0.1:6379> zadd day:3 10 post:1
  8. (integer) 1
  9. 127.0.0.1:6379> zadd day:1 5 post:2
  10. (integer) 1
  11. 127.0.0.1:6379> zadd day:2 5 post:2
  12. (integer) 1
  13. 127.0.0.1:6379> zadd day:3 5 post:2
  14. (integer) 1
  15. 127.0.0.1:6379> keys *
  16. 1) "day:1"
  17. 2) "day:2"
  18. 3) "day:3"

查看当天的排行榜命令 ZRevrange

  1. 127.0.0.1:6379> zrevrange day:1 0 -1 withscores
  2. 1) "post:1"
  3. 2) "10"
  4. 3) "post:2"
  5. 4) "5"
  6. 127.0.0.1:6379>

每周的评论排行榜记录。因为我只有三天的，所以只写了3天的

  1. 127.0.0.1:6379> zrevrange week:rank 0 -1 withscores
  2. 1) "post:1"
  3. 2) "30"
  4. 3) "post:2"
  5. 4) "15"
  6. 127.0.0.1:6379>


上面的记录是没有错误的。上述的命令可以帮我们简单的实现了我们的想法。下面用代码来实现。上面还有一个小的 bug 就是当day:1这一天可能会出现就是不可能直接就过完了。可能会一条一条的增加，这个时候应该使用的是自增这个命令来解决这个问题。

  1. #什么时候+1 什么时候-1 就是当你 添加一条评论的时候就添加1 删除的的时候就减1
  2. ZINCRBY day:1 10 post:1

代码来进行实现

目前前端的样式，这样的话我们就需要在项目一开始的时候就启动这个功能
7730770295bba0b3c9280ffd2a8c594f.png
cec558d4cd6bb8a8148b2f588065f8fa.png

  1. @Component
  2. // 实现 启动类 ，还有 上下文的servlect
  3. public class ContextStartup implements ApplicationRunner, ServletContextAware {
  6.     // 注入 categoryService
  7.     @Autowired
  8.     IMCategoryService categoryService;
  9.     ServletContext servletContext;
  10.     // 注入post 的服务类
  11.     @Autowired
  12.     IMPostService postService;
  14.     @Override
  15.     public void run(ApplicationArguments args) throws Exception {
  18.         // 调用全查的方法
  19.         List<MCategory> list = categoryService.list(new QueryWrapper<MCategory>().eq("status", 0));
  20.         servletContext.setAttribute("List", list);
  21.         // 调用每周热评的方法
  22.         postService.initweek();
  23.     }
  25.     @Override
  26.     public void setServletContext(ServletContext servletContext) {
  29.         this.servletContext = servletContext;
  30.     }
  31. }

服务类serviceimpl类
大概的思路

  1. 1，// 获取7天内发表的文章
  2. 2，// 初始化文章的总阅读量
  3. // 缓存文章的基本信息（id,标题，评论数，作者 ID ）
  4. // 这样就可以避免的查库。可以直接用我们的缓存。
  5. 3，// 做并集

这里需要一个Redis 的工具类，我在网上找到的，不是我写的。网上一大堆。直接拿来用就可以了

  1. package com.example.springbootblog.util;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.RedisTemplate;
  5. import org.springframework.data.redis.core.ZSetOperations;
  6. import org.springframework.stereotype.Component;
  7. import org.springframework.util.CollectionUtils;
  9. import java.util.Collection;
  10. import java.util.List;
  11. import java.util.Map;
  12. import java.util.Set;
  13. import java.util.concurrent.TimeUnit;
  15. @Component
  16. public class RedisUtil {
  20.     @Autowired
  21.     private RedisTemplate redisTemplate;
  23.     /**
  24.     * 指定缓存失效时间
  25.     *
  26.     * @param key  键
  27.     * @param time 时间(秒)
  28.     * @return
  29.     */
  30.     public boolean expire(String key, long time) {
  33.         try {
  36.             if (time > 0) {
  39.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  40.             }
  41.             return true;
  42.         } catch (Exception e) {
  45.             e.printStackTrace();
  46.             return false;
  47.         }
  48.     }
  50.     /**
  51.     * 根据key 获取过期时间
  52.     *
  53.     * @param key 键 不能为null
  54.     * @return 时间(秒) 返回0代表为永久有效
  55.     */
  56.     public long getExpire(String key) {
  59.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  60.     }
  62.     /**
  63.     * 判断key是否存在
  64.     *
  65.     * @param key 键
  66.     * @return true 存在 false不存在
  67.     */
  68.     public boolean hasKey(String key) {
  71.         try {
  74.             return redisTemplate.hasKey(key);
  75.         } catch (Exception e) {
  78.             e.printStackTrace();
  79.             return false;
  80.         }
  81.     }
  83.     /**
  84.     * 删除缓存
  85.     *
  86.     * @param key 可以传一个值 或多个
  87.     */
  88.     @SuppressWarnings("unchecked")
  89.     public void del(String... key) {
  92.         if (key != null && key.length > 0) {
  95.             if (key.length == 1) {
  98.                 redisTemplate.delete(key[0]);
  99.             } else {
  102.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
  103.             }
  104.         }
  105.     }
  107.     //============================String=============================
  109.     /**
  110.     * 普通缓存获取
  111.     *
  112.     * @param key 键
  113.     * @return 值
  114.     */
  115.     public Object get(String key) {
  118.         return key == null ? null : redisTemplate.opsForValue().get(key);
  119.     }
  121.     /**
  122.     * 普通缓存放入
  123.     *
  124.     * @param key   键
  125.     * @param value 值
  126.     * @return true成功 false失败
  127.     */
  128.     public boolean set(String key, Object value) {
  131.         try {
  134.             redisTemplate.opsForValue().set(key, value);
  135.             return true;
  136.         } catch (Exception e) {
  139.             e.printStackTrace();
  140.             return false;
  141.         }
  143.     }
  145.     /**
  146.     * 普通缓存放入并设置时间
  147.     *
  148.     * @param key   键
  149.     * @param value 值
  150.     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
  151.     * @return true成功 false 失败
  152.     */
  153.     public boolean set(String key, Object value, long time) {
  156.         try {
  159.             if (time > 0) {
  162.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  163.             } else {
  166.                 set(key, value);
  167.             }
  168.             return true;
  169.         } catch (Exception e) {
  172.             e.printStackTrace();
  173.             return false;
  174.         }
  175.     }
  177.     /**
  178.     * 递增
  179.     *
  180.     * @param key 键
  181.     * @param delta  要增加几(大于0)
  182.     * @return
  183.     */
  184.     public long incr(String key, long delta) {
  187.         if (delta < 0) {
  190.             throw new RuntimeException("递增因子必须大于0");
  191.         }
  192.         return redisTemplate.opsForValue().increment(key, delta);
  193.     }
  195.     /**
  196.     * 递减
  197.     *
  198.     * @param key 键
  199.     * @param delta  要减少几(小于0)
  200.     * @return
  201.     */
  202.     public long decr(String key, long delta) {
  205.         if (delta < 0) {
  208.             throw new RuntimeException("递减因子必须大于0");
  209.         }
  210.         return redisTemplate.opsForValue().increment(key, -delta);
  211.     }
  213.     //================================Map=================================
  215.     /**
  216.     * HashGet
  217.     *
  218.     * @param key  键 不能为null
  219.     * @param item 项 不能为null
  220.     * @return 值
  221.     */
  222.     public Object hget(String key, String item) {
  225.         return redisTemplate.opsForHash().get(key, item);
  226.     }
  228.     /**
  229.     * 获取hashKey对应的所有键值
  230.     *
  231.     * @param key 键
  232.     * @return 对应的多个键值
  233.     */
  234.     public Map<Object, Object> hmget(String key) {
  237.         return redisTemplate.opsForHash().entries(key);
  238.     }
  240.     /**
  241.     * HashSet
  242.     *
  243.     * @param key 键
  244.     * @param map 对应多个键值
  245.     * @return true 成功 false 失败
  246.     */
  247.     public boolean hmset(String key, Map<String, Object> map) {
  250.         try {
  253.             redisTemplate.opsForHash().putAll(key, map);
  254.             return true;
  255.         } catch (Exception e) {
  258.             e.printStackTrace();
  259.             return false;
  260.         }
  261.     }
  263.     /**
  264.     * HashSet 并设置时间
  265.     *
  266.     * @param key  键
  267.     * @param map  对应多个键值
  268.     * @param time 时间(秒)
  269.     * @return true成功 false失败
  270.     */
  271.     public boolean hmset(String key, Map<String, Object> map, long time) {
  274.         try {
  277.             redisTemplate.opsForHash().putAll(key, map);
  278.             if (time > 0) {
  281.                 expire(key, time);
  282.             }
  283.             return true;
  284.         } catch (Exception e) {
  287.             e.printStackTrace();
  288.             return false;
  289.         }
  290.     }
  292.     /**
  293.     * 向一张hash表中放入数据,如果不存在将创建
  294.     *
  295.     * @param key   键
  296.     * @param item  项
  297.     * @param value 值
  298.     * @return true 成功 false失败
  299.     */
  300.     public boolean hset(String key, String item, Object value) {
  303.         try {
  306.             redisTemplate.opsForHash().put(key, item, value);
  307.             return true;
  308.         } catch (Exception e) {
  311.             e.printStackTrace();
  312.             return false;
  313.         }
  314.     }
  316.     /**
  317.     * 向一张hash表中放入数据,如果不存在将创建
  318.     *
  319.     * @param key   键
  320.     * @param item  项
  321.     * @param value 值
  322.     * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
  323.     * @return true 成功 false失败
  324.     */
  325.     public boolean hset(String key, String item, Object value, long time) {
  328.         try {
  331.             redisTemplate.opsForHash().put(key, item, value);
  332.             if (time > 0) {
  335.                 expire(key, time);
  336.             }
  337.             return true;
  338.         } catch (Exception e) {
  341.             e.printStackTrace();
  342.             return false;
  343.         }
  344.     }
  346.     /**
  347.     * 删除hash表中的值
  348.     *
  349.     * @param key  键 不能为null
  350.     * @param item 项 可以使多个 不能为null
  351.     */
  352.     public void hdel(String key, Object... item) {
  355.         redisTemplate.opsForHash().delete(key, item);
  356.     }
  358.     /**
  359.     * 判断hash表中是否有该项的值
  360.     *
  361.     * @param key  键 不能为null
  362.     * @param item 项 不能为null
  363.     * @return true 存在 false不存在
  364.     */
  365.     public boolean hHasKey(String key, String item) {
  368.         return redisTemplate.opsForHash().hasKey(key, item);
  369.     }
  371.     /**
  372.     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  373.     *
  374.     * @param key  键
  375.     * @param item 项
  376.     * @param by   要增加几(大于0)
  377.     * @return
  378.     */
  379.     public double hincr(String key, String item, double by) {
  382.         return redisTemplate.opsForHash().increment(key, item, by);
  383.     }
  385.     /**
  386.     * hash递减
  387.     *
  388.     * @param key  键
  389.     * @param item 项
  390.     * @param by   要减少记(小于0)
  391.     * @return
  392.     */
  393.     public double hdecr(String key, String item, double by) {
  396.         return redisTemplate.opsForHash().increment(key, item, -by);
  397.     }
  399.     //============================set=============================
  401.     /**
  402.     * 根据key获取Set中的所有值
  403.     *
  404.     * @param key 键
  405.     * @return
  406.     */
  407.     public Set<Object> sGet(String key) {
  410.         try {
  413.             return redisTemplate.opsForSet().members(key);
  414.         } catch (Exception e) {
  417.             e.printStackTrace();
  418.             return null;
  419.         }
  420.     }
  422.     /**
  423.     * 根据value从一个set中查询,是否存在
  424.     *
  425.     * @param key   键
  426.     * @param value 值
  427.     * @return true 存在 false不存在
  428.     */
  429.     public boolean sHasKey(String key, Object value) {
  432.         try {
  435.             return redisTemplate.opsForSet().isMember(key, value);
  436.         } catch (Exception e) {
  439.             e.printStackTrace();
  440.             return false;
  441.         }
  442.     }
  444.     /**
  445.     * 将数据放入set缓存
  446.     *
  447.     * @param key    键
  448.     * @param values 值 可以是多个
  449.     * @return 成功个数
  450.     */
  451.     public long sSet(String key, Object... values) {
  454.         try {
  457.             return redisTemplate.opsForSet().add(key, values);
  458.         } catch (Exception e) {
  461.             e.printStackTrace();
  462.             return 0;
  463.         }
  464.     }
  466.     /**
  467.     * 将set数据放入缓存
  468.     *
  469.     * @param key    键
  470.     * @param time   时间(秒)
  471.     * @param values 值 可以是多个
  472.     * @return 成功个数
  473.     */
  474.     public long sSetAndTime(String key, long time, Object... values) {
  477.         try {
  480.             Long count = redisTemplate.opsForSet().add(key, values);
  481.             if (time > 0) expire(key, time);
  482.             return count;
  483.         } catch (Exception e) {
  486.             e.printStackTrace();
  487.             return 0;
  488.         }
  489.     }
  491.     /**
  492.     * 获取set缓存的长度
  493.     *
  494.     * @param key 键
  495.     * @return
  496.     */
  497.     public long sGetSetSize(String key) {
  500.         try {
  503.             return redisTemplate.opsForSet().size(key);
  504.         } catch (Exception e) {
  507.             e.printStackTrace();
  508.             return 0;
  509.         }
  510.     }
  512.     /**
  513.     * 移除值为value的
  514.     *
  515.     * @param key    键
  516.     * @param values 值 可以是多个
  517.     * @return 移除的个数
  518.     */
  519.     public long setRemove(String key, Object... values) {
  522.         try {
  525.             Long count = redisTemplate.opsForSet().remove(key, values);
  526.             return count;
  527.         } catch (Exception e) {
  530.             e.printStackTrace();
  531.             return 0;
  532.         }
  533.     }
  534.     //===============================list=================================
  536.     /**
  537.     * 获取list缓存的内容
  538.     *
  539.     * @param key   键
  540.     * @param start 开始
  541.     * @param end   结束  0 到 -1代表所有值
  542.     * @return
  543.     */
  544.     public List<Object> lGet(String key, long start, long end) {
  547.         try {
  550.             return redisTemplate.opsForList().range(key, start, end);
  551.         } catch (Exception e) {
  554.             e.printStackTrace();
  555.             return null;
  556.         }
  557.     }
  559.     /**
  560.     * 获取list缓存的长度
  561.     *
  562.     * @param key 键
  563.     * @return
  564.     */
  565.     public long lGetListSize(String key) {
  568.         try {
  571.             return redisTemplate.opsForList().size(key);
  572.         } catch (Exception e) {
  575.             e.printStackTrace();
  576.             return 0;
  577.         }
  578.     }
  580.     /**
  581.     * 通过索引 获取list中的值
  582.     *
  583.     * @param key   键
  584.     * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  585.     * @return
  586.     */
  587.     public Object lGetIndex(String key, long index) {
  590.         try {
  593.             return redisTemplate.opsForList().index(key, index);
  594.         } catch (Exception e) {
  597.             e.printStackTrace();
  598.             return null;
  599.         }
  600.     }
  602.     /**
  603.     * 将list放入缓存
  604.     *
  605.     * @param key   键
  606.     * @param value 值
  607.     * @return
  608.     */
  609.     public boolean lSet(String key, Object value) {
  612.         try {
  615.             redisTemplate.opsForList().rightPush(key, value);
  616.             return true;
  617.         } catch (Exception e) {
  620.             e.printStackTrace();
  621.             return false;
  622.         }
  623.     }
  625.     /**
  626.     * 将list放入缓存
  627.     *
  628.     * @param key   键
  629.     * @param value 值
  630.     * @param time  时间(秒)
  631.     * @return
  632.     */
  633.     public boolean lSet(String key, Object value, long time) {
  636.         try {
  639.             redisTemplate.opsForList().rightPush(key, value);
  640.             if (time > 0) expire(key, time);
  641.             return true;
  642.         } catch (Exception e) {
  645.             e.printStackTrace();
  646.             return false;
  647.         }
  648.     }
  650.     /**
  651.     * 将list放入缓存
  652.     *
  653.     * @param key   键
  654.     * @param value 值
  655.     * @return
  656.     */
  657.     public boolean lSet(String key, List<Object> value) {
  660.         try {
  663.             redisTemplate.opsForList().rightPushAll(key, value);
  664.             return true;
  665.         } catch (Exception e) {
  668.             e.printStackTrace();
  669.             return false;
  670.         }
  671.     }
  673.     /**
  674.     * 将list放入缓存
  675.     *
  676.     * @param key   键
  677.     * @param value 值
  678.     * @param time  时间(秒)
  679.     * @return
  680.     */
  681.     public boolean lSet(String key, List<Object> value, long time) {
  684.         try {
  687.             redisTemplate.opsForList().rightPushAll(key, value);
  688.             if (time > 0) expire(key, time);
  689.             return true;
  690.         } catch (Exception e) {
  693.             e.printStackTrace();
  694.             return false;
  695.         }
  696.     }
  698.     /**
  699.     * 根据索引修改list中的某条数据
  700.     *
  701.     * @param key   键
  702.     * @param index 索引
  703.     * @param value 值
  704.     * @return
  705.     */
  706.     public boolean lUpdateIndex(String key, long index, Object value) {
  709.         try {
  712.             redisTemplate.opsForList().set(key, index, value);
  713.             return true;
  714.         } catch (Exception e) {
  717.             e.printStackTrace();
  718.             return false;
  719.         }
  720.     }
  722.     /**
  723.     * 移除N个值为value
  724.     *
  725.     * @param key   键
  726.     * @param count 移除多少个
  727.     * @param value 值
  728.     * @return 移除的个数
  729.     */
  730.     public long lRemove(String key, long count, Object value) {
  733.         try {
  736.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  737.             return remove;
  738.         } catch (Exception e) {
  741.             e.printStackTrace();
  742.             return 0;
  743.         }
  744.     }
  746.     //================有序集合 sort set===================
  747.     /**
  748.     * 有序set添加元素
  749.     *
  750.     * @param key
  751.     * @param value
  752.     * @param score
  753.     * @return
  754.     */
  755.     public boolean zSet(String key, Object value, double score) {
  758.         return redisTemplate.opsForZSet().add(key, value, score);
  759.     }
  761.     public long batchZSet(String key, Set<ZSetOperations.TypedTuple> typles) {
  764.         return redisTemplate.opsForZSet().add(key, typles);
  765.     }
  767.     public void zIncrementScore(String key, Object value, long delta) {
  770.         redisTemplate.opsForZSet().incrementScore(key, value, delta);
  771.     }
  773.     public void zUnionAndStore(String key, Collection otherKeys, String destKey) {
  776.         redisTemplate.opsForZSet().unionAndStore(key, otherKeys, destKey);
  777.     }
  779.     /**
  780.     * 获取zset数量
  781.     * @param key
  782.     * @param value
  783.     * @return
  784.     */
  785.     public long getZsetScore(String key, Object value) {
  788.         Double score = redisTemplate.opsForZSet().score(key, value);
  789.         if(score==null){
  792.             return 0;
  793.         }else{
  796.             return score.longValue();
  797.         }
  798.     }
  800.     /**
  801.     * 获取有序集 key 中成员 member 的排名 。
  802.     * 其中有序集成员按 score 值递减 (从大到小) 排序。
  803.     * @param key
  804.     * @param start
  805.     * @param end
  806.     * @return
  807.     */
  808.     public Set<ZSetOperations.TypedTuple> getZSetRank(String key, long start, long end) {
  811.         return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
  812.     }
  814. }

实现类的代码

  2. // 每周热评的方法
  3. @Override
  4. public void initweek() {
  7.     //获取 7天的文章
  8.     List<MPost> posts = this.list(new QueryWrapper<MPost>().ge("created", DateUtil.lastWeek())
  9.                                   .select("id", "title", "user_id", "comment_count", "view_count", "created")
  10.                                  );// 获取到7天前的以及按照这几个查询，不需要全部查询
  11.     // 初始化文章的总评论
  12.     for (MPost post : posts) {
  15.         // 设置 key
  16.         String key = "day:rank:" + DateUtil.format(post.getCreated(), DatePattern.PURE_DATE_FORMAT);
  17.         // 缓存进去的评论数量
  18.         redisUtil.zSet(key, post.getId(), post.getCommentCount());
  19.         //设置自动过期 7天过期
  20.         long between = DateUtil.between(new Date(), post.getCreated(), DateUnit.DAY);
  21.         long expireTime = (7 - between) * 24 * 60 * 60; // 有效 时间
  23.         redisUtil.expire(key, expireTime);
  24.         // 缓存文章的一些基本信息
  25.         this.hashCachePost(post, expireTime);
  26.     }
  27.     // 做并集
  28.     this.zunionAndStore();
  29. }
  31. /**
  32. * 文章每周评论数量并集操作
  33. **/
  34. private void zunionAndStore() {
  37.     String destkey = "day:rank:" + DateUtil.format(new Date(), DatePattern.PURE_DATE_FORMAT);
  38.     // 设置并集后的新的 key
  39.     String newkey = "week:rank";
  40.     ArrayList<String> otherKeys = new ArrayList<>();
  41.     // 计算7天的
  42.     for (int i = -6; i < 0; i++) {
  45.         String temp = "day:rank:" + DateUtil.format(DateUtil.offsetDay(new Date(), i), DatePattern.PURE_DATE_FORMAT);
  46.         otherKeys.add(temp);
  47.     }
  48.     redisUtil.zUnionAndStore(destkey, otherKeys, newkey);
  49. }
  51. /**
  52. * 文章作者缓存
  53. **/
  54. private void hashCachePost(MPost post, long expireTime) {
  57.     // 设置 key
  58.     String key = "rank:post:" + post.getId();
  59.     // 判断存在不存在
  60.     boolean hasKey = redisUtil.hasKey(key);
  61.     if (!hasKey) {
  64.         // 就存到缓存里面
  65.         redisUtil.hset(key, "post:id", post.getId(), expireTime);
  66.         redisUtil.hset(key, "post:title", post.getTitle(), expireTime);
  67.         redisUtil.hset(key, "post:commentCount", post.getCommentCount(), expireTime);
  69.     }
  70. }
  72. }

这样就可以把我们的命令行转换成代码的形式。就可以把我们的数据库的数据先存到缓存中去了。
效果

  1. 127.0.0.1:6379> keys *
  2. 1) "rank:post:4"
  3. 2) "week:rank"
  4. 3) "day:rank:20210724"
  5. 4) "rank:post:3"
  6. 5) "rank:post:2"
  7. 6) "day:rank:20210726"
  8. #查看我们并集完后的数据 id 为 3 的有 1条评论。
  9. 127.0.0.1:6379> zrevrange week:rank 0 -1 withscores
  10. 1) "3"
  11. 2) "1"
  12. 3) "2"
  13. 4) "1"
  14. 5) "4"
  15. 6) "0"
  16. 127.0.0.1:6379>

数据库中id 为 3 的有 1条评论
9ad5fac70c72d0319214f12345e152f4.png
1419489b792060f1539d246fe15f8f13.png
确实只有一条评论的

前端展示出来

这里的思路就比较简单了，把我们的数据从缓存中取出来就可以。用的freemarker可以自定义标签。我自定义了标签。
Hosttemplate

  1. /**
  2.  * 本周热议
  3.  */
  4. @Component
  5. public class HotsTemplate extends TemplateDirective {
  7.     @Autowired
  8.     RedisUtil redisUtil;
  10.     @Override
  11.     public String getName() {
  13.         return "hots";
  14.     }
  16.     @Override
  17.     public void execute(DirectiveHandler handler) throws Exception {
  19. // 设置 key
  20.         String key ="week:rank";
  21.         Set<ZSetOperations.TypedTuple> zSetRank = redisUtil.getZSetRank(key, 0, 6);
  22.         ArrayList<Map> maps = new ArrayList<>();
  24.         // 便利
  25.         for (ZSetOperations.TypedTuple typedTuple : zSetRank) {
  27.             // 创建 Map
  28.             HashMap<String, Object> map = new HashMap<>();
  29.             Object post_id = typedTuple.getValue();
  30.             String PostHashKey = "rank:post:" +post_id;
  31.             map.put("id",post_id);
  32.             map.put("title",redisUtil.hget(PostHashKey,"post:title"));
  33.             map.put("commentCount",typedTuple.getScore());
  34.             maps.add(map);
  35.         }
  36.         handler.put(RESULTS,maps).render();
  37.     }
  38. }

在FreemarkerConfig把我们写的便签注入就可以使用我们自定义的标签了

  1. @Configuration
  2. public class FreemarkerConfig {
  6.     @Autowired
  7.     private freemarker.template.Configuration configuration;
  8.     @Autowired
  9.     PostsTemplate postsTemplate;
  10.     @Autowired
  11.     HotsTemplate hotsTemplate;
  12.     @PostConstruct
  13.     public void setUp() {
  16.         configuration.setSharedVariable("timeAgo", new TimeAgoMethod());
  17.         configuration.setSharedVariable("posts", postsTemplate);
  18.         configuration.setSharedVariable("hosts", hotsTemplate);
  19.     }
  20. }

a47d829916147e73048ebd3b327bc5c0.png

总结

在做这个功能的时候。不够全面。虽然写完了，但是应该是获取7天内的评论。我获取了7天的文章。虽然是个 bug 但是我不想修复。就这样吧。现在能用就行。道理是一样的。到时候有时间出问题了在改吧。累了，无情的代码机器记录代码生活中。。。。。。