知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 33 - IM 即时通讯系统设计 > 导读:本文用一问一答的方式,拆解"设计一个类微信 IM 系统"这道系统设计题——从长连接管理、消息路由、写/读扩散,到已读回执与消息存储。适合准备后端面试、或想理解即时通讯(IM,Instant Messaging)底层机制的工程师阅读。 ## 一、先建立全局认知 ### Q:IM 系统的整体架构由哪些组件构成? A:结论:一条 IM 链路可以抽象成"网关收连接、路由找位置、MQ 做解耦、存储做兜底、推送负责送达"五件事。先看全景:  *图:IM 消息主链路与核心组件职责* ```text 客户端 → 长连接网关(WebSocket/TCP)→ 消息路由服务 → MQ → 消息处理服务 ↓ 消息存储(MySQL + Redis) ↓ 推送服务(在线推送 / 离线 Push) 核心组件: 长连接网关:维护客户端连接,消息收发 消息路由:根据接收者找到其连接的网关节点 消息存储:持久化消息,支持历史消息查询 推送服务:在线走长连接,离线走 APNs/FCM ``` 几个关键组件的作用: - 长连接网关:维持客户端与服务的持久连接,负责消息收发与心跳保活。 - 消息路由:根据接收者 ID 找到它当前连在哪台网关节点上。 - 消息存储:把消息持久化,支持历史消息分页查询。 - 推送服务:接收方在线时走长连接投递,离线时走 APNs(Apple 推送)/ FCM(Firebase Cloud Messaging)等系统级推送。  [编辑 Excalidraw 源图](/images/java-interview-copy/system-design/33-design-im-design-im-architecture-diagram.excalidraw) ### Q:为什么 IM 必须用长连接,而不是轮询? A:结论:因为"消息到达"是服务端主动事件,而轮询(客户端定时问服务端"有没有新消息")的本质是客户端主动拉取,二者在实时性和资源消耗上直接冲突。 三种做法的取舍: - 短轮询:客户端每隔固定间隔请求一次。实现最简单,但绝大多数请求是空轮询,实时性受轮询间隔限制——间隔越短越实时,空请求也越多。 - 长轮询:服务端把请求挂起,直到有新消息或超时再返回。实时性比短轮询好,代价是每次返回后客户端要立刻重连,服务端需要维护大量挂起请求。 - 长连接(WebSocket/TCP):一次握手后连接常驻,服务端可随时推送,实时性最好;代价是需要维护海量连接状态(连接内存、心跳、断线重连),因此必须做网关集群 + 连接路由。 这正是架构里要专门拆出"长连接网关"和"消息路由"两个组件的原因。 ## 二、理解核心机制 ### Q:长连接网关是怎么维护"用户连在哪台网关"的? A:结论:本机用内存 Map 存"用户 → 连接会话",跨机用 Redis 存"用户 → 网关 ID",并用带 TTL 的心跳续期来兜底清理。原文实现: ```java // WebSocket 网关:维护用户连接映射 @ServerEndpoint("/ws/chat/{userId}") public class ChatWebSocket { // 本机连接映射:userId → Session private static final ConcurrentHashMap<Long, Session> localSessions = new ConcurrentHashMap<>(); @OnOpen public void onOpen(Session session, @PathParam("userId") Long userId) { localSessions.put(userId, session); // 注册到 Redis:记录用户连接在哪台网关 redis.opsForValue().set("user:gateway:" + userId, gatewayId, 5, TimeUnit.MINUTES); // 拉取离线消息 pushOfflineMessages(userId, session); } @OnClose public void onClose(@PathParam("userId") Long userId) { localSessions.remove(userId); redis.delete("user:gateway:" + userId); } // 心跳保活:客户端每 30 秒发一次心跳,服务端刷新 Redis 过期时间 @OnMessage public void onMessage(String message, @PathParam("userId") Long userId) { if ("ping".equals(message)) { redis.expire("user:gateway:" + userId, 5, TimeUnit.MINUTES); return; } // 处理聊天消息 handleChatMessage(userId, message); } } ``` 设计要点: - 为什么本地 Map 和 Redis 各存一份?本机 Map 存的是真正的 Session(连接对象无法跨进程),Redis 存的是"路由信息",让别的网关也能定位到该用户连在哪台机器。 - 为什么要给 Redis key 设 5 分钟 TTL?如果客户端异常断开、没触发 `@OnClose`,连接映射就成了脏数据。心跳每 30 秒续期一次,只要还在心跳说明连接还活着;一旦停止续期,key 自然过期,避免"用户明明离线却还被路由到已死连接"。 - 代价:TTL 太长会残留脏映射,太短会在网络抖动时误判离线,需要结合心跳间隔与业务容忍度权衡(具体取值需结合版本确认)。 ### Q:一条单聊消息从发出到送达,完整链路是怎样的? A:结论:发送 → 生成全局有序消息 ID → 持久化 → 写收件箱 → 查在线状态 → 路由推送 → 回 ACK。原文实现: ```java public class MessageService { public void sendMessage(ChatMessage msg) { // 1. 生成消息 ID(全局唯一,有序) msg.setMsgId(snowflake.nextId()); msg.setTimestamp(System.currentTimeMillis()); // 2. 持久化消息 messageMapper.insert(msg); // 3. 写入接收者的收件箱(Redis List,用于离线消息) redis.opsForList().rightPush("inbox:" + msg.getToUserId(), JSON.toJSONString(msg)); // 4. 查找接收者在线状态 String gatewayId = redis.opsForValue().get("user:gateway:" + msg.getToUserId()); if (gatewayId != null) { // 在线:通过 MQ 路由到对应网关,推送给接收者 mqProducer.send("msg-push-" + gatewayId, msg); } else { // 离线:发送 App Push 通知 pushService.sendOfflinePush(msg.getToUserId(), msg); } // 5. 给发送者回执(ACK) ackToSender(msg.getFromUserId(), msg.getMsgId(), "sent"); } } ``` 关键取舍: - 先持久化再推送:这是"消息不丢"的地基——即使推送失败,消息也已落库并写入收件箱,客户端重连后可以补齐。 - 消息 ID 用 Snowflake(雪花算法,生成全局唯一且趋势递增的 64 位 ID):既保证全局唯一便于去重,又保证有序便于分页。 - 在线/离线分流:在线走 MQ 路由到目标网关、经长连接推送;离线只发系统级 Push 通知,真正的消息内容留在收件箱等上线拉取。 ### Q:群聊为什么要在"写扩散"和"读扩散"之间做选择? A:结论:这是一次典型的"写放大换读性能"的取舍——小群用写扩散(推模式)换读取快,大群用读扩散(拉模式)换写入省。 ```text 写扩散(推模式): 发送者发一条群消息 → 给群内每个成员的收件箱写一份 优点:读取快(直接读自己的收件箱) 缺点:写放大(500 人群 = 写 500 次) 适用:小群(< 200 人) 读扩散(拉模式): 发送者发一条群消息 → 只写一份到群的消息队列 成员读取时,从群消息队列拉取 优点:写入少(只写 1 次) 缺点:读取时需要合并多个群的消息 适用:大群(> 200 人)、超级群 ``` 两种实现的代码: ```java // 写扩散实现(小群) public void sendGroupMessage(GroupMessage msg) { // 1. 持久化到群消息表 groupMessageMapper.insert(msg); // 2. 获取群成员列表 List<Long> memberIds = groupService.getMembers(msg.getGroupId()); // 3. 写入每个成员的收件箱(批量写入) for (Long memberId : memberIds) { if (!memberId.equals(msg.getFromUserId())) { redis.opsForList().rightPush("inbox:" + memberId, JSON.toJSONString(msg)); } } // 4. 推送给在线成员 pushToOnlineMembers(memberIds, msg); } // 读扩散实现(大群) public List<ChatMessage> pullGroupMessages(Long userId, Long groupId, Long lastMsgId) { // 从群消息表拉取 lastMsgId 之后的消息 return groupMessageMapper.selectAfter(groupId, lastMsgId, 50); } ``` 设计要点: - 写扩散的代价:群越大写放大越严重,"发消息"的耗时随成员数线性增长。 - 读扩散的代价:读取时要合并多个群的消息流,分页和"未读数"计算更复杂。 - 边界:原文以 200 人作为小群/大群的分界示例;实际分界点需结合单条消息的成员数、收件箱容量来定。工程上还有一种折中思路——只推"有新消息"的通知、正文仍靠拉取,把推和拉结合,可缓解超大群的写放大(属常见实践,非原文结论)。 ### Q:已读回执怎么实现,单聊和群聊有何不同? A:结论:单聊记录"已读到的消息 ID"并实时推给对方;群聊只用 Redis Hash 记录每个成员的已读位置,查询时现算已读人数、不逐人推送,避免消息风暴。 ```java // 单聊已读回执 public void markRead(Long userId, Long conversationId, Long lastReadMsgId) { // 1. 更新已读位置 redis.opsForValue().set( "read:" + conversationId + ":" + userId, lastReadMsgId.toString()); // 2. 通知对方(实时推送) Long otherUserId = getOtherUser(conversationId, userId); pushReadReceipt(otherUserId, conversationId, lastReadMsgId); } // 群聊已读回执(只记录已读人数,不逐个推送) public void markGroupRead(Long userId, Long groupId, Long lastReadMsgId) { // 用 Redis Hash 记录每个成员的已读位置 redis.opsForHash().put("group:read:" + groupId, userId.toString(), lastReadMsgId.toString()); } // 查询群消息已读人数 public int getReadCount(Long groupId, Long msgId) { Map<Object, Object> readMap = redis.opsForHash().entries("group:read:" + groupId); return (int) readMap.values().stream() .filter(v -> Long.parseLong(v.toString()) >= msgId) .count(); } ``` 设计要点: - 为什么单聊可以实时推、群聊不行?单聊只有一个人要通知;群聊里若 N 个人已读就要广播 N 次,成员越多推送越爆炸。群聊改成"记录状态 + 按需计算",把实时推送开销换成了查询时的聚合计算。 - 如何判断"某人是否已读某条消息"?用的不是"已读标记集合",而是"已读到哪个 msgId"——因为消息 ID 有序,`lastReadMsgId >= msgId` 即代表已读,存储更省。 ### Q:消息怎么存,表结构怎么设计? A:结论:核心是三张表——消息表、会话表、用户会话关系表;消息表按会话分表,`(conversation_id, msg_id)` 建联合索引支撑历史消息分页。 ```sql -- 消息表(按会话分表) CREATE TABLE message ( msg_id BIGINT PRIMARY KEY, -- Snowflake ID,有序 conversation_id BIGINT NOT NULL, -- 会话 ID from_user_id BIGINT NOT NULL, msg_type TINYINT NOT NULL, -- 1 文本 2 图片 3 语音 4 视频 content TEXT, create_time DATETIME DEFAULT NOW(), INDEX idx_conversation_time (conversation_id, msg_id) ); -- 会话表 CREATE TABLE conversation ( id BIGINT PRIMARY KEY, type TINYINT NOT NULL, -- 1 单聊 2 群聊 last_msg_id BIGINT, last_msg_content VARCHAR(200), -- 冗余最后一条消息摘要 update_time DATETIME ); -- 用户会话关系表 CREATE TABLE user_conversation ( user_id BIGINT NOT NULL, conversation_id BIGINT NOT NULL, unread_count INT DEFAULT 0, is_muted TINYINT DEFAULT 0, -- 是否免打扰 PRIMARY KEY (user_id, conversation_id) ); ``` 设计要点: - 消息表为什么把 `msg_id` 放进联合索引?因为查历史消息是"按会话 + 按时间/ID 翻页",`(conversation_id, msg_id)` 正好覆盖这个访问模式。 - 会话表冗余 `last_msg_content`:会话列表只需要展示最后一条摘要,冗余一份可避免每次都回消息表取最新一行。 - 用户会话关系表存 `unread_count` 和 `is_muted`:把"未读数""免打扰"这类高频读写的状态从消息表里拆出来,避免会话列表接口扫消息表。 ## 三、放进真实场景 ### Q:如何保证消息不丢不重? A:结论:从发送端、服务端、接收端三端各自保证,用"ACK + 重推 + 去重"闭环。 ① 发送端:发送后等待服务端 ACK,超时重发;重发的消息带同一个消息 ID,用于去重。 ② 服务端:消息持久化后再推送;推送失败则存入离线队列。 ③ 接收端:收到消息后回 ACK,服务端收到 ACK 后才从离线队列删除。 消息 ID 全局唯一,接收端按 ID 去重。 ### Q:多端同步怎么做? A:结论:每个设备维护自己独立的"已同步消息 ID",用"上线拉增量 + 在线全推"保证多端一致。 每个设备维护独立的"已同步消息 ID"。设备上线时,从服务端拉取"已同步 ID"之后的所有消息;新消息同时推送到用户的所有在线设备。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:分四层作答,从架构到细节层层收口: 1. 长连接用 WebSocket/TCP,网关集群 + Redis 记录用户连接在哪台网关。 2. 消息流程:发送 → 持久化 → 写收件箱 → 路由推送(在线走长连接,离线走 Push)。 3. 群聊策略:小群写扩散(快读慢写),大群读扩散(快写慢读)。 4. 消息可靠性:客户端 ACK 机制 + 服务端重推 + 离线消息存储。 延伸加分点:多端同步按设备维度维护已同步游标;群聊已读回执要避免广播风暴。 ### Q:如果消息量继续增长,最先需要优化的环节是哪个? A:结论:优先看"写放大"和"存储成本"两处,因为它们是随规模线性放大的环节。 - 群聊写扩散:群规模增大时写放大最严重,应向读扩散切换或做推拉结合。 - 收件箱(Redis List):在线用户越多,收件箱写入越密集,需要考虑容量与过期策略。 - 消息表:单表数据量增长后查询变慢,需要按会话分表/分库。 - 连接层:连接数增长时靠网关水平扩展 + Redis 路由信息支撑。 ## 自测 1. 长连接网关为什么要把"用户 → 网关"的映射同时存在本地 Map 和 Redis 里,各自的作用是什么? 2. 写扩散和读扩散的取舍本质是什么?分别适合什么规模的群? 3. 三端(发送端/服务端/接收端)各自靠什么机制保证消息"不丢不重"?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入