> 科技资讯 > day10-好友关注

day10-好友关注

科技资讯 投稿 8400℃ 0 评论

day10-好友关注

功能05-好友关注

6.功能05-好友关注

6.1关注和取关

6.1.1需求分析

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

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

    关注和取关接口
  1. 判断是否关注的接口
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

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

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. 请求博主发布过的笔记信息

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

//根据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的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"

代码实现

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

//关注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中的数据：

重新登录一个用户，关注两个博主：

（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号用户。

6.3关注推送

6.3.1Feed流的Timeline模式

当我们关注了用户后，如果这个用户发了动态，那么我们应该把这些数据推送给用户，这个需求又叫做Feed流。关注推送也叫做Feed流，直译为投喂。为用户持续的提供“沉浸式”的体验，通过无限下拉刷新获取新的信息。

对于新型的Feed流的的效果：不需要用户再去推送信息，而是系统分析用户到底想要什么，然后直接把内容推送给用户，从而使用户能够更加的节约时间，不用主动去寻找。

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

在本例中的个人主页，是基于关注的好友来做Feed流的，因此采用的是Timeline的模式。

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

（1）拉模式：也叫读扩散

粉丝会有一个收件箱，这个收件箱平常是空的，只有当他要去读消息的时候，才会从他关注的人的发件箱中，一个一个地拉取消息到自己的收件箱中，然后按照信息会按照时间排序，这样他就可以按照时间去读消息了。

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

（2）推模式：也叫写扩散。

因此这种模式的优点是延时低，但缺点是内存占用高。

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

    • 如果是普通用户，将采用写扩散方式，直接把数据写入到粉丝的收件箱中去，因为普通用户的粉丝关注量比较小，所以这样做没有压力
    • 如果是大V，则直接将数据先写入到一份到发件箱里边去，然后再直接写一份到活跃粉丝收件箱里边去

  • 在收件人角度来看

      如果是活跃粉丝，那么大V和普通的人发的都会直接写入到自己收件箱里边来
  • 如果是普通粉丝，由于他们上线不是很频繁，所以等他们上线时，再从发件箱里边去拉信息

（4）三种模式对比

6.3.2基于推模式实现关注推送

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

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

综上，关注推送业务的关键，就是：

  1. 推送消息

Redis中的list和zset结构都可以实现排序，list结构可以按照脚标查询；zset结构没有脚标，但是可以按照排名（根据score）进行查询，也可以实现分页。那么应该如何选择呢？

Feed流的分页问题：

如下，t1时刻有10条消息，它们按照时间排序。此时读取的第一页（假设为5条）为消息10-6。在t2时刻发布了一条新消息，由于是按时间排序，此条消息会被放到最上面。这时，当读取第二页的时候，由于分页是从当前的第一条消息（11）开始计算，因此读取的就是6-2。

Feed流的滚动分页：

如下，t1时读取了第一页，记录lastId为6；t2时发布一条新消息，经过排序放到了最新的位置。t3时刻读取第二页，由于记录了lastId为6，就不会出现重复读取的问题。

Feed流滚动分页选用的数据结构：

但是，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流分页的底层结构。

6.3.2.2代码实现

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

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=2的用户，发布一篇探店笔记：

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

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

编程笔记 » day10-好友关注

赞同 (36) or 分享 (0)
游客 发表我的评论   换个身份
取消评论

表情
(0)个小伙伴在吐槽