day10-好友关注

功能05-好友关注

6.功能05-好友关注

6.1关注和取关

6.1.1需求分析

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

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

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

  1. 关注和取关接口
  2. 判断是否关注的接口

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

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

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

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

6.1.2代码实现

(1)Follow.java,记录用户和博主的关系

package com.hmdp.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.time.LocalDateTime;

/**
 * 关注关系(用户和博主)
 *
 * @author 李
 * @version 1.0
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("tb_follow")
public class Follow implements Serializable {

    private static final long serialVersionUID = 1L;

    //主键
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    //用户id(粉丝)
    private Long userId;

    //关注的用户id(博主)
    private Long followUserId;

    //创建时间
    private LocalDateTime createTime;
}

(2)IFollowService.java,声明方法接口

package com.hmdp.service;

import com.hmdp.dto.Result;
import com.hmdp.entity.Follow;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 *  服务类
 *
 * @author 李
 * @version 1.0
 */
public interface IFollowService extends IService<Follow> {

    Result follow(Long followUserId, Boolean isFollow);

    Result isFollow(Long followUserId);
}

(3)FollowServiceImpl.java,实现方法

package com.hmdp.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.hmdp.dto.Result;
import com.hmdp.entity.Follow;
import com.hmdp.mapper.FollowMapper;
import com.hmdp.service.IFollowService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.utils.UserHolder;
import org.springframework.stereotype.Service;

/**
 * 服务实现类
 *
 * @author 李
 * @version 1.0
 */
@Service
public class FollowServiceImpl extends ServiceImpl<FollowMapper, Follow> implements IFollowService {

    //关注or取关功能
    @Override
    public Result follow(Long followUserId, Boolean isFollow) {
        if (UserHolder.getUser() == null) {
            return Result.fail("用户未登录");
        }
        //1.获取登录用户
        Long userId = UserHolder.getUser().getId();
        //2.判断是关注还是取关功能
        if (isFollow) {
            //3.关注,新增数据
            Follow follow = new Follow();
            follow.setUserId(userId);
            follow.setFollowUserId(followUserId);
            save(follow);
        } else {
            //4.取关,删除数据 delete form tb_follow where user_id = ? and follow_user_id = ?
            remove(new QueryWrapper<Follow>()
                    .eq("user_id", userId).eq("follow_user_id", followUserId));
        }
        return Result.ok();
    }

    //查询当前用户对某博主的关注状态
    @Override
    public Result isFollow(Long followUserId) {
        if (UserHolder.getUser() == null) {
            return Result.fail("用户未登录");
        }
        //1.获取登录用户
        Long userId = UserHolder.getUser().getId();
        //2.查询是否关注 select count(*) from tb_follow where user_id =? and follow_user_id =?
        Integer count = query().eq("user_id", userId).eq("follow_user_id", followUserId).count();
        return Result.ok(count > 0);//如果count>0,表示已关注,返回true,反之,返回false
    }
}

(4)FollowController.java

package com.hmdp.controller;


import com.hmdp.dto.Result;
import com.hmdp.service.IFollowService;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

/**
 * 前端控制器
 *
 * @author 李
 * @version 1.0
 */
@RestController
@RequestMapping("/follow")
public class FollowController {
    @Resource
    private IFollowService followService;

    @PutMapping("/{id}/{isFollow}")
    public Result follow(@PathVariable("id") Long followUserId, @PathVariable("isFollow") Boolean isFollow) {
        return followService.follow(followUserId, isFollow);
    }

    @GetMapping("/or/not/{id}")
    public Result follow(@PathVariable("id") Long followUserId) {
        return followService.isFollow(followUserId);
    }
}

(5)测试:重启项目,进入博客详情

点击关注按钮,提示关注成功:

数据库的tb_follow表添加一条新数据:

再点击取消关注按钮,提示取消关注成功:

数据库tb_follow删除该条数据:

6.2共同关注

6.2.1博主首页信息

点击博主头像,可以进入博主首页,查看博主首页的信息:包括博主信息,发布的笔记,共同关注。

当点击进入博主首页的时候,将会发出两个请求:

  1. 请求博主的用户信息
  2. 请求博主发布过的笔记信息

当点击共同关注的时候,就会发出请求查询共同关注。

博主个人首页依赖于两个功能:

(1)在UserController.java中增加queryUserById()方法,用于请求博主的用户信息

//根据id查询用户信息
@GetMapping("/{id}")
public Result queryUserById(@PathVariable("id") Long userId) {
    //查询详情
    User user = userService.getById(userId);
    if (user == null) {
        return Result.ok();
    }
    UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
    //返回
    return Result.ok(userDTO);
}

(2)在BlogController.java中增加queryBlogByUserId方法,用于查询最近10条笔记

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

(3)重启项目,点击某个博主首页,显示如下:

6.2.2共同关注

需求:使用Redis合适的数据结构,实现共同关注功能。在博主个人页面展示出当前用户与博主的共同好友。

我们可以使用Redis的Set结构,求多个set集合的交集:

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

例如:

127.0.0.1:6379> SADD s1 m1 m2
(integer) 2
127.0.0.1:6379> SADD s2 m2 m3
(integer) 2
127.0.0.1:6379> SINTER s1 s2
1) "m2"

代码实现

要使用set结构实现共同关注功能,首先将用户关注的列表添加到redis的set集合中。

因此,我们需要修改之前的关注功能:在关注用户的时候,不仅要记录到数据库中,还要将关注的用户放到redis的set集合中(key为当前用户id,value为当前用户关注的所有用户的id)。

(1)修改FollowServiceImpl.java的follow方法:

//关注or取关功能
@Override
public Result follow(Long followUserId, Boolean isFollow) {
    if (UserHolder.getUser() == null) {
        return Result.fail("用户未登录");
    }
    //1.获取登录用户
    Long userId = UserHolder.getUser().getId();
    String key = "follows:" + userId;
    //2.判断是关注还是取关功能
    if (isFollow) {
        //3.关注,新增数据
        Follow follow = new Follow();
        follow.setUserId(userId);
        follow.setFollowUserId(followUserId);
        boolean isSuccess = save(follow);
        if (isSuccess) {
            //将关注用户的id,放入到redis的set集合中 sadd userId followerUserId
            stringRedisTemplate.opsForSet().add(key, followUserId.toString());
        }
    } else {
        //4.取关,删除数据 delete form tb_follow where user_id = ? and follow_user_id = ?
        boolean isSuccess = remove(new QueryWrapper<Follow>()
                .eq("user_id", userId).eq("follow_user_id", followUserId));
        if (isSuccess) {
            //将关注用户的id从set集合中移除
            stringRedisTemplate.opsForSet().remove(key, followUserId);
        }
    }
    return Result.ok();
}

(2)测试,使用一个用户任意关注两个博主后,redis中的数据:

数据库:

重新登录一个用户,关注两个博主:

可以看到用户1034和用户1的共同关注为用户2号,关注功能已经修改完毕,接下来实现共同关注功能。

(3)修改IFollowService接口,声明followCommons方法

Result followCommons(Long id);

(4)修改FollowServiceImpl,实现followCommons()方法

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

(5)修改FollowController,增加接口

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

(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需求分析
  1. 修改新增探店笔记的业务,在保存blog到数据库的同时,推送到粉丝的收件箱
  2. 收件箱满足可以根据时间戳排序,必须用Redis的数据结构实现
  3. 查询收件箱数据时,可以实现分页查询

推模式是没有发件箱的,用户发布的消息会直接推送消息到其粉丝收件箱中。在我们的业务中,消息就是探店笔记,每当有人发布探店笔记时,我们就应该将笔记推送到其粉丝的收件箱。

之前实现的探店笔记功能:当用户发布探店笔记时,会将笔记的信息直接保存到数据库中。为了实现新功能——消息推送,需要改造发布探店笔记功能:保存笔记到数据库的同时,还要将笔记推送到粉丝的收件箱中。为了节省内存空间,推送消息时,只需要推送一个blogId即可。粉丝去查询笔记时,再根据id到数据库中查询笔记详细信息。

综上,关注推送业务的关键,就是:

  1. 实现收件箱

  2. 推送消息

最后是消息的分页功能:

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;下次查询时,去找比这个时间戳小的消息,如此就可以实现滚动分页了。

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

因此,我们可以选择zset结构作为实现Feed流分页的底层结构。

(在数据有变化的情况下,尽量不要使用List这种队列去做分页,而是使用SortedSet,例如排行榜)

6.3.2.2代码实现

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

(1)修改IBlogService.java,增加方法声明

Result saveBlog(Blog blog);

(2)修改BlogServiceImpl.java,实现saveBlog()方法

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

(3)修改BlogController,添加接口

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

(4)测试

可以看到当前id=1和id=1034的用户都关注了id=2的用户

我们登陆id=2的用户,发布一篇探店笔记:

在数据库的tb_blog表中可以看到已经成功保存笔记数据:blogId=11

在redis中,可以看到id=1和id=1034两个用户的收件箱中都分别收到了blogId=11的笔记推送(每个用户都有一个收件箱):

测试通过。

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

热门相关:骑士归来   夫人,你马甲又掉了!   夫人,你马甲又掉了!   惊世毒妃:轻狂大小姐   惊世毒妃:轻狂大小姐