聊天消息拉取与推送

已于 2024-11-30 22:43:18 修改
阅读量812 收藏 19
点赞数 22
分类专栏： 基于Netty的网络聊天室 文章标签： 扩散读 讨论组 聊天消息 拉取机制
于 2024-11-24 12:51:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/littleschemer/article/details/143996732
版权

微信如何实现聊天消息实时推送，消息不丢失，多设备消息共享呢。带着这个疑问，我们尝试实现一个较为合理的消息拉取机制。

1.消息存储机制

消息存储在数据库，为了存储海量级的消息内容，肯定是需要分库分表等机制。这里我们不讨论这种级别的消息存储，只使用单表存储。

对于讨论组的每一条消息，假设讨论组有1000个人，用户发送一条消息，典型地，有两种方式来存储这条消息。

1.1.扩散读

该机制下，每条消息只存储一份数据，不同用户使用自己的消息seq来拉取数据。这种做法，最大的优势是减轻数据库压力。但缺点是，对于每个用户，不同的讨论组，用户要分别存储对应的seq。关于seq机制，后文介绍。

1.2.扩散写

该机制下，对于每条消息，每个用户都独立复制一份。这种做法，最大的优势是，统一seq。无论是讨论组还是qq群，还是点对点聊天，用户只需要保存统一的seq，就可以批量拉取所有消息。业务逻辑相对简单很多。（据说，企业微信是采用此方式）。但缺点是非常浪费存储，毕竟，1000个人，每个人发一条消息，就要存储100w条数据。

本文采用扩散读机制。

2.消息拉取机制

如何实现消息实时推送与消息不丢失呢？

2.1.消息实时推送

当有新消息到达，需要推送给用户知道。对于http客户端来说，只能使用http轮训。对于socket客户端，则可以主动推送消息。如果涉及到移动客户端，还需要借助移动设备的Push功能。

当消息到达之后，根据消息所属的频道，如果是讨论组，则目标是所有成员；如果是私聊，则目标是消息的发送方与接收方。这里为什么要加上发送方，有两个目的，一个是为了简化逻辑，不管是发送还是接收，都使用统一的拉取机制。第二个是为了保证消息已发送到服务器，而不会因为网络异常而丢失。

对于所有在线成员，推送一个新消息到达的协议。（这里不考虑移动设备的离线用户）

2.2.消息不丢失

对于在线用户，不能说因为用户在线，就认为用户一定可以收到消息，有可能是发送的时刻用户是在线的，但是消息到达用户客户端的时候，用户突然下线了。这时候，消息就丢失了。

当有新消息的时候，不使用推送的机制。而是告诉客户端有新消息了，然后客户端发送自己的消息seq，从服务器批量获取差量消息。同时，服务器返回消息列表的时候，不会自动更新客户端的seq。当客户端真正获取到信息之后，让发送确定协议，通知服务器更新seq。由于是客户端收到消息之后，才更新seq。这种机制就不会丢失消息。

当客户端收到消息之后，可以选择把消息保存到本地。这样，服务器理论上不会再把相同id的消息推送给客户端。

2.3.使用seq实现批量拉取

设想这种场景，讨论组成员噼里啪啦聊了很多东西。第二天，另外一个成员上线，如何高效批量获取获取这种消息呢？答案是使用最大seq机制。

前文说过，每一条消息都有一个递增性的消息id（可以使用数据库的自增长机制），这个id可以直接作为消息的seq。

对于群里的每个成员，都独立存在一个最大seq。当一个成员上线之后，会根据成员这个maxseq与群的消息id进行比较，所有大于成员seq的消息都是这个成员未读的，可以推送给成员。

当新成员加入讨论组，则把新成员的maxseq置为当前讨论组的最大消息的id。

3.服务器代码实现

3.1.适配各种频道

对于不同的频道，消息拉取机制都是一样的，大部分代码都是可以重用的。例如，对于私聊，讨论组，不同的只是接收方列表，最大seq的存储位置。

我们统一定义各种频道处理消息的行为接口

/**
 * 消息频道处理器
 */
public interface ChatChannelHandler {

    void send(Long senderId, Long target, MessageContent content);

    /**
     * 对消息进行持久化
     * @param senderId 发送方id
     * @param target 目标id，频道不同，目标id的种类也不同
     * @param content 消息类型，支持各种消息格式
     */
    void saveToDb(Long senderId, Long target, MessageContent content);

    /**
     * 消息的接收方列表
     * @param senderId
     * @param target
     * @return
     */
    Collection<Long> receivers(Long senderId, Long target);

    /**
     * 成员批量拉取消息
     * @param receiver
     * @param target
     * @param maxSeq
     * @return
     */
    List<ChatMessage> pullMessages(Long receiver, Long target, long maxSeq);

    /**
     * 频道类型 {@link pers.kinson.im.common.constants.Channels}
     * @return
     */
    byte channelType();
}

3.1.1.私聊频道处理器

@Service
public class PersonalChannelHandler implements ChatChannelHandler {

    @Autowired
    MessageDao messageDao;

    @Override
    public void send(Long senderId, Long target, MessageContent content) {
        if (SpringContext.getUserService().getUserName(target) == null) {
            return;
        }
        saveToDb(senderId, target, content);

        ResNewMessageNotify notify = new ResNewMessageNotify();
        notify.setChannel(Channels.person);
        notify.setTopic(target);
        receivers(senderId, target).forEach(e -> SessionManager.INSTANCE.sendPacketTo(e, notify));
    }

    @Override
    public void saveToDb(Long senderId, Long target, MessageContent content) {
        Message message = new Message();
        message.setChannel(channelType());
        message.setType(content.getType());
        message.setDate(new Date());
        message.setSender(senderId);
        message.setReceiver(target);
        message.setContent(JsonUtil.object2String(content));
        messageDao.insert(message);
    }

    @Override
    public Collection<Long> receivers(Long senderId, Long target) {
        return Arrays.asList(senderId, target);
    }

    @Override
    public List<ChatMessage> pullMessages(Long receiver, Long target, long maxSeq) {
        List<Message> newMessages = messageDao.fetchNewPersonal(receiver, maxSeq);
        return newMessages.stream().map(e -> {
            ChatMessage vo = new ChatMessage();
            vo.setId(e.getId());
            vo.setType(e.getType());
            vo.setJson(e.getContent());
            vo.setDate(DateUtil.format(e.getDate()));
            vo.setSenderId(e.getSender());
            vo.setReceiverId(e.getReceiver());
            vo.setReceiverName(SpringContext.getUserService().getUserName(e.getReceiver()));
            vo.setSenderName(SpringContext.getUserService().getUserName(e.getSender()));
            return vo;
        }).collect(Collectors.toList());
    }

    @Override
    public byte channelType() {
        return Channels.person;
    }
}

3.1.2.讨论组频道处理器

@Service
public class PersonalChannelHandler implements ChatChannelHandler {

    @Autowired
    MessageDao messageDao;

    @Override
    public void send(Long senderId, Long target, MessageContent content) {
        if (SpringContext.getUserService().getUserName(target) == null) {
            return;
        }
        saveToDb(senderId, target, content);

        ResNewMessageNotify notify = new ResNewMessageNotify();
        notify.setChannel(Channels.person);
        notify.setTopic(target);
        receivers(senderId, target).forEach(e -> SessionManager.INSTANCE.sendPacketTo(e, notify));
    }

    @Override
    public void saveToDb(Long senderId, Long target, MessageContent content) {
        Message message = new Message();
        message.setChannel(channelType());
        message.setType(content.getType());
        message.setDate(new Date());
        message.setSender(senderId);
        message.setReceiver(target);
        message.setContent(JsonUtil.object2String(content));
        messageDao.insert(message);
    }

    @Override
    public Collection<Long> receivers(Long senderId, Long target) {
        return Arrays.asList(senderId, target);
    }

    @Override
    public List<ChatMessage> pullMessages(Long receiver, Long target, long maxSeq) {
        List<Message> newMessages = messageDao.fetchNewPersonal(receiver, maxSeq);
        return newMessages.stream().map(e -> {
            ChatMessage vo = new ChatMessage();
            vo.setId(e.getId());
            vo.setType(e.getType());
            vo.setJson(e.getContent());
            vo.setDate(DateUtil.format(e.getDate()));
            vo.setSenderId(e.getSender());
            vo.setReceiverId(e.getReceiver());
            vo.setReceiverName(SpringContext.getUserService().getUserName(e.getReceiver()));
            vo.setSenderName(SpringContext.getUserService().getUserName(e.getSender()));
            return vo;
        }).collect(Collectors.toList());
    }

    @Override
    public byte channelType() {
        return Channels.person;
    }
}

3.2.聊天消息接收门面

    public void chatToChannel(Long sender, byte channel, long target, byte contentType, String content) {
        ChatChannelHandler handler = handlers.get(channel);
        MessageContent chatMessage = SpringContext.getMessageContentFactory().parse(contentType, content);
        chatMessage.setType(contentType);
        handler.send(sender, target, chatMessage);
    }

3.3.不同频道逻辑差异

 从私聊与讨论组消息的处理代码可知，最大的不同是消息拉取的逻辑。

对于讨论组而已，查找的是指定讨论组id，并且id>member.maxSeq， sql如下：

 SELECT * FROM message
        WHERE
        channel = #{channelType}
        AND receiver = #{receiver}
        AND id > #{maxSeq}

对于私聊来说，由于发送方，接收方采用同样的机制。对于消息发送方来说，也是发送之后，再重新根据自己的seq来拉取已经发送的消息。sql如下：

 SELECT * FROM message
        WHERE
        channel = 0
        AND (receiver = #{receiver} OR sender = #{receiver})
        AND id > #{maxSeq}

4.客户端代码实现

4.1.消息发送

客户端点击消息发送按钮之后，会把频道类型，接收方，消息类容（打包成json格式），发送到服务器

    public void sendMessageTo(long friendId, MessageContent content) {
        ReqChatToChannel request = new ReqChatToChannel();
        request.setChannel(Constants.CHANNEL_PERSON);
        request.setTarget(friendId);
        request.setContent(JsonUtil.object2String(content));
        request.setContentType(content.getType());
        IOUtil.send(request);
    }

4.2.消息拉取

服务器收到消息之后，推送一个新消息到达的消息给客户端。客户端收到之后，根据频道的类型，使用不同的maxseq作为参数（前文说的分散读存储机制），进行批量获取消息

    private void notifyNewMessage(Object packet) {
        ResNewMessageNotify message = (ResNewMessageNotify) packet;
        ReqFetchNewMessage reqFetchNewMessage = new ReqFetchNewMessage();
        // 这里先写点丑代码，后续优化
        if (message.getChannel() == Constants.CHANNEL_DISCUSSION) {
            DiscussionGroupVo targetDiscussionGroup = Context.discussionManager.getDiscussionGroupVo(NumberUtil.longValue(message.getTopic()));
            if (targetDiscussionGroup != null) {
                reqFetchNewMessage.setChannel(Constants.CHANNEL_DISCUSSION);
                reqFetchNewMessage.setTopic(targetDiscussionGroup.getId());
                reqFetchNewMessage.setMaxSeq(targetDiscussionGroup.getMaxSeq());

            }
        } else if (message.getChannel() == Constants.CHANNEL_PERSON) {
            reqFetchNewMessage.setTopic(Context.userManager.getMyUserId());
            reqFetchNewMessage.setMaxSeq(Context.userManager.getMyProfile().getChatMaxSeq());
        }
        IOUtil.send(reqFetchNewMessage);
    }

4.3.消息seq确认

客户端收到消息之后，对消息进行展示（同时将消息保存在本地客户端）。

此时，再发送消息跟服务器进行确认，如此，就不会发生消息丢失的情况了。

 private void refreshNewMessage(Object packet) {
        ResNewMessage message = (ResNewMessage) packet;
        if (message.getMessages() == null || message.getMessages().isEmpty()) {
            return;
        }
        long maxSeq = 0;
        for (ChatMessage e : message.getMessages()) {
            e.setContent(Context.messageContentFactory.parse(e.getType(), e.getJson()));
            maxSeq = Math.max(maxSeq, e.getId());
        }

        ReqMarkNewMessage reqMarkNewMessage = new ReqMarkNewMessage();
        reqMarkNewMessage.setChannel(message.getChannel());
        reqMarkNewMessage.setMaxSeq(maxSeq);
        // 根据消息来源进行分发
        if (message.getChannel() == Constants.CHANNEL_DISCUSSION) {
            long discussionId = message.getMessages().get(0).getReceiverId();
            reqMarkNewMessage.setTopic(discussionId);
            Context.discussionManager.receiveDiscussionMessages(maxSeq, message.getMessages());
        } else if (message.getChannel() == Constants.CHANNEL_PERSON) {
            Context.userManager.getMyProfile().setChatMaxSeq(maxSeq);
            Context.chatManager.receiveFriendPrivateMessage(message.getMessages());
        }

        // 收到消息之后再通知服务器，保证不丢消息
        IOUtil.send(reqMarkNewMessage);
    }

4.4.多端同步机制

对于支持多端登录的聊天软件，例如桌面版，手机版，网页版，可以对每个频道保存自己的maxseq，以实现各个频道消息同步接收不丢失。

全部代码已在github上托管

服务端代码请移步 --> 聊天室服务器

客户端代码请移步 --> 聊天室客户端

微信小程序开发中的推送消息和通知功能
吃不胖.
03-23 7325
其中，touser参数表示接收消息和通知的用户的openid，templateId参数表示消息和通知的模板ID，data参数表示消息和通知的内容，page参数表示点击消息跳转的页面。其中，touser参数表示接收消息和通知的用户的openid，template_id参数表示消息和通知的模板ID，form_id参数表示消息和通知的表单ID，data参数表示消息和通知的内容，page参数表示点击消息跳转的页面。在小程序的页面中，可以通过调用云函数来触发云函数的执行，从而实现发送消息和通知的功能。
微信消息推送神器pushplus介绍，让消息推送更简单
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
10-09 1万+
很早之前曾经做过微信公众号消息推送，实现了一些有意思的小功能。如设备报警消息推送、每日天气预报和大盘资讯简报推送等，使用的是微信官方的api。后台使用golang做了个简单的服务，操作使用上是有点儿麻烦。
微信公众号消息推送教程
程序员凯小白的博客
09-03 1万+
微信每日消息推送
微信开发中的消息推送
大大怪将军的博客
07-30 7927
​ 微信开发中小程序及服务号的消息推送实现。
消息通知——公众号、小程序、短信对比
我是 二川兄，对Web开发、GIS开发、3D模型、机器学习、面试技巧等方面都有一些涉猎~ 欢迎您加入技术交流圈！你可以在我的文章末尾找到我~
11-06 9585
消息通知——公众号、小程序、短信对比
微信小程序实现订阅消息推送的实现步骤
热门推荐
向心行者
06-14 4万+
而Post方法， 当用户在微信小程序中主动订阅一次性消息时，腾讯服务器将请求Post的接口，发送用户的相关行为事件结果到开发者服务器，只有用户订阅的用户才允许进行消息推送，其实这里接收的不只是消息订阅事件，各类的交互事件都在这里进行接收的。在实际应用中，我们应该维护一张需要推送消息的微信用户数据表，包括该用户是否已订阅，微信用户的openid等信息，这里暂时演示，省略了该信息，直接固定硬编码了模板ID、消息内容、微信用户openId等信息。完成上述工作后，启动服务，先通过微信小程序进行消息订阅，
消息推送技术：Pull与Push机制深入解析
消息推送客户端5.0的开发涉及了客户端与服务器之间的信息同步机制。在这一过程中，有两类主要的消息推送模式，即拉（Pull）模式和推（Push）模式，它们在实际应用中各有优劣，下面详细阐述这两种消息推送模式的知识...
Server_Pushes：回购以从服务器推送和拉取文件
02-09
在"Server_Pushes：回购以从服务器推送和拉取文件"这个主题中，我们可以深入探讨以下几个关键知识点： 1. **HTTP/2 Server Push**：HTTP/2是HTTP协议的最新版本，它引入了Server Push特性。当客户端请求一个资源时...
利用ZeroMQ与signalR实现消息的实时广播推送系统
- 实时通信：允许服务器主动向客户端推送消息，适用于聊天室、股票市场、游戏等场景。 - 自适应传输：根据客户端和服务器之间的网络状况选择最佳的通信方式，如WebSockets、Long Polling等。 - 简单的API：提供了...
使用DWR实现WEB端一对一精准消息推送
消息推送是服务器向客户端发送信息的过程，可以分为“推送”和“拉取”两种基本方式。推送给用户是指服务器将新数据实时发送给客户端，而客户端则无需主动请求即可接收到数据更新。这种方式特别适用于即时通讯、实时...
服务器端轮询推送消息,消息推送机制-轮询、长轮询、SSE(Server Sent Event)和WS(WebSocket)...
weixin_27966471的博客
08-12 1631
实际应用中经常会有实现页面无刷新更新内容的需求。本文就轮询、长轮询、SSE(Server Sent Event)和WS(WebSocket)介绍具体的应用场景。相关知识点：es6 API、nodejs、html5文章结构：轮询长轮询SSE(Server Sent Event)WS(WebSocket)1. 轮询-数据拉取轮询是在特定的的时间间隔(如每隔1秒)，由浏览器(客户端)对服务器发出HTTP...
微信小程序开通消息推送
大魔王的博客
09-14 4012
URL(服务器地址)：必须以http://或https://开头，分别支持80端口和443端口，填写接口路径。token自己随便定义（必须为英文或数字，长度为3-32字符），待会要配置到消息推送的配置中。appId和appSecret都可以从公众平台上获取，在开发管理-开发者ID里面。AccessToken：可以参考 微信工具类getAccessToken()方法。若是URL和Token填写不正确，会提交不了。Token：就刚刚项目中配置的token。
微信消息实现自动推送--方式一 成功啦 进来学
木易巷的小博客
08-25 5097
微信消息实现自动推送--方式一 成功啦！ 进来学！！！
微信消息推送流程架构解析
qq_33665793的博客
11-28 1441
**调用发送接口**：在获得`Access Token`后，可以通过API调用具体的消息发送接口，如`/cgi-bin/message/custom/send`（发送客服消息）或`/cgi-bin/message/template/send`（发送模板消息）。- 消息内容要与用户的需求相关，避免推送过于冗长或无关的内容。- **模板消息**：基于特定模板的消息，具有更高的定制化功能，可以插入用户的个性化信息。- **接收**：用户的微信客户端接收到消息后，消息会显示在用户的聊天界面或公众号消息列表中。
微信小程序开发中的推送通知和消息订阅
吃不胖.
03-24 887
微信小程序开发中的推送通知和消息订阅是两种不同的功能，推送通知是指向用户发送实时消息的方式，而消息订阅是用户通过小程序订阅一些特定的消息类型，小程序会在满足条件时向用户发送订阅消息。下面我将分别介绍推送通知和消息订阅的具体实现方式，并给出相应的代码案例。消息订阅是指用户通过小程序订阅一些特定的消息类型，小程序会在满足条件时向用户发送订阅消息。以上是微信小程序开发中推送通知和消息订阅的代码案例，可以根据实际需求进行相应的修改和扩展。在小程序后台设置订阅消息模板，并获取相应的模板ID。
微信公众号指定用户消息推送
qq_40881695的博客
09-13 1575
以上方法针对微信公众号提供的测试号，若是正式号（通过认证的），可以调用以下接口替换相关步骤。
微信小程序开发——消息推送
最新发布
大魔王的博客
01-08 2287
一次性订阅：每一条通知信息，前端都要去询问一次。长期订阅：前端询问一次即可永久通知用户。若是没有符合的，可以申请自定义的。
小程序与公众号关联
技术刘的博客
05-15 2936
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

jforgame

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值