day10-好友关注

功能05-好友关注

6.功能05-好友关注

6.1关注和取关

6.1.1需求分析

在探店图文的详情页面中，可以关注发布笔记的作者：

• 关注和取关：点击关注按钮就会发出请求（上图）：http://127.0.0.1:8080/api/follow/2/true（2是关注的用户id，最后面的参数可以是true或者false，取决于当前的关注状态）
  
• 查询当前关注状态：（下图）http://127.0.0.1:8080/api/follow/or/not/2，返回两种状态：true（已关注）或者false（未关注）。关注和取关功能根据关注状态来实现。
  
• 整体流程：进入页面详情的时候，会自动查询当前用户对blog博主的关注状态，根据关注状态来悬渲染“关注”或“已关注”按钮，根据关注状态，用户可以做相对的“关注”或者“取关”操作。
  

需求：基于该表数据结构，实现两个接口：

• 关注和取关接口
  
• 判断是否关注的接口
  

关注是User之间的关系，是博主与粉丝之间的关系，数据库使用tb_follow来表示：

1. CREATE TABLE `tb_follow` (
2.   `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
3.   `user_id` bigint(20) unsigned NOT NULL COMMENT '用户id',
4.   `follow_user_id` bigint(20) unsigned NOT NULL COMMENT '关联的用户id',
5.   `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
6.   PRIMARY KEY (`id`) USING BTREE
7. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=COMPACT

复制代码

注意：这里要把主键改为自增长，简化开发。

取关就是删除该表的一条对应记录，关注就是新增一条表对应的记录。根据user_id和follow_user_id判断关注状态。
6.1.2代码实现

（1）Follow.java，记录用户和博主的关系

1. package com.hmdp.entity;
3. import com.baomidou.mybatisplus.annotation.IdType;
4. import com.baomidou.mybatisplus.annotation.TableId;
5. import com.baomidou.mybatisplus.annotation.TableName;
6. import lombok.Data;
7. import lombok.EqualsAndHashCode;
8. import lombok.experimental.Accessors;
10. import java.io.Serializable;
11. import java.time.LocalDateTime;
13. /**
14. * 关注关系（用户和博主）
15. *
16. * @author 李
17. * @version 1.0
18. */
19. @Data
20. @EqualsAndHashCode(callSuper = false)
21. @Accessors(chain = true)
22. @TableName("tb_follow")
23. public class Follow implements Serializable {
25.     private static final long serialVersionUID = 1L;
27.     //主键
28.     @TableId(value = "id", type = IdType.AUTO)
29.     private Long id;
31.     //用户id（粉丝）
32.     private Long userId;
34.     //关注的用户id（博主）
35.     private Long followUserId;
37.     //创建时间
38.     private LocalDateTime createTime;
39. }

复制代码

（2）IFollowService.java，声明方法接口

1. package com.hmdp.service;
3. import com.hmdp.dto.Result;
4. import com.hmdp.entity.Follow;
5. import com.baomidou.mybatisplus.extension.service.IService;
7. /**
8. *  服务类
9. *
10. * @author 李
11. * @version 1.0
12. */
13. public interface IFollowService extends IService<Follow> {
15.     Result follow(Long followUserId, Boolean isFollow);
17.     Result isFollow(Long followUserId);
18. }

复制代码

（3）FollowServiceImpl.java，实现方法

1. package com.hmdp.service.impl;
3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
4. import com.hmdp.dto.Result;
5. import com.hmdp.entity.Follow;
6. import com.hmdp.mapper.FollowMapper;
7. import com.hmdp.service.IFollowService;
8. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
9. import com.hmdp.utils.UserHolder;
10. import org.springframework.stereotype.Service;
12. /**
13. * 服务实现类
14. *
15. * @author 李
16. * @version 1.0
17. */
18. @Service
19. public class FollowServiceImpl extends ServiceImpl<FollowMapper, Follow> implements IFollowService {
21.     //关注or取关功能
22.     @Override
23.     public Result follow(Long followUserId, Boolean isFollow) {
24.         if (UserHolder.getUser() == null) {
25.             return Result.fail("用户未登录");
26.         }
27.         //1.获取登录用户
28.         Long userId = UserHolder.getUser().getId();
29.         //2.判断是关注还是取关功能
30.         if (isFollow) {
31.             //3.关注，新增数据
32.             Follow follow = new Follow();
33.             follow.setUserId(userId);
34.             follow.setFollowUserId(followUserId);
35.             save(follow);
36.         } else {
37.             //4.取关，删除数据 delete form tb_follow where user_id = ? and follow_user_id = ?
38.             remove(new QueryWrapper<Follow>()
39.                     .eq("user_id", userId).eq("follow_user_id", followUserId));
40.         }
41.         return Result.ok();
42.     }
44.     //查询当前用户对某博主的关注状态
45.     @Override
46.     public Result isFollow(Long followUserId) {
47.         if (UserHolder.getUser() == null) {
48.             return Result.fail("用户未登录");
49.         }
50.         //1.获取登录用户
51.         Long userId = UserHolder.getUser().getId();
52.         //2.查询是否关注 select count(*) from tb_follow where user_id =? and follow_user_id =?
53.         Integer count = query().eq("user_id", userId).eq("follow_user_id", followUserId).count();
54.         return Result.ok(count > 0);//如果count>0,表示已关注，返回true，反之，返回false
55.     }
56. }

复制代码

（4）FollowController.java

1. package com.hmdp.controller;
4. import com.hmdp.dto.Result;
5. import com.hmdp.service.IFollowService;
6. import org.springframework.web.bind.annotation.*;
8. import javax.annotation.Resource;
10. /**
11. * 前端控制器
12. *
13. * @author 李
14. * @version 1.0
15. */
16. @RestController
17. @RequestMapping("/follow")
18. public class FollowController {
19.     @Resource
20.     private IFollowService followService;
22.     @PutMapping("/{id}/{isFollow}")
23.     public Result follow(@PathVariable("id") Long followUserId, @PathVariable("isFollow") Boolean isFollow) {
24.         return followService.follow(followUserId, isFollow);
25.     }
27.     @GetMapping("/or/not/{id}")
28.     public Result follow(@PathVariable("id") Long followUserId) {
29.         return followService.isFollow(followUserId);
30.     }
31. }

复制代码

（5）测试：重启项目，进入博客详情
点击关注按钮，提示关注成功：
数据库的tb_follow表添加一条新数据：
再点击取消关注按钮，提示取消关注成功：
数据库tb_follow删除该条数据：
6.2共同关注

6.2.1博主首页信息

点击博主头像，可以进入博主首页，查看博主首页的信息：包括博主信息，发布的笔记，共同关注。
当点击进入博主首页的时候，将会发出两个请求：

• 请求博主的用户信息
  
• 请求博主发布过的笔记信息
  

当点击共同关注的时候，就会发出请求查询共同关注。
博主个人首页依赖于两个功能：
（1）在UserController.java中增加queryUserById()方法，用于请求博主的用户信息

1. //根据id查询用户信息
2. @GetMapping("/{id}")
3. public Result queryUserById(@PathVariable("id") Long userId) {
4.     //查询详情
5.     User user = userService.getById(userId);
6.     if (user == null) {
7.         return Result.ok();
8.     }
9.     UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
10.     //返回
11.     return Result.ok(userDTO);
12. }

复制代码

（2）在BlogController.java中增加queryBlogByUserId方法，用于查询最近10条笔记

1. //根据用户id查询blog
2. @GetMapping("/of/user")
3. public Result queryBlogByUserId(
4.         @RequestParam(value = "current", defaultValue = "1") Integer current,
5.         @RequestParam("id") Long id) {
6.     //根据用户查询
7.     Page<Blog> page = blogService.query()
8.             .eq("user_id", id)
9.             .page(new Page<>(current, SystemConstants.MAX_PAGE_SIZE));
10.     //获取当前页数据
11.     List<Blog> records = page.getRecords();
12.     return Result.ok(records);
13. }

复制代码

（3）重启项目，点击某个博主首页，显示如下：
6.2.2共同关注

需求：使用Redis合适的数据结构，实现共同关注功能。在博主个人页面展示出当前用户与博主的共同好友。
我们可以使用Redis的Set结构，求多个set集合的交集：

1. SINTER key [key ...]
2. summary: Intersect multiple sets
3. since: 1.0.0

复制代码

例如：

1. 127.0.0.1:6379> SADD s1 m1 m2
2. (integer) 2
3. 127.0.0.1:6379> SADD s2 m2 m3
4. (integer) 2
5. 127.0.0.1:6379> SINTER s1 s2
6. 1) "m2"

复制代码

代码实现

要使用set结构实现共同关注功能，首先将用户关注的列表添加到redis的set集合中。
因此，我们需要修改之前的关注功能：在关注用户的时候，不仅要记录到数据库中，还要将关注的用户放到redis的set集合中（key为当前用户id，value为当前用户关注的所有用户的id）。
（1）修改FollowServiceImpl.java的follow方法：

1. //关注or取关功能
2. @Override
3. public Result follow(Long followUserId, Boolean isFollow) {
4.     if (UserHolder.getUser() == null) {
5.         return Result.fail("用户未登录");
6.     }
7.     //1.获取登录用户
8.     Long userId = UserHolder.getUser().getId();
9.     String key = "follows:" + userId;
10.     //2.判断是关注还是取关功能
11.     if (isFollow) {
12.         //3.关注，新增数据
13.         Follow follow = new Follow();
14.         follow.setUserId(userId);
15.         follow.setFollowUserId(followUserId);
16.         boolean isSuccess = save(follow);
17.         if (isSuccess) {
18.             //将关注用户的id，放入到redis的set集合中 sadd userId followerUserId
19.             stringRedisTemplate.opsForSet().add(key, followUserId.toString());
20.         }
21.     } else {
22.         //4.取关，删除数据 delete form tb_follow where user_id = ? and follow_user_id = ?
23.         boolean isSuccess = remove(new QueryWrapper<Follow>()
24.                 .eq("user_id", userId).eq("follow_user_id", followUserId));
25.         if (isSuccess) {
26.             //将关注用户的id从set集合中移除
27.             stringRedisTemplate.opsForSet().remove(key, followUserId);
28.         }
29.     }
30.     return Result.ok();
31. }

复制代码

（2）测试，使用一个用户任意关注两个博主后，redis中的数据：
数据库：
重新登录一个用户，关注两个博主：
可以看到用户1034和用户1的共同关注为用户2号，关注功能已经修改完毕，接下来实现共同关注功能。
（3）修改IFollowService接口，声明followCommons方法

1. Result followCommons(Long id);

复制代码

（4）修改FollowServiceImpl，实现followCommons()方法

1. @Override
2. public Result followCommons(Long id) {
3.     //1.获取当前用户
4.     Long userId = UserHolder.getUser().getId();
5.     String key = "follows:" + userId;
6.     String key2 = "follows:" + id;
7.     //2.求交集
8.     //结果为交集的所有用户id
9.     Set<String> intersect = stringRedisTemplate.opsForSet().intersect(key, key2);
10.     if (intersect == null || intersect.isEmpty()) {
11.         //如果没有交集
12.         return Result.ok(Collections.emptyList());
13.     }
14.     //3.解析id集合
15.     List<Long> ids = intersect.stream().map(Long::valueOf).collect(Collectors.toList());
16.     //4.查询用户
17.     List<UserDTO> users = userService.listByIds(ids)
18.             .stream()
19.             .map(user -> BeanUtil.copyProperties(user, UserDTO.class))
20.             .collect(Collectors.toList());
21.     return Result.ok(users);
22. }

复制代码

（5）修改FollowController，增加接口

1. @GetMapping("/common/{id}")
2. public Result followCommons(@PathVariable("id") Long id) {
3.     return followService.followCommons(id);
4. }

复制代码

（6）测试：登录id为1034的用户，查看id为1的用户主页，页面显示两个用户共同关注为2号用户。
和redis中的数据一致，测试通过。
6.3关注推送

6.3.1Feed流的Timeline模式

当我们关注了用户后，如果这个用户发了动态，那么我们应该把这些数据推送给用户，这个需求又叫做Feed流。关注推送也叫做Feed流，直译为投喂。为用户持续的提供“沉浸式”的体验，通过无限下拉刷新获取新的信息。
对于传统的模式的内容解锁：需要用户去通过搜索引擎或者是其他的方式去解锁想要看的内容
对于新型的Feed流的的效果：不需要用户再去推送信息，而是系统分析用户到底想要什么，然后直接把内容推送给用户，从而使用户能够更加的节约时间，不用主动去寻找。
Feed流产品有两种常见模式：

• Timeline：不做内容筛选，简单地按照内容发布时间排序，常用于好友或关注。例如朋友圈
  
  
  
  • 优点：信息全面，不会有缺失。并且实现也相对简单
    
  • 缺点：信息“噪音”较多，用户不一定感兴趣，内容获取效率低
    
  
  
• 智能排序：利用智能算法屏蔽掉违规的、用户不感兴趣的内容。推送用户感兴趣的信息来吸引用户
  
  
  
  • 优点：投喂用户感兴趣信息，用户粘度很高，容易沉迷
    
  • 缺点：如果算法不精准，可能会起到反作用
    
  
  

在本例中的个人主页，是基于关注的好友来做Feed流的，因此采用的是Timeline的模式。
该模式的实现方案有三种：

• 拉模式
  
• 推模式
  
• 拉推结合模式
  

（1）拉模式：也叫读扩散
如上所示，每个博主都会发布自己的笔记，视频等数据，我们称之为“消息”。每个人都会有一个发件箱，发送的消息会发到各自的发件箱里（消息除了数据本身，还会附带一个时间戳）。
粉丝会有一个收件箱，这个收件箱平常是空的，只有当他要去读消息的时候，才会从他关注的人的发件箱中，一个一个地拉取消息到自己的收件箱中，然后按照信息会按照时间排序，这样他就可以按照时间去读消息了。

拉模式只有在读消息的时候才会拉取一个消息副本，因此拉模式又叫读扩散

• 优点：节省内存空间。因为收件箱读完后就可以清理掉数据了，下一次要读的时候再重新拉取消息，消息只保存在发件人的发件箱中，比较节省内存空间。
  
• 缺点：延时高。用户每次读消息的时候，都要重新拉取发件箱的消息，然后做消息排序，这一系列动作耗时长，读取的延迟比较高。
  

（2）推模式：也叫写扩散。
推模式没有发件箱，博主发布的消息会直接推送到他的所有粉丝的收件箱中，然后收件箱中的消息会按照时间进行排序。粉丝要读消息的时候，就可以直接读取已经排序好的消息，不需要临时去拉取消息。
因此这种模式的优点是延时低，但缺点是内存占用高。

推模式模式在发布消息的时候，通过直接写到收件箱中来进行消息扩散，因此叫做写扩散。

（3）推拉结合模式：也叫做读写混合，兼具推和拉两种模式的优点。

• 在发件人角度来看
  
  
  
  • 如果是普通用户，将采用写扩散方式，直接把数据写入到粉丝的收件箱中去，因为普通用户的粉丝关注量比较小，所以这样做没有压力
    
  • 如果是大V，则直接将数据先写入到一份到发件箱里边去，然后再直接写一份到活跃粉丝收件箱里边去
    
  
  
• 在收件人角度来看
  
  
  
  • 如果是活跃粉丝，那么大V和普通的人发的都会直接写入到自己收件箱里边来
    
  • 如果是普通粉丝，由于他们上线不是很频繁，所以等他们上线时，再从发件箱里边去拉信息
    
  
  

（4）三种模式对比
这里采取推模式。
6.3.2基于推模式实现关注推送

6.3.2.1需求分析

• 修改新增探店笔记的业务，在保存blog到数据库的同时，推送到粉丝的收件箱
  
• 收件箱满足可以根据时间戳排序，必须用Redis的数据结构实现
  
• 查询收件箱数据时，可以实现分页查询
  

推模式是没有发件箱的，用户发布的消息会直接推送消息到其粉丝收件箱中。在我们的业务中，消息就是探店笔记，每当有人发布探店笔记时，我们就应该将笔记推送到其粉丝的收件箱。
之前实现的探店笔记功能：当用户发布探店笔记时，会将笔记的信息直接保存到数据库中。为了实现新功能——消息推送，需要改造发布探店笔记功能：保存笔记到数据库的同时，还要将笔记推送到粉丝的收件箱中。为了节省内存空间，推送消息时，只需要推送一个blogId即可。粉丝去查询笔记时，再根据id到数据库中查询笔记详细信息。
综上，关注推送业务的关键，就是：

• 实现收件箱
  
• 推送消息
  

最后是消息的分页功能：
Redis中的list和zset结构都可以实现排序，list结构可以按照脚标查询；zset结构没有脚标，但是可以按照排名（根据score）进行查询，也可以实现分页。那么应该如何选择呢？
Feed流的分页问题：
因为Feed流中的数据会不断更新，所以数据的脚标也在变化，因此不能使用传统的分页模式：
如下，t1时刻有10条消息，它们按照时间排序。此时读取的第一页（假设为5条）为消息10-6。在t2时刻发布了一条新消息，由于是按时间排序，此条消息会被放到最上面。这时，当读取第二页的时候，由于分页是从当前的第一条消息（11）开始计算，因此读取的就是6-2。
我们可以发现6被重复读取了两次，分页出现了混乱，因此Feed不能采用传统的分页模式。
Feed流的滚动分页：
所谓的滚动分页，其实就是记录每次查询的最后一条，下一次查询以该位置作为起始位置。第一次查询时，起始位置记为无穷。
如下，t1时读取了第一页，记录lastId为6；t2时发布一条新消息，经过排序放到了最新的位置。t3时刻读取第二页，由于记录了lastId为6，就不会出现重复读取的问题。
Feed流滚动分页选用的数据结构：
回到之前的问题：list结构不支持这种滚动分页，因为在list中查询数据，只能按照脚标查询（即只能实现传统的分页模式）。zset可以按照score值排序，但如果按照排名1，2，3，4....这样查询，就和list脚标查询一样了。
但是，zset还支持按照score值范围进行查询：在score中存放时间戳，每一次查询时，记住最小的时间戳（即当前页的最后一条消息），这样就相当于记录了lastId；下次查询时，去找比这个时间戳小的消息，如此就可以实现滚动分页了。

1. ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]
2. summary: Return a range of members in a sorted set, by score, with scores ordered from high to low
3. since: 2.2.0

复制代码

因此，我们可以选择zset结构作为实现Feed流分页的底层结构。
（在数据有变化的情况下，尽量不要使用List这种队列去做分页，而是使用SortedSet，例如排行榜）
6.3.2.2代码实现

需求1：修改新增探店笔记的业务，在保存blog到数据库的同时，推送到粉丝的收件箱

（1）修改IBlogService.java，增加方法声明

1. Result saveBlog(Blog blog);

复制代码

（2）修改BlogServiceImpl.java，实现saveBlog()方法

1. @Override
2. public Result saveBlog(Blog blog) {
3.     //1.获取登录用户
4.     UserDTO user = UserHolder.getUser();
5.     blog.setUserId(user.getId());
6.     //2.保存探店笔记
7.     boolean isSuccess = save(blog);
8.     if (!isSuccess) {
9.         return Result.fail("新增笔记失败！");
10.     }
11.     //3.查询笔记作者的所有粉丝 select * from tb_follow where follow_user_id=?
12.     List<Follow> follows = followService.query()
13.             .eq("follow_user_id", user.getId()).list();
14.     //4.推送笔记id给所有粉丝
15.     for (Follow follow : follows) {
16.         //4.1获取粉丝id
17.         Long userId = follow.getUserId();
18.         //4.2推送
19.         String key = "feed:" + userId;
20.         //key为粉丝id，value为blogId，score为时间戳
21.         stringRedisTemplate.opsForZSet()
22.                 .add(key, blog.getId().toString(), System.currentTimeMillis());
23.     }
24.     //5.返回笔记id
25.     return Result.ok(blog.getId());
26. }

复制代码

（3）修改BlogController，添加接口

1. @PostMapping
2. public Result saveBlog(@RequestBody Blog blog) {
3.    return blogService.saveBlog(blog);
4. }

复制代码

（4）测试
可以看到当前id=1和id=1034的用户都关注了id=2的用户
我们登陆id=2的用户，发布一篇探店笔记：

在数据库的tb_blog表中可以看到已经成功保存笔记数据：blogId=11
在redis中，可以看到id=1和id=1034两个用户的收件箱中都分别收到了blogId=11的笔记推送（每个用户都有一个收件箱）：
测试通过。

需求2：在个人主页的“关注”卡片中，查询并展示推送的Blog信息，并实现分页查询

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！