Redis实现好友关注的示例代码

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

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

@Override
public Result follow(Long id, Boolean isFollow) {
    //获取当前用户id
    Long userId = UserHolder.getUser().getId();
    //判断是关注操作还是取关操作
    if(BooleanUtil.isTrue(isFollow)){
        //关注操作
        Follow follow = new Follow();
        follow.setUserId(userId);
        follow.setFollowUserId(id);
        save(follow);
    }else{
        //取关操作
        remove(new QueryWrapper<Follow>().eq("user_id",userId).eq("follow_user_id",id));
    }
    return Result.ok();
}
 

@Override
public Result isFollow(Long id) {
    //获取当前用户id
    Long userId = UserHolder.getUser().getId();
    Integer count = query().eq("user_id", userId).eq("follow_user_id", id).count();
    if(count>0){
        return Result.ok(true);
    }
    return Result.ok(false);
}

@Override
public Result follow(Long id, Boolean isFollow) {
    //获取当前用户id
    Long userId = UserHolder.getUser().getId();
    String key = "follow:" + userId;
    //判断是关注操作还是取关操作
    if(BooleanUtil.isTrue(isFollow)){
        //关注操作
        Follow follow = new Follow();
        follow.setUserId(userId);
        follow.setFollowUserId(id);
        boolean success = save(follow);
        if(success){
            //插入set集合中
            stringRedisTemplate.opsForSet().add(key,id.toString());
        }
    }else{
        //取关操作
        boolean success = remove(new QueryWrapper<Follow>().eq("user_id", userId).eq("follow_user_id", id));
        //从set集合中移除
        if(success){
            stringRedisTemplate.opsForSet().remove(key,id.toString());
        }
    }
    return Result.ok();
}

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

@Override
public Result followCommons(Long id) {
    Long userId = UserHolder.getUser().getId();
    //当前用户的key
    String key1 = "follow:" + userId;
    //指定用户的key
    String key2 = "follow:" + id;
    //判断两个用户的交集
    Set<String> intersect = stringRedisTemplate.opsForSet().intersect(key1, key2);
    if(intersect==null||intersect.isEmpty()){
        //说明没有共同关注
        return Result.ok();
    }
    //如果有共同关注，则获取这些用户的信息
    List<Long> userIds = intersect.stream().map(Long::valueOf).collect(Collectors.toList());
    List<UserDTO> userDTOS = userService.listByIds(userIds).stream().map(item -> (BeanUtil.copyProperties(item, UserDTO.class))).collect(Collectors.toList());
    return Result.ok(userDTOS);
}

@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_KEY + userId;
        stringRedisTemplate.opsForZSet().add(key, blog.getId().toString(), System.currentTimeMillis());
    }
    // 5.返回id
    return Result.ok(blog.getId());
}

@Data
public class ScrollResult {
    private List<?> list;
    private Long minTime;
    private Integer offset;
}

@GetMapping("/of/follow")
public Result queryBlogOfFollow(
    @RequestParam("lastId") Long max, @RequestParam(value = "offset", defaultValue = "0") Integer offset){
    return blogService.queryBlogOfFollow(max, offset);
}

@Override
public Result queryBlogOfFollow(Long max, Integer offset) {
    //获取当前用户
    Long userId = UserHolder.getUser().getId();
    //组装key
    String key = RedisConstants.FEED_KEY + userId;
    //分页查询收件箱，一次查询两条 ZREVRANGEBYSCORE key Max Min LIMIT offset count
    Set<ZSetOperations.TypedTuple<String>> typedTuples = stringRedisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, 0, max, offset, 2);
    //若收件箱为空则直接返回
    if (typedTuples == null || typedTuples.isEmpty()) {
        return Result.ok();
    }
    //通过上述数据获取笔记id，偏移量和最小时间
    ArrayList<Long> ids = new ArrayList<>();
    long minTime = 0;
    //因为这里的偏移量是下一次要传给前端的偏移量，所以初始值定为1
    int os = 1;
    for (ZSetOperations.TypedTuple<String> typedTuple : typedTuples) {
        //添加博客id
        ids.add(Long.valueOf(typedTuple.getValue()));
        //获取时间戳
        long score = typedTuple.getScore().longValue();
        //由于数据是按时间戳倒序排列的，因此最后被赋值的就是最小时间
        if (minTime == score) {
            //如果有两个数据时间戳相等，那么偏移量开始计数
            os++;
        } else {
            //如果当前数据的时间戳与已经记录的最小时间戳不相等，则说明当前时间小于已记录的最小时间戳，将其赋给minTime
            minTime = score;
            //偏移量重置
            os = 1;
        }
    }
    //需要考虑到时间戳相等的消息数量大于2的情况，这时候偏移量就需要加上上一页查询时的偏移量
    os = minTime == max ? os : os + offset;
 
    //根据id查询blog
    String idStr = StrUtil.join(",", ids);
    //查询时需要手动指定顺序
    List<Blog> blogs = query().in("id", ids).last("ORDER BY FIELD(id," + idStr + ")").list();
    //这里还需要查询博客作者的相关信息，这里对比视频中，用一次查询代替了多次查询，提高效率
    List<Long> blogUserIds = blogs.stream().map(blog -> blog.getUserId()).collect(Collectors.toList());
    String blogUserIdStr = StrUtil.join(",", blogUserIds);
    HashMap<Long, User> userHashMap = new HashMap<>();
    userService.query().in("id", blogUserIds).last("ORDER BY FIELD(id," + blogUserIdStr + ")").list().
        stream().forEach(user -> {
        userHashMap.put(user.getId(), user);
    });
    //为blog封装数据
    Iterator<Blog> blogIterator = blogs.iterator();
    while (blogIterator.hasNext()) {
        Blog blog = blogIterator.next();
        User user = userHashMap.get(blog.getUserId());
        blog.setName(user.getNickName());
        blog.setIcon(user.getIcon());
        blog.setIsLike(isLikeBlog(blog.getId()));
    }
    //返回封装数据
    ScrollResult scrollResult = new ScrollResult();
    scrollResult.setList(blogs);
    scrollResult.setMinTime(minTime);
    scrollResult.setOffset(os);
    return Result.ok(scrollResult);
}