您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

面向協議編程與 Cocoa 的邂逅(下):動手重構一個網絡層

編輯:iOS 開發基礎

本文是筆者在 MDCC 16(移動開發者大會)iOS 專場主題演講的文字整理,上半部分談的是理論:面向對象的困境、面向協議的基本概念與決策模型。下半部分則回到實務,看看日常與 Cocoa 打交道時,POP 究竟能幫上什麼忙。

從理論走進日常開發

WWDC 2015 的 #408 號演講《Protocol-Oriented Programming in Swift》是 POP 的一篇優秀入門,Apple 工程師用畫圖與排序兩個例子闡釋了 POP 的解耦思路與組合式重用。但那場演講偏理論,而我們每天寫 App,面對的其實是 Cocoa 框架。看完之後我們一直在想:怎麼把 POP 落進日常代碼裡?

接下來用一個真實場景來回答這個問題——網絡請求層。

為什麼網絡層適合 POP

網絡請求層是實踐 POP 的理想場所。我們會從零開始,先用最直白的面向協議方式搭出一個「能用但不完美」的請求與模型層,它必然帶著不合理的設計與耦合;然後逐步梳理職責邊界並重構;最後為它補上測試。目標是得到同時具備類型安全、低耦合、易測試與良好擴展性的代碼。

Talk is cheap, show me the code.

第一版:先跑起來再說

需求很簡單:從 API 撈一段 JSON,轉成 Swift 可用的模型。示例 API 可以直接訪問 https://api.onevcat.com/users/onevcat,回傳:

{"name":"onevcat","message":"Welcome to MDCC 16!"}

新建專案後加上 User.swift:

// User.swift import Foundation struct User {     let name: String     let message: String     init?(data: Data) {         guard let obj = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] else {             return nil         }         guard let name = obj?["name"] as? String else {             return nil         }         guard let message = obj?["message"] as? String else {             return nil         }         self.name = name         self.message = message     } }

User.init(data:) 把回傳數據解析為 JSON,取出 name 與 message,組出 User 實例。

接下來是有意思的部分:用 POP 的方式從 URL 取數據並生成 User。先定義一個協議代表「請求」,它需要交代路徑、方法與參數:

enum HTTPMethod: String {     case GET     case POST } protocol Request {     var host: String { get }     var path: String { get }     var method: HTTPMethod { get }     var parameter: [String: Any] { get } }

host 與 path 拼接後即為請求位址。為簡化,這裡只保留 GET 與 POST,且示例只用 GET。接著讓 UserRequest 滿足協議:

struct UserRequest: Request {     let name: String     let host: = "https://api.onevcat.com"     var path: String {         return "/users/\(name)"     }     let method: HTTPMethod = .GET     let parameter: [String: Any] = [:] }

name 沒有預設值,其餘都是為了滿足協議。因為參數是透過 URL 傳遞的,parameter 給個空字典就好。有了協議與具體請求,接著要能發送。為了讓所有 Request 共用同一套發送邏輯,把方法寫在協議擴展上:

extension Request {     func send(handler: @escaping (User?) -> Void) {         // ... send 的實現     } }

但回調參數寫死成 User,顯然無法通用。這裡用關聯類型把結果抽象出來:

protocol Request {     ...     associatedtype Response } struct UserRequest: Request {     ...     typealias Response = User }

於是 send 可以改寫成泛型版本,這裡用 URLSession 發送:

extension Request {     func send(handler: @escaping (Response?) -> Void) {         let url = URL(string: host.appending(path))!         var request = URLRequest(url: url)         request.httpMethod = method.rawValue         // 示例中不需要 httpBody,實務上可能需要把 parameter 轉成 data         let task = URLSession.shared.dataTask(with: request) { data, res, error in print(data) } task.resume()     } }

剩下的事是把回調裡的 data 轉成合適的型別。User 有 User.init(data:) 可用,但泛型 Response 沒有。直覺做法是再要求協議實作一個 parse 方法,把轉換責任「下放」給 UserRequest:

protocol Request {     ...     associatedtype Response     func parse(data: Data) -> Response? } struct UserRequest: Request {     ...     typealias Response = User     func parse(data: Data) -> User? {         return User(data: data)     } }

send 於是得以處理結果,並切回主線程回調:

    let task = URLSession.shared.dataTask(with: request) { data, _, error in         if let data = data, let res = parse(data: data) {             DispatchQueue.main.async { handler(res) }         } else {             DispatchQueue.main.async { handler(nil) }         }         } task.resume()

試一下:

let request = UserRequest(name: "onevcat") request.send { user in     if let user = user {         print("\(user.message) from \(user.name)")     } } // Welcome to MDCC 16! from onevcat

重構:把職責拆開

能跑,但設計很糟。問題在於 Request 管得太多:它應該只定義請求入口與期望的響應型別,現在卻連 host 的值、數據怎麼解析都一手包辦;send 更是被綁死在 URLSession 上,還掛在 Request 底下。這意味著我們無法在不改動請求的前提下更換發送方式,兩者被硬焊在一起。

這種結構讓測試變得極其痛苦:必須靠 stub、mock 攔截請求再回構造數據,得動用 NSURLProtocol 或引入第三方測試框架,專案複雜度直線上升。在 Objective-C 時代這或許是妥協項,但 Swift 有更漂亮的解法。

第一步,把 send 從 Request 抽出來,定義一個負責發送的協議:

protocol Client {     func send(_ r: T, handler: @escaping (T.Response?) -> Void)     var host: String { get } }

注意這裡不能直接把 Request 當參數型別——含關聯類型的協議只能作為約束,不能作為獨立型別,因此改用泛型參數 T。同時把 host 從 Request 搬到 Client,那才是它該待的地方。

刪掉 Request 上的擴展,重新實作一個滿足 Client 的型別,內部一樣用 URLSession:

struct URLSessionClient: Client {     let host = "https://api.onevcat.com"     func send(_ r: T, handler: @escaping (T.Response?) -> Void) {         let url = URL(string: host.appending(r.path))!         var request = URLRequest(url: url)         request.httpMethod = r.method.rawValue         let task = URLSession.shared.dataTask(with: request) { data, _,, error in             if let data = data, let res = T.Response.parse(data: data) {                 DispatchQueue.main.async { handler(res) }             } else {                 DispatchQueue.main.async { handler(nil) }             }         } task.resume()     } }

發送與請求本身終於分開了,而且 Client 是協議,任何型別都能實作它。這在測試時會帶來關鍵好處。

第二個問題是 parse。請求不該知道怎麼解析數據,這該由 Response 自己負責。新增一個協議:

protocol Decodable {     static func parse(data: Data) -> Self? }

並用它約束 Response,Request 裡的 parse 宣告就可以移除:

protocol Request {     var path: String { get }     var method: HTTPMethod { get }     var parameter: [String: Any] { get }     associatedtype Response: Decodable }

讓 User 滿足 Decodable,並把 Client 內的解析改成呼叫 Response 的靜態方法:

extension User: Decodable {     static func parse(data: Data) -> User? {         return User(data: data)     } }

清理 UserRequest 中不再需要的 host 與 parse 後,一個類型安全、低耦合的網絡層就出現了:

URLSessionClient().send(UserRequest(name: "onevcat")) { user in     if let user = user {         print("\(user.message) from \(user.name)")     } }

要加單例降低建立成本、要改成 Promise 風格呼叫,在這個結構下都很自然,也不會牽動請求的其他部分。新增 API 時,只需定義請求必要內容,不必碰網絡實作。

網絡層測試

把 Client 定義成協議,額外好處是不再綁定某種特定技術。你可以輕易換成 AFNetworking 或 Alamofire,也可以提供一組「假」的回應來做測試。概念上接近傳統的 stub & mock,但實作簡單得多,也更明確。

先準備一個文字檔並加入測試 target,作為回傳內容:

// 文件名:users:onevcat {"name":"Wei Wang", "message": "hello"}

再寫一個滿足 Client 的型別。它的 send 不會真的發請求,而是從本地讀檔並驗證模型是否正確——這正是測試要確認的事:若服務端依文件正確回應,我們能否得到正確的模型。

struct LocalFileClient: Client {     func send(_ r: T, handler: @escaping (T.Response?) -> Void) {         switch r.path {         case "/users/onevcat":             guard let fileURL = Bundle(for: ProtocolNetworkTests.self).url(forResource: "users:onevcat", withExtension: "") else { fatalError() }             guard let data = try? Data(contentsOf: fileURL) else { fatalError() }             handler(T.Response.parse(data: data))         default: fatalError("Unknown path")         }     }     // 為了滿足 Client 的要求,實際不會發請求     let host = "" }

要測其他請求,加新的 case 即可。測試本身因此變得非常直白:

func testUserRequest() {     let client = LocalFileClient()     client.send(UserRequest(name: "onevcat")) { user in         XCTAssertNotNil(user)         XCTAssertEqual(user!.name, "Wei Wang")     } }

沒有第三方測試庫,沒有 URL 代理,也沒有 runtime 消息轉發這些複雜技巧。保持代碼與邏輯簡單,對專案的維護與演進至關重要。

可擴展性

高度解耦換來的,是寬鬆的擴展空間。Client 不必自己從頭實作,可以包裝現成框架;想換掉正在使用的請求方式,也不會影響請求的定義與呼叫端。Response 這邊同理,如今有了 Decodable,要換成任何 JSON 解析庫,只需實作一個把 Data 轉成模型的方法。

如果你對這種 POP 風格的網絡層與模型解析有興趣,可以看看 APIKit,本文示例的核心思路正來自那個框架。

結語:讓協議成為設計工具

面向協議讓我們從繼承的束縛中解放出來,像堆積木一樣組裝程式。每個協議專注於自己的職能,加上協議擴展,我們得以降低類與繼承帶來的共享狀態風險,讓代碼更清晰。

高度協議化有助於解耦、測試與擴展;搭配泛型使用,還能免於動態派發與型別轉換的困擾,保住編譯期安全。

提問環節

Q:示範裡你都是先寫 protocol,實踐 POP 都該這樣嗎?
A:我直接寫 protocol,是因為我很清楚要做什麼,也不希望演講超時。實際開發時,一開始未必寫得出合適的協議定義。建議先「粗略」定義,再透過重構收斂;也可以先用紙筆勾勒輪廓。當然,也沒人規定必須先定義協議,你完全可以從普通型別寫起,等發現共通點或遇到困境時,再回頭判斷 POP 是否更合適——這需要一些經驗累積。

Q:既然 POP 這麼好,是否就不需要面向對象了?
A:答案可能令人失望。日常打交道的 Cocoa 依然是個帶濃厚 OOP 色彩的框架,短期內不可能拋棄 OOP。所幸兩者能和諧共處。也要補充,POP 並非銀彈:最大的問題是它會增加代碼的抽象層級(這點與類繼承相同),當協議又繼承其他協議時尤其嚴重。層層繼承之後,要滿足末端協議會變得困難,你也難以確定某個方法究竟滿足哪個協議的要求,代碼迅速複雜化。若一個協議並未描述足夠的共通點,用基本型別反而更簡單。

Q:你們專案裡實際怎麼用 POP?
A:用得很多。上面網絡請求的例子就是從真實專案抽出來的,寫起來非常輕鬆,代碼簡單,新人交接也順手。除了模型層,view 與 view controller 層也用了一些 POP 手法,例如從 nib 建立 view 的 NibCreatable、支援分頁載入的 NextPageLoadable、空列表顯示頁面的 EmptyPage 等。每個協議都讓 View Controller 變短,也讓測試變成可能。

推薦資料

  • Protocol-Oriented Programming in Swift — WWDC 15 #408

  • Protocols with Associated Types — @alexisgallagher

  • Protocol Oriented Programming in the Real World — @_matthewpalmer

  • Practical Protocol-Oriented-Programming — @natashatherobot

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved