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 階。每一階只用前面講過的東西。

  1. 1local database手機裡的信件抽屜
  2. 2source of truth正本在誰手上
  3. 3HTTP手機先開口
  4. 4WebSocket不掛斷的門鈴線
  5. 5idem­potency key信封上的編號
  6. 6message status回條:一勾兩勾
  7. 7ordering手錶不準怎麼排
  8. 8outbox寄件匣
  9. 9push notification總機叫醒手機
  10. 10E2E encryption上鎖的盒子
  11. 11sync出隧道補信
  12. 12Signal / Message門鈴 vs 信

第 1–4 階 · 信放哪、誰先開口

要回答:正本在手機還是後端?server 怎麼主動通知手機?

第 5–7 階 · 一封信的編號與回條

要回答:重寄怎麼不變兩封?勾勾怎麼變?手錶不準怎麼排?

第 8–10 階 · 寄件匣、總機、上鎖

要回答:沒寄出的信放哪?App 沒開怎麼叫醒?郵局能偷看嗎?

第 11–12 階 · Triton 的補信

要回答:出隧道之後,漏掉的和重複的怎麼辦?

全程只用一個情境:阿明在捷運隧道裡傳「我到了」給小美(虛構)

手機 = client信件抽屜 = SQLite chats.db寄件匣 = MessageRequests郵局 = backend回條 = status門鈴 = WebSocket總機 = FCM / APNs書籤 = lastSyncedMessage / minMsgId

每爬 3 階左右,有一頁「到這裡你已經會了」。

延伸基礎第 1 階 · local database懂的人可以跳過

  1. local database
  2. source of truth
  3. HTTP
  4. WebSocket
  5. idempotency key
  6. message status
  7. ordering
  8. outbox
  9. push notification
  10. E2E encryption
  11. sync
  12. Signal / Message

捷運隧道裡沒訊號,還翻得到昨天的信嗎?

① 先想像

有人把收到的信都收進家裡的抽屜。有人什麼都不留,每次想看就跑去郵局調。

你猜猜看:阿明在隧道裡沒訊號,打開聊天 App 往上滑,看得到小美昨天說的話嗎?

③ 這叫做 local database、SQLite

local database:存在手機自己身上的資料庫,就是抽屜。SQLite:手機上最常用的一種,一個檔案就是一整個資料庫。

④ 跟這章的關係

原書把所有對話存在手機的 SQLite 檔 chats.db(第 23 頁)。「沒網路也能翻紀錄」是需求之一。

② 動手玩:信放在哪裡?

—等了多久(示意)

延伸基礎第 2 階 · source of truth懂的人可以跳過

  1. local database
  2. source of truth
  3. HTTP
  4. WebSocket
  5. idempotency key
  6. message status
  7. ordering
  8. outbox
  9. push notification
  10. E2E encryption
  11. sync
  12. Signal / Message

手機掉進水裡,舊信還找得回來嗎?

① 先想像

郵局可以「送到就銷毀」,也可以「留一份底」。阿明的手機昨天掉進水裡。

你猜猜看:郵局送到就銷毀。阿明換新手機,小美上個月寄來的 10 封信還在嗎?

③ 這叫做 source of truth、relay

source of truth:正本,有疑問時以它為準。relay:轉運站,只負責轉交,送到就不留。

④ 跟這章的關係

原書:手機是正本,後端只是 relay(像 WhatsApp)。Triton 的設計反過來,第 49 頁對照。

② 動手玩:10 封已送到、2 封還在路上

—新手機拿回幾封(共 12 封)

原書 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

這一步要解決的問題使用者會看到哪幾個畫面?畫面決定手機要存哪些資料。

📖 原書 Figure 2聊天 App 的基本草圖(依原書內容重繪成 wireframe)

📖 原書 左邊是 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 章講過,懂的人可以跳過

  1. local database
  2. source of truth
  3. HTTP
  4. WebSocket
  5. idempotency key
  6. message status
  7. ordering
  8. outbox
  9. push notification
  10. E2E encryption
  11. sync
  12. 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

這一步要解決的問題信一定經過郵局轉交。難的是反方向:郵局怎麼主動通知收件人?

📖 原書 Figure 3聊天系統中 client 與 server 的互動(依原書內容重繪)

文組翻譯

你到郵局寄信很簡單:走過去交給櫃台(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 只能手機先開口。最簡單的辦法:一直問。

📖 原書 Figure 4Polling strategy(依原書內容重繪)

文組翻譯: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 有事就說?

📖 原書 Figure 6Server-Sent Events strategy(依原書內容重繪)

📖 原書 SSE

Server 透過一條 HTTP 連線推更新給 client。為了不因閒置而 timeout,server 會定期送一行冒號開頭的 comment 保持連線。

  1. Client 對 SSE endpoint 發 HTTP GET,Accept: text/event-stream
  2. Server 回 200 OK、Content-Type: text/event-stream,連線保持開著
  3. Server 用簡單的文字格式持續送 event
  4. 斷線時 client 通常自動重連,帶 Last-Event-ID header,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

四種做法的取捨:耗電、延遲、伺服器負擔

這一步要解決的問題四種做法各犧牲了什麼?手機最在意的是耗電。

0一小時喚醒網路幾次0白跑幾次0平均晚到0%相對耗電(最耗的 = 100%)
📖 Table 1AdvantagesDisadvantages
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 只用在即時功能

這一步要解決的問題送和收,要用同一條線,還是分開?

📖 原書 Figure 8Sender 用 https、Receiver 用 wss(依原書內容重繪)

📖 原書 選擇 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

  1. local database
  2. source of truth
  3. HTTP
  4. WebSocket
  5. idempotency key
  6. message status
  7. ordering
  8. outbox
  9. push notification
  10. E2E encryption
  11. sync
  12. Signal / Message

到這裡你已經會了:信放哪、誰先開口

下一階要解決的問題

決定好「HTTP 送」之後:寄出一封信要帶什麼?回條沒回來、重寄了,小美會不會收到兩封?

延伸基礎第 5 階 · idempotency key懂的人可以跳過

  1. local database
  2. source of truth
  3. HTTP
  4. WebSocket
  5. idempotency key
  6. message status
  7. ordering
  8. outbox
  9. push notification
  10. E2E encryption
  11. sync
  12. 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
原書表格是 Kotlin、Swift 兩欄並列
data class NewMessageRequest
  requestId: Long
  toUserId: Long
  content: String
  createdAt: String
data class NewMessageResponse
  message: Message
  fromMessageRequestId: Long?

📖 原書 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懂的人可以跳過

  1. local database
  2. source of truth
  3. HTTP
  4. WebSocket
  5. idempotency key
  6. message status
  7. ordering
  8. outbox
  9. push notification
  10. E2E encryption
  11. sync
  12. Signal / Message

時鐘、一個勾、兩個勾、藍勾,各代表什麼?

① 先想像

寄掛號信,你會一路收到消息:還在你家、郵局收件了、送到小美家了、小美拆開了。

你猜猜看:「我到了」旁邊只有一個灰勾。代表什麼?

③ 這叫做 message status、read receipt

message status:每則訊息現在走到哪一站。read receipt:已讀回條,對方打開時傳回來的通知。

④ 跟這章的關係

原書 Message 的 status 有四個值:PENDING、SYNCED、DELIVERED、READ(下一頁)。

② 動手玩:「我到了」走完四站

  1. 按下送出:還在阿明手機裡(時鐘)
  2. 郵局收到了(一個灰勾)
  3. 送到小美的手機(兩個灰勾)
  4. 小美打開來看(兩個藍勾)

原書 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
data class ConversationPreview
  contact: User
  lastMessageSummary: String
  lastMessageTimestamp: String
  unreadCount: Int

data class User
  id: Long
  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

📖 原書 status 決定畫面上的訊息圖示

PENDINGBackend 還沒收到
SYNCEDBackend 收到了
DELIVEREDBackend 已送到收件人
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 裡面分成哪幾塊,各管什麼?

📖 原書 Figure 9聊天系統的高階 mobile 架構(依原書內容重繪)

📝 原書 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懂的人可以跳過

  1. local database
  2. source of truth
  3. HTTP
  4. WebSocket
  5. idempotency key
  6. message status
  7. ordering
  8. outbox
  9. push notification
  10. E2E encryption
  11. sync
  12. Signal / Message

兩支手機的時鐘差了一分鐘,信要怎麼排?

① 先想像

小美的手錶是準的,阿明的手錶慢 60 秒。兩人都在信上寫「現在幾點」。

你猜猜看:小美 12:00:30 問「晚餐吃什麼?」,阿明 20 秒後回「火鍋?」,手錶寫 11:59:50。照信上的時間排,誰在上面?

③ 這叫做 createdAt、messageId

createdAt:手機自己寫的時間,可能不準。messageId:郵局(server)蓋的流水號,越晚越大。

流水號的完整版:03 第 12 章第 18 頁

④ 跟這章的關係

原書:有流水號的照 messageId;還沒寄出的照 createdAt,放最後(第 26 頁)。

② 動手玩:拉阿明的手錶

原書 Step 4Design deep dive · Message lifecycle · Figure 10

一則訊息的一生:先上畫面,再等 server 給 ID

這一步要解決的問題「我到了」從按下送出到小美看到,中間經過哪幾站?

📖 原書 Figure 10Message lifecycle in the chat system(依原書內容重繪)

📖 原書 Deep dive 要談:訊息在螢幕上的排序、送出訊息、DB 實作細節、push notifications。(原文寫「five critical areas」,但只列了這四項。)

📖 原書 照時間排看起來簡單,在手機上有四個難題:網路延遲讓訊息亂序抵達;離線時的訊息要在重連後整合進來;不同裝置的系統時鐘可能不一樣;過去的訊息和新的更新都要保持一致的順序。

  1. Messages repository 立刻建立並儲存新訊息,UI 馬上顯示,給即時回饋
  2. Repository 交給 Messages remote data source,包成 NewMessageRequest,用 HTTP 送到 backend
  3. Backend 處理 request,替訊息產生唯一的 messageId
  4. Backend 同時做兩件事:4.1 回 201 和 NewMessageResponse 給 sender;4.2 通知收件人:在線上就走 WebSocket,不在就走 push notification
  5. 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 byAdvantagesDisadvantages
messageIdServer 產生,各 client 順序一致;backend 仍是 source of truthBackend 產生之前 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

  1. local database
  2. source of truth
  3. HTTP
  4. WebSocket
  5. idempotency key
  6. message status
  7. ordering
  8. outbox
  9. push notification
  10. E2E encryption
  11. sync
  12. Signal / Message

到這裡你已經會了:一封信的編號與回條

下一階要解決的問題

還沒寄出的信,要放在哪裡才不會不見?寄失敗了怎麼辦?

延伸基礎第 8 階 · outbox懂的人可以跳過

  1. local database
  2. source of truth
  3. HTTP
  4. WebSocket
  5. idempotency key
  6. message status
  7. ordering
  8. outbox
  9. push notification
  10. E2E encryption
  11. sync
  12. Signal / Message

飛航模式下打的字,App 被關掉之後還在嗎?

① 先想像

沒訊號時寫好的信,先放寄件匣。寄件匣可以只記在腦子裡,也可以寫在紙上收進抽屜。

你猜猜看:飛航模式下連打 3 則,接著 App 被手機關掉。重開 App、關掉飛航模式,3 則還會寄出嗎?

③ 這叫做 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

📖 原書 網路可能讓訊息送不到,要追蹤三種情況:還沒送、傳送中、送失敗。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 說收到了,手機裡要更新哪些東西,畫面才變一個勾?

📖 原書 Figure 11Client receiving message confirmation data flow(依原書內容重繪)
  1. Messages Remote DataSource 收到 backend 的成功回應
  2. Remote DataSource 把結果交給 Messages Repository
  3. Repository 做第一個 DB 操作:刪掉暫時的 message request
  4. 第二個 DB 操作:用 backend 確認的 ID 建立新的 Message
  5. DB 變動自動觸發更新,流到 Conversations Repository
  6. 再到 Conversation State Holder
  7. Conversation Screen 顯示訊息送達成功

📖 原書 已讀回條也是同一條路

  1. Backend 透過 WebSocket 送 read_messages event
  2. Client 的 Real-time Updates Remote DataSource 收到
  3. 通知 Messages Repository 狀態變了
  4. Repository 更新本地 DB 的訊息狀態
  5. 變動流到 UI,更新已讀圖示

(前面 event 清單叫 message_read,這裡寫 read_messages,原書用詞不一。)

白話:DB 變動自動觸發更新=抽屜一改,畫面自己跟著變,不用另外通知(reactive programming)。

原書 Step 4 · 動手玩Message delivery failures · Exponential backoff

送失敗不要馬上放棄,但也不要一直狂按

這一步要解決的問題寄失敗了,多久再寄?寄幾次才放棄?

0總共送了幾次0白送幾次–何時成功

📖 原書 有時某個 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 不要太累

這一步要解決的問題寄件匣、重試、逾時,要交給誰負責?

📖 原書 Figure 12Data layer design update(依原書內容重繪)

🔍 業界

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 合併成一串對話

這一步要解決的問題資料拆成兩張表,畫面怎麼看到一串對話?

📖 原書 Figure 13Data layer design update:只畫 repositories 與 local data source 相關元件(依原書內容重繪)

📖 原書 三張新表各自是一個 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懂的人可以跳過

  1. local database
  2. source of truth
  3. HTTP
  4. WebSocket
  5. idempotency key
  6. message status
  7. ordering
  8. outbox
  9. push notification
  10. E2E encryption
  11. sync
  12. Signal / Message

App 被滑掉了,小美的訊息怎麼叫醒你?

① 先想像

App 開著時,門鈴(WebSocket)直接響。App 被滑掉,門鈴的線也斷了。這時只剩手機系統自己的那支總機。

你猜猜看:阿明把聊天 App 滑掉了。小美傳來「我到了」,誰讓手機跳出通知?

③ 這叫做 push notification、FCM / APNs

push notification:App 沒開也會跳出來的通知。FCM / APNs:Google 和 Apple 各自的推播總機。

後端怎麼打給總機:03 第 10 章第 8 頁

④ 跟這章的關係

原書:WebSocket 只給 App 開著的人;沒連上的,後端打給 FCM / APNs(下一頁)。

② 動手玩:阿明的 App 在哪個狀態?

郵局(backend)門鈴線 WebSocket總機 FCM / APNs阿明的手機

原書 Step 4Push notifications · Sending from the backend · Figure 14

App 沒開的時候,靠作業系統的那條線叫醒你

這一步要解決的問題App 沒開時,後端怎麼叫醒手機?

📖 原書 Figure 14聊天系統中與推播相關的元件(依原書內容重繪)

文組翻譯

每支手機都和作業系統的「總機」(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懂的人可以跳過

    1. local database
    2. source of truth
    3. HTTP
    4. WebSocket
    5. idempotency key
    6. message status
    7. ordering
    8. outbox
    9. push notification
    10. E2E encryption
    11. sync
    12. 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

    1. local database
    2. source of truth
    3. HTTP
    4. WebSocket
    5. idempotency key
    6. message status
    7. ordering
    8. outbox
    9. push notification
    10. E2E encryption
    11. sync
    12. Signal / Message

    到這裡你已經會了:原書的整個設計

    下一階要解決的問題

    原書全部講完。出了隧道,門鈴和補信同時進來,漏掉的和重複的怎麼辦?接下來是 Triton。

    Triton 觀點先看全貌

    這一次原書和 Triton 大方向一致,差在「斷線之後」

    你猜猜看:原書和 Triton 都選了「HTTP 送、WebSocket 收」。兩邊最大的不同會在哪裡?

    ✅ 一致 原書做對的地方

    • 送訊息走 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 的理由是:部署時不要斷線

    0斷線的手機(8 支中)
    auth <jwt>
    subscribe chatroom <chatroomId>
    unsubscribe chatroom <chatroomId>

    🗣️ 062 第 17 頁Triton 的 WebSocket 從 client 收的指令只有這三個

    你猜猜看:如果送訊息也走 WebSocket,部署新版「發訊息」程式時,8 支手機會怎樣?

    📖 原書「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 認得出是同一則嗎?

    1. 離線時打了「我到了」:存進寄件匣,ID 先決定好
    2. 重新連線:Scheduler 發出 POST
    3. Server 寫進 DB 成功,但 201 回應掉在隧道裡
    4. Client 等不到回應 → timeout → 原封不動再 POST 一次
    5. Server 收到第二次 POST
    6. Client 收到回應,寄件匣清空

    你猜猜看:server 已寫進 DB,201 卻掉在隧道裡。手機原封不動再 POST,沒帶任何 ID。DB 會有幾筆?

    「用戶要寫新留言 – 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懂的人可以跳過

    1. local database
    2. source of truth
    3. HTTP
    4. WebSocket
    5. idempotency key
    6. message status
    7. ordering
    8. outbox
    9. push notification
    10. E2E encryption
    11. sync
    12. Signal / Message

    出了隧道,漏掉的信怎麼補回來?

    ① 先想像

    阿明進隧道時,最後看到第 40 封。隧道裡小美又寄了 3 封,門鈴響了,阿明聽不到。

    你猜猜看:出隧道後,門鈴會把漏響的 3 次重響一遍嗎?

    ③ 這叫做 sync、dedupe

    sync:照書籤把漏掉的補齊。dedupe:同一封收到兩次,丟掉一封。

    書籤的完整版:03 第 12 章第 24 頁dedupe:第 43 頁

    ④ 跟這章的關係

    原書的 ?lastSyncedMessage=、Triton 的 ?minMsgId= 都是這張書籤(下一頁)。

    ② 動手玩:隧道、補信、遲到的門鈴

    40書籤:看到第幾封

    阿明的手機

    郵局(有留底)

    Triton 的做法 · 一步一步062「用戶流程」 · 078「面對WebSocket斷線」

    出隧道之後:先收著、再 GET 補、最後 sort + dedupe

    Server DB(chatroom 42)

    WebSocket buffer

    GET ?minMsgId=40 的 response

    你猜猜看:出隧道時 WebSocket 先收到 #44–#46,GET 又回 #41–#45。收到就直接顯示,畫面會怎樣?

    「呼叫 /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 章講過,懂的人可以跳過

    1. local database
    2. source of truth
    3. HTTP
    4. WebSocket
    5. idempotency key
    6. message status
    7. ordering
    8. outbox
    9. push notification
    10. E2E encryption
    11. sync
    12. Signal / Message

    門鈴漏響,和信弄丟,哪個比較嚴重?

    ① 先想像

    門鈴沒聽到,信還在郵局,自己去拿就好。信如果在路上掉了,就真的沒了。

    你猜猜看:郵局有留底。門鈴(WebSocket)漏響一次,小美的信會不見嗎?

    ③ 這叫做 Signal、Message

    Signal:門鈴,要快,漏了沒關係。Message:信本身,可以慢,但絕對不能丟。

    完整版:03 第 12 章第 40 頁

    ④ 跟這章的關係

    Triton:聊天室裡 WebSocket 傳的是 Signal(下一頁)。前提是郵局真的有留底。

    ② 動手玩:門鈴漏響一次

    Triton 補充078 MQ 淺談 · Signal vs Message

    門鈴可以漏響,信不能掉:手機上的寄件匣也是 Message

    你猜猜看:原書 WebSocket 的 new_message 漏了一則。最壞會怎樣?

    「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、requestIdPOST /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 簡報。

    你猜猜看:原書的後端送到就刪。阿明換了新手機,三個月前的對話從哪裡來?

    🔭 推論 原書自己點出、卻沒解的問題

    原書列 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

    1. local database
    2. source of truth
    3. HTTP
    4. WebSocket
    5. idempotency key
    6. message status
    7. ordering
    8. outbox
    9. push notification
    10. E2E encryption
    11. sync
    12. Signal / Message

    到這裡你已經會了:Triton 怎麼補信

    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 可以丟」就不成立

    本章名詞小卡課後複習用 · 每個名詞一句白話

    今天出現的名詞,一句話講完

    client / backend手機那一端/後端的電腦(郵局)
    local database存在手機自己身上的資料庫(抽屜)
    SQLite手機上最常用的資料庫,一個檔案就是一整個
    source of truth正本,有疑問時以它為準
    relay轉運站,只轉交、送到就不留
    DAU每天至少打開一次 App 的人數
    HTTP / REST API手機先問、server 才答的約定/照這個約定開的窗口
    polling / long polling每隔一陣子去問/問了就坐著等
    SSEserver 單向一直推的一條 HTTP 線
    WebSocket開著不掛斷、兩邊都能先開口的線
    TCP / UDP掛號信(照順序、掉了重寄)/廣播(快但可能漏)
    keep-alive偶爾輕敲一下,確認線還在

    給工程師的重點出處與標籤

    引述來源(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。

    ← → 翻頁 · S 講者備註 · D 深/淺色
    1 / 1目錄