
前言
嗯,你們等的大招。本文同時發布了 CTPersistance 與 CTJSBridge 兩個庫,使用上遇到問題歡迎直接給我 issue、PR 或留言,每一則我都會回。
不論服務端還是客戶端,持久化方案都很值得討論。在服務端,持久化的優劣往往直接影響產品效能;而在客戶端,真正涉及持久化的業務需求並不多,多數情況下對效能也沒那麼苛刻。所以我在行動端設計持久化方案時,優先考慮的是可維護性與可擴展性,效能調優反而排在後面。因此本文不會單獨開一節講效能,而是把它穿插在各個小節裡,有興趣的可以留意。
持久化方案對整個 App 架構的影響,和網絡層方案類似——它往往就是專案高耦合的元兇。我一向是去 Model 化的實踐者,而在持久層去 Model 化的過程中,我引入了 Virtual Record 的設計,文中會詳細說明。
本文要談五件事:
針對資料庫儲存這塊,我另外寫了 CTPersistance,目前大致能覆蓋多數持久層需求,同時也是 Virtual Record 這個思路的示範實作。它可以直接透過 CocoaPods 引入,用起來若有問題,歡迎多給我 issue。
依需求決定持久化方案
一旦有持久化需求,可選方案其實不少:NSUserDefaults、Keychain、檔案,以及基於資料庫的無數變體。所以第一步永遠是判斷「該用哪一種」。
NSUserDefaults
小規模、弱業務相關的資料放這裡剛好。資料量大、與業務強相關的內容就不適合了。順帶抱怨一下,我曾見過某些龐大 App 完全沒有經過設計的持久層,於是各業務線各顯神通,甚至有人把大部分業務資料一股腦塞進 NSUserDefaults——問起原因,得到的答案居然是「寫起來方便」。
Keychain
Keychain 是 Apple 提供的可逆加密儲存機制,常用於各類密碼場景。此外,只要系統沒重裝,App 卸載後 Keychain 裡的資料仍會保留,加上能被 iCloud 同步,所以大家都愛在這裡存使用者唯一標識。需要加密、需要走 iCloud 的敏感小資料,放這裡最合適。
檔案儲存
檔案儲存包含 Plist、archive、Stream 等方式。結構化或需要方便查詢的資料通常用 Plist;archive 適合存取頻率低但體積大、或讀出來希望直接物件化的資料,因為它會把物件及其關係序列化,解碼(解壓或物件化,取決於 encode/decode 的實作)相對耗時;Stream 就是一般檔案儲存,適合存圖片這類使用頻率高、資料量又不算太大的內容。
資料庫儲存
資料庫的花樣最多。Apple 自帶 Core Data,業界也有無數替代方案,但真正在 iOS 領域流通的,除了 Core Data 就是 FMDB。資料庫的價值在於增刪改查方便:當資料帶有狀態與類別時,尤其這些狀態與類別還高度綁定業務,就該用資料庫。畢竟你不可能靠遍歷檔案系統去篩出「某狀態、某類別」的資料,成本太高。反過來說,大量資料(圖片、長文)也不適合直接進資料庫,一般做法是在庫裡存一個檔名,指向實際檔案。若真要全文索引,建議掛個 API 交給服務端做。
總的來說,NSUserDefaults、Keychain、File 這三種方案都很基礎,分清楚場合別亂用就好,它們之上也長不出太複雜的衍生需求。真正複雜的變體多半得靠資料庫方案來滿足,所以本文的重心放在資料庫相關的架構設計。
持久層實作時要注意的隔離
設計持久層時,我會關注四個面向的隔離:
1. 持久層與業務層的隔離
談到這裡,得先把 Model 這個詞說清楚。
我在/View 層設計裡談過胖 Model 與瘦 Model,並且表明自己傾向胖 Model;而在網絡層設計裡,我又用了去 Model 化的思路來設計 APIManager 與業務層的交互。這兩件事看似矛盾,實際上在持久層方案裡是彼此配合的。之所以把解釋留到這裡,是因為這個話題牽涉面太廣,放在網絡層那篇講反而失焦。
和不同領域的架構師交流時,我發現大家常把 Model 與 Model Layer 混用,結果討論到最後根本不在同一個點上:我說 Model,他跟我說 Model Layer;我改說 Model Layer,他又跳回 Model,於是聊不下去。對架構師來說,這兩個概念分不清楚,設計出來的東西品質一定受影響。解法很簡單——把 Model 唸成 Data Model,再跟 Model Layer 擺在一起,界線立刻清楚。
Data Model
Data Model 處理的問題領域是「業務資料的建模」以及「這個模型在程式碼中的表徵方式」。兩者相輔相成:業務本身的特點決定了建模方案,建模方案又決定了表徵方式。同一批資料,抽象出的邏輯實體大致相同,但表徵方式可以差很多:位元組流(TCP 封包)、字串流(JSON、XML)、物件流;而物件流又分通用資料物件(NSDictionary)與業務資料物件(HomeCellModel)。習慣上,我們講「Model 化」時通常指的都是最後那一種;而「去 Model 化」則是更多地使用通用資料物件來表徵資料,不把業務資料物件放在優先位置——某種意義上,通用資料物件有點像泛型。
Model Layer
Model Layer 處理的問題領域是資料的增刪改查以及相關業務處理。採用瘦 Model 思路時,差不多到 CURD 為止;胖 Model 還會替需要資料的上層提供增刪改查以外的服務與方案,例如快取、資料同步、弱業務處理等。
我的傾向
我偏向去 Model 化:網絡層用 reformer 實作,持久層則用 Virtual Record。具體的 Model 很容易把耦合帶進來,弱化 Model 概念能替業務接入留出空間,同時也能靠去 Model 的設計把強弱業務區分開——這在後續的程式碼遷移與維護裡至關重要。很多架構腐化得很快,就是因為架構師沒意識到區分強弱業務的重要性。
所以說回來,持久層與業務層的隔離,本質上是靠強弱業務的隔離達成的。Virtual Record 正是因為去 Model 化,才能同時做到隔離與可交互。它具體長什麼樣,後面再拆。
2. 資料庫讀寫隔離
網站架構做讀寫分離是為了提高響應速度;iOS 應用架構做讀寫隔離,主要目的卻是提高程式碼的可維護性。這是兩個領域對架構師側重點要求不同的地方。
這裡所謂的讀寫隔離,並不是把讀操作與寫操作拆開,而是畫出一條界線:界線以外的資料模型不可寫、不可改,或者改了也不影響資料庫內容;界線以內的資料才可寫可改。實務上,這條界線通常會與持久層/業務層的界線重合——業務層從持久層拿到資料後一律不可改,只有持久層內部的操作才會作用到資料庫檔案。
Apple 的 Core Data 在這件事上並沒有做隔離,資料一律以 NSManagedObject 丟出來,業務工程師稍不留意改動某個屬性,save 的時候就寫進去了。另外,當你想對所有增刪改查做 AOP 切片時,Core Data 的實作會變得非常複雜。
整體看來,Core Data 對多數需求而言是過度設計。我當年做聊天模組的持久層時就用了 Core Data,為了讀寫隔離,得把丟出來的 NSManagedObject 全轉成普通物件;加上聊天記錄業務相當複雜,用 Core Data 之後為了滿足需求不得不引入大量 hack,反而降低了可維護性、拉高了接手者的學習曲線。讀寫隔離還有一個附加好處:寫入被集中在一個固定位置,加 AOP 切片時就很好落點,這在講資料同步方案時會看到實際應用。
3. 多執行緒導致的隔離
Core Data
Core Data 要求多執行緒場景下為非同步操作另開一個 NSManagedObjectContext,把 ConcurrencyType 設為 NSPrivateQueueConcurrencyType,再將它的 parentContext 指向主執行緒的 Context。這比直接用原生 SQLite 處理多執行緒輕)=(不少。要注意的是,跨執行緒傳遞時不能丟 NSManagedObject 的指標,得傳 NSManagedObjectID——這屬於多執行緒環境下的物件傳遞隔離。
SQLite
純 SQLite 本身支援多執行緒,並提供三種模式:Single Thread、Multi Thread、Serialized。Single Thread 不是執行緒安全的,不提供任何同步機制;Multi Thread 要求 database connection 不能跨執行緒共用,其餘沒什麼限制;Serialized 顧名思義由一個序列佇列執行所有操作,對使用者來說除了慢一點幾乎沒有限制。SQLite 多數情況下預設就是 Serialized。
從 Core Data 在多執行緒下的表現判斷,它以 SQLite 為載體時用的應該是 Multi Thread 模式。而 SQLite 在這個模式下使用的是讀寫鎖,而且是對整個資料庫加鎖,不是表鎖也不是行鎖——這一點請架構師們特別留意。如果對響應速度要求很高,建議開一個輔助資料庫,先把大的寫入任務寫進去,再拆成幾個小任務見縫插針地不定時往主庫補寫,寫完再把輔助庫刪掉。
不過就實務經驗看,本地 App 的讀寫量通常不大,注意好幾個關鍵點後一般不太影響使用者體驗。因此相比 Multi Thread,我認為 Serialized 的性價比更高:程式碼好寫好維護,效能損失有限。為了幾十毫秒而犧牲可維護性,我覺得不划算。
Realm
我還沒來得及深入研究,先不妄言。
4. 資料表達與資料操作的隔離
這是最容易被忽略的一點,而它做不做得到,直接決定了整個程式的可擴展性。
長期以來我們都很習慣 Active Record 風格的資料操作與表達:
Record *record = [[Record alloc] init]; record.data = @"data"; [record save];
或者:
Record *record = [[Record alloc] init]; NSArray *result = [record fetchList];
也就是讓一個物件同時映射「資料庫中的一張表」,以及「這張表中的某一筆資料」,然後對物件操作就等於對表與資料操作。問題就在這裡:這兩種映射職責被混在了一起。我見過不少框架(不限 iOS,Python、PHP 圈也一樣)都這樣處理。若沿襲這種方式,在胖 Model 實踐下會讓強弱業務難以區分,遷移與複用幾乎無從談起。
強弱業務分不開,最大的代價就出在程式碼複用與遷移上。持久層裡的強業務對 View 層業務的高耦合無法避免,而弱業務只向下耦合、不向上耦合;我們想複用的通常是弱業務。強弱一旦混在一起,複用與遷移都會變成惡夢。
另一個問題是:現實中資料在 view 層的表達方式千變萬化,可能是某個 View,也可能是某個自訂物件。如果一律用「映射資料庫表的資料物件」去承載,這種多樣性就被抹平了,每次使用資料的地方都得多一層轉換。
我認為這種坏习惯的根源在於:物件對「資料表」的映射,和物件對「資料表達」的映射,長得實在太像,尤其在表達 Column 時幾乎一模一樣。要區分兩者,關鍵判準是:這個映射物件的操作著手點,相對資料表而言是對內還是對外。對內操作只涉及當前這張表,映射給資料表模型很合適;對外操作可能牽動其他資料表,就不該放進資料表物件裡。
所以我的實作是:以資料表為單位封裝操作,再針對資料記錄做表達封裝。資料表上的操作都是針對記錄的普通增刪改查,屬於弱業務;資料記錄只是資料的表達方式,涉及它的複雜操作應該交給資料層裡負責強業務的物件執行。
持久層與業務層的交互方式
說到這裡就不得不提 CTPersistance 與 Virtual Record 了。先看整體分層:
+----------------------------------------------------------------+
| View Layer |
| LogicA / LogicB / LogicC <--> Virtual Record |
+------------------------------+---------------------------------+
|
+----------------------------------------------------------------+
| Data Logic Layer |
| Strong Logics: DataCenterA / DataCenterB / DataCenterC |
| Weak Logics : Table1 / Table2 / Table3 |
+------------------------------+---------------------------------+
|
+----------------------------------------------------------------+
| Data Persistance Layer |
| QueryCommand -> Database Pool -> DatabaseA / DatabaseB |
+----------------------------------------------------------------+
持久層裡有專門對接 View 層模組或業務的 DataCenter,兩者之間透過 Record 交互。DataCenter 對上層提供「業務友善」的接口,這通常屬於強業務,例如「依使用者篩選條件回傳符合的資料」。為了完成這個接口,DataCenter 會調度各個 Table、跑一連串業務邏輯,最後生成 record 物件交給 View 層。
DataCenter 在過程中會做資料組裝與跨表操作。資料組裝因 View 層需求而異,是強業務;跨表操作本質上是各個單表操作的組合,DataCenter 負責調度它們取得基礎資料,因此單表操作屬於弱業務,由 Table 映射物件負責。Table 透過 QueryCommand 生成 SQL,交給資料庫引擎查詢,再把結果交回 DataCenter。
DataCenter 與 Virtual Record
DataCenter 其實是一個業務物件,是整個 App 裡持久層與業務層之間的膠水:對上開放業務友善的接口,對下調度持久層的弱業務邏輯與資料記錄,完成強業務後把結果交回去。正因為它夾在中間,它執行業務邏輯所依賴的載體,必須同時能被業務層與持久層理解。
CTPersistanceTable 封裝了弱業務邏輯,由 DataCenter 呼叫來操作資料;而 Virtual Record 就是那個「雙向都能理解」的資料載體。
Virtual Record 其實不是一個物件,它只是一個 protocol——這就是它「Virtual」的原因。任何物件只要實作這個 protocol,就能直接被持久層當成 Record 操作,所以它也是一個 Record,連起來就是 Virtual Record。因此它的實作者可以是任何物件,通常是業務層物件;而業務層裡最常見的資料表達形式是 View,所以實作者往往就是一個 View。
對照傳統流程:先從資料庫取資料,Model 化成物件,丟給 Controller,再由 Controller 轉成 View,然後才做後續操作。Virtual Record 的步驟類似,唯一的不同是整個過程中不需要一個中間物件來做資料表達——不同表達方式由各自的 Virtual Record 實作者自己完成,不必把這些程式碼塞進 Controller,這就是去 Model 化。若日後這段轉換邏輯需要複用,直接複用 Virtual Record 就好,非常省事。
要用好 Virtual Record,關鍵在於 DataCenter 提供的接口對業務夠友善、有足夠的業務上下文。因此 DataCenter 通常由 Controller 持有;如果整個 App 只有一個 DataCenter,那其實不是好事。我見過不少 App 的持久層就是一個全域單例,所有業務都走它,這做法相當痛苦。DataCenter 需要依業務高度分化,每個大業務一個 DataCenter,掛在相關 Controller 之下,例如 SettingsDataCenter、ChatRoomDataCenter、ProfileDataCenter;同時要注意幾個 DataCenter 之間最好不要有業務重疊。若某個 DataCenter 業務實在太大,就再往下拆;單個小業務都很大,就拆成各個 Category(具體做法可參考我框架裡 CTPersistanceTable 與 CTPersistanceQueryCommand 的實踐)。
如此一來,要遷移涉及持久層的強業務,只需搬走 DataCenter;要遷移弱業務,只需搬走 CTPersistanceTable。
實際場景
假設業務層收集到了使用者的篩選條件:
NSDictionary *filter = @{
@"key1": @{ @"minValue1": @(1), @"maxValue1": @(9) },
@"key2": @{ @"minValue2": @(1), @"maxValue2": @(9) },
@"key3": @{ @"minValue3": @(1), @"maxValue3": @(9) },
};
ViewController 呼叫 DataCenter 對外提供的接口,拿到資料直接展示:
/* in view controller */ NSArray *fetchedRecordList = [self.dataCenter fetchItemListWithFilter:filter]; [self.dataList addObjectsFromArray:fetchedRecordList]; [self.tableView reloadData];
View 層的工作到這裡就結束了。回頭看 DataCenter 怎麼把它做出來:
/* in DataCenter */
- (NSArray *)fetchItemListWithFilter:(NSDictionary *)filter {
// 1. 解析 filter,取得查詢所需的 whereCondition 與 whereConditionParams
// 2. 告訴 Table 物件查完之後要轉成的物件型別
// (統一型別方便日後合併來自不同表的資料)
self.itemATable.recordClass = [Item class];
self.itemBTable.recordClass = [Item class];
self.itemCTable.recordClass = [Item class];
// 3. 透過 Table 物件取得資料 —— 這一步執行的就是弱業務
NSArray *itemAList = [self.itemATable findAllWithWhereCondition:whereCondition
conditionParams:whereConditionParams
isDistinct:NO
error:NULL];
NSArray *itemBList = [self.itemBTable findAllWithWhereCondition:whereCondition
conditionParams:whereConditionParams
isDistinct:NO
error:NULL];
NSArray *itemCList = [self.itemCTable findAllWithWhereCondition:whereCondition
conditionParams:whereConditionParams
isDistinct:NO
error:NULL];
// 4. 組裝資料
NSMutableArray *resultList = [[NSMutableArray alloc] init];
[resultList addObjectsFromArray:itemAList];
[resultList addObjectsFromArray:itemBList];
[resultList addObjectsFromArray:itemCList];
return resultList;
}
大致就是這樣的流程。架構師設計得不好的持久層,通常就是沒有透過 DataCenter 與 Table 把強弱業務分開。有了這層切分,遷移強業務時把 DataCenter 和 Table 一起帶走,只遷移弱業務時帶走 Table 就好。
這裡還要強調一個觀念:把 Table 與 Record 分開。我在架構圖上已經有所體現,但值得再說一次。其實很多持久層框架(包含 Core Data 與 FMDB,也不限於 iOS 領域,CodeIgniter、ThinkPHP、Yii、Flask 也都一樣)都沒有做這個區分。順帶一提,前面我說 Core Data 被過度設計,意思正是:該設計的地方沒設計,不該堆的地方卻堆滿了設計。
最常見的交互場景是:經過一連串邏輯組裝出一個資料物件,再交給持久層處理。這是一對一場景,實作方式跟你想的一樣,CTPersistance 的測試案例裡都是這種,這裡就不細說。既然有一對一,自然也會有多對一與一對多。
多對一場景
「多對一」有兩種理解。第一種:一筆記錄的資料由多個 View 的資料拼成。例如使用者表存了全部資料,但有的 View 只需要暱稱與頭像,有的只需要 ID 與 Token。第二種:View A 與 View B 各自都含有一筆記錄的完整資訊,也就是多個不同物件表達了同一筆 Record。
同時「交互」又分存與取兩個方向。兩種理解的解法其實相同:透過 Merge 操作完成匯總與分發。
存:ViaRecord 協定提供了下面這個方法,望文生義就是「一個 record 與另一個 record 合併」。
- (id<CTPersistanceRecordProtocol>)mergeRecord:(id<CTPersistanceRecordProtocol>)record
shouldOverride:(BOOL)shouldOverride;
當 shouldOverride 為 NO 時,任何一邊的 nil 都會被另一邊的非空值補上;若 merge 過程中兩邊都有值,則由 shouldOverride 決定是否讓傳入參數的資料覆蓋自己;若 shouldOverride 為 YES,即使傳入值是 nil 也會覆蓋。這個方法會回傳合併後的物件,方便串接呼叫。
/* RecordViewA / RecordViewB / RecordViewC 都實作了 mergeRecord:shouldOverride: */ RecordViewA *a; RecordViewB *b; RecordViewC *c; // ... 收集 a、b、c 的邏輯 ... [[a mergeRecord:b shouldOverride:YES] mergeRecord:c shouldOverride:YES]; [self.dataCenter saveRecord:a];
思路就是用 merge 拼出完整資料,而具體怎麼合併由各個 View 自己決定。View 最了解自己的屬性,因此最有條件把自己負責的那部分資料取出來合併;於是這段「湊資料」的程式碼就被分散到各個 View 裡,Controller 保持乾淨,整體可維護性自然提高。若用傳統做法,ViewController 或 DataCenter 裡會散落一堆合併程式碼,又長又難維護。
取:這個說法其實不精準——不論 Virtual Record 如何實作,從資料庫取出的資料一定是完整的。更準確的描述是「取出之後如何分發給不同物件」,用的仍是 mergeRecord:
RecordViewA *a; RecordViewB *b = [[RecordViewB alloc] init]; RecordViewC *c = [[RecordViewC alloc] init]; a = [self.table findLatestRecordWithError:NULL]; [b mergeRecord:a]; [c mergeRecord:a]; return @[a, b, c];
一對多場景
同樣有兩種理解。其一是一個物件包含多張表的資料——這個物件是個大熔爐。以使用者列表為例,使用者相關的表可能有很多張,通常是因為單表 Column 太多,為了維護性與查詢效能而做的「縱切」:依業務場景把一張寬表拆成幾張窄表。但有些頁面仍要展示完整資料,例如使用者詳情頁,於是這個 View 可能同時包含使用者基礎資訊表(暱稱、ID、Token)與詳細資訊表(信箱、手機號)。
其二是一個物件用於展示多種表的資料。例如資料庫裡有二手房、新房、租房三張表,這是一種「橫切」:在保留資料完整性的前提下,把原本資料量龐大的一張表拆成幾張小表。橫切可以依類型切,也可以依 ID 取餘數切——後者擴展性更好,資料表變大時只要換一個更大的除數即可。這三張表在展示時只有細節差異,所以會用同一個 View 呈現。
一個物件包含多張表的資料時:取操作與前面多對一的取法一樣,用 merge 就好。
RecordViewA *a; a = [self.CasaTable findLatestRecordWithError:NULL]; [a mergeRecord:[self.TaloyumTable findLatestRecordWithError:NULL] shouldOverride:YES]; [a mergeRecord:[self.CasatwyTable findLatestRecordWithError:NULL] shouldOverride:YES]; return a;
存操作則要求實作者實作下面這個方法,依傳入的 columnInfo 與 tableName 回傳對應的資料:
- (NSDictionary *)dictionaryRepresentationWithColumnInfo:(NSDictionary *)columnInfo
tableName:(NSString *)tableName;
RecordViewA *a = ......; // a 會依不同 Table 的關注點,自動提供對方感興趣的內容,所以直接存就好 [self.CasaTable insertRecord:a error:NULL]; [self.TaloyumTable insertRecord:a error:NULL]; [self.CasatwyTable insertRecord:a error:NULL];
用過 Virtual Record 你會發現程式碼量一下少掉很多,那些原本亂七八糟用來拼條件的邏輯全被分散到各個虛擬記錄的實作裡,維護因此變得輕鬆。若用傳統做法,存取之前少不了一大段邏輯,一旦要遷移,這段也得跟著搬,非常頭痛。
一個物件用於展示多種表的資料時:存操作與上一小節完全相同,實作者會依目標表的資訊自行組裝資料。取操作不太一樣,但因為取出的物件是唯一的(一對多嘛),程式碼同樣簡單:
RecordViewA *a = [[RecordViewA alloc] init]; [a mergeRecord:[self.itemATable findLatestRecordWithError:NULL]]; [a mergeRecord:[self.itemBTable findLatestRecordWithError:NULL]]; [a mergeRecord:[self.itemCTable findLatestRecordWithError:NULL]]; return a;
這裡 a、b、c 其實是同一個 View,而 itemATable、itemBTable、itemCTable 是三種不同型別的表。用傳統方法,這裡得寫一堆適配程式碼;改用 Virtual Record 之後,這些都被各自的實作者消化掉了,跑業務邏輯時不必再操心適配。
至於多對多場景,本質上就是上述一對多與多對一的排列組合,實作方式一樣,這裡不再重複。
交互方案總結
設計交互方案時,架構師要先把強弱業務分清楚,把傳統的 Data Model 拆成 Table 與 Record,由 DataCenter 承擔強業務、Table 承擔弱業務。實作上,業務工程師負責建立 DataCenter、對業務層提供友善接口,再在 DataCenter 內部操作 Table 完成需求。這樣切分的好處是:
不區分強弱業務的架構,基本上就是架構師在耍流氓。
而與業務層交互時,用 Virtual Record 來設計 Record,由具體業務物件實作它,並作為 DataCenter 與業務層之間的資料媒介,而不是拿出傳統資料模型。好處是:
這段也順帶提了一下橫切與縱切。原本我打算單開一節寫資料庫效能優化,但行動 App 場景下可用的手段實在不比服務端豐富,很多厲害的參數調校根本用不上,差不多只剩資料切片比較有效。理解切片的方式與場合,就足以依自己的業務做優化;再搭配 Instruments 的 Time Profile 與 SQLite 提供的相關函數,慢在哪裡一目了然。至於工具怎麼用,翻官方手冊就好,我就不寫了。
資料庫版本遷移方案
有持久層的 App 通常都伴隨版本遷移需求:使用者從舊版本升上來,若表結構要改、或資料需要批次更新,就得有遷移機制;而這個機制還必須能跨多個版本。因此大方向基本只有一種:建立資料庫版本節點,遷移時一版一版跑過去。
實作起來不難,掌握三件事就好:
CTPersistance 在這塊做了一點偷懶的設計:凡是資料庫裡還沒有的表,使用時會自動建立,所以業務工程師什麼都不用多做。這也替版本遷移省下了幾個步驟。
此外它提供了 Migrator。你可以針對某個資料庫寫一個 Migrator,前提是繼承 CTPersistanceMigrator 並符合 Migrator 協定,提供一個 migrationStep 字典與記錄版本順序的陣列,再把你自己派生的類別名稱與對應的資料庫名稱寫進 CTPersistanceConfiguration.plist。CTPersistance 在初始化資料庫時會依 plist 找到對應的 Migrator 並執行遷移。
版本遷移要特別注意效能。我們一般不會在主執行緒做遷移,這點不必多說;要強調的是,SQLite 容錯性很強,幾乎每執行一句 SQL 內部都走一個 Transaction。當某一版的 SQL 數量特別多時,建議自己在遷移方法裡建立一個 Transaction,把相關 SQL 包起來,執行速度會明顯好一些。
資料同步方案
資料同步大致分兩類:單向與雙向。
單向資料同步
只把本地較新資料的操作推到服務器,不會主動從服務器拉取同步操作。
以即時通訊為例:一台裝置發訊息後,需要等服務器回覆才知道成功與否,資料庫裡的狀態會依結果改變。若換一台裝置繼續操作,它只會拉到舊資料(例如聊天記錄),而對這些舊資料並沒有刪改需求,因此不會向服務器索取同步操作——這就是單向同步。
單向同步通常也不需要背景 job 定時更新。如果某個操作遲遲沒收到確認,就可以視為失敗,在界面上標示出來讓使用者勾選重試。微信的實作就是這樣:訊息送出失敗時前面會出現紅色感嘆號,只有使用者點擊才重新發送,背後並沒有一個 job 一直在跑。
細化之後會發現,單向同步其實只需要同步「狀態」。具體做法有四個關鍵:
加入 identifier。主要是解決客戶端與服務端主鍵不一致的問題。既然是單向同步,資料生產者只有當前裝置,identifier 也理應由裝置產生。裝置發起同步請求時帶上 identifier,服務器完成後回傳時也帶回這些 identifier,客戶端再依此更新本地狀態。identifier 一般用 UUID 字串。
加入 isDirty。用來標記插入與修改。本地新增或更新資料後,在收到服務器確認前把 isDirty 設為 YES;確認包回來後,依 identifier 找到該筆資料並設回 NO。
但這裡有個極端情況:從請求發出到收到回覆這短短幾秒內,使用者又改了同一筆資料。若照上面的邏輯,確認包一來 isDirty 就被設成 NO,這次新的修改就永遠同步不上去了。最簡單的處理方式是:請求往返期間,界面上不允許修改。若想做得更細緻、允許使用者繼續編輯,就得多開一張 DirtyList 表記錄這些操作,至少要有 identifier 與 primaryKey 兩個欄位。每次操作都配一組新的 identifier,同步時依 primaryKey 找到原表裡的那筆記錄,把資料連同 identifier 交給服務器;確認包回來後,只要拿 identifier 把對應的操作記錄刪掉即可。這張表也能服務多張表,只要再加一個 tablename 欄位。
加入 isDeleted。有同步需求時,刪除就不能是直接物理刪除,而只是邏輯刪除——把 isDeleted 記為 YES,等服務器確認後才真正移除。isDeleted 與 isDirty 的差別在於確認包回來後要做的事不同:若 identifier 指向的是刪除操作,就刪掉這筆;若只是新增或更新,改狀態就好。新增與更新在收到確認後要做的事一樣,所以共用 isDirty 就夠。兩者缺一不可。
在請求包中加入 dependencyIdentifier。我看過的很多方案都沒有這一項,於是會出現這樣的問題:假設接連發出兩次同步請求 A、B(A 先、B 後),結果 B 先到、A 後到。若 A 的系列操作裡包含新增某個物件,而 B 的操作裡正好要刪除它,由於抵達順序顛倒,這筆資料就永遠刪不掉。
在行動裝置上這很容易發生——網路環境本來就多變,先發的包後到並不罕見。解法是在請求包裡帶上「上一次請求的系列 identifier 中的其中一個」,一般選最後一個操作的 identifier,就足以代表上次那批操作。服務器則記錄最近 100 個請求包的最後一個 identifier(100 這個數字純屬經驗判斷,一般不會依賴到更早的包)。收到同步請求時,先看 dependencyIdentifier 是否已被記錄:已記錄就執行這個包的操作;未記錄就先擱著等,條件滿足後再執行。
之所以不用更新時間而用 identifier,是因為時間戳只能取客戶端「送出資料包的時刻」,而不同裝置的時鐘未必完全對齊,多少會差幾秒幾毫秒;若同時有兩台裝置發請求,兩個包的時間甚至完全相同。用時間做依賴,A1 到了之後,B2 說不定就直接執行,而 A1 根本還沒抵達服務器。當然用時間也有好處——服務器只需記一個時間點,凡依賴時間大於它的都再等等,實作比較省事。但為了讓 bug 盡可能少,我認為依賴還是以 identifier 為準更好,而且實作的複雜度並沒有增加太多。
單向同步總結:
要注意的一點:用表記錄更新操作時,短時間內很可能對同一筆資料連續更新多次。同步之前最好先合併這些重複的更新,能省下不少服務器資源——除非你的後端強到不在乎。
雙向資料同步
雙向同步常見於筆記類、日程類應用。對一台裝置來說,它不只會往上推自己的同步資訊,也會主動向服務器索取別處產生的同步資訊。
舉例來說:一台裝置建立了某時段的資料,之後在另一台裝置上修改了這些歷史資料;回到原本那台裝置時,它就必須主動詢問服務器「舊資料有沒有被改過」,有的話要把操作下載下來套用到本地。
雙向同步的實作比單向複雜,而且有些場景還有即時同步需求(例如協同編輯)。方案本身已經夠複雜,還得兼顧業務工程師的上手門檻,因此寫起來反而挺有意思。
封裝操作物件。單向同步時你只需要告訴服務器「哪筆資料、做什麼事」,倒是沒必要封裝;但雙向同步時你必須解析操作,雙方就得約定一套協議,把協議封裝起來就等於完成了操作物件的封裝。這個協議應該包含:
逐項說明:
操作的唯一標識:作用與單向同步時相同,讓本地在收到確認包後能找到對應操作並做確認處理。
資料的唯一標識:執行確認邏輯時難免要處理物件本身,不論更新或刪除都得落到本地資料庫,這個標識就是用來定位資料的。
操作的類型:Delete、Update、Insert 對應不同的本地資料庫動作,用它來分流。
具體的資料:Update 與 Insert 需要它參與。這裡的資料不一定是單筆內容,也可能是批次指令,例如「把 10 月 1 日之前的任務全部標記為完成」。所以具體怎麼表達也需要一層協議:什麼時候當單筆內容處理,什麼時候當批次更新處理,依實際業務定義即可。
操作的依賴標識:同樣是為了防止「先發的包後到、後發的先到」這種極端情況。
時間戳:因為跨裝置,加上舊資料也可能被更新,衝突自然會發生。從服務器同步下來的操作會先存進一個「待操作資料表」,執行時要與「待同步資料表」比對;若針對同一筆資料的兩個操作衝突,就以時間戳決定執行順序,或者乾脆把結果丟到界面上讓使用者決定。
新增待操作資料表與待同步資料表。從服務器拉回來的待執行操作列表存在前者,執行完畢後若有回報需求,等於走一次單向同步。執行過程中這些操作要與待同步資料表比對:無衝突就繼續,有衝突則依時間戳處理或交給使用者決定。拉取待執行列表時,也要把最後一次操作的 identifier 丟給服務器,它才知道該回傳哪些資料。
待同步資料表的作用與單向同步時類似:防止送出請求的同時使用者還在操作,也為衝突處理提供便利。發起同步請求前,都應該先查一次待執行列表;列表同步完成後即可刪除其中記錄,再把本地待同步資料交給服務器,同步完成後清空。所以正常情況下,衝突只會發生在「待操作」與「待執行」之間。有些依邏輯算衝突的極端情況(例如待執行資料拉取太晚,而其中又與待同步的操作撞車)其實無解,只能接受,發生機率也不高。
何時從服務器拉取待執行列表:
雙向同步總結:
要注意的一點:我也見過直接把 SQL 丟出去做同步的方案,不建議這麼做。最好把操作與資料分開並細化,否則偵測衝突時你得去解析 SQL。這種實作一旦有 bug,修起來還得考慮前後相容與機制重建成本——貪一時之懶,最後得不償失。
總結
本文以 CTPersistance 為例,談了持久層的架構設計,以及資料遷移與資料同步方案。著重點在於各種持久層方案設計時必須考慮的隔離,並提出了 Virtual Record 這個思路;遷移方案則強調了幾個實作要點;同步方案分開討論了單向與雙向兩種設計,具體落地仍得依業務需求權衡。
希望這些內容能對各位工作中遇到的問題有點價值,有疑問歡迎在留言區討論。
另外補充一句關於動態部署:直到今天,iOS 領域其實仍然沒有特別理想的動態部署方案,我認為最可靠的仍是 H5 與 Native 的 Hybrid。React Native 相比 Hybrid 的限制還是偏多。Hybrid 這塊我提供了 CTJSBridge 來滿足需求。動態部署那篇成文其實已經很久,遲遲不發是因為當初並沒有什麼銀彈能解決 iOS 的動態部署,加上還有些問題沒想清楚;如今那些問題我已確認無解,而當初寫的內容我一直認為不足以獨立成文,所以一併放在這裡,權供參考。