Mobile System Design Interview · 第 4 章Triton 覆蓋度:🟢 高(後端與同步協定)Triton 線
Design a Chat App
寄件匣、回條、補信:手機上的訊息怎麼不掉
原書設計一個全球 3,000 萬 DAU 的一對一聊天 App:送訊息走 HTTP REST、收即時更新走 WebSocket,手機用 SQLite 存全部對話,一則訊息從 PENDING 一路走到 READ。Triton 的講義剛好主張同一套「REST 寫、WebSocket 只推」,還多講了兩件原書沒講透的事:POST 帶 client 自己決定的 messageId、重連後先 GET 補信再 dedupe。手機本地資料庫那一半 Triton 沒有資料,照原書講。
給文組
全程用「阿明在捷運隧道裡傳訊息給小美」和「寄件匣與回條」,一階一階爬 12 個概念。頁首標 延伸基礎 的頁是補基礎,懂的人可以跳過。
給工程師
第 6–40 頁完整講原書,中間穿插延伸基礎頁(14 張圖除了 Figure 1 的 App logo,全部重繪),後面是 Triton 的批判與補充。後端的 RabbitMQ、PK 細節在 03 第 12 章 Chat System 簡報,這裡不重講。
標籤怎麼看
📖 原書 🗣️ Triton 本人說 📝 上課筆記 🔭 依 Triton 原則推論 📅 2026 補充
先用生活理解寄件匣與回條 · 動手玩
沒訊號時寫的信,先放寄件匣
先打開飛航模式,連寫兩封信,再關掉飛航模式。
你的手機是一本自己的信件抽屜:寫好的信放進寄件匣,有訊號才寄出;郵局只負責轉交,交到朋友手上就不留底。每封信旁邊有小圖示:還在寄件匣、郵局收到了、朋友收到了、朋友讀了。
這一章的對照表
| 生活 | 聊天 App(原書用語) |
|---|---|
| 寄件匣 | MessageRequests 表(PENDING / FAILED) |
| 自己的信件抽屜 | 手機上的 SQLite chats.db:client 是 source of truth |
| 郵局只轉交、不留底 | backend 當 temporary message relay |
| 回條:收到了、讀了 | SYNCED → DELIVERED → READ |
| 郵差按門鈴 | WebSocket(App 開著)/push notification(App 沒開) |
學習地圖本章的概念階梯
今天爬 12 階。每一階只用前面講過的東西。
- 1local database手機裡的信件抽屜
- 2source of truth正本在誰手上
- 3HTTP手機先開口
- 4WebSocket不掛斷的門鈴線
- 5idempotency key信封上的編號
- 6message status回條:一勾兩勾
- 7ordering手錶不準怎麼排
- 8outbox寄件匣
- 9push notification總機叫醒手機
- 10E2E encryption上鎖的盒子
- 11sync出隧道補信
- 12Signal / Message門鈴 vs 信
第 1–4 階 · 信放哪、誰先開口
要回答:正本在手機還是後端?server 怎麼主動通知手機?
第 5–7 階 · 一封信的編號與回條
要回答:重寄怎麼不變兩封?勾勾怎麼變?手錶不準怎麼排?
第 8–10 階 · 寄件匣、總機、上鎖
要回答:沒寄出的信放哪?App 沒開怎麼叫醒?郵局能偷看嗎?
第 11–12 階 · Triton 的補信
要回答:出隧道之後,漏掉的和重複的怎麼辦?
全程只用一個情境:阿明在捷運隧道裡傳「我到了」給小美(虛構)
每爬 3 階左右,有一頁「到這裡你已經會了」。
延伸基礎第 1 階 · local database懂的人可以跳過
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
捷運隧道裡沒訊號,還翻得到昨天的信嗎?
① 先想像
有人把收到的信都收進家裡的抽屜。有人什麼都不留,每次想看就跑去郵局調。
你猜猜看:阿明在隧道裡沒訊號,打開聊天 App 往上滑,看得到小美昨天說的話嗎?
信只放在郵局,沒訊號就調不到。原書把全部對話存在手機裡,所以隧道裡也翻得到。右邊切換試試。
③ 這叫做 local database、SQLite
local database:存在手機自己身上的資料庫,就是抽屜。SQLite:手機上最常用的一種,一個檔案就是一整個資料庫。
④ 跟這章的關係
原書把所有對話存在手機的 SQLite 檔 chats.db(第 23 頁)。「沒網路也能翻紀錄」是需求之一。
② 動手玩:信放在哪裡?
延伸基礎第 2 階 · source of truth懂的人可以跳過
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
手機掉進水裡,舊信還找得回來嗎?
① 先想像
郵局可以「送到就銷毀」,也可以「留一份底」。阿明的手機昨天掉進水裡。
你猜猜看:郵局送到就銷毀。阿明換新手機,小美上個月寄來的 10 封信還在嗎?
送到就銷毀,郵局手上沒有。唯一的一份在泡水的手機裡。郵局只還收著「還沒送到」的信。
③ 這叫做 source of truth、relay
source of truth:正本,有疑問時以它為準。relay:轉運站,只負責轉交,送到就不留。
④ 跟這章的關係
原書:手機是正本,後端只是 relay(像 WhatsApp)。Triton 的設計反過來,第 49 頁對照。
② 動手玩:10 封已送到、2 封還在路上
原書 Step 1Understand the problem · Figure 1
先問清楚:一對一還是群組?後端要不要存?
這一步要解決的問題要做哪一種聊天 App?一對一或群組、後端存不存,答案不同,設計就不同。
📖 原書 應徵者 × 面試官
| 應徵者問 | 面試官答 |
|---|---|
| 開場:今天設計聊天 App 的 mobile client 架構和後端溝通 | (面試官的題目) |
| 一對一、群組,還是都要? | 只做一對一,群組不在範圍內 |
| 後端像 WhatsApp 那樣只當暫時的 message relay,送達前保留、不永久存? | 是,就用這個做法 |
| 只有文字,還是附件、reactions? | 只有文字 |
| 新訊息推播、typing indicator、online status? | 都要 |
| 規模?新創還是全球? | 全球約 3,000 萬 DAU |
| 可以假設已經登入、開 App 時聯絡人清單已載入? | 可以 |
| client–backend 連線當然要加密;裝置上的訊息也要加密嗎? | 裝置上的加密先不做 |
白話:DAU=每天至少打開一次的人數(03 第 2 章);message relay=轉運站(第 5 頁);typing indicator=「對方正在輸入…」。
📖 原書 為什麼要先問
聊天 App 的用途很廣:一對一、朋友群組、家人分享照片、玩家在比賽中討論戰術。功能這麼多,一定要先把這次要做的需求講清楚。
💡 Pro tip
遇到熟悉的題目,主動先提出功能與非功能需求。這展現領導力,也讓你的面試更突出。
📖 原書 Figure 1 不重繪
原圖是六個 App 的 logo(WhatsApp、Facebook messenger、WeChat、Line、Google Chat、Discord),沒有任何流程或關係。商標不適合重畫,這裡只列名字。
原書 Step 1Requirements · 動手分類
五個功能需求、三個非功能需求、三件不做的事
這一步要解決的問題要做的、不做的、要多可靠,先列清楚;後面每個決定都拿它來對。
📖 原書 Functional
- 看最近的對話,依最新一則訊息的時間排序
- 即時聊天:送出和接收文字訊息
- 對話中看得到對方的 online status、typing indicator、message delivery status、read receipts
- 沒有網路也能翻聊天紀錄;歷史用 pagination 有效率地載入
- 新訊息有 push notification
📖 Non-functional
- Scalability:3,000 萬 DAU,各種網路狀況都穩定
- Data integrity:離線使用時保持一致,尤其是等連線恢復才送出的訊息
- Durability:client 端資料是訊息的 source of truth,必須可靠
📖 Out of scope
- User authentication 與註冊
- 群組聊天與媒體檔分享
- Message encryption
原書提醒:規模會大幅影響每個設計決定。
猜猜看:這句是哪一類?
💡 Pro tip 問 DAU 不只是要一個數字
使用者的規模和地理分布直接影響技術決定。DAU 高,通常代表要多談 performance optimization、資源效率、可擴展的架構模式,以及選對網路協定。面試時要一直把規模需求連到你的技術選擇上。
白話:pagination=一頁一頁往回載;scalability=人變多也撐得住;data integrity=資料不亂、不少;durability=存了就不會不見;source of truth=正本(第 5 頁)。
原書 Step 1UI sketch · Figure 2
兩個畫面:Chat List 和 Conversation
這一步要解決的問題使用者會看到哪幾個畫面?畫面決定手機要存哪些資料。
📖 原書 左邊是 Chat List screen:最近的對話,加上一個開新對話的按鈕。點一段對話,打開 Conversation screen:最近的訊息、對方的 online 與 typing 狀態、一個輸入新訊息的文字框。
原圖上有什麼
- 左邊每一列:圓形頭像、一條灰色長條(原圖描述猜是已讀狀態或其他 metadata)、時間(5:30 PM、12:30 PM、10:15 AM、08:06 AM),新的在上面
- 左下角有一個「+」按鈕
- 一個彎箭頭從第三列(10:15 AM)指到右邊
- 右邊:頭像、「Online Typing...」、幾個灰色的訊息方塊,底部有一個播放三角形(原圖描述猜是語音訊息或送出按鈕)
文組翻譯
左邊是信件抽屜的目錄,每一格是一位朋友、寫著最後一封信的時間;右邊是打開其中一格,看到你們之間的所有信。
延伸基礎 · 快速複習第 3–4 階 · HTTP、WebSocket03 第 12 章講過,懂的人可以跳過
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
郵局收到信,可以自己打電話給你嗎?
① 先想像
郵局櫃台的規矩:你來問,櫃台才回答。櫃台不會自己打電話給你。
你猜猜看:小美的信第 23 秒到了郵局。照這個規矩,阿明什麼時候知道?
櫃台只會回答,不會先開口。所以要嘛一直跑去問,要嘛在家裝一支門鈴。右邊兩種都試試。
③ 這叫做 HTTP、WebSocket
HTTP:手機先問、server 才答的約定。WebSocket:一條開著不掛斷的線,兩邊都能先開口。
HTTP:03 第 12 章第 5 頁pollinglong pollingWebSocket:第 9 頁④ 跟這章的關係
原書:送信走 HTTP、收即時更新走 WebSocket(第 15 頁)。中間的 polling、SSE 接下來幾頁照原書講。
② 動手玩:信第 23 秒到郵局
原書 Step 2API design · Client and backend expectations · Figure 3
兩支手機不直接互傳,一律經過 backend
這一步要解決的問題信一定經過郵局轉交。難的是反方向:郵局怎麼主動通知收件人?
文組翻譯
你到郵局寄信很簡單:走過去交給櫃台(client 主動發 HTTP)。難的是反方向:郵局要怎麼「主動」通知朋友有信?HTTP 只能由 client 開口,server 沒辦法先開口。
📖 原書 Step 2 要看四件事:client 與 backend 的期望、server-initiated connections、聊天 App 的網路協定、endpoints 與 data models。
📖 原書 Client 之間不直接溝通,都連到當中間人的 backend。Client 送出訊息到 backend,backend 找出收件人並轉送;收件人不在線上,backend 就先收著,等他連上來。
📖 原書 兩種互動
- Client 主動找 backend:送訊息、同步待處理的訊息。這是簡單的 request-response,用 HTTP 很合適。
- Backend 要找 client:即時送達訊息、online status 更新。收件人的 App 要立刻知道,但 HTTP 只允許 client 發 request,反過來不行。
📖 原書 Push notification 能在 App 沒在用時通知新訊息,但對正在進行的對話不夠:它可能慢、不穩定。聊天對延遲很敏感,需要更即時、更可靠的做法。
白話:request-response=一問一答;push notification=App 沒開也會跳的通知(第 36 頁細講)。
原書 Step 2Server-initiated connections · Polling · Long polling · Figure 4–5
讓 server「主動說話」:先從一直問開始
這一步要解決的問題HTTP 只能手機先開口。最簡單的辦法:一直問。
文組翻譯:polling 是每五分鐘下樓問管理員「有我的信嗎」;long polling 是坐在郵局櫃台等,等到信或等到打烊才回家,然後馬上再去坐。
📖 原書 支援 server-initiated connection 的技術有:polling、long polling、Server-Sent Events(SSE)、WebSocket,以及建在 HTTP/2 上的 gRPC 等。行動系統設計面試常考。
📖 原書 Polling(short polling)
Client 一直問「有我的新訊息嗎?」:問、server 回有或沒有、等一下、再問。好做,但很浪費:多數 request 沒有新資料,來回消耗 client 和 server 的網路與運算。
📖 原書 Long polling
Client 問了之後等著:server 把連線開著,直到有新資料或 timeout;client 一拿到回應就立刻再問。比 short polling 好,但還是有三個問題:
- 不常聊天的人,多數 request 只是 timeout
- 多台 server 時,拿到新訊息的那台不一定是握著收件人連線的那台
- Server 不容易判斷 client 是否已經斷線
原書 Step 2Server-Sent Events · WebSocket · Figure 6–7
開一條不掛斷的線:SSE 單向、WebSocket 雙向
這一步要解決的問題一直問太浪費。能不能開一條線,讓 server 有事就說?
📖 原書 SSE
Server 透過一條 HTTP 連線推更新給 client。為了不因閒置而 timeout,server 會定期送一行冒號開頭的 comment 保持連線。
- Client 對 SSE endpoint 發 HTTP GET,
Accept: text/event-stream - Server 回
200 OK、Content-Type: text/event-stream,連線保持開著 - Server 用簡單的文字格式持續送 event
- 斷線時 client 通常自動重連,帶
Last-Event-IDheader,server 只補送之後的 event
比 polling 有效率得多。聊天 App 可以 SSE 收、另外發 HTTP request 送:一種 hybrid。
📖 原書 WebSocket(WS)
最常見的即時雙向方案。一開始是普通 HTTP 連線,經過定義好的協定「upgrade」成 WebSocket;用和 HTTP/HTTPS 一樣的 port 80、443,所以碰到防火牆也通常能用。建好後雙方自由互傳,不限資料格式,純文字到 binary 都可以。
原書 Step 2Messaging protocols used in real-world apps · 動手配對
TCP 還是 UDP?真實的 App 用了哪些協定
這一步要解決的問題這條線底下用哪種「寄送方式」?真實的 App 各選了什麼?
📖 原書 TCP vs UDP
TCP:WebSocket 建在 TCP 上。整個 session 維持一條連線,保證封包依序、無誤送達:做 error-checking、確認收到、重送遺失的封包。
UDP:不先建連線,每個封包獨立送,不保證送達、順序或正確。少了 TCP 的可靠性,但 overhead 小,某些應用更快。
多年來各種即時訊息協定都是依需求建在 TCP 或 UDP 上。
文組翻譯
TCP 像掛號信:每封都要簽收、照順序、掉了重寄。UDP 像廣播電台:一直播,你沒聽到那句就沒了,但不用等誰簽收,所以快。講電話(語音、視訊)寧可偶爾斷一個字,也不要整段延遲,所以常走 UDP。
點卡片:誰用了哪個協定?
Triton 對 MQTT 的一句話見第 42 頁
白話:封包(packet)=資料切成的一小包;protocol=雙方約好的溝通規矩;peer-to-peer=兩支手機直接連,不經過 server;presence=在不在線上。
原書 Step 2 · 動手玩Network protocols in the chat app · Table 1
四種做法的取捨:耗電、延遲、伺服器負擔
這一步要解決的問題四種做法各犧牲了什麼?手機最在意的是耗電。
| 📖 Table 1 | Advantages | Disadvantages |
|---|---|---|
| Short polling | 實作簡單;用標準 HTTP 基礎設施,跨平台相容性廣 | request 過多、效率差;多數 request 沒有新資料時頻寬浪費大 |
| Long polling | 接近即時,request 比 short polling 少;適合非關鍵更新 | timeout 處理複雜;server 資源消耗大,client 多時擴展不好 |
| SSE | 一條開著的 HTTP 連線做 server→client;內建重連,在 HTTP/2 上表現好 | 單向,client→server 要另一套機制;連線多時資源消耗大 |
| WebSocket | 真正雙向;低延遲,不必重複 request/response,overhead 小 | 要更多基礎設施支援(例如 load balancer),實作較複雜;持久連線不好擴展 |
📖 原書 Table 1選擇即時功能網路協定的取捨(照原書內容)
文組翻譯:手機每次「醒來上網」都要耗電。一直問(polling)醒得最勤;開一條線等著(SSE、WebSocket),沒事時只偶爾輕輕敲一下確認線還在(keep-alive)。
白話:overhead=每次額外多花的力氣(標頭、握手);HTTP/2=新一點的 HTTP,一條線能同時跑很多請求;load balancer=把連線分給好幾台 server 的帶位員。
原書 Step 2決定:HTTP 送、WebSocket 收 · Figure 8
原書的決定:hybrid,WebSocket 只用在即時功能
這一步要解決的問題送和收,要用同一條線,還是分開?
📖 原書 選擇 hybrid:HTTP + REST API 做 client 發起的操作(例如送訊息);WebSocket 接收 server 的即時訊息。兩套協定多一點複雜度,但 App 長大後更好維護:WebSocket 只做即時功能、不包含送訊息,就能避開 production 常見的擴展問題。App 啟動時建 WebSocket,直到 client 或 server 中斷。
✅ Decisions made
- 送訊息和其他 client 發起的操作:HTTP + REST API
- Server 需要推更新的即時功能:WebSocket
- 小心限制 WebSocket 的使用範圍,管住擴展的複雜度
⚠️ Careful WebSocket 在 production 擴展的挑戰
- 管理持久連線很吃 server 資源
- Load balancing WebSocket 比一般 HTTP 複雜
- 連線恢復與狀態管理要處理得很周全
- 監控與除錯需要專門工具
📖 原書 為什麼選 WebSocket 不選 SSE
聊天場景下效能更好:延遲更低、header overhead 更小,對 typing indicator、read receipt 這種頻繁的小訊息很關鍵。SSE 雖然能做單向更新,但 WebSocket 在各行動平台的支援更一致、管理連線的工具更成熟,內建 reconnection 策略和 keep-alive 機制。
🔍 業界
Slack 大部分寫入走 HTTP 的 Web API,即時事件走 WebSocket 的 Real-Time Messaging(RTM)API;Discord 也類似。
Triton 也是這樣切,見第 43 頁
到這裡你已經會了小結 1 / 4
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
到這裡你已經會了:信放哪、誰先開口
- 信收在手機自己的抽屜(local database,原書用 SQLite),隧道裡也翻得到。
- 原書的正本(source of truth)在手機,後端只是送到就不留的轉運站(relay)。
- 手機先開口用 HTTP;要 server 先開口,就開一條不掛斷的 WebSocket。原書:HTTP 送、WebSocket 收。
下一階要解決的問題
決定好「HTTP 送」之後:寄出一封信要帶什麼?回條沒回來、重寄了,小美會不會收到兩封?
延伸基礎第 5 階 · idempotency key懂的人可以跳過
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
回條沒回來,再寄一次,小美會收到兩封嗎?
① 先想像
阿明在隧道裡寄出「我到了」。郵局其實收到了,但回條在隧道裡掉了。阿明不知道,只好再寄一次。
你猜猜看:信封上什麼都沒寫。郵局收到兩封「我到了」,小美會看到幾次?
郵局分不出是同一封寄兩次,還是阿明真的說了兩次,只好兩封都送。右邊在信封寫上編號再試。
③ 這叫做 retry、idempotency key
retry:沒收到回條就重寄。idempotency key:自己先寫在信封上的編號,同一個編號寄幾次都只算一次。
另一個例子:03 第 10 章的重寄通知訂房按兩次:03 第 22 章④ 跟這章的關係
原書寄信的 body 裡有 requestId,就是這個編號(下一頁)。
② 動手玩:寄出、回條掉了、再寄
郵局收件簿
小美的手機
原書 Step 2Endpoints · Client-initiated requests
送一則訊息:POST /v1/messages,帶一個 requestId
這一步要解決的問題寄出一則訊息要帶哪些資料?重寄時怎麼不變兩則?
Authentication: Bearer <token> POST /v1/messages Body: NewMessageRequest Response: 201 Created. Payload of type NewMessageResponse
data class NewMessageRequest requestId: Long toUserId: Long content: String createdAt: String
struct NewMessageRequest requestId: Int64 toUserId: Int64 content: String createdAt: String
data class NewMessageResponse message: Message fromMessageRequestId: Long?
struct NewMessageResponse message: Message fromMessageRequestId: Int64?
📖 原書 App 初始化時同步新訊息的 endpoint:
Authentication: Bearer <token>
GET /v1/messages?lastSyncedMessage={messageId}&limit={limit}
Body: empty
Response: 200 OK. Payload of type SyncMessagesResponse
📖 原書 兩個欄位的用途
NewMessageRequest.requestId 是 idempotency key:同一個 request 不小心送了好幾次,backend 可以 de-duplicate。
NewMessageResponse.fromMessageRequestId(optional):把回來的 Message 和當初的 NewMessageRequest 配對起來。
文組翻譯
寄掛號信時,你在信封角落自己寫一個編號「A-17」。郵局如果收到兩封都寫 A-17,就知道是你緊張寄了兩次,只收一封。回執上也寫「這是 A-17 的回執」,你才知道是哪一封寄到了。
原書沒寫的
原書沒有定義 SyncMessagesResponse 的欄位;lastSyncedMessage 帶的是 messageId,意思是「給我這則之後的訊息」。Triton 的同一招見第 44、46 頁
白話:Bearer <token>=出示通行證;Body=信的內容;201 Created=「新增成功」;idempotency key=信封上的編號(第 17 頁)。
延伸基礎第 6 階 · message status懂的人可以跳過
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
時鐘、一個勾、兩個勾、藍勾,各代表什麼?
① 先想像
寄掛號信,你會一路收到消息:還在你家、郵局收件了、送到小美家了、小美拆開了。
你猜猜看:「我到了」旁邊只有一個灰勾。代表什麼?
一個勾只代表郵局收到,小美的手機可能關機。兩個勾才是送到她手機,變藍才是她讀了。
③ 這叫做 message status、read receipt
message status:每則訊息現在走到哪一站。read receipt:已讀回條,對方打開時傳回來的通知。
④ 跟這章的關係
原書 Message 的 status 有四個值:PENDING、SYNCED、DELIVERED、READ(下一頁)。
② 動手玩:「我到了」走完四站
- 按下送出:還在阿明手機裡(時鐘)
- 郵局收到了(一個灰勾)
- 送到小美的手機(兩個灰勾)
- 小美打開來看(兩個藍勾)
原書 Step 2Data models · Message · ConversationPreview · Conversation
一則訊息有四種狀態;畫面用的 model 只屬於 client
這一步要解決的問題一則訊息要記哪些欄位?畫面要的資料歸誰管?
data class Message messageId: Long fromUserId: Long toUserId: Long content: String status: MessageStatus createdAt: String enum class MessageStatus PENDING, SYNCED, DELIVERED, READ
struct Message messageId: Int64 fromUserId: Int64 toUserId: Int64 content: String status: MessageStatus createdAt: String enum MessageStatus case pending, synced, delivered, read
data class ConversationPreview contact: User lastMessageSummary: String lastMessageTimestamp: String unreadCount: Int data class User id: Long name: String avatarUrl: String lastConnectedAt: String
struct ConversationPreview contact: User lastMessageSummary: String lastMessageTimestamp: String unreadCount: Int struct User id: Int64 name: String avatarUrl: String lastConnectedAt: String
data class Conversation contact: User contactInfo: ContactInfo? unreadCount: Int messages: List<Message> data class ContactInfo onlineStatus: String typing: Boolean
struct Conversation contact: User contactInfo: ContactInfo? unreadCount: Int messages: [Message] struct ContactInfo onlineStatus: String typing: Bool
📖 原書 status 決定畫面上的訊息圖示
PENDING | Backend 還沒收到 |
SYNCED | Backend 收到了 |
DELIVERED | Backend 已送到收件人 |
READ | 收件人讀了 |
📖 原書 畫面用的 model
ConversationPreview 是 Chat list 的一列,只帶剛好夠顯示的資料。點下去打開和那位使用者的 Conversation screen;一對一所以每個人只有一段對話,User 的 id 就是對話的唯一識別。打開時載入完整的 Conversation。這些和畫面有關的 model 是 client 私有的,backend 不管 client 怎麼顯示。
文組翻譯:Chat list 一列像信件抽屜的標籤「小美:明天見 · 10:15 · 2 封未讀」;打開抽屜才拿出整疊信(Conversation)。
白話:data class / struct=欄位固定的一張表格;enum=只能從幾個選項挑一個;Long / Int64=很大的整數;status 的四站見第 19 頁。
原書 Step 2Real-time features · WebSocket URI 與 event 格式
WebSocket 上只有三種 event
這一步要解決的問題門鈴(WebSocket)上會傳來哪幾種消息?
wss://my-api.chat.com/v1/socket/updates
📖 原書 WebSocket 的 URI 格式和 HTTP URL 類似:HTTP 是 http://、https://,WebSocket 是 ws://(一般)或 wss://(加密)。
{
"type": "message_type",
"payload": {}
}
📖 原書 每個 event 兩部分:type 指定 event 類型,payload 是 JSON 物件的實際資料,內容依 type 而不同。連線建好後,backend 可以推:
📖 原書 三種 event
new_message:給這個 client 的新訊息message_read:某則訊息被收件人讀了contact_status_update:聯絡人的狀態,包括 online status、typing indicator 或其他相關資訊
📌 Remember API 為什麼要有版本
URL 裡放 v1,新版本可以加 breaking change 或大功能,舊版本保持穩定;也能有計畫地淘汰舊 API。詳見原書第 10 章 Building Blocks。
文組翻譯
門鈴只會響三種聲音:「有你的信」「你寄的信被讀了」「朋友現在在家/正在寫字」。每一聲都附一張小紙條說明細節(payload)。
白話:URI=網址;JSON=用大括號寫的資料格式;payload=紙條上的內容;breaking change=會讓舊版 App 壞掉的改動。
原書 Step 3High-level client architecture · Figure 9
手機裡分兩層:UI layer 和 Data layer
這一步要解決的問題手機 App 裡面分成哪幾塊,各管什麼?
📝 原書 Note 這些元件和上一章 News Feed 差不多,原書快速帶過。
📖 原書 外部元件:Backend、CDN、Push Notifications Provider。第三方的推播服務讓 App 沒在用時也找得到使用者,處理可靠送達所需的複雜基礎設施。
📖 原書 Client 架構:沿用前幾章的 layered architecture,遵循 Unidirectional Data Flow(UDF)、reactive programming、separation of concerns。
📖 原書 Data layer:Message 是核心資料,Messages Repository 管所有讀寫;Users Repository 管名字、頭像。Repository 同時用 local 和 remote data source:client 發起的 request 走傳統 HTTP endpoint,專門的 Real time updates Remote DataSource 維持一條持久 WebSocket 收即時更新。Push Notifications Client 監聽外部推播。
📖 原書 UI layer:兩個主畫面 Chat List、Conversation。圖片載入集中在一個 Image Loader,從 CDN 拿。Message List 依時間顯示對話的所有訊息,包括送失敗和還在等待的;失敗的訊息在 UI 上標出來,每則都可以重送。
白話:Repository=管某種資料的管家;DataSource=實際去拿資料的人(Local=抽屜、Remote=郵局);State Holder=替畫面保管目前狀態;UDF=資料只往一個方向流。
原書 Step 3Data storage · Eviction policy · 動手玩
對話全存在手機上:用 relational DB,空間不夠時問使用者
這一步要解決的問題全部對話都存在手機上,要用哪種資料庫?空間滿了怎麼辦?
📖 原書 為什麼不用 key-value store
Android 的 SharedPreferences、iOS 的 UserDefaults 適合使用者偏好這種小資料,但不是設計來處理越來越多的訊息歷史,和訊息、對話、使用者之間的關係。量一大會變慢,也很難搜尋。
📖 原書 選 relational database 的三個好處
訊息本來就是結構化資料:屬於某段對話、有作者、格式固定。
- 複雜查詢有效率:搜尋歷史、篩選對話,歷史很大也找得快
- 資料一致性與 ACID(Atomicity、Consistency、Isolation、Durability):同時送收很多訊息也不衝突
- 支援未來成長:加 reactions、thread replies 時擴充 schema,不動到舊訊息
一開始設定比較多,但給了可靠聊天 App 需要的穩固基礎。
✅ Decisions made
- 用 relational database 把訊息存在磁碟上
- 空間不夠時提醒使用者
📖 原書 Eviction policy
所有對話都在裝置上,管理空間很關鍵。WhatsApp 空間不足時提醒並引導使用者清理;Slack 免費版自動刪掉超過 90 天或一年的訊息。可選做法:依日期或附件大小 evict;固定時間後自動刪除;讓使用者自己管,顯示用量和清理選項。
💡 Pro tip 空間不足時怎麼處理訊息常是產品決定。可以提方案、分析取捨,但先問面試官這在不在範圍內。
原書的 user-centric 策略:定期檢查可用空間;不足時主動提醒,給清楚的選項。
白話:key-value store=只能用名字查一格的置物櫃;ACID=一組寫入要嘛全成、要嘛全不成;schema=表格的欄位設計;evict=清掉。
延伸基礎第 7 階 · ordering懂的人可以跳過
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
兩支手機的時鐘差了一分鐘,信要怎麼排?
① 先想像
小美的手錶是準的,阿明的手錶慢 60 秒。兩人都在信上寫「現在幾點」。
你猜猜看:小美 12:00:30 問「晚餐吃什麼?」,阿明 20 秒後回「火鍋?」,手錶寫 11:59:50。照信上的時間排,誰在上面?
11:59:50 比 12:00:30 早,回答跑到問題前面。所以不能全信手機自己的時鐘。
③ 這叫做 createdAt、messageId
createdAt:手機自己寫的時間,可能不準。messageId:郵局(server)蓋的流水號,越晚越大。
流水號的完整版:03 第 12 章第 18 頁④ 跟這章的關係
原書:有流水號的照 messageId;還沒寄出的照 createdAt,放最後(第 26 頁)。
② 動手玩:拉阿明的手錶
原書 Step 4Design deep dive · Message lifecycle · Figure 10
一則訊息的一生:先上畫面,再等 server 給 ID
這一步要解決的問題「我到了」從按下送出到小美看到,中間經過哪幾站?
📖 原書 Deep dive 要談:訊息在螢幕上的排序、送出訊息、DB 實作細節、push notifications。(原文寫「five critical areas」,但只列了這四項。)
📖 原書 照時間排看起來簡單,在手機上有四個難題:網路延遲讓訊息亂序抵達;離線時的訊息要在重連後整合進來;不同裝置的系統時鐘可能不一樣;過去的訊息和新的更新都要保持一致的順序。
- Messages repository 立刻建立並儲存新訊息,UI 馬上顯示,給即時回饋
- Repository 交給 Messages remote data source,包成
NewMessageRequest,用 HTTP 送到 backend - Backend 處理 request,替訊息產生唯一的
messageId - Backend 同時做兩件事:4.1 回
201和NewMessageResponse給 sender;4.2 通知收件人:在線上就走 WebSocket,不在就走 push notification - Sender 收到 HTTP response,用新的
messageId更新本地儲存,UI 刷新顯示成功
白話:messageId=郵局蓋的流水號(第 24 頁);201=新增成功;inactive=App 沒開、沒有門鈴線。
原書 Step 4 · 動手玩Message ordering · Table 2 · messageId responsibilities
用 messageId 還是 createdAt 排?原書:兩個都用
這一步要解決的問題還沒拿到流水號的訊息,畫面上要排在哪裡?
📖 messageId 的責任 ID 要能依時間排序,新的永遠比舊的大。大規模下正確產生並不容易,所以交給 backend:server 更適合快速、準確地替數百萬則訊息產生唯一、依時間排序的 ID。
| 📖 Table 2 · Order by | Advantages | Disadvantages |
|---|---|---|
| messageId | Server 產生,各 client 順序一致;backend 仍是 source of truth | Backend 產生之前 client 拿不到;不能有效支援離線訊息 |
| createdAt timestamp | 低延遲,不等 backend 就顯示;支援離線訊息 | 裝置時鐘不同會不一致;容易被 client 端竄改 |
| createdAt + client-backend 時鐘同步 | 保留時間戳的好處、更可靠;用同步(例如 WebSocket event 或 Meta 的 Simple Precision Time Protocol)減少排序問題 | 裝置間的 clock drift 仍可能出問題;在各種網路下準確實作很複雜 |
📖 原書 Table 2client 端排序訊息的取捨
✅ Decisions made Hybrid
- 已送到 server 並被確認的:依 server 產生的 messageId 排
- 還在等待或傳送中的:依 client 的 createdAt 排,而且永遠放在最後面
時鐘同步可行但太複雜、太貴。多數熱門 App 用 server 給的 ID 排序:Discord 公開了 Snowflake ID;WhatsApp 的 id、Messenger 的 mid、Slack 的 ts 則不透明。等待中的訊息怎麼排是產品決定。
白話:clock drift=時鐘慢慢走偏;Snowflake ID=依時間遞增的流水號格式;opaque=外人看不出裡面的意思。
到這裡你已經會了小結 2 / 4
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
到這裡你已經會了:一封信的編號與回條
- 回條沒回來就重寄;信封上先寫好的編號(idempotency key,原書的
requestId)讓重寄只算一次。 - 每則訊息有狀態(message status):PENDING 時鐘 → SYNCED 一勾 → DELIVERED 兩勾 → READ 藍勾。
- 手機時鐘不準(ordering):原書有流水號的照 messageId,還沒寄出的照 createdAt 放最後。
下一階要解決的問題
還沒寄出的信,要放在哪裡才不會不見?寄失敗了怎麼辦?
延伸基礎第 8 階 · outbox懂的人可以跳過
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
飛航模式下打的字,App 被關掉之後還在嗎?
① 先想像
沒訊號時寫好的信,先放寄件匣。寄件匣可以只記在腦子裡,也可以寫在紙上收進抽屜。
你猜猜看:飛航模式下連打 3 則,接著 App 被手機關掉。重開 App、關掉飛航模式,3 則還會寄出嗎?
只記在記憶體(腦子裡),App 一關就沒了。寫進資料庫(抽屜),重開還在,有訊號就一則一則寄出。
③ 這叫做 outbox、pending message
outbox:寄件匣,還沒寄成功的訊息先排在這裡。pending message:在寄件匣裡等著的那一則。
④ 跟這章的關係
原書的寄件匣是 SQLite 裡的 MessageRequests 表:DRAFT、PENDING、SENT、FAILED(下一頁)。
② 動手玩:寄件匣放在哪?
寄件匣(outbox)
已寄到郵局
原書 Step 4 · 一步一步Sending messages · MessageRequest
寄件匣裡的信,和抽屜裡的信,是兩種東西
這一步要解決的問題還沒寄成功的信要怎麼記?跟已寄出的放一起嗎?
MessageRequests(寄件匣)
Messages(抽屜)
data class MessageRequest requestId: Long toUserId: Long content: String status: MessageRequestStatus lastModifiedAt: String lastSentAt: String? failCount: Int? enum class MessageRequestStatus DRAFT, PENDING, SENT, FAILED
struct MessageRequest requestId: Int64 toUserId: Int64 content: String status: MessageRequestStatus lastModifiedAt: String lastSentAt: String? failCount: Int? enum MessageRequestStatus case draft, pending, sent, failed
📖 原書 網路可能讓訊息送不到,要追蹤三種情況:還沒送、傳送中、送失敗。Data layer 用 MessageRequest 表示,送出前才由 remote data source 轉成 NewMessageRequest,方便做 retry。DRAFT:建了但還沒送;PENDING:排好隊準備送;SENT:已交給 backend,還沒收到確認;FAILED:server 回報失敗或 request timeout。
📝 原書 Note 刻意沒有 SUCCEEDED:server 確認後不改狀態,而是刪掉 MessageRequest、新建一個 Message(用 response 裡的 messageId 和 fromMessageRequestId)。同理,Message 表裡永遠不會有 PENDING;顯示時把兩邊合併。
白話:DRAFT=草稿;timeout=等太久就算失敗;retry=重寄;寄件匣的概念見第 28 頁。
原書 Step 4Sending messages data flow · Read receipts · Figure 11
Server 說「收到了」之後,手機裡發生七件事
這一步要解決的問題Server 說收到了,手機裡要更新哪些東西,畫面才變一個勾?
- Messages Remote DataSource 收到 backend 的成功回應
- Remote DataSource 把結果交給 Messages Repository
- Repository 做第一個 DB 操作:刪掉暫時的 message request
- 第二個 DB 操作:用 backend 確認的 ID 建立新的 Message
- DB 變動自動觸發更新,流到 Conversations Repository
- 再到 Conversation State Holder
- Conversation Screen 顯示訊息送達成功
📖 原書 已讀回條也是同一條路
- Backend 透過 WebSocket 送
read_messagesevent - Client 的 Real-time Updates Remote DataSource 收到
- 通知 Messages Repository 狀態變了
- Repository 更新本地 DB 的訊息狀態
- 變動流到 UI,更新已讀圖示
(前面 event 清單叫 message_read,這裡寫 read_messages,原書用詞不一。)
白話:DB 變動自動觸發更新=抽屜一改,畫面自己跟著變,不用另外通知(reactive programming)。
原書 Step 4 · 動手玩Message delivery failures · Exponential backoff
送失敗不要馬上放棄,但也不要一直狂按
這一步要解決的問題寄失敗了,多久再寄?寄幾次才放棄?
📖 原書 有時某個 NewMessageRequest 永遠等不到回應:網路不穩或其他意外。Request 失敗或 timeout 時不立刻放棄:把 MessageRequest 標成 FAILED、failCount + 1,靠它決定要繼續用 exponential backoff 重試,還是失敗太多次就停。
📌 Remember Exponential backoff
每次重試之間的等待越拉越長:例如從 1 秒開始,下次 2 秒、再來 4 秒,以此類推。避免連珠炮式的重試壓垮系統,也給網路恢復的機會。
📖 原書 不會永遠重試:設一個上限。失敗太多次就自動停止、標成永久失敗並通知使用者,讓他手動重送或刪除。
✅ Decision made
用 exponential backoff 演算法重試失敗的訊息。
文組翻譯:打電話給朋友沒人接,第一次等 1 分鐘再打,再來等 2 分鐘、4 分鐘……打了六次都沒接,就傳一句「看到回我」,交給他決定。
原書 Step 4Data layer design update · Figure 12
多三個元件,讓 Remote DataSource 不要太累
這一步要解決的問題寄件匣、重試、逾時,要交給誰負責?
🔍 業界
Airbnb 做了 message synchronization 機制,減少網路 request 和資料不一致,inbox 載入更快,在慢網路地區尤其明顯。Facebook Messenger 的「Lightspeed」重寫引入 MSYS(Messenger SYnc System)管理本地資料與工作,用來處理離線訊息。
📖 原書 為了處理失敗、重連和 message request,client 架構要更新。新增三個元件,各有明確責任:
Messages Scheduler
在 background thread 安排送出訊息;適當時候 batch,並和 Timeout Controller 合作管理失敗訊息的 retry。
Messages Timeout Controller
監控還在等 backend 確認的訊息有沒有 timeout。
Pending Messages Provider
從 local data source 拿出 pending 或送失敗的 message request。依 dependency injection 的最佳做法,實際實作會依賴 Messages Local Data Source。
元件變多、Remote Data Source 變簡單,整體更好讀、更好維護。
原書 Step 4DB implementation details · SQLite statements
SQLite:已送出的放 Messages,還沒送的放 MessageRequests
這一步要解決的問題三張表實際長什麼樣?為什麼寄件匣要獨立一張?
CREATE TABLE Users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
avatar_url TEXT,
last_connected_at TEXT,
)
CREATE TABLE MessageRequests (
request_id INTEGER PRIMARY KEY,
to_user_id INTEGER NOT NULL,
content TEXT NOT NULL,
status TEXT NOT NULL,
last_modified_at TEXT NOT NULL,
last_sent_at TEXT,
fail_count INTEGER,
FOREIGN KEY (to_user_id)
REFERENCES Users(id)
)
CREATE TABLE Messages (
id INTEGER PRIMARY KEY,
from_user_id INTEGER NOT NULL,
to_user_id INTEGER NOT NULL,
content TEXT NOT NULL,
status TEXT NOT NULL,
created_at TEXT NOT NULL,
FOREIGN KEY (from_user_id)
REFERENCES Users(id),
FOREIGN KEY (to_user_id)
REFERENCES Users(id)
);
📅 補充 照原書抄錄:Users 最後一欄後面多了一個逗號(紅色),SQLite 會回報 syntax error,要拿掉才能執行。另外 SQLite 的 foreign key 檢查預設是關的,要 PRAGMA foreign_keys = ON 才會生效。
🛠️ Platform
Apple 的 CoreData 可以用 SQLite 當底層儲存;也可以考慮開源的 SQLite.swift、FMDB。Android 最常用 Google 的 Jetpack Room 和 Square 的 SQLDelight。
文組翻譯:寄件匣裡的信還沒有郵局編號,只有你自己寫的編號(request_id);寄到後郵局蓋上正式編號,才搬進抽屜(Messages.id)。
📖 原書 SQLite 是行動裝置上很好的選擇:輕量但強大的 relational DB,容易嵌進行動作業系統;支援複雜查詢和 transaction,適合聊天 App。
📖 原書 為了效能,entity-relationship model 要配合 SQLite 的運作方式。一般訊息存 Messages 表、還沒同步的存 MessageRequests 表。分開很重要,因為還沒同步的 request 還沒有 Message id。
📝 原書 Note 為什麼 ID 是 INTEGER
Kotlin 是 Long、Swift 是 Int64,SQLite 裡寫 INTEGER。SQLite 用以 type affinity 為基礎的動態型別:依宣告的型別決定欄位的 storage class。INTEGER 是有號整數,用 1、2、3、4、6 或 8 bytes 存;型別名稱含「INT」(INT、INTEGER、BIGINT、SMALLINT)都有 INTEGER affinity。
原書 Step 4 · 動手玩Data layer updates · Figure 13
兩張表,Repository 合併成一串對話
這一步要解決的問題資料拆成兩張表,畫面怎麼看到一串對話?
📖 原書 三張新表各自是一個 DAO(Data Access Object)。為了 separation of concerns,訊息和使用者資訊分成各自的 repository。
📖 原書 訊息分在兩張表,但不影響整體資料流:這件事藏在 data layer 後面。Repository 合併 Messages 和 MessageRequests,上層看到的是一串統一的對話,不必知道底下拆成兩張。
Messages
MessageRequests
畫面看到的
白話:DAO=專門讀寫某一張表的小幫手;separation of concerns=各管各的,不互相插手。
原書 Step 4Challenges:schema 初始化 · Size and performance
本地 DB 的兩個麻煩:建表順序、越長越大
這一步要解決的問題手機上的資料庫:建表順序、越長越大,怎麼處理?
📖 原書 Table dependencies 與 schema 初始化
多個 SQL 敘述,不論在同一個或不同 script 檔,執行順序都重要:Users 要先建,因為其他表依賴它。把所有 CREATE TABLE 放在同一個 SQL script 能避免順序問題,讓 DB 設定更可靠。
為了簡單、一致、資料完整,三張表(Users、Messages、MessageRequests)都放在同一個 SQLite 檔 chats.db。
把 Users 拆成獨立 DB 可能比較模組化、未來可跨 App 重用,但有三個麻煩:
- 跨 DB 檔的 foreign key 無法強制,referential integrity 要在 application layer 手動維護
- 同一個 App 管多個 DB 要小心協調,尤其在 development、testing、production 不同環境
- 多個 DB 更容易執行順序錯,造成 schema 設定失敗,除錯很花時間
✅ Decisions made 三張表同在 chats.db;CREATE TABLE 放在同一個 SQL script。
📖 原書 Size and performance
App 長大,DB 變大會拖慢效能;Android 和 iOS 對有效率的儲存與存取都有限制。可以:
📌 Remember 所有 DB 操作都在 background thread 做,不要卡住 UI thread。
文組翻譯
建表順序像搬家:先放書櫃,才能把書放上去。一個 chats.db 就是「全部放同一間房」,找東西、搬家都簡單;拆成好幾間房,哪本書屬於哪個書櫃就得自己記。
📅 補充 細節:SQLite 在 CREATE TABLE 時並不檢查被參照的表是否已存在,foreign key 錯誤要到寫入資料、而且開了 PRAGMA foreign_keys 才會出現。順序仍然值得固定,因為 migration、seed data 和其他資料庫會在意。
這一整塊 client 本地 DB,Triton 的講義沒有談,簡報不替他推論。
延伸基礎第 9 階 · push notification懂的人可以跳過
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
App 被滑掉了,小美的訊息怎麼叫醒你?
① 先想像
App 開著時,門鈴(WebSocket)直接響。App 被滑掉,門鈴的線也斷了。這時只剩手機系統自己的那支總機。
你猜猜看:阿明把聊天 App 滑掉了。小美傳來「我到了」,誰讓手機跳出通知?
App 關掉,WebSocket 也斷了。每支手機都和 Apple 或 Google 保持一條省電的專線,後端請它們代為通知。
③ 這叫做 push notification、FCM / APNs
push notification:App 沒開也會跳出來的通知。FCM / APNs:Google 和 Apple 各自的推播總機。
後端怎麼打給總機:03 第 10 章第 8 頁④ 跟這章的關係
原書:WebSocket 只給 App 開著的人;沒連上的,後端打給 FCM / APNs(下一頁)。
② 動手玩:阿明的 App 在哪個狀態?
原書 Step 4Push notifications · Sending from the backend · Figure 14
App 沒開的時候,靠作業系統的那條線叫醒你
這一步要解決的問題App 沒開時,後端怎麼叫醒手機?
文組翻譯
每支手機都和作業系統的「總機」(FCM / APNs)保持一條很省電的專線。你的 App 不用自己守著電話,後端只要打給總機說「請通知這支手機」,總機就叫醒它。
📖 原書 需求包含:使用者離線時用 push notification 提醒新訊息。高階架構已經列了元件,這裡看它們怎麼互動,以及 Android、iOS 的做法。
📖 原書 從 backend 發推播
訊息送給 inactive user(沒有和我們的 server 維持 WebSocket 連線的人)時,backend 觸發推播:對外部 Push Notifications Provider 發 HTTPS request。Android 是 Firebase Cloud Messaging(FCM),iOS 是 Apple Push Notification Service(APNs)。
為了正確投遞,backend 維護使用者與裝置的 mapping:安裝 App 時,裝置在背景註冊推播,backend 存下每台裝置唯一的 token。
📌 Remember 推播的種類
- Alert:立刻提醒使用者
- Silent:在背景處理,使用者不知道
- Rich media:可以帶圖片、影片或其他媒體
本章送 alert notification:告訴使用者有幾則未讀、以及訊息內容。
原書 Step 4 · 動手玩Receiving push notifications · Challenges
收到推播時,App 在前景、背景還是被關掉?
這一步要解決的問題通知到的那一刻,App 在不同狀態,各該做什麼?
🔍 業界 Slack
由 server 端決定何時推、推什麼。每則訊息都經過 Slack 的 event pipeline,並 enqueue 一個 background job 處理可能的通知;Slack 的 job queue 一天處理超過十億個 job,包括推播的 fan-out。
📖 原書 Android、iOS 裝置分別和 FCM、APNs 維持一條低耗電、持久、TLS 加密的 TCP 連線。各個 App 不必自己管連線(那很耗資源)。通知到達時,裝置喚醒對應的 App,或在 App 沒跑時直接顯示通知。
🛠️ Platform Android 由 Google Play Services 維持連線,iOS 由背景的 push notification daemon。Android 實作一個繼承 FirebaseMessagingService 的 service;iOS 用 UNUserNotificationCenterDelegate,通常整合進 UIApplicationDelegate。
📖 原書 推播的挑戰
- FCM、APNs 或裝置本身可能 throttle:省電模式下延遲送達、限制網路、批次處理
- 要使用者同意;拒絕或之後關掉,就少了這個管道
- Android、iOS 的 API 與流程不同,要平台專屬的程式碼,體驗可能不一致
- 常要導到 App 內特定畫面:URL scheme 或 universal link;App 沒在跑時還原狀態很棘手
- 各種裝置與 OS 版本的相容性;非同步的特性讓送達問題很難除錯
因此本章把推播主要當成輕量的提醒機制。
延伸基礎第 10 階 · E2E encryption懂的人可以跳過
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
郵局能不能偷看信的內容?
① 先想像
小美發給大家很多「誰都能鎖、只有她能開」的掛鎖。阿明把信鎖進盒子才寄,郵局只看得到盒子。
你猜猜看:用了這種上鎖的盒子,郵局(後端)看得到「我到了」這三個字嗎?
開鎖的鑰匙只在小美手機裡。郵局還是知道「寄給誰、幾點寄」,但打不開盒子。
③ 這叫做 end-to-end encryption、public / private key
end-to-end encryption:只有寄件人和收件人的手機解得開。public / private key:發給大家的掛鎖/只留在自己手機的鑰匙。
④ 跟這章的關係
原書把 message encryption 列為不做,最後才列成延伸題(下一頁)。
② 動手玩:三種寄法,誰看得到?
| 誰 | 看到什麼 |
|---|---|
| 路上偷看的人 | — |
| 郵局(後端) | — |
| 小美的手機 | — |
原書 Step 5Wrap-up · 還有時間可以談
原書的收尾:HTTP 送、WebSocket 收,和六個延伸題
這一步要解決的問題主體設計完,面試官常問:還能怎麼延伸?
📖 原書 總結
設計了一個聊天系統:client 發起的 request 用 HTTP,即時更新(包括已讀回條、使用者 online status)用 WebSocket。
畫了 client 架構、定義了 backend 的 HTTP 和 WebSocket endpoint、建了需要的 data model;深入看了訊息在螢幕上的排序、client 怎麼送訊息、DB 實作、push notifications。
📖 原書 有多的時間,或想挑戰不同需求
- Online status / presence:WebSocket 斷線怎麼影響使用者的 online 狀態,TCP half-open 在其中扮演什麼角色
- 群組聊天:群組的訊息建立與送達;role-based 權限管理、在群組對話中 mention 使用者
- 加強安全:資料庫加密防止未授權存取;end-to-end encryption 讓只有收發雙方讀得到
- Rich media:圖片、影片、位置等附件;用壓縮處理大檔、產生縮圖做有效率的預覽
- 訊息管理:編輯與刪除;追蹤並顯示編輯歷史;選擇性刪除(只刪自己或所有人)
- 搜尋:單一對話內的搜尋,和跨所有聊天的全域搜尋(full-text search)
把整章串成一句話
按下送出:先放進寄件匣(MessageRequests)、畫面立刻顯示;Scheduler 用 HTTP 寄出,失敗就 backoff 重試;server 回 201,寄件匣那筆換成抽屜裡有正式編號的 Message;對方的回條透過 WebSocket 回來,勾勾一路變色。App 沒開時,門鈴改由 FCM / APNs 代按。
到這裡原書全部講完,下一頁開始是 Triton。
白話:TCP half-open=一邊以為線還通、另一邊早就斷了;role-based=依角色給權限;full-text search=搜尋整段文字裡的字;thumbnail=縮圖。
到這裡你已經會了小結 3 / 4
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
到這裡你已經會了:原書的整個設計
- 寄件匣(outbox)寫進 SQLite 的 MessageRequests 表,App 被關掉也還在;失敗就 backoff 重試。
- App 沒開時,後端請 FCM / APNs 這支總機叫醒手機(push notification)。
- End-to-end encryption:鑰匙只在收件人手機裡,郵局只轉交上鎖的盒子;原書列為延伸題。
下一階要解決的問題
原書全部講完。出了隧道,門鈴和補信同時進來,漏掉的和重複的怎麼辦?接下來是 Triton。
Triton 觀點先看全貌
這一次原書和 Triton 大方向一致,差在「斷線之後」
你猜猜看:原書和 Triton 都選了「HTTP 送、WebSocket 收」。兩邊最大的不同會在哪裡?
送和收的分法一樣。Triton 多講的是出隧道之後怎麼補信,而且他的後端一定留底;手機資料庫那一半 Triton 沒有資料。
✅ 一致 原書做對的地方
- 送訊息走 REST、WebSocket 只推(第 43 頁)062 · 090 · 113
- POST 帶一個 client 產生的 key,讓重送不會變兩則(第 44 頁)078 · 028
- Client 記住同步到哪,用它補拉:
lastSyncedMessage≈minMsgId(第 46 頁)078 - 推播交給作業系統的服務:「如果你是要把 Message 推送到手機上,請使用 GCM / APNS,別自行來架 Server」073
- 推播只當輕量提醒 ≈ Signal(門鈴,漏了沒關係;第 47、48 頁)078
❌ 原書沒講 / 不一樣
- WebSocket 和補拉的 GET 同時進來時,要先 buffer、再 sort + dedupe(第 46 頁)062 · 078
- 後端只當 relay、不存 → Triton 的訊息一律先寫進 DB,斷線補拉靠它(第 49 頁)078 · 062
- 原書的理由是「避開擴展問題」;Triton 的理由是部署與 single responsibility090
- Backend 是黑盒子:訊息怎麼從收 HTTP 的 server 到握 WebSocket 的 server,原書沒講078 · 062
先說清楚定位:🗣️ 062「今天目的是教學 不是求職面試 所以不採用 top-down approach」「今天的設計不是用來面對上百萬在線用戶的」。🗣️ 078「警告:現實 chatroom會用MQTT機制,這篇單純教學MQ,請勿真的實作」。
Triton 沒有資料的部分:client 本地 DB(SQLite、兩張表、eviction)、UI 架構(UDF、State Holder)、推播的平台 API、訊息狀態圖示。前面 22–38 頁照原書,不做 Triton 推論。
Triton 補充 · 動手玩090 RESTful 範例 · 062 Websocket design
同一個結論,Triton 的理由是:部署時不要斷線
auth <jwt> subscribe chatroom <chatroomId> unsubscribe chatroom <chatroomId>
🗣️ 062 第 17 頁Triton 的 WebSocket 從 client 收的指令只有這三個
你猜猜看:如果送訊息也走 WebSocket,部署新版「發訊息」程式時,8 支手機會怎樣?
商業邏輯住在 WebSocket server 裡,改邏輯就要重啟它,連在上面的手機全斷。上面兩種架構切換驗證。
📖 原書「By using WebSocket only for real-time features rather than all communication, including sending messages, we avoid common scaling issues」:理由是擴展(連線資源、load balancing、狀態管理、監控)。
「如果Websocket只用來接收 server push,那麼websocket可以非常簡單 – 單純簡單用戶身份驗證後, listen RabbitMQ特定 channel,把收到的東西全部 relay給用戶 就好 – 幾乎沒有Application Logic,所以極少改動」「如果WebSocket有Application Logic – 那麼,你就會因為App Logic Change / Bug Fix 而需要做production deployment」🗣️ Triton 本人說 090-restful-demo.pdf.md · 第 10 頁
「WebSocket單純用來接收其他玩家的改動 要出牌是用傳統的 RESTful API AS是 Stateless,不同的用戶的Websocket會散落在不同的機器上」🗣️ Triton 本人說 090 · 第 12 頁「合乎 RESTful的架構選擇」
🗣️「你知道跟為何跟客戶建立websocket的伺服器,最好跟處理普通HTTP Request的伺服器最好別放在同一台機器上嗎?」113 · 第 7 題
📝 上課筆記「when deplying AS roll up user 不會發現 但 wss socket deploy時 會斷掉」「所以這個架構 可以 websocket 少很多 deployment」009
Triton 的做法 · 一步一步078 POST …/messages/{messageId} · 028 Idempotence
回應掉在隧道裡:重送時,server 認得出是同一則嗎?
- 離線時打了「我到了」:存進寄件匣,ID 先決定好
- 重新連線:Scheduler 發出 POST
- Server 寫進 DB 成功,但 201 回應掉在隧道裡
- Client 等不到回應 → timeout → 原封不動再 POST 一次
- Server 收到第二次 POST
- Client 收到回應,寄件匣清空
你猜猜看:server 已寫進 DB,201 卻掉在隧道裡。手機原封不動再 POST,沒帶任何 ID。DB 會有幾筆?
server 分不出這是重送還是新訊息,只好再寫一筆。第 17 頁「信封上的編號」就是解法。
「用戶要寫新留言 – POST /v1/chatrooms/{roomId}/messages/{messageId} – 留言會寫進MariaDB / HBase中」🗣️ Triton 本人說 078-mq-intro.pdf.md · 第 4 頁
「延伸思考:在不穩定網路下,用戶建立一份資源時,卻發出了二次的 POST ,怎麼辦? – 雖然原始 HTTP POST 定義是 non-idempotent ,但是他沒禁止你自行解決 idempotent 問題」🗣️ Triton 本人說 028-RESTful API Design-tw-2.2.pdf.md ·「HTTP method-POST」
「在客戶端,任何未成功收到傳回訊息的 API ,只需要重新呼叫。 伺服器端需要懂得處理重覆 API request 在建立新物件時,把客戶端時間也放到 API request 中,讓伺服器能分辦是否收到重覆的 HTTP POST」🗣️ Triton 本人說 028 ·「Idempotence (重新呼叫)」
🔭 推論 對照原書
原書的 requestId(idempotency key)和 createdAt(client 時間)就是 028 說的兩樣東西,方向一致。差別:原書 key 放在 body、正式 ID 由 server 再發一個,所以有 requestId 和 messageId 兩個 ID;078 把 client 決定的 messageId 直接放進 URL,只有一個 ID。078 沒有解釋這個設計,也沒說 messageId 怎麼產生。
延伸基礎第 11 階 · sync懂的人可以跳過
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
出了隧道,漏掉的信怎麼補回來?
① 先想像
阿明進隧道時,最後看到第 40 封。隧道裡小美又寄了 3 封,門鈴響了,阿明聽不到。
你猜猜看:出隧道後,門鈴會把漏響的 3 次重響一遍嗎?
門鈴響過就過了。手機要記住一張書籤,跟郵局要「第 40 封之後的」。
④ 跟這章的關係
原書的 ?lastSyncedMessage=、Triton 的 ?minMsgId= 都是這張書籤(下一頁)。
② 動手玩:隧道、補信、遲到的門鈴
阿明的手機
郵局(有留底)
Triton 的做法 · 一步一步062「用戶流程」 · 078「面對WebSocket斷線」
出隧道之後:先收著、再 GET 補、最後 sort + dedupe
Server DB(chatroom 42)
WebSocket buffer
GET ?minMsgId=40 的 response
你猜猜看:出隧道時 WebSocket 先收到 #44–#46,GET 又回 #41–#45。收到就直接顯示,畫面會怎樣?
兩條路同時進來,#44、#45 各出現兩次,#41 還排在 #46 後面。上面切到「收到就顯示」驗證。
「呼叫 /v1/chatrooms/{roomId}/messages?minMsgId=X GET (註: X為斷線前在 chatroom最後的留言的 Id) 補回斷線期間留言 – 在拿到Get response前,WebSocket所收到的東西全前保留下來 – 拿到Get response後 WebSocket收到的訊息,其MsgId少於GET response的MsgId全都丟掉 不用管」🗣️ Triton 本人說 078 · 第 11 頁
「建立 websocket 連線 有加入的 chatrooms – 在 websocket 對 subscription – 把收到的 message 先 buffer 起來 – 拿最近 50 個 messages GET /v1/chatrooms/<roomId>/messages – 把最近 50 個 messsage 和 buffered message 作 sorting + deduplication 然後顯示給用戶 – 之後,所有收到的 message 直接顯示給用戶」🗣️ Triton 本人說 062 · 第 18 頁「用戶流程」(不是 009 筆記)
📝 上課筆記「回傳不是固定的 client依照時間排就好」009
🔭 推論 原書少的那一塊
原書有 GET /v1/messages?lastSyncedMessage=…,也有 WebSocket 的 new_message,但沒講兩者同時在跑時的重複與亂序;Repository 只合併本地的兩張表。補上 062 / 078 這幾步,就是把 SSE 的 Last-Event-ID 想法搬到 WebSocket + REST 上。
延伸基礎 · 快速複習第 12 階 · Signal / Message03 第 12 章講過,懂的人可以跳過
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
門鈴漏響,和信弄丟,哪個比較嚴重?
① 先想像
門鈴沒聽到,信還在郵局,自己去拿就好。信如果在路上掉了,就真的沒了。
你猜猜看:郵局有留底。門鈴(WebSocket)漏響一次,小美的信會不見嗎?
門鈴只是叫你。真正的信在郵局的帳本裡,上一階的 sync 補得回來。
④ 跟這章的關係
Triton:聊天室裡 WebSocket 傳的是 Signal(下一頁)。前提是郵局真的有留底。
② 動手玩:門鈴漏響一次
Triton 補充078 MQ 淺談 · Signal vs Message
門鈴可以漏響,信不能掉:手機上的寄件匣也是 Message
你猜猜看:原書 WebSocket 的 new_message 漏了一則。最壞會怎樣?
門鈴漏了,只要郵局還留著那封信,照書籤 GET 就補得回來。Triton 把這種東西叫 Signal。
「Signal – 要高度即時性 – 丟失沒太大差 Message – 可以排隊一個一個工作慢慢來~ – 絕對不能丟失」🗣️ Triton 本人說 078 · 第 8 頁
「如果 UserB斷線了,用 GET API也能得到斷線期間的留言 – i.e. 斷線期間的留言,不經WebSocket重傳也沒差啊 – 所以, chatroom系統內的是 Signal,不是Message」🗣️ Triton 本人說 078 · 第 9 頁
「正常的MQ Server – 會把收到的Message先存到HDD,然後才回應成功 – 會等待收件者回傳「工作完成」,才真的把訊息刪掉」🗣️ Triton 本人說 078 · 第 7 頁
🗣️ 062 的 MVP 明列「今天不包」:「「對方已讀」顯示」062 · 第 4 頁。🗣️「你知道不應該每數秒做一次Get request,而是應該打開websocket / Firebase push notification(或是相似的技術)」113 · 第 6 題
猜猜看:原書的這些東西,是 Signal 還是 Message?
文組翻譯
門鈴(WebSocket、推播)沒響,信還在郵局,你自己去查就拿得到;但你寫好還沒寄出的信,只存在你家的寄件匣,弄丟了就真的沒了。所以寄件匣要寫在紙上(磁碟),不能只記在腦子裡(記憶體)。
Triton 對照原書Backend 不是黑盒子 · 後端細節見 SDI 第 12 章簡報
原書的 backend 只是一個方塊;Triton 的 backend 長這樣
| 📖 原書 | 🗣️ Triton | |
|---|---|---|
| 後端存不存 | 暫時 relay,送達前保留、不永久存 | 「留言會寫進MariaDB / HBase中」「留言要保存三個月」078;「最近 30 日聊天歷史」062 |
| 送訊息 | POST /v1/messages,body 帶 toUserId、requestId | POST /v1/chatrooms/<roomId>/messages 062;URL 帶 {messageId} 078 |
| 補拉 | ?lastSyncedMessage={messageId}&limit | ?minMsgId=X 078;往前翻 ?lastTs、約 50 則、回 nextPageTs 062 |
| 排序 | Hybrid:有 ID 依 messageId,等待中依 createdAt 放最後 | PK「一定是 (chatroomId, createTs)」062;📝「createTs ⇒ ms」「若一樣時間 就 failed 掉,再重發」009 |
| 認證 | Authentication: Bearer <token>;WebSocket 沒說 | WebSocket 第一句 auth <jwt> 062;「使用jwt是不用redis-access就能知道這個request是否系統用戶」131 |
| HTTP → WS | 沒講 | 「系統需要 MQ Server,讓 Users的新訊息能傳到 websocket所在的 AS」078;RabbitMQ fanout,一台一個 queue 062 |
| MQ 選誰 | 沒講 | 「如果系統還沒到每秒1K Message的,kafka對你會是overkill。」138 |
PK、RabbitMQ 四個設定、cache 分頁的完整說明:SDI 第 12 章 Chat System 簡報。
你猜猜看:原書的後端送到就刪。阿明換了新手機,三個月前的對話從哪裡來?
送到就刪,後端手上沒有舊訊息。Triton 的設計反過來:訊息一律先寫進 DB,DB 才是正本。
🔭 推論 原書自己點出、卻沒解的問題
原書列 long polling 的缺點:「多台 server 時,拿到新訊息的那台不一定是握著收件人連線的那台」。換成 hybrid 之後,這個問題還在:收 HTTP POST 的 server 和握 WebSocket 的 server 不同台。078 第 5 頁講的就是這件事,答案是中間放 MQ;而它傳的是 Signal,所以 Redis Pub/Sub 也可以(078 第 10 頁)。
🔭 推論 後端不存,Signal 就不能丟
078「Signal 丟了沒差」的前提是 DB 裡有、GET 補得回來。原書的後端送達就刪,DB 不是 source of truth:換手機、重灌、或推播與 WebSocket 都漏掉時,補拉 endpoint 只拿得到還沒送達的。這是 WhatsApp 式的產品取捨,不是錯;但面試時要說清楚,backend 的 relay 必須自己保證「送達確認後才刪」,也就是把它當 Message 處理。
🗣️ Triton 本人說 什麼叫 stateless
「stateless component就是指像:Application Server(AS) / Ngnix 這些不會存放application state的component stateful component是指像:postgresql database / kafka / rabbitMQ 這些會存放application state的component」017
到這裡你已經會了小結 4 / 4
- local database
- source of truth
- HTTP
- WebSocket
- idempotency key
- message status
- ordering
- outbox
- push notification
- E2E encryption
- sync
- Signal / Message
到這裡你已經會了:Triton 怎麼補信
- 出隧道後,WebSocket 先收著;拿書籤(
minMsgId)GET 補信,再排序、重複的丟掉(sync、dedupe)。 - WebSocket 和推播是門鈴(Signal),漏了沒關係;寄件匣裡的信是 Message,絕對不能丟。
- 「門鈴可以漏」的前提是後端有留底;原書的後端送到就刪,就要保證確認送達才刪。
12 階全部走完了
下一頁用一句話收尾;再下一頁是名詞小卡,給大家課後複習。
一句話記住
信先寫進寄件匣,自己編好號再寄;
門鈴漏響沒關係,回家先去郵局補信,再把重複的丟掉。
原書的做法
- HTTP REST 送、WebSocket 只推三種 event
- MessageRequests(寄件匣)與 Messages(抽屜)兩張表,Repository 合併
- Hybrid 排序:有 ID 依 messageId,等待中放最後
- 失敗:FAILED + failCount + exponential backoff,超過上限交給使用者
- App 沒開:FCM / APNs alert 推播
和 Triton 一致
- WebSocket 不碰商業邏輯,部署不斷線(090)
- POST 帶 client 決定的 ID,重送不重複(078、028)
- Client 記住看到哪,用 GET 補(078 minMsgId)
- 推播用 GCM / APNS,別自己架(073)
原書沒講的
- 重連時 WebSocket 與 GET 同時進來:buffer → GET → sort + dedupe(062、078)
- 收 HTTP 的 server 怎麼通知握 WebSocket 的 server(078 MQ)
- 後端不存的話,「Signal 可以丟」就不成立
本章名詞小卡課後複習用 · 每個名詞一句白話
今天出現的名詞,一句話講完
給工程師的重點出處與標籤
引述來源(materials/core)與原書對照
Triton 本人的講義 / 文章
- 078-mq-intro.pdf.md — MQ 淺談:MQTT 警告、
POST …/messages/{messageId}、?minMsgId=X、stateless AS 需要 MQ、正常 MQ 先存 HDD 才回成功、Signal vs Message、Redis Pub/Sub、面對 WebSocket 斷線(第 4–11 頁) - 062-im-system design.pdf.md — Instant messenger:教學定位與 MVP 範圍(不包「對方已讀」)、RESTful endpoints、
lastTs/nextPageTs、PK (chatroomId, createTs)、WebSocket 的 auth / subscribe、用戶流程的 buffer + sorting + deduplication(第 18 頁)、MQ - 090-restful-demo.pdf.md — UNO 範例:WebSocket 只 relay、有 App Logic 就要部署(第 10 頁)、合乎 RESTful 的架構選擇(第 12 頁)
- 028-RESTful API Design-tw-2.2.pdf.md — HTTP method-POST 的二次 POST、淺談網路的不穩定性、Idempotence(重新呼叫)、中國象棋「足夠完整的資料」
- 113-喵的 backend 測驗.md 第 6–7 題 · 073-lesson3.pdf.md GCM / APNS · 131-喵談 jwt和Session ID.md 主文第 1 點(留言不引) · 017-High Availability stateful component vs stateless component.md · 138-喵談 rabbitMQ 和 kafka.md
上課筆記:009 System Design on a MVP IM(Roy 的 Notion,📝 非原文;其中的 ChatGPT 分享連結不引)。不引用:040(Clarence 的心得筆記)、048(Roy 的專案報告)、131 的留言者。
循序漸進(文組版)的頁面
學習地圖(第 3 頁);延伸基礎 12 階:local database(4)、source of truth(5)、HTTP / WebSocket(9,快速複習,連到 03 第 12 章)、idempotency key(17)、message status(19)、ordering(24)、outbox(28)、push notification(36)、E2E encryption(39)、sync(45)、Signal / Message(47,快速複習);小結(16、27、41、50);名詞小卡(52)。阿明與小美是虛構情境,秒數與時鐘偏差是示意;E2E 一頁是一般原理的白話版,原書與 Triton 都沒有細講。
一個可以直接問自己的問題
你的 App 重連時,WebSocket 先到的那幾則和補拉的 GET 重疊了,畫面上會不會出現兩次?POST 的回應沒回來,重送時 server 認不認得出來?
原書對照
Mobile System Design Interview Ch.4 Chat app。開頭與 Figure 1(第 6 頁,logo 不重繪);Step 1 問答(6)、Requirements(7)、UI sketch 與 Figure 2(8);Step 2 Client and backend expectations 與 Figure 3(10)、Polling / Long polling 與 Figure 4–5(11)、SSE / WebSocket 與 Figure 6–7(12)、Messaging protocols(13)、Table 1(14)、決策與 Figure 8(15)、Client-initiated requests(18)、Data models(20)、Real-time features(21);Step 3 架構與 Figure 9(22)、Data storage 與 Eviction policy(23);Step 4 Message lifecycle 與 Figure 10(25)、Message ordering、Table 2、messageId responsibilities(26)、Sending messages(29)、Data flow 與 Figure 11(30)、Delivery failures(31)、Figure 12(32)、SQLite(33)、Figure 13(34)、Challenges(35)、Push notifications 與 Figure 14(37–38);Step 5 Wrap-up(40)。Figure 2–14 依圖說與 alt 描述重繪,不是原圖。
原書內文的小出入(簡報已註明)
「five critical areas」只列四項;HTTP 寫成經過 Local DataSource;新 Message 的「RECEIVED status」不在 enum 裡;SENT 定義用了 send_messages event;message_read vs read_messages;沒有 DELIVERED event;Users 的 CREATE TABLE 多一個逗號;MessageRequests 沒有 created_at。