功能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來表示：

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 = "https://www.cnblogs.com/liyuelian/p/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）在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 = "https://www.cnblogs.com/liyuelian/p/current", defaultValue = "https://www.cnblogs.com/liyuelian/p/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需求分析

修改新增探店筆記的業務，在保存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；下次查詢時，去找比這個時間戳小的訊息，如此就可以實作滾動分頁了，

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資訊，并實作分頁查詢

轉載請註明出處，本文鏈接：https://www.uj5u.com/shujuku/551581.html

標籤：NoSQL

上一篇：1、etcd基礎介紹

下一篇：返回列表

day10-好友關注