redis实现好友关注&消息推送的方法示例

更新时间：2023年10月24日 10:16:58 作者：明矾java

Redis作为一款开源的内存数据库,具有可靠性、速度快、易用性等优点,已经被广泛应用于开发实际项目中,本文主要介绍了redis实现好友关注&消息推送的方法示例,感兴趣的可以了解一下

关注和取消关注

在查看笔记详情时，会自动发送请求，调用接口来检查当前用户是否已经关注了笔记作者，我们要实现这两个接口

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

关注和取关接口
判断是否关注的接口

关注是User之间的关系，是博主与粉丝的关系，数据库中有一张tb_follow表来标识，我们要将用户与博主关联起来，只需要向这张表插入数据即可，需要将主键设为自增加，降低开发难度

FollowController

//关注
@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 isFollow(@PathVariable("id") Long followUserId) {
      return followService.isFollow(followUserId);
}

判断当前用户与博主是否已经关注了博主我们只需要查询follow表中是否有记录即可，等值查询建议进行非空判断，防止出现异常

@Override
    public Result isFollow(Long followUserId) {
        Long userId = UserHolder.getUser().getId();
        LambdaQueryWrapper<Follow> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(followUserId != null, Follow::getFollowUserId, followUserId)
                .eq(userId != null, Follow::getUserId, userId);
        Integer count = followMapper.selectCount(queryWrapper);
        return Result.ok(count > 0);
    }

前端发送请求时，会发送isFollow这个boolean值，用来让后端判断当前用户是否已经关注了博主，如果为true，则直接插入数据库，表示关注成功，如果为false，表示已经关注要取消关注了

@Override
    public Result follow(Long followUserId, Boolean isFollow) {
        Long userId = UserHolder.getUser().getId();
        String key = "follows:" + userId;
        if (isFollow) {
            //封装follow对象
            Follow follow = new Follow();
            follow.setFollowUserId(followUserId);
            follow.setUserId(userId);
            follow.setCreateTime(LocalDateTime.now());
            //插入数据库
            boolean isSuccess = save(follow);
        
        } else {
            LambdaQueryWrapper<Follow> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(Follow::getFollowUserId, followUserId)
                    .eq(Follow::getUserId, userId);
            boolean isSuccess = remove(queryWrapper);
           
        }
        return Result.ok();
    }

共同关注

共同关注的好友，需要首先进入到这个页面，这个页面会发起两个请求

1、去查询用户的详情

2、去查询用户的笔记

// UserController 根据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);
}
 
// BlogController  根据id查询博主的探店笔记
@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);
}

共同关注的需求：利用Redis中恰当的数据结构，实现共同关注功能。在博主个人页面展示出当前用户与博主的共同关注。在这里我们选用set集合，因为在set集合中，有交集并集补集的api，我们可以把两人的关注的人分别放入到一个set集合中，然后再通过api去查看这两个set集合中的交集数据。

首先对添加关注进行改造，在插入数据的同时也要将当前用户关注的博主用户id插入到set集合中去，用于查找交集

 @Override
    public Result follow(Long followUserId, Boolean isFollow) {
        Long userId = UserHolder.getUser().getId();
        String key = "follows:" + userId;
        if (isFollow) {
            //封装follow对象
            Follow follow = new Follow();
            follow.setFollowUserId(followUserId);
            follow.setUserId(userId);
            follow.setCreateTime(LocalDateTime.now());
            //插入数据库
            boolean isSuccess = save(follow);
            if (isSuccess) {
                stringRedisTemplate.opsForSet().add(key, followUserId.toString());
            }
        } else {
            LambdaQueryWrapper<Follow> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(Follow::getFollowUserId, followUserId)
                    .eq(Follow::getUserId, userId);
            boolean isSuccess = remove(queryWrapper);
            if (isSuccess) {
                stringRedisTemplate.opsForSet().remove(key);
            }
        }
        return Result.ok();
    }

controller层，定义common接口，传入的id是笔记博主的id

 @GetMapping("/common/{id}")
    public Result common(@PathVariable("id") Long id){
        System.out.println(id);
        return followService.commonFollow(id);
    }

service层

@Override
    public Result commonFollow(Long id) {
        //获取当前用户
        Long userId = UserHolder.getUser().getId();
        String key1 = "follows:" + userId;
        String key2 = "follows:" + id;
        Set<String> intersect = stringRedisTemplate.opsForSet().intersect(key1, key2);
        if(intersect == null || intersect.isEmpty()) {
            // 无交集
            return Result.ok(Collections.emptyList());
        }
        //解析用户id集合
        List<Long> userIds = intersect.stream().map(item -> Long.valueOf(item)).collect(Collectors.toList());
        List<UserDTO> users = userService.selectByIds(userIds).stream().map(
                user -> BeanUtil.copyProperties(user, UserDTO.class)).collect(Collectors.toList());
        return Result.ok(users);
    }

Feed流实现方案

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

对于传统的模式的内容解锁：我们是需要用户去通过搜索引擎或者是其他的方式去解锁想要看的内容

对于新型的Feed流的的效果：不需要我们用户再去推送信息，而是系统分析用户到底想要什么，然后直接把内容推送给用户，从而使用户能够更加的节约时间，不用主动去寻找。类似B站，抖音等平台的大数据推送机制

Feed流的两种模式

Feed流的实现有两种模式：

Feed流产品有两种常见模式： Timeline：不做内容筛选，简单的按照内容发布时间排序，常用于好友或关注。例如朋友圈

优点：信息全面，不会有缺失。并且实现也相对简单
缺点：信息噪音较多，用户不一定感兴趣，内容获取效率低

智能排序：利用智能算法屏蔽掉违规的、用户不感兴趣的内容。推送用户感兴趣信息来吸引用户

优点：投喂用户感兴趣信息，用户粘度很高，容易沉迷
缺点：如果算法不精准，可能起到反作用。本例中的个人页面，是基于关注的好友来做Feed流，因此采用Timeline的模式。该模式的实现方案有三种

Timeline模式的实现方案

拉模式：也叫做读扩散

该模式的核心含义就是：当张三和李四和王五发了消息后，都会保存在自己的邮箱中，假设赵六要读取信息，那么他会从读取他自己的收件箱，此时系统会从他关注的人群中，把他关注人的信息全部都进行拉取，然后在进行排序

优点：比较节约空间，因为赵六在读信息时，并没有重复读取，而且读取完之后可以把他的收件箱进行清楚。

缺点：比较延迟，当用户读取数据时才去关注的人里边去读取数据，假设用户关注了大量的用户，那么此时就会拉取海量的内容，对服务器压力巨大。

推模式：也叫做写扩散。

推模式是没有写邮箱的，当张三写了一个内容，此时会主动的把张三写的内容发送到他的粉丝收件箱中去，假设此时李四再来读取，就不用再去临时拉取了

优点：时效快，不用临时拉取

缺点：内存压力大，假设一个大V写信息，很多人关注他，就会写很多分数据到粉丝那边去

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

推拉模式是一个折中的方案，站在发件人这一段，如果是个普通的人，那么我们采用写扩散的方式，直接把数据写入到他的粉丝中去，因为普通的人他的粉丝关注量比较小，所以这样做没有压力，如果是大V，那么他是直接将数据先写入到一份到发件箱里边去，然后再直接写一份到活跃粉丝收件箱里边去，现在站在收件人这端来看，如果是活跃粉丝，那么大V和普通的人发的都会直接写入到自己收件箱里边来，而如果是普通的粉丝，由于他们上线不是很频繁，所以等他们上线时，再从发件箱里边去拉信息。即根据用户的活跃程度来判断是推模式还是拉模式

推送到粉丝收件箱

需求：

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

分页查询方案

Feed流中的数据会不断更新，所以数据的角标也在变化，因此不能采用传统的分页模式。

传统了分页在feed流是不适用的，因为我们的数据会随时发生变化

假设在t1 时刻，我们去读取第一页，此时page = 1 ，size = 5 ，那么我们拿到的就是10~6 这几条记录，假设现在t2时候又发布了一条记录，此时t3 时刻，我们来读取第二页，读取第二页传入的参数是page=2 ，size=5 ，那么此时读取到的第二页实际上是从6 开始，然后是6~2 ，那么我们就读取到了重复的数据，所以feed流的分页，不能采用原始方案来做。

Feed流的滚动分页

我们需要记录每次操作的最后一条，然后从这个位置开始去读取数据

举个例子：我们从t1时刻开始，拿第一页数据，拿到了10~6，然后记录下当前最后一次拿取的记录，就是6，t2时刻发布了新的记录，此时这个11放到最顶上，但是不会影响我们之前记录的6，此时t3时刻来拿第二页，第二页这个时候拿数据，还是从6后一点的5去拿，就拿到了5-1的记录。我们这个地方可以采用sortedSet来做，可以进行范围查询，并且还可以记录当前获取数据时间戳最小值，就可以实现滚动分页了，11这条新插入的数据进行上拉刷新的时候就会刷新，不必担心漏读

分页演示

首先创建一个Zset集合

通过这一命令我们可以通过score值降序排的方式取出前三条记录，这么看似乎没有问题，我们下一页要查询的就是后四条记录，但feed流的数据是不断更新，恰好此时set集合中加入m8

zrevrange z1 0 2 withscores

后三条记录的查询理论上是再查三条，这时候按照角标查m5就已经重复查询了，这在业务中是不允许的

按照score值来查就可以避免该问题，我们只需要记住上一次查询的最小分数，让它在下次查询时最为max，即可实现分页查询，limit 后面的第一个参数即是偏移量，0表示要包含max，1表示小于max分数的下一个元素

zrevrangebyscore z1 6 0 withscores limit 1 3

推送收件箱

当用户发送完笔记后，也要将笔记推送粉丝的收件箱中，即用户id为key的zest集合中

@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());
}

实现分页查询收邮箱

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

具体操作如下：

1、每次查询完成后，我们要分析出查询出数据的最小时间戳，这个值会作为下一次查询的条件，即下一次查询的最大时间戳

2、我们需要找到与上一次查询相同的查询个数作为偏移量，下次查询时，跳过这些查询过的数据，拿到我们需要的数据

综上：我们的请求参数中就需要携带 lastId：上一次查询的最小时间戳和偏移量这两个参数。

这两个参数第一次会由前端来指定，以后的查询就根据后台结果作为条件，再次传递到后台。

定义返回实体类

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

BlogController

注意：RequestParam 表示接受url地址栏传参的注解，当方法上参数的名称和url地址栏不相同时，可以通过RequestParam 来进行指定

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

BlogServiceImpl

@Override
public Result queryBlogOfFollow(Long max, Integer offset) {
    // 1.获取当前用户
    Long userId = UserHolder.getUser().getId();
    // 2.查询收件箱 ZREVRANGEBYSCORE key Max Min LIMIT offset count
    String key = FEED_KEY + userId;
    Set<ZSetOperations.TypedTuple<String>> typedTuples = stringRedisTemplate.opsForZSet()
        .reverseRangeByScoreWithScores(key, 0, max, offset, 2);
    // 3.非空判断
    if (typedTuples == null || typedTuples.isEmpty()) {
        return Result.ok();
    }
    // 4.解析数据：blogId、minTime（时间戳）、offset
    List<Long> ids = new ArrayList<>(typedTuples.size());
    long minTime = 0; // 2
    int os = 1; // 2
    for (ZSetOperations.TypedTuple<String> tuple : typedTuples) { // 5 4 4 2 2
        // 4.1.获取id
        ids.add(Long.valueOf(tuple.getValue()));
        // 4.2.获取分数(时间戳）
        long time = tuple.getScore().longValue();
        if(time == minTime){
            os++;
        }else{
            minTime = time;
            os = 1;
        }
    }
	os = minTime == max ? os : os + offset;
    // 5.根据id查询blog
    String idStr = StrUtil.join(",", ids);
    List<Blog> blogs = query().in("id", ids).last("ORDER BY FIELD(id," + idStr + ")").list();
 
    for (Blog blog : blogs) {
        // 5.1.查询blog有关的用户
        queryBlogUser(blog);
        // 5.2.查询blog是否被点赞
        isBlogLiked(blog);
    }
 
    // 6.封装并返回
    ScrollResult r = new ScrollResult();
    r.setList(blogs);
    r.setOffset(os);
    r.setMinTime(minTime);
 
    return Result.ok(r);
}

到此这篇关于redis实现好友关注&消息推送的方法示例的文章就介绍到这了,更多相关redis 好友关注&消息推送内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

redis缓存的简单操作（get、put）
这篇文章主要介绍了redis缓存的简单操作，包括引入jedisjar包、配置redis、RedisDao需要的一些工具等，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2017-09-09
redis淘汰策略的几种实现
redis内存数据数据集大小升到一定大的时候,就会实行数据淘汰策略,本文主要介绍了redis淘汰策略的几种实现,具有一定的参考价值,感兴趣的可以了解一下
2024-05-05
Redis 定长队列探索及实践
这篇文章主要介绍了Redis 定长队列探索及实践，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的小伙伴可以参考一下
2022-08-08
分布式锁为什么要选择Zookeeper而不是Redis?看完这篇你就明白了
Zookeeper的机制可以保证分布式锁实现业务代码简单，成本低，Redis如果要解决分布式锁的问题，对于一些复杂的情况，很难解决，成本较高，这篇文章重点给大家介绍分布式锁选择Zookeeper 而不是Redis的理由，一起看看吧
2021-05-05
虚拟机下的Redis无法访问报错500解决方法
这篇文章主要介绍了虚拟机下的Redis无法访问,报错500解决方法,由于我的redis是在虚拟机下安装的,无法访问redis的原因是因为虚拟机的ip地址和主机不同,文中通过图文结合给出了详细的解决方法,需要的朋友可以参考下
2024-02-02
Redis客户端及服务端的安装教程详解
这篇文章主要介绍了Redis客户端及服务端的安装教程,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2020-11-11
Caffeine实现类似redis的动态过期时间设置示例
这篇文章主要为大家介绍了Caffeine实现类似redis的动态过期时间示例,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
2023-08-08
利用Redis的有序集合实现排行榜功能实例代码
这篇文章主要给大家介绍了关于如何利用Redis的有序集合实现排行榜功能的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者使用Redis具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
2019-03-03
Redis使用命令行与多数据库配置
本文详细讲解了Redis使用命令行与多数据库配置的方法，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2022-03-03
Redis五种数据结构在JAVA中如何封装使用
本篇博文就针对Redis的五种数据结构以及如何在JAVA中封装使用做一个简单的介绍。对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2021-11-11