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

@Override
public Result follow(Long followUserId, Boolean isFollow) {
    // 1. 获取当前登录用户
    Long userId = UserHolder.getUser().getId();

    if (isFollow) {
        // 2. 关注 → 新增数据
        Follow follow = new Follow();
        follow.setUserId(userId);
        follow.setFollowUserId(followUserId);
        boolean isSuccess = save(follow);
    } else {
        // 3. 取关 → 删除数据
        boolean isSuccess = remove(new QueryWrapper<Follow>()
                .eq("user_id", userId)
                .eq("follow_user_id", followUserId));
    }
    return Result.ok();
}

@Override
public Result isFollow(Long followUserId) {
    Long userId = UserHolder.getUser().getId();
    // 查询关注关系是否存在
    Integer count = query().eq("user_id", userId)
            .eq("follow_user_id", followUserId)
            .count();
    return Result.ok(count > 0);
}

# 添加关注关系
SADD follows:1 2     # 用户1 关注了 用户2
SADD follows:1 3     # 用户1 关注了 用户3
SADD follows:2 3     # 用户2 关注了 用户3

# 求交集 → 共同关注
SINTER follows:1 follows:2
# 结果: {3} → 用户1 和 用户2 共同关注了用户3

@Override
public Result follow(Long followUserId, Boolean isFollow) {
    Long userId = UserHolder.getUser().getId();
    String key = FOLLOW_KEY + userId;

    if (isFollow) {
        // 关注：写入数据库
        Follow follow = new Follow();
        follow.setUserId(userId);
        follow.setFollowUserId(followUserId);
        boolean isSuccess = save(follow);
        // 同时写入 Redis Set
        if (isSuccess) {
            stringRedisTemplate.opsForSet().add(key, followUserId.toString());
        }
    } else {
        // 取关：删除数据库
        boolean isSuccess = remove(new QueryWrapper<Follow>()
                .eq("user_id", userId)
                .eq("follow_user_id", followUserId));
        // 同时从 Redis Set 移除
        if (isSuccess) {
            stringRedisTemplate.opsForSet().remove(key, followUserId.toString());
        }
    }
    return Result.ok();
}

@Override
public Result followCommons(Long id) {
    // 1. 获取当前用户 ID
    Long userId = UserHolder.getUser().getId();
    String key1 = FOLLOW_KEY + userId;
    String key2 = FOLLOW_KEY + id;

    // 2. 求两个 Set 的交集
    Set<String> intersect = stringRedisTemplate.opsForSet().intersect(key1, key2);

    if (intersect == null || intersect.isEmpty()) {
        return Result.ok(Collections.emptyList());
    }

    // 3. 解析用户 ID，查询用户信息
    List<Long> ids = intersect.stream()
            .map(Long::valueOf)
            .collect(Collectors.toList());

    List<UserDTO> userDTOS = userService.listByIds(ids)
            .stream()
            .map(user -> BeanUtil.copyProperties(user, UserDTO.class))
            .collect(Collectors.toList());

    return Result.ok(userDTOS);
}

@Override
public Result saveBlog(Blog blog) {
    // 1. 获取登录用户
    blog.setUserId(UserHolder.getUser().getId());

    // 2. 保存探店笔记到数据库
    boolean isSuccess = save(blog);
    if (!isSuccess) {
        return Result.fail("新增笔记失败！");
    }

    // 3. 查询笔记作者的所有粉丝
    List<Follow> follows = followService.query()
            .eq("follow_user_id", blog.getUserId())
            .list();

    // 4. 推送笔记 ID 到每个粉丝的收件箱（Sorted Set）
    for (Follow follow : follows) {
        Long fanId = follow.getUserId();
        String key = FEED_KEY + fanId;
        stringRedisTemplate.opsForZSet()
                .add(key, blog.getId().toString(), System.currentTimeMillis());
    }

    return Result.ok(blog.getId());
}

ZREVRANGEBYSCORE key max min WITHSCORES LIMIT offset count

@Data
public class ScrollResult<T> {
    private List<T> list;       // 当前页数据
    private Long minTime;       // 最小时间戳（下次查询的 max）
    private Integer offset;     // 偏移量（下次查询的 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) {
    // 1. 获取当前用户
    Long userId = UserHolder.getUser().getId();

    // 2. 查询收件箱（Sorted Set 滚动分页）
    String key = FEED_KEY + userId;
    Set<ZSetOperations.TypedTuple<String>> tuples = stringRedisTemplate.opsForZSet()
            .reverseRangeByScoreWithScores(key, 0, max, offset, 2);

    if (tuples == null || tuples.isEmpty()) {
        return Result.ok();
    }

    // 3. 解析数据：blogId 集合 + minTime + offset
    List<Long> ids = new ArrayList<>(tuples.size());
    long minTime = 0;
    int os = 1;

    for (ZSetOperations.TypedTuple<String> tuple : tuples) {
        ids.add(Long.valueOf(tuple.getValue()));
        long time = tuple.getScore().longValue();
        if (time == minTime) {
            os++;  // 相同 score 计数 +1
        } else {
            minTime = time;
            os = 1;  // 遇到新的更小值，重置
        }
    }

    // 4. 根据 ID 批量查询 Blog（保证顺序）
    String idStr = StrUtil.join(",", ids);
    List<Blog> blogs = query()
            .in("id", ids)
            .last("ORDER BY FIELD(id," + idStr + ")")
            .list();

    // 5. 为每个 Blog 补充用户信息和点赞状态
    for (Blog blog : blogs) {
        queryBlogUser(blog);
        isBlogLiked(blog);
    }

    // 6. 封装返回结果
    ScrollResult<Blog> result = new ScrollResult<>();
    result.setList(blogs);
    result.setMinTime(minTime);
    result.setOffset(os);

    return Result.ok(result);
}