白板 op 同步协议:Node + ws 最小实现
上一篇写了双坐标系:元素永远存 world 坐标,视口只影响渲染。这篇写建立在这条规矩之上的同步协议——一个 Node + ws 的最小实现,总共一百行出头,只做三件事:房间管理、op 广播、新人下发快照。没有 OT,没有 CRDT,没有鉴权和持久化,但两个人能实时在同一块白板上画画。
先定操作模型:op 只有六种
客户端(board.html)里所有改动都先变成一个 op,再本地应用、再广播。op 只有六种类型:
// op 类型:add / delete / move / clear / addMany / deleteMany
// 白板 op 天然可交换(增删为主),不需要 OT;并发改同一元素用 last-write-wins。
一个 op 就是一段 JSON:{ opId, type, ... }。add 带一个完整元素,delete 只带 id,move 带 id 和位移 dx / dy,clear 清空,addMany / deleteMany 是批量版——撤销清屏、批量删除时用。元素本身就是上一篇那个模型:stroke 存点列,shape 存两个对角点,text 存落点和字号,坐标全是 world 坐标,所以 op 发到谁手里,画出来的都是同一个位置。
每个 op 带一个全局唯一的 opId,格式是 clientId:seq:
nextId() { return this.clientId + ':' + (++this.seq); }
clientId 是连上服务器时服务端分配的('c' + 随机串),seq 是本端自增计数。这个 id 是整个协议里最关键的一行,后面去重和快照衔接全靠它。
本地先应用,再广播:undo 顺手就有了
本地产生 op 的流程是固定的三步:doApply 应用到本地状态 → 生成逆操作压入撤销栈 → 发给服务端。applyOp 的代码就是这个顺序:
function applyOp(op, isLocal) {
doApply(op);
if (isLocal) {
const inv = inverseOf(op);
if (inv) { undoStack.push(inv); redoStack.length = 0; }
op.opId = sync.nextId();
sync.send(op);
}
afterChange();
}
doApply 本身就是按 op 类型改一个 Map,add 是 els.set(op.el.id, op.el),delete 是 els.delete(op.id),move 按元素类型平移点列或端点。inverseOf 则把每个 op 翻成它的逆操作:add 的逆是 delete,delete 的逆是 add(先把被删的元素抓出来存在 op._el 里),clear 的逆是 addMany(清之前先把全部元素存下来),move 的逆是反向位移。
这个设计让撤销不需要单独的逻辑:撤销就是把逆操作当成一个新 op 走同一条路——本地应用、再广播出去,远端收到这个 op 也跟着撤销:
function undo() {
const inv = undoStack.pop(); if (!inv) return;
doApply(inv);
const redo = inverseOf(inv);
if (redo) redoStack.push(redo);
inv.opId = sync.nextId(); sync.send(inv); // 撤销本身也是一个 op,广播给远端
afterChange();
}
远端不需要知道“对方按了撤销”,它只看到又来了一个普通的 op。重做同理。操作模型和同步协议在这里是同一套东西,没有为协同另写一套状态机。
服务端:只转发,不决策
服务端(server.js)的职责在文件头就写明了:房间管理、op 广播、新人下发快照。它维护一个 rooms Map:roomId -> { clients, els, seen },每个房间一份全量元素 els 和一个已见 opId 集合 seen。
收到 op 时,服务端只做四件事:
if (msg.t === 'op' && roomId) {
const room = getRoom(roomId);
const op = msg.op;
if (!op || !op.opId || room.seen.has(op.opId)) return; // 去重:重连补发不重复应用
room.seen.add(op.opId);
applyToRoom(room, op);
broadcast(room, roomId, { t: 'op', op }, ws);
}
第一,去重:opId 已在 seen 里就直接丢弃。这是给重连补发准备的——客户端断线后重发没确认的 op,服务端不会重复应用。第二,用和客户端 doApply 语义一致的 applyToRoom 更新房间的全量状态。第三,广播给同房间的其他人(不包括发送者本人,他本地已经应用过了)。第四,不做任何合并、排序或冲突解决:白板操作以增删为主,天然可交换,并发改同一元素的概率极低,直接 last-write-wins。
seen 集合不能无限增长,超过 5 万条时截断只留最近 3 万条;元素超过 2 万个时只打一条警告日志——这两个都是 Demo 级别的内存保护,生产环境该落盘的落盘、该分页的分页。
新人加入:先快照,再收增量
新人加入房间时,服务端先回一个 welcome(带分配的 clientId 和当前人数),再把房间全量元素一次性发过去,最后才开始给他推增量 op:
if (msg.t === 'join') {
roomId = String(msg.room || 'demo');
const room = getRoom(roomId);
room.clients.add(ws);
ws.send(JSON.stringify({ t: 'welcome', clientId, count: room.clients.size }));
// 新人先拿全量快照,再收增量 op(快照后到达的 op 按 opId 去重,不会重复应用)
ws.send(JSON.stringify({ t: 'snapshot', els: [...room.els.values()] }));
broadcast(room, roomId, { t: 'count', count: room.clients.size }, ws);
}
快照和增量之间有个天然的竞态:快照发出后、客户端还没收到的这段时间里,房间里又来了新 op,客户端会不会应用两次?不会——快照里已有的元素,之后到达的 op 如果是同一个 add,它的 opId 早已在服务端的 seen 里,而客户端这边 els.set 同一个 id 本来就是幂等的;更关键的是,客户端收到快照后对 opId 去重,重复的 op 不会二次应用。快照 + 去重这两步合起来,才是“新人加入不丢也不重”的完整答案,缺一不可。
整个协议的线上一共只有五种消息,README 里一张表就写完了:
C → S { t:'join', room }
S → C { t:'welcome', clientId, count }
S → C { t:'snapshot', els:[...] }
C → S { t:'op', op:{ opId, type:'add'|'delete'|'move'|'clear'|'addMany'|'deleteMany', ... } }
S → C { t:'op', op } // 广播给同房间其他人
S → C { t:'count', count } // 在线人数
跑起来也只需要两步:npm i ws && node server.js(监听 8080),两个人打开同一个 board.html?room=abc 就能互相看到对方的笔画。单机模式也保留着:file:// 直接打开就能画,起服务后再刷新才联机。
诚实说一句:这只是最小实现
这个协议能跑通两个人实时画画,但产品化要补的东西都在 README 的待办里,一个都没做:没有鉴权,知道 room 名就能进;没有持久化,服务端重启房间就空了(房间没人时也只是留在内存里,没有落盘);没有断线重连——连接断开时客户端只会降级成单机模式,提示“刷新重连”,断线期间本地画的内容不会自动补发;也没有远程光标,队友的笔尖在哪、正在看哪块区域都看不到;文档转码更没影。
但这正是“最小实现”的意思:先把“一个 op 从 A 到 B 原样落地”这条主线跑通,last-write-wins 和 opId 去重这两个取舍写死在代码里,后面加鉴权、持久化、重连时,协议本身不用推倒重来。下一篇(第 9 篇)会写另一个待做项:AI 消息“复制纯文本”——复制时剥掉 Markdown 标记只拿干净文本,那也是个“看起来小、做起来要想清楚”的功能。
一句话总结
op 同步协议就三句话:**本地操作先变成 op 再应用,撤销就是再发一个逆 op;服务端只做去重和转发,不替你做决定;新人先拿快照、再收增量,靠 opId 去重衔接。**一百多行代码,跑通了两个人实时协同——剩下的鉴权、持久化、重连,都是在这个骨架上长出来的。
- 点赞
- 收藏
- 关注作者
评论(0)