iOS 應用架構談 開篇
iOS 應用架構談 view 層的組織和調用方案
iOS 應用架構談 網絡層設計方案
iOS 應用架構談 動態部署方案
iOS 應用架構談 本地持久化方案
網絡層是任何一個 App 都少不了的部分,工程師在這裡能發揮的空間也相當大。何況 Apple 早已把網絡請求封裝得很完善,業界的 AFNetworking 也被廣泛使用。其它的 ASIHttpRequest、MKNetworkKit 其實也都不錯,只是前者早已棄坑,後者也在棄坑邊緣。在實際的 App 開發中,AFNetworking 已經成為各大 App 事實上的標準配置。
網絡層在一個 App 裡承載了 API 呼叫、使用者操作日誌記錄,甚至即時通訊等任務。我看過一些 App(開源的和不開源的)的程式碼,每次讀到網絡層這一段,尤其是看到各位架構師各顯神通秀出各種技巧時,我都覺得很振奮。但有時候,我也會對其中的某些缺陷感到失望。
網絡層的設計方案會有很多,需要權衡的地方會有很多,甚至有爭議的地方也會有很多。但無論如何,我不打算對這些問題有任何閃避——我會在這篇文章裡給出我的看法與解法,觀點絕不中立,也不跟各位打太極。
本文主要談三件事:
網絡層跟業務對接部分的設計
網絡層的安全機制實作
網絡層的優化方案
在安居客 App 架構換代升級的時候,我深深感受到「網絡層與業務對接部分」的設計有多重要,因此我做的最大改動就是針對這一段。這部分設計得好壞,會直接影響業務工程師實作功能時的心情。
正式開始之前,我們得先討論幾個問題:
用哪一種交互模式跟業務層對接?
有必要把 API 回傳的資料封裝成物件再交給業務層嗎?
用集約化呼叫方式還是離散型呼叫方式去呼叫 API?
討論完之後,我會給出一個完整的設計方案供參考。設計方案是魚,這些討論是漁;我兩者都給了,各位各取所需。
這裡其實包含兩個問題:
用什麼方式把資料交給業務層?
交什麼樣的資料給業務層?
用什麼方式把資料交給業務層?
iOS 開發領域有很多物件間資料傳遞的方式,我見過的大多數 App 在網絡層主要采用這三種:Delegate、Notification、Block。KVO 與 Target-Action 我目前還沒看到有人用。
就我所知,邊鋒主要用 block,大智慧主要用 Notification,安居客早期以 Block 為主、後來改成以 Delegate 為主;阿里的程式碼裡沒發現用 Notification 傳資料的地方(可能有),Delegate、Block 與 target-action 都有,阿里 iOS App 網絡層作者說這是為了方便業務層挑選自己順手的方式。這部分大家都各顯神通,每次看到這種地方我都喜歡問作者為什麼採用這種方案,但很少有作者能說出個條條框框來。
而在我這邊,我的意見是:以 Delegate 為主,Notification 為輔。原因如下:
盡可能減少跨層資料交流的可能,限制耦合
統一回調方法,便於除錯與維護
在跟業務層對接的部分只採用一種手段(我這裡就是只用 delegate),以此換取應用程式的可維護性
盡可能減少跨層資料交流的可能,限制耦合
什麼叫跨層資料交流?就是某一層(或模塊)跟另一個與它沒有直接對接關係的層(或模塊)發生了資料交換。這種情況為什麼不好?嚴格說來大部分情況都不好,雖然有些時候跨層資料交流確實也是一種需求。之所以說不好,是因為它會導致程式碼混亂、破壞模塊的封裝性。我們做分層架構的目的之一,就在於讓下層對上層做一次抽象,使上層不必關心下層細節就能執行自己的業務。
所以,一旦下層細節被跨層暴露:一方面你很容易因此失去鄰層對這個暴露細節的保護;另一方面,你又不可能不去處理這個細節,於是處理細節的程式碼就會散落各地,最終難以維護。
說得具體一點:考慮 A <- B <- C 這樣的結構。當 C 發生什麼事件,透過某種方式告知 B,然後 B 執行相應邏輯。一旦告知方式不合理,讓 A 有了跨層知道 C 的事件的可能,你就很難保證 A 層的業務工程師將來不會對這個細節做處理。一旦業務工程師在 A 層產生處理操作,可能是補充邏輯,也可能是執行業務,那麼這個細節的相關處理程式碼就會有一部分散落在 A 層。前者是不應該散落在 A 層的,後者有可能是需求。另外,因為 B 層是對 A 層的抽象,執行補充邏輯時有可能和 B 層針對這個事件的處理邏輯產生衝突,這是我們很不希望看到的。
那什麼情況下跨層資料交流會成為需求?在網絡層這邊,信號從 2G 變 3G、變 4G、變 Wi-Fi,這就是一個跨層資料交流的需求。除此之外我暫時想不到別的了,哈哈,應該也就這一個。
嚴格來說,用 Notification 做網絡層與業務層之間的資料交換,並不一定就是跨層資料交流;但使用 Notification 相當於給跨層資料交流開了一道口子,因為 Notification 的影響面不可控,只要存在實例就有被影響的可能。這也導致誰都不能保證相關處理程式碼就在唯一的那個地方,進而帶來維護災難。作為架構師,在這裡限制業務工程師的操作靈活性是必要的。另外,Notification 支援一對多,這也給程式碼散落提供了條件。同時,Notification 對應的響應方法很難在編譯層面做限制,不同的業務工程師會給它取不同的名字,這對可維護性同樣是災難。
手機淘寶架構組的俠武同學曾經給我分享過一個問題,我在這裡也轉述給大家:曾經有位工程師在監聽 Notification 之後,忘了寫釋放監聽的程式碼。當然,要找出這個原因又是一段漫長的故事。現在原因找到了,然而監聽這個 Notification 的物件有那麼多,不知道是哪一個 Notification,也不知道是哪個物件沒釋放監聽。後來大家折騰了很久都沒轍,最後是一位經驗豐富的工程師提出用 hook(Method Swizzling)的方式,才找到那個沒釋放監聽的物件,bug 也就修好了。
我分享這個問題不是想強調 Notification 有多不好——Notification 本身就是一種設計模式,在屬於它的問題領域內,它是非常好的一種解法。我想強調的是:就網絡層這個問題領域而言,架構師首先要限制程式碼的影響範圍,能用影響範圍小的方案時就盡量採用,否則將來有什麼奇怪需求或出了什麼小問題,維護起來會非常痛苦。因此 Notification 不能作為首選,只能作為備選。
當然 Notification 也不是完全不能用。當需求要求跨層時,我們就可以用它,比如前面提到的網絡條件切換,而這個需求恰好也需要一對多。
所以,為了符合前面說的那些要求,Delegate 能很好地避免跨層訪問,同時限制了響應程式碼的形式,相較 Notification 有更好的可維護性。
順便說說為什麼盡量不要用 block。
block 很難追蹤,難以維護
除錯時我們常單步追蹤到某一處,發現這裡有個 block。想知道這個 block 裡做了什麼事,這時候就很折磨人了。
- (void)someFunctionWithBlock:(SomeBlock *)block {
...
-> block(); // 當你單步走到這兒,要想知道 block 裡做了哪些事,會很麻煩。
...
}block 會延長相關物件的生命週期
block 會給內部所有物件的參考計數加一。一方面這帶來潛在的 retain cycle,不過我們可以用 Weak Self 解決;另一方面比較重要的是,它會延長物件的生命週期。
在網絡回調中使用 block,就是 block 導致物件生命週期被延長的一個典型場合。當 ViewController 從 window 上卸下時,如果還有請求帶著 block 在外面飛,而 block 裡面引用了 ViewController(這種場合非常常見),那麼 ViewController 就不能被及時回收——即便你已經取消了請求,也仍舊得等請求落地之後才能回收。
用 delegate 就沒有這個問題:delegate 是弱引用,哪怕請求還在外面飛,ViewController 還是能及時回收,回收之後指標自動被設為 nil,無傷大雅。
所以平常盡量不要濫用 block,尤其是在網絡層這裡。
統一回調方法,便於除錯與維護
前面談的是跨層問題,藉此區分了 Delegate 與 Notification,順帶聊了 Block。現在要講的是另一個「block 不太合適」的情況。首先,block 本身無好壞對錯之分,只有合適與不合適。在這一節要講的情況裡,block 無法做到回調方法的統一,除錯與維護時也很難在呼叫堆疊上顯示出來,找的時候會很頭痛。
在發送網絡請求、以及網絡層接收請求的地方,用 block 沒問題。但在把資料交給業務方時,最好還是透過 Delegate 通知業務方。因為 block 所包含的回調程式碼跟呼叫邏輯放在同一處,會讓那段程式碼變得很長——裡面同時包含了呼叫前與呼叫後的邏輯。從另一個角度說,這在一定程度上違背了 single function, single task 原則:需要呼叫 API 的地方就只寫 API 呼叫相關的程式碼,回調的地方就寫回調的程式碼。
我見過大部分 App 裡,業務工程師寫到這邊時也意識到了這個問題,於是他們會在 block 裡寫一句話的方法接收參數再轉發,這樣就能把方法放到其他地方,繞過「block 回調著陸點不統一」的情況。比如這樣:
[API callApiWithParam:param successed:^(Response *response){
[self successedWithResponse:response];
} failed:^(Request *request, NSError *error){
[self failedWithRequest:request error:error];
}];這實質上跟用 Delegate 沒有區別,只是繞了一下,而且仍然沒解決「統一回調方法」的問題——block 裡寫的方法名字在不同的 ViewController 物件中可能都不一樣,畢竟業務工程師是很多人,各有各的想法。所以架構師在這裡別貪圖方便,還是採用 delegate 手段吧,這樣業務工程師那邊就不必繞了。Block 是目前大部分第三方網絡庫都採用的方式,因為在發送請求那一塊用 block 能寫得比較簡潔,所以在請求層沒問題;只是在交換資料之後,還是轉成 delegate 比較好。比如 AFNetworking 裡面:
[AFNetworkingAPI callApiWithParam:self.param successed:^(Response *response){
if ([self.delegate respondsToSelector:@selector(successWithResponse:)]) {
[self.delegate successedWithResponse:response];
}
} failed:^(Request *request, NSError *error){
if ([self.delegate respondsToSelector:@selector(failedWithResponse:)]) {
[self failedWithRequest:request error:error];
}
}];這樣業務方那邊的回調函式就能比較統一,便於維護。
綜上,對於「用什麼方式把資料交給業務層?」這個問題,我的回答是:盡可能透過 Delegate 回調交付資料,以避免不必要的跨層訪問;當出現跨層訪問的需求時(比如信號類型切換),改用 Notification 交付;正常情況下應該避免使用 Block。
交什麼樣的資料給業務層?
我見過非常多 App 的網絡層在拿到 JSON 之後,會把資料轉變成對應的物件原型。注意,我這裡指的不是 NSDictionary,而是類似 Item 這樣的物件。這種做法確實能提高後續操作程式碼的可讀性。在比較直覺的思路裡,好像是需要這段轉化過程的,但這段過程的成本很大,主要成本在於:
陣列內容的轉化成本高:陣列裡每一項都要轉成 Item 物件,如果 Item 裡面還有陣列,就更頭痛。
轉化之後的資料在大多數情況下不能直接展示,為了能展示,還需要第二次轉化。
只有在 API 回傳資料高度標準化時,這些物件原型的可複用程度才高,否則容易出現類型爆炸,提高維護成本。
除錯時透過物件原型查看資料內容,不如直接看 NSDictionary/NSArray 直觀。
同一 API 的資料被不同 View 展示時,難以控制資料轉化的程式碼,它們可能散落在任何需要的地方。
我們的理想情況,是希望 API 資料下發之後就能直接被 View 展示。首先要說,這種情況非常少;其次,這種做法讓 View 和 API 綁得太緊,也是我們不希望發生的。
在設計安居客的網絡層資料交付部分時,我加入了 reformer(名字而已,叫什麼都好)這個物件來封裝資料轉化的邏輯。它是一個獨立物件,事實上它是作為 Adaptor 模式存在的。我們可以這樣理解:想像洗澡時用的蓮蓬頭,水管裡出來的水是 API 下發的原始資料,reformer 就是蓮蓬頭上的不同水流擋板,需要什麼模式就撥到什麼模式。
實際使用時,程式碼觀感是這樣的:
先定義一個 protocol:
@protocol ReformerProtocol
- (NSDictionary)reformDataWithManager:(APIManager *)manager;
@end
在 Controller 裡是這樣:
@property (nonatomic, strong) id<ReformerProtocol> XXXReformer;
@property (nonatomic, strong) id<ReformerProtocol> YYYReformer;
#pragma mark - APIManagerDelegate
- (void)apiManagerDidSuccess:(APIManager *)manager {
NSDictionary *reformedXXXData = [manager fetchDataWithReformer:self.XXXReformer];
[self.XXXView configWithData:reformedXXXData];
NSDictionary *reformedYYYData = [manager fetchDataWithReformer:self.YYYReformer];
[self.YYYView configWithData:reformedYYYData];
}
在 APIManager 裡面,fetchDataWithReformer 是這樣:
- (NSDictionary)fetchDataWithReformer:(id<ReformerProtocol>)reformer {
if (reformer == nil) {
return self.rawData;
} else {
return [reformer reformDataWithManager:self];
}
}要點 1:reformer 是一個符合 ReformerProtocol 的物件,它提供通用方法供 Manager 使用。
要點 2:API 的原始資料(JSON 物件)由 Manager 實例保管,reformer 方法裡面取 Manager 的原始資料(manager.rawData)做轉換,然後交付出去。蓮蓬頭的水管部分是 Manager,負責提供原始水流(資料流);reformer 就是不同的模式,換什麼 reformer 就出來什麼水流。
要點 3:例子中的場景是一個 API 資料被多個 View 使用,體現了 reformer 的一個特點:可以按需改變同一資料來源的展示方式。比如 API 資料展示的是「附近的小區」,這個資料可以被列表(XXXView)和地圖(YYYView)共用,不同 view 需要的資料轉化方式不同,這就透過不同的 reformer 解決了。
要點 4:在一個 view 用來展示同一結構的不同 API 資料時,reformer 是絕佳利器。比如安居客列表 view 的資料來源可能有二手房列表 API、租房列表 API、新房列表 API。這些 API 回傳資料的 value 可能一致,但 key 都不一樣。這時就可以用同一個 reformer 做資料的標準化輸出,讓 view 程式碼復用成為可能。這體現了 reformer 的另一個特點:同一個 reformer 出來的資料是高度標準化的。形象點說就是:只要蓮蓬頭不換,哪怕水管的水變成海水或污水,也依舊能輸出符合洗澡要求的淡水水流。舉個例子:
- (void)apiManagerDidSuccess:(APIManager *)manager {
// 這個回調方法有可能來自二手房列表 APIManager,也有可能是租房,也有可能是新房。
// 但是在 Controller 層面我們不需要額外區分,只要是同一個 reformer 出來的資料,
// 我們就能保證一定能被 self.XXXView 使用。這樣的保證由 reformer 的實作者提供。
NSDictionary *reformedXXXData = [manager fetchDataWithReformer:self.XXXReformer];
[self.XXXView configWithData:reformedXXXData];
}要點 5:有沒有發現,用了 reformer 之後 Controller 的程式碼簡潔了很多?而且,資料原型在這種情況下就沒有必要存在了,隨之而來的成本也被我們繞開了。
reformer 本質上就是一個符合某個 protocol 的物件。Controller 需要從 API Manager 取得資料時,順便把 reformer 傳進去,於是就能拿到經過 reformer 重新洗過的資料,直接拿去用。
更抽象地說,reformer 是對「資料轉化邏輯」的一個封裝。Controller 從 Manager 取到資料、交給 View 之前,這段期間或多或少都要做一次資料轉化;有時候不同 View 對應的轉化邏輯還不一樣,但展示的資料是同一份。而且這部分程式碼往往非常複雜、與業務強相關,直接寫進去將來很難維護。所以我們可以考慮用不同的 reformer 封裝不同的轉化邏輯,讓 Controller 按需挑一個合適的裝上,就像洗澡的蓮蓬頭:需要什麼樣的水流(資料的表現形式)就換什麼樣的頭,然而水(資料)始終一樣。這樣做能大幅提高程式碼可維護性,也能縮小 ViewController 的體積。
總結一下:reformer 事實上是把轉化的程式碼封裝之後,再從主體業務中拆分出來。拆分之後不只降低了原有業務的複雜度,更重要的是,它提高了資料交付的靈活性。另外,因為 Controller 負責調度 Manager 與 View,所以它知道兩者之間的關係;知道這個關係之後,Controller 就有了充分條件為不同 View 挑選不同的 Reformer,用這個 Reformer 去改造 Manager 的資料,然後把處理好的資料直接交給 View 使用。Controller 因此瘦身,負責業務資料轉化的程式碼也不必寫在 Controller 裡,可維護性提升。
所以 reformer 機制能帶來這些好處:
好處 1:繞開了 API 資料原型的轉換,避免相關成本。
好處 2:在處理「單 View 對多 API」以及「單 API 對多 View」時,reformer 提供了非常優雅的手段,隔離了轉化邏輯與主體業務邏輯,避免維護災難。
好處 3:轉化邏輯集中,且把轉化次數降為一次。用資料原型的轉化邏輯至少有兩次:第一次把 JSON 映射成原型,第二次把原型轉成 View 能處理的資料;reformer 一步到位。另外,轉化邏輯集中在 reformer 裡,將來 API 資料有變,只要找到對應的 reformer 改掉就好。
好處 4:Controller 因此省下大量程式碼,降低複雜度,同時提高靈活性——任何時候切換 reformer 而不必切換業務邏輯,就能應對不同 View 的資料需求。
好處 5:業務資料與業務邏輯有了適當隔離。將來業務邏輯要改,換一個 reformer 就好;如果其他業務也有相同的資料轉化需求,直接拿這個 reformer 就能用,不必重寫。另外,如果 Controller 要改(比如 UI 交互方式變了),也可以放心換,完全不必擔心業務資料的處理。
不用特定物件表征資料時,如何保持可讀性?
不用物件表征資料,實質上就是用 NSDictionary。那麼問題就是:在 NSDictionary 表征資料的前提下,如何保持良好的可讀性?
Apple 已經給出了非常好的做法:用固定字串當 key。比如你收到 KeyBoardWillShow 的 Notification 時,附帶的 userInfo,它的 key 都是類似 UIKeyboardAnimationCurveUserInfoKey 這樣的寫法。所以我們採用同樣的方案來維持可讀性。舉個例子:
PropertyListReformerKeys.h extern NSString * const kPropertyListDataKeyID; extern NSString * const kPropertyListDataKeyName; extern NSString * const kPropertyListDataKeyTitle; extern NSString * const kPropertyListDataKeyImage;
PropertyListReformer.h #import "PropertyListReformerKeys.h" ... ...
PropertyListReformer.m
NSString * const kPropertyListDataKeyID = @"kPropertyListDataKeyID";
NSString * const kPropertyListDataKeyName = @"kPropertyListDataKeyName";
NSString * const kPropertyListDataKeyTitle = @"kPropertyListDataKeyTitle";
NSString * const kPropertyListDataKeyImage = @"kPropertyListDataKeyImage";
- (NSDictionary *)reformData:(NSDictionary *)originData fromManager:(APIManager *)manager {
...
...
NSDictionary *resultData = nil;
if ([manager isKindOfClass:[ZuFangListAPIManager class]]) {
resultData = @{
kPropertyListDataKeyID:originData[@"id"],
kPropertyListDataKeyName:originData[@"name"],
kPropertyListDataKeyTitle:originData[@"title"],
kPropertyListDataKeyImage:[UIImage imageWithUrlString:originData[@"imageUrl"]]
};
}
if ([manager isKindOfClass:[XinFangListAPIManager class]]) {
resultData = @{
kPropertyListDataKeyID:originData[@"xinfang_id"],
kPropertyListDataKeyName:originData[@"xinfang_name"],
kPropertyListDataKeyTitle:originData[@"xinfang_title"],
kPropertyListDataKeyImage:[UIImage imageWithUrlString:originData[@"xinfang_imageUrl"]]
};
}
if ([manager isKindOfClass:[ErShouFangListAPIManager class]]) {
resultData = @{
kPropertyListDataKeyID:originData[@"esf_id"],
kPropertyListDataKeyName:originData[@"esf_name"],
kPropertyListDataKeyTitle:originData[@"esf_title"],
kPropertyListDataKeyImage:[UIImage imageWithUrlString:originData[@"esf_imageUrl"]]
};
}
return resultData;
}PropertListCell.m
#import "PropertyListReformerKeys.h"
- (void)configWithData:(NSDictionary *)data {
self.imageView.image = data[kPropertyListDataKeyImage];
self.idLabel.text = data[kPropertyListDataKeyID];
self.nameLabel.text = data[kPropertyListDataKeyName];
self.titleLabel.text = data[kPropertyListDataKeyTitle];
}這一大段程式碼看過來,我如果不分析一下要點,那基本上就白寫了。先看結構:
---------------------------------- -----------------------------------------
| | | |
| PropertyListReformer.m | | PropertyListReformer.h |
| | | |
| #import PropertyListReformer.h | <------- | #import "PropertyListReformerKeys.h" |
| NSString * const key = @"key"; | | |
| | | |
---------------------------------- -----------------------------------------
|
|
|
|
|
|
---------------------------------
| |
| PropertyListReformerKeys.h |
| |
| extern NSString * const key; |
| |
---------------------------------用 Const 字串表征 Key:字串的定義跟著 reformer 的實作檔走,字串的 extern 宣告放在獨立的標頭檔內。
這樣 reformer 產生的資料 key 都用 Const 字串表示,之後別的地方需要使用相關資料時,把 PropertyListReformerKeys.h 這個標頭檔 import 進去就好了。
另外要注意:如果一份 OriginData 可能會被多個 Reformer 處理,那麼 Key 的命名規範需要能表征出它對應的 reformer 名字。如果 reformer 是 PropertyListReformer,那麼 Key 的名字就是 PropertyListKeyXXXX。
這麼做的好處是將來遷移時相當方便,只要丟標頭檔就好,而且只丟標頭檔不會有「拔出蘿蔔帶出泥」的問題;同時也避免了自訂物件帶來的額外程式碼體積。
另外,關於交付的 NSDictionary,具體還是要看 View 的需求。reformer 的設計初衷是:透過 reformer 轉化出來的,可以直接是 View,或者是 View 直接能使用的物件(包括 NSDictionary)。比如地圖標點列表 API 的資料,經過 reformer 轉化之後可以直接變成 MKAnnotation,MKMapView 拿來就能用。這裡講的只是「當你的需求是交付 NSDictionary 時,如何保證可讀性」,再強調一次:reformer 交付的是 View 直接能用的物件,交付出去的可以是 NSDictionary,也可以是 UIView,跟 DataSource 結合之後交付的甚至可以是 UITableViewCell/UICollectionViewCell。別被 NSDictionary 或所謂「轉化成 model 再交付」的思想局限住。
綜上,我對「交什麼樣的資料給業務層?」的回答是:對業務層而言,由 Controller 根據 View 與 APIManager 之間的關係,挑選合適的 reformer,把 View 可以直接使用的資料轉化好之後交付給 View。對網絡層而言,只需要保住原始資料即可,不需要主動轉化成資料原型。然後資料用 NSDictionary 加 Const 字串 key 來表征,既避免了用物件表征帶來的遷移困難,也不失去可讀性。
集約型 API 呼叫,就是所有 API 的呼叫只有一個類別,這個類別接收 API 名字、API 參數,以及回調著陸點(可以是 target-action、block、delegate 等各種模式)作為參數,然後執行類似 startRequest 的方法,它就會依據這些參數起飛去呼叫 API,拿到資料之後再按指定著陸點著陸。比如這樣:
集約型 API 呼叫方式: [APIRequest startRequestWithApiName:@"itemList.v1" params:params success:@selector(success:) fail:@selector(fail:) target:self];
離散型 API 呼叫則是這樣:一個 API 對應一個 APIManager,這個 APIManager 只需要提供參數就能起飛,API 名字、著陸方式都已經集成在 APIManager 裡。比如這樣:
離散型 API 呼叫方式:
@property (nonatomic, strong) ItemListAPIManager *itemListAPIManager;
// getter
- (ItemListAPIManager *)itemListAPIManager {
if (_itemListAPIManager == nil) {
_itemListAPIManager = [[ItemListAPIManager alloc] init];
_itemListAPIManager.delegate = self;
}
return _itemListAPIManager;
}
// 使用的時候就這麼寫:
[self.itemListAPIManager loadDataWithParams:params];這兩者並不互斥。單看下層,大家都是集約型:發起一個 API 請求之後,除去業務相關的部分(參數、API 名字等),剩下的都要統一處理——加密、URL 拼接、請求的起飛與著陸。這些如果不用集約化方式實作,作者非瘋即傻。但對於整個網絡層,尤其是業務方使用的那部分,我傾向於提供離散型的 API 呼叫方式,並不建議業務層程式碼直接使用集約型呼叫。原因如下:
原因 1:當前請求正在外面飛的時候,依不同業務需求存在兩種起飛策略:一是取消新發起的請求,等外面飛著的那個著陸;二是取消外面飛著的請求,讓新的起飛。集約化的呼叫方式如果要滿足這種需求,每次呼叫時都得額外寫一段判斷與取消的程式碼,手段做不到乾淨。
前者的業務場景例如刷新頁面的請求:刷新詳情、刷新列表。後者的場景例如列表多維度篩選:你先篩商品類型,再篩價格區間。當然,後者不一定每次篩選都要呼叫 API,我們先假設這種篩選每次都得透過 API 才能取得資料。
如果是離散型呼叫,在實作不同 APIManager 時就可以針對不同 API 設定不同起飛策略;實際使用時,呼叫方不必再關心起飛策略,因為 APIManager 裡已經寫好了。
原因 2:便於針對某個 API 請求做 AOP。在集約型呼叫方式下,要對某個 API 請求的起飛與著陸過程做 AOP,這程式碼得寫成什麼樣……噢,這畫面太美,我都不敢想。
原因 3:當 API 請求的著陸點消失時,離散型呼叫方式能更透明地處理這種情況。
當一個頁面的請求正在天上飛,使用者等得不耐煩,小手點了個 back,ViewController 被 pop 掉了。此時請求的著陸點就沒了。這是很危險的情況——著陸點沒了就容易 crash。一般處理方式是在 dealloc 時取消當前頁面所有請求。如果是集約型呼叫,這段程式碼就得寫在 ViewController 的 dealloc 裡;但如果是離散型呼叫,寫在 APIManager 裡就可以了,然後隨著 ViewController 的回收進程,APIManager 也會被跟著回收,這部分程式碼自然得到呼叫機會。這樣業務方使用時就不必關心著陸點消失的情況,可以更專注於業務。
原因 4:離散型呼叫方式能最大程度地給業務方提供靈活性,比如 reformer 機制就是建立在離散型呼叫之上的。另外,如果是需要翻頁機制的 API,APIManager 就能簡單地提供 loadNextPage 方法去載入下一頁,頁碼管理不必交給業務方。還有,若要針對業務請求參數做驗證(比如使用者填寫註冊資訊),在離散型 APIManager 裡實作會非常輕鬆。
綜上,關於集約型與離散型 API 呼叫,我傾向於這樣:對外提供一個 BaseAPIManager 給業務方做派生,在 BaseManager 裡面用集約化手段組裝請求、放飛請求;而業務方呼叫 API 時,則以離散型方式呼叫。如果你的 App 只提供了集約化方式而沒有離散通道,那我建議你再封裝一層,讓業務方能用離散方式放飛請求。
要做成離散型呼叫,繼承是逃不掉的。BaseAPIManager 負責集約化的部分,外部派生的 XXXAPIManager 負責離散的部分。對 BaseAPIManager 來說,離散部分有些是必要的資訊,比如 API 名字等,而我們派生的目的也正是為了提供這些資料。
我在這篇文章裡列舉了種種繼承的壞處,呼籲大家盡量不要使用繼承。但現在到了不得不用繼承的時候,所以我得提醒一下:別把繼承用壞了。
在 APIManager 這個場景下,最直覺的思路是 BaseAPIManager 提供一些空方法給子類覆寫,比如 apiMethodName 這樣的函式。然而我的建議是:不要這麼做。我們可以用 IOP( informally-used protocol )的方式來限制派生類的覆寫。
大概長這樣:
BaseAPIManager 的 init 方法裡這麼寫:
// 注意是 weak。
@property (nonatomic, weak) id<APIManager> child;
- (instancetype)init {
self = [super init];
if ([self conformsToProtocol:@protocol(APIManager)]) {
self.child = self;
} else {
// 不遵守這個 protocol 的就讓他 crash,防止派生類亂來。
NSAssert(NO, @"子類必須要實現 APIManager 這個 protocol。");
}
return self;
}
protocol 這麼寫,把原本要覆寫的函式都定義在這個 protocol 裡面,就不用在父類裡寫空方法了:
@protocol APIManager
@required
- (NSString *)apiMethodName;
...
@end
然後在父類裡面要使用的話,就這麼寫:
[self requestWithAPIName:[self.child apiMethodName] ......];簡單說,就是在 init 時檢查自己是否符合預先設計的子類 protocol,這就要求所有子類必須遵守這個 protocol;所有針對父類的覆寫也都以這個 protocol 為準,protocol 以外的方法不允許覆寫。而在父類自己的程式碼裡,則不必遵守這個 protocol,保留了未來維護的靈活性。
這麼做的好處是避免了父類寫空方法,同時給子類戴上緊箍咒:想當我的孩子,就得守這些規矩,不能亂來。業務方實作子類時,只要按 protocol 中的方法一一實作即可,約定也比較好做:不允許覆寫父類方法,只允許選擇實作或不實作 protocol 中的方法。
關於這一點的具體論述,可以參考我另一篇文章,有興趣不妨看看。
這一節主要談了:
用 delegate 做資料對接,僅在必要時採用 Notification 做跨層訪問
交付 NSDictionary 給業務層,用 Const 字串當 Key 來保持可讀性
提供 reformer 機制來處理網絡層回饋的資料,這個機制很重要,好處極多
網絡層上部分用離散型設計,下部分用集約型設計
設計合理的繼承機制,讓派生出來的 APIManager 受到限制,避免混亂
應該不止這 5 點……
使用這個機制的目的主要有兩點:
確保 API 的呼叫者來自你自己的 App,防止競爭對手爬你的 API
如果你對外提供了需要註冊才能使用的 API 平台,那你需要這個機制來識別是否為註冊使用者呼叫了你的 API
解法:設計簽名
要達到第一個目的其實很簡單:服務端給你一個密鑰,每次呼叫 API 時,你用這個密鑰加上 API 名字與請求參數算一個 hash 出來,請求時帶上這個 hash。服務端收到請求後,用同樣的密鑰、同樣的演算法也算一個 hash,再跟請求帶來的 hash 比對;如果一致,就表示這個 API 的呼叫者確實是你的 App。為了不讓別人取得這個密鑰,最好不要把它存在本地,直接寫死在程式碼裡就好。另外適度增加求 hash 的演算法複雜度,比如各種 hash 演算法(如 MD5)加點鹽再回爐跑一次。這樣第一個目的就達到了:確保你的 API 來自你自己的 App。
一般情況下,大部分公司不會出現需要滿足第二種情況的需求,除非公司開發了自己的 API 平台給第三方使用。這個需求和上面那個有一點不同:符合授權的 API 請求者不只是一個,所以需要的安全機制會更複雜一些。
這裡有一個比較容易實作的方案:客戶端呼叫 API 時,把自己的密鑰透過一個可逆的加密演算法加密後,連著請求與加密後的 Hash 一起送上去。這個可逆加密演算法肯定是放在呼叫 API 的 SDK 裡、編譯好的。服務端拿到加密後的密鑰與加密的 Hash 之後,先解碼取得原始密鑰,再用它去算 Hash,最後進行比對。
使用這個機制的主要目的有兩點:
防止中間人攻擊,比如運營商很喜歡往使用者的 Http 請求裡塞廣告
SPDY 依賴 HTTPS,而且是未來 HTTP/2 的基礎,它們能提升你 App 在網絡層的整體效能
解法:HTTPS
目前使用 HTTPS 的主要目的在於防止運營商往你的 Response Data 裡加廣告之類的東西(中間人攻擊),面對的威脅範圍更廣。從 2011 年開始,國外業界就已經提倡所有請求(不只是 API,還包括網站)都走 HTTPS;國內差不多晚了兩年(2013 年左右)才開始提倡,天貓更是這兩個月才開始做 HTTPS 的全 App 遷移。
關於速度,HTTPS 肯定比 HTTP 慢,畢竟多了一次握手;但掛上 SPDY 之後,有了連結複用,這方面的效能就有較大提升。這裡的效能提升並不是說一個請求原本要 500ms 現在只要 300ms,那是錯的。所謂整體效能,是基於大量請求來討論的:同樣的請求量(假設 100 個)在短期內發生時,掛上 SPDY 之後完成這些任務所花的時間比不掛要少。SPDY 還有 Header 壓縮功能,不過因為單個 API 請求本身已經比較小,壓縮帶來的效能提升不會特別明顯,所以單看一個請求,提升幅度比較小。這是下一節要談的事,這裡只是順帶一提。
這一節講了兩種安全機制。一般來說第一種是標配,第二種屬於可選配置。不過隨著我國互聯網基礎設施的完善、行動裝置效能的提高,以及優化技術的進步,第二種配置的缺點(速度慢)正變得越來越微不足道,因此 HTTPS 也會在不久之後成為 App 網絡層安全機制的標配。各位架構師,如果你的 App 還沒掛 HTTPS,現在就可以開始著手了。
網絡層的優化手段主要從三方面考慮:
針對連結建立環節的優化
針對連結傳輸資料量的優化
針對連結複用的優化
各種五花八門的優化手段基本上都不會逃出這三方面。下面分別說明。
API 發起請求建立連結的環節,大致會經歷這些步驟:
發起請求
DNS 域名解析得到 IP
依 IP 進行三次握手(HTTPS 四次握手),連結建立成功
第三步的優化手段跟第二步其實是一致的,我在講第二步時一起說明。
1.1 針對發起請求的優化手段
要解決的問題其實就是:網絡層該不該為這個 API 呼叫發起請求。
1.1.1 用緩存減少請求的發起次數
大部分 API 請求帶來的資料,時效性其實比較長,比如商品詳情、App 皮膚等。那我們就可以針對這些資料做本地緩存,下次請求同樣的資料時就不必再發起新請求。
一般做法是把 API 名字與參數拼成一個字串,取 MD5 當 key,存儲對應的回傳資料。這樣下次有同樣請求時,直接讀這裡的資料就好。這裡有一個緩存策略問題需要討論:什麼時候清理緩存?要麼按超時時間清理,要麼按緩存資料大小清理。策略選擇要依據具體 App 的操作日誌來決定。
比如安居客 App,日誌顯示使用者平均使用時長不到 3 分鐘,但查看房源詳情的次數比較多,而房源詳情資料量較大。這種情況就適合按使用時長做緩存,我當時給安居客設定的緩存超時時間就是 3 分鐘,這樣能保證緩存在大部分使用者的使用時間內發揮作用。極端情況下的緩存策略不必考慮,只要能服務好 80% 的使用者就可以了;針對極端情況做的優化對大部分普通使用者而言是不必要的,做了反而有影響。
再比如網絡圖片緩存,資料量基本上都特別大,這種就比較適合按緩存大小來清理。
另外,前面的緩存都是基於記憶體的。我們也可以把需要清理的緩存存到硬盤上(App 的本地儲存,我姑且用「硬盤」來表示,雖然很少有手機硬盤的說法,哈哈)。比如前面提到的圖片緩存,因為圖片很可能在很久之後還會被顯示,那原本該被清理的圖片緩存,就可以考慮存到硬盤上。下次再有顯示網絡圖片的需求時,先從記憶體找,找不到就從硬盤找,都找不到才發起請求。
當然,有些時效性非常短的 API 資料就不能用這招,比如使用者的資金資料,那就得每次都呼叫。
1.1.2 用策略減少請求的發起次數
這個我前面提過,就是針對重複請求的發起與取消,是有對應策略的。先說取消策略。
如果是界面刷新請求這種,而且存在重複請求(下拉刷新時,在請求著陸之前使用者不斷執行下拉操作),那麼後面重複操作導致的 API 請求就可以不必發送了。
如果是條件篩選這種,那就取消前面已經發送的請求。雖然很可能這個請求已經被執行了,取消帶來的效能提升就基本沒有了;但如果這個請求還在隊列中待執行,那麼對應的這次連結就能省下來。
另外一種是請求策略,類似使用者操作日誌那樣。使用者操作會觸發操作日誌上報 Server,這種請求特別頻繁,但它是暗地裡進行的,不需要使用者感知,所以也沒必要操作一次就發一次請求。這裡可以採用這樣的策略:在本地記錄使用者的操作,累積滿 30 條時發起一次請求把日誌上傳到伺服器;然後每次 App 啟動時,順手上傳上次遺留下來沒傳的記錄。這樣能有效降低裝置耗電量,同時提升網絡層效能。
小結
針對建立連結這部分的優化原則就是:能不發請求就盡量不發,必須要發時,能合併就盡量合併。然而任何優化手段都有前提,也不能保證對所有需求都有效;有些 API 請求就是不符合這些前提,那就老老實實發請求吧。不過這類請求所占比例一般不大,大部分請求都或多或少符合優化條件,所以針對發送請求的優化還是值得做的。
1.2 & 1.3 針對 DNS 域名解析的優化,以及建立連結的優化
整個 DNS 鏈路上其實也有 DNS 緩存,理論上也能提速。這個鏈路上的 DNS 緩存在 PC 使用者身上效果明顯,因為 PC 使用者的 DNS 鏈路相對穩定,信號源不會變來變去。但在行動裝置使用者這邊,鏈路上的 DNS 緩存帶來的效能提升就不太明顯了:行動裝置的實際使用場景比較複雜,網絡信號源會經常變換,信號源每換一次,對應的 DNS 解析鏈路就換一次,原鏈路上的 DNS 緩存也就失效了。而且信號源變換的情況特別頻繁,所以對行動裝置使用者來說,鏈路的 DNS 緩存基本上可以當作沒有。
所以大部分時候起作用的是手機系統自帶的本地 DNS 緩存。但一般來說,行動裝置上網的需求特別頻繁,專門為我們這個 App 所做的 DNS 緩存很可能被別的 DNS 緩存擠出去清掉。這種情況特別多:使用者看一會兒知乎、刷一下微博、查一下地圖、逛一逛點評、再聊個 Q,回來之後很可能屬於你自己 App 的本地 DNS 緩存就沒了。
這還沒完,這裡還有一個只有在中國特色社會主義互聯網環境中才會有的問題:由於 GFW 的存在,國內的 DNS 服務速度會比正常情況慢不少。
基於以上三個原因,最終結果就是 API 請求在 DNS 解析階段的耗時會很多。
那對應的優化方案就是:索性直接走 IP 請求,不就繞過 DNS 服務的耗時了嘛。
另外一個是上面提到的建立連結第三步:國內網絡環境分北網通南電信(實際情況更複雜,這裡隨便說說),不同服務商之間的連結延時很大。我們需要想辦法讓使用者在最適合他的 IP 上取得服務,那麼對「繞過 DNS 服務」這個手段就有一個額外要求:盡可能不要讓使用者使用對他來說很慢的 IP。
所以方案就應該是這樣:本地維護一份 IP 列表,這些 IP 是所有提供 API 的伺服器的 IP;每次應用啟動時,針對列表裡的所有 IP 取 ping 延時,然後取延時最小的那個作為之後發起請求的 IP 位址。
針對建立連結的優化手段,其實和 DNS 域名解析的優化手段是同一套。不過這需要你的伺服器提供服務的網絡情況要多一些——現在的伺服器一般都是雙網卡,電信和網通。由於中國特色的互聯網 ISP 分布,南北網絡之間存在瓶頸,而我們針對連結的優化主要就是著手於如何減輕這個瓶頸對 App 的影響,所以需要維護一個 IP 列表,這樣就能就近連結,達到優化效果。
我們一般在應用啟動時取得本地列表中所有 IP 的 ping 值,然後透過 NSURLProtocol 的手段,把 URL 中的 HOST 改為我們找到的最快 IP。另外,這個本地 IP 列表也需要透過一個 API 來維護,一般是每天第一次啟動時讀一次 API,然後更新到本地。
如果你還不熟 NSURLProtocol 怎麼玩,看完官方文件加上這篇文章以及這個 Demo 之後,你肯定就會了,其實很簡單。另外,剛才提到的那篇文章作者(mattt)還寫了一個基於 NSURLProtocol 的工具,相當好用,可以直接拿來集成到專案裡。
不用 NSURLProtocol 的話,用其他手段也能做到這一點,但那些手段未免又比較愚蠢。
這個很好理解:傳輸的資料少了,速度自然上去。這裡沒什麼花樣可講,就是壓縮,各種壓縮。
建立連結本身屬於比較消耗資源的行為,耗電耗時。SPDY 自帶連結複用與資料壓縮功能,所以服務端支援 SPDY 時,App 直接掛上就好。如果服務端不支援 SPDY,也可以用 PipeLine,Apple 原生自帶這個功能。
業界普遍的認識是 SPDY 優於 PipeLine。即便如此,SPDY 帶來的網絡層效率提升其實也沒有文獻圖表上那麼明顯,但確實有提升。另外還有一種比較笨的連結複用方法:維護一個隊列,把隊列裡的請求合併成一個發出去。之所以會有請求滯留在隊列中,是因為上一個請求還在外面飄著。這種做法表面上看跟連結複用差別不大,但並不是真正的連結複用,只能說是請求合併。
說回來,我建議最好用 SPDY。SPDY 和 pipeline 雖然都屬於連結複用的範疇,但 pipeline 並不是真正意義上的連結複用,SPDY 的複用相對更徹底。SPDY 目前也有現成的客戶端 SDK 可用:一個是 twitter 的 CocoaSPDY,另一個是 Voxer/iSPDY,這兩個庫都很活躍,可以挑合適的採用。
不過目前的業界趨勢是傾向於用 HTTP/2.0 取代 SPDY,只是 HTTP/2.0 還沒正式出台,相關實作大部分都還在 demo 階段,所以我們還是先把 SPDY 搞起來就好。未來很有可能會放棄 SPDY,轉而採用 HTTP/2.0 來做網絡優化,這是各位架構師需要注意的事。嗯,我也不知道 HTTP/2.0 什麼時候能出來。
這裡是我當年設計並實作的安居客網絡層架構程式碼。當然,該脫敏的地方我都已經脫敏了,所以編不過是正常的,哈哈哈。但程式碼比較齊全,重要地方我也寫了很多註解。另外,為了讓大家能把這些程式碼看明白,我還附上了當年介紹這個框架演講時的 PPT。(補充說明一下,評論區好多人問 PPT 找不到在哪兒——PPT 也在上面提到的 repo 裡,是個 key 副檔名的檔案,用 Keynote 打開。)
然後就是,當年有很多問題其實我考慮得並沒有現在清楚,所以有些地方還是做得不夠好,比如攔截器和繼承。而且當時的優化手段只有本地 cache——安居客沒有那麼多 IP 給我 ping,當年也沒流行 SPDY,API 也不支援 HTTPS,所以當時的程式碼裡沒有在這些地方做優化,比較原始。然而整個架構的基本思路一直沒變:優先服務於業務方。另外,安居客的網絡層多了一個 service 的概念,這是我這篇文章中沒有講的,主要是因為安居客的 API 提供方很多:二手房、租房、新房、X 專案等等,API 都是不同團隊提供的,以 service 作區分。如果你的 App 也是類似情況,我也建議你設計一套 service 機制。現在這些 service 被我刪得只剩一個 google 的 service,因為其他都屬於敏感內容。
另外,這裡提供的 PPT 我很希望大家能花時間看看。PPT 裡面有些更細的東西我在部落格裡沒有寫,主要是我比較懶,加上這篇文章拖的時間比較長了,花時間搬運這些沒什麼意思,不過內容還是很值得各位讀者看的。關於 PPT 裡的任何問題,也可以在評論區問,我都會回答。
第一部分主要講了網絡層應當如何跟業務層進行資料交互、交互時採用怎樣的資料格式,以及程式碼結構上的一些問題:繼承的處理、回調的處理、交互方式的選擇、reformer 的設計、保持資料可讀性等等,主要偏重於設計(這可是藝術活,哈哈哈)。
第二部分講了網絡安全上客戶端要做的兩件事。當然,從網絡安全的角度看,服務端要做的事情還有很多,客戶端要處理的邊角細節也還會有不少,比如做一些程式碼混淆、盡可能避免程式碼中明文展示 key。不過大頭主要就是這兩個,而且都需要服務端同學配合。這部分主要偏重於介紹(主要是也沒什麼好實踐的,google 一下教程照著做就好)。
第三部分講了優化。優化的所有面向都已經列出來了,業界若再有七七八八的別的手段,也基本逃不出本文的範圍。這裡有些手段需要服務端同學配合,有些不需要,大家看各自情況決定。這部分主要偏重於實踐。
最後給出了我之前在安居客做的網絡層架構主要程式碼,以及當時演講的 PPT。關於程式碼或 PPT 有任何問題,都可以在評論區問我。
這篇文章出得比較晚,因為公司的事情中間隔了一個禮拜,希望大家諒解。另外,隔了一個禮拜之後再寫,有些地方我已經想不起來當初該怎麼行文下去了;發佈之前我把文章又看了幾遍,盡可能把斷片的地方抹平。如果大家讀起來有什麼地方覺得奇怪,或者講到一半就沒了的,那應該就是斷片了,在評論區跟我說一下,我補上去。
如果有需要勘誤的地方,也請在評論區指出,幫助我把錯的地方訂正回來;如果有沒講到、但你特別想了解的,也可以在評論區提出來,我會補上。說不定看完之後你腦袋裡還會有很多個問號,也請在評論區問出來——說不定別人也有跟你一樣的問題,他就能在評論區找到答案了。
在第二篇文章的評論區裡出現了噴子。遇到這種情況我怎麼可能刪帖呢?那根本就不是我的風格哇,哈哈哈。我肯定是會噴回去的,並且還會把連結傳播給周圍人,發動朋友們來看:「快看,這兒有 2B,哈哈哈」。
嗯,所以評論的時候你一定要想清楚哈。我寫程式碼的實力不差,打嘴仗的實力那可比寫程式碼強多了。評論區同樣歡迎切磋。
本文遵守 CC-BY。請保持轉載後文章內容的完整,以及文章出處。本人保留所有版權相關權利。