面向協議編程(Protocol Oriented Programming,簡稱 POP)是 Apple 在 2015 年 WWDC 提出的 Swift 編程範式。相比傳統的面向對象編程(OOP),POP 更為靈活。搭配 Swift 的值語義與標準庫實作,這一年來人們找到了越來越多適用場景。本文希望先建立 POP 的基礎理解,再引導讀者開始在日常工作中嘗試它。
Swift 標準庫中有五十多個繁簡不一的協議,幾乎所有實際型別都滿足若干協議。protocol 是 Swift 語言的底座,語言的其他部分正是在這個底座上組織起來的——這與我們熟悉的面向對象建構方式很不一样。
protocol Greetable { var name: String { get } func greet() }這段代碼定義了一個名為 Greetable 的協議,含一個 name 屬性與一個 greet 方法。所謂協議,就是一組屬性和/或方法的定義;型別若想遵守它,就得實作這些內容。協議做的事,本質上只是「關於實作的約定」。
在深入協議之前,先重新審視面向對象。這個詞我們都極熟悉,但有個問題並非每個人都想過:OOP 的核心思想究竟是什麼?
class Animal { var leg: Int { return 2 } func eat() { print("eat food.") } func run() { print("run with \(leg) legs") } } class Tiger: Animal { override var leg: Int { return 4 } override func eat() { print("eat meat.") } } let tiger = Tiger() tiger.eat() // "eat meat" tiger.run() // "run with 4 legs"父類 Animal 定義了 leg、eat 與 run 並給出實作;子類 Tiger 依自身情況改寫 leg(四條腿)與 eat(吃肉),run 則沿用父類。Tiger 與 Animal 共享了一部分代碼,被封裝進父類,其他子類也能複用——這正是 OOP 的核心:用封裝與繼承把相關內容放在一起。
前輩們為了替真實世界的對象建模而發展出這套概念,但它有明顯缺陷。真實事物往往是一組特質的組合,而非一脈相承、逐層擴展的樹狀結構。因此我們越來越常發現,繼承並不能很好地抽象事物。
回到 Cocoa。假設有個 ViewController 繼承自 UIViewController,我們想加一個 myMethod:
class ViewCotroller: UIViewController { // 繼承:view, isFirstResponder()... func myMethod() { } }而另一個繼承自 UITableViewController 的 AnotherViewController,也想加同樣的方法:
class AnotherViewController: UITableViewController { // 繼承:tableView, isFirstResponder()... func myMethod() { } }第一個困境出現了:我們很難在不同繼承鏈的類之間共用代碼。用行話說,這叫「橫切關注點」(Cross-Cutting Concerns)——myMethod 位於 UIViewController → ViewCotroller 與 UIViewController → UITableViewController → AnotherViewController 兩條鏈的橫切面上。OOP 無法描述「兩個不同事物具有某個相同特性」,而在這裡,特性的組合顯然比繼承更貼近本質。
可能的解法各有問題:
複製貼上:最糟的選擇,尤其在工期緊張時特別常見。可以理解,但這是壞代碼的起點。
引入 BaseViewController:把共用代碼放到一個 Base 類,或直接在 UIViewController 上加 extension。看似可行,但一路加下去,Base 很快變成垃圾堆——職責不明、誰走了 Base 不清楚、對整體的影響無法預估。
依賴注入:由外部傳入帶有 myMethod 的物件。較好,但引入了額外依賴關係。
多重繼承:Swift 不支援。就算支援,也會撞上另一個著名問題:菱形缺陷。
若有多重繼承,ViewController 與 AnotherViewController 的關係會變成:

這種拓撲下,只需在 ViewController 實作 myMethod,AnotherViewController 就能沿鏈繼承使用,看似完美。但問題在於:當兩個父類都實作了同名方法,子類該用哪一個?由於繼承結構呈菱形,這被稱為菱形缺陷(Diamond Problem)。C++ 選擇把難題丟給開發者,複雜且易人為出錯;絕大多數現代語言則直接迴避多重繼承。
Objective-C 名副其實是門典型 OOP 語言,並繼承了 Smalltalk 的消息發送機制。這套機制極為靈活,卻也相對危險:
ViewController *v1 = ...; [v1 myMethod]; AnotherViewController *v2 = ...; [v2 myMethod]; NSArray *array = @[v1, v2]; for (id obj in array) { [obj myMethod]; }兩個類都實作了 myMethod,這段代碼沒問題。但若陣列裡混進一個沒有實作的型別呢?
NSObject *v3 = [NSObject new]; NSArray *array = @[v1, v2, v3]; for (id obj in array) { [obj myMethod]; } // Runtime error: unrecognized selector sent to instance編譯照樣通過,執行時卻會崩潰。Objective-C 預設你知道方法一定有實作,這是消息發送靈活性必須付出的代價。對 App 開發而言,用可能的崩潰換取靈活,代價實在太高。這雖非 OOP 範式本身的問題,卻在 OC 時代給了我們切膚之痛。
總結起來,OOP 面臨三個問題:動態派發安全性、橫切關注點、菱形缺陷。前者讓錯誤延後到執行期才暴露,可能直接發生在上線產品上;後兩者讓我們難以完美建模,也讓代碼重用變糟。
協議不是新東西,也不是 Swift 的發明。Java 與 C# 稱它為 Interface,Swift 的 protocol 繼承了這個概念並發揚光大。回到 Greetable 並實作它:
struct Person: Greetable { let name: String func greet() { print("你好 \(name)") } } Person(name: "Wei Wang").greet()其他型別也能實作 Greetable,例如 Cat:
struct Cat: Greetable { let name: String func greet() { print("meow~ \(name)") } }於是協議可以當作標準型別,對方法呼叫做動態派發:
let array: [Greetable] = [Person(name: "Wei Wang"), Cat(name: "onevcat")] for obj in array { obj.greet() } // 你好 Wei Wang // meow~ onevcat而未實作的型別會在編譯期就被攔下:
struct Bug: Greetable { let name: String } // Compiler Error: 'Bug' does not conform to protocol 'Greetable'消息誤發送的風險就此消除。只要你留在 Swift 的世界裡,代碼就是安全的。
回到 myMethod。先定義一個含該方法的協議:
protocol P { func myMethod() }此時並未提供任何實作,仍要在各型別中自行實作:
extension ViewController: P { func myMethod() { doWork() } } extension AnotherViewController: P { func myMethod() { doWork() } }你可能要問:這和複製貼上有何不同?確實沒不同。真正帶來質變的是 WWDC 2015 與 Swift 2 引入的協議擴展。它允許我們為協議提供預設實作:
protocol P { func myMethod() } extension P { func myMethod() { doWork() } }之後只要宣告遵守,就能直接使用:
extension ViewController: P { } extension AnotherViewController: P { } viewController.myMethod() anotherViewController.myMethod()更進一步,擴展裡還能加入協議本身沒定義過的方法,並在其中依賴已定義的入口。
協議定義:提供實作入口,遵守者需自行實作。
協議擴展:為入口提供預設實作,並可基於入口提供額外能力。
橫切關注點的問題,就此被簡單且安全地化解。
最後是多重重疊。同名元素的衝突在協議裡依然存在,但可以唯一且安全地確定:
protocol Nameable { var name: String { get } } protocol Identifiable { var name: String { get } var id: Int { get } }同時實作兩者時,一個 name 屬性即可同时满足:
struct Person: Nameable, Identifiable { let name: String let id: Int }有意思的是,若為其中一個協議加上預設 name:
extension Nameable { var name: String { return "default name" } } struct Person: Nameable, Identifiable { // let name: String let id: Int }編譯可以通過——因為 Nameable 的擴展提供了 name,Person 仍能滿足 Identifiable。但若兩個協議都提供了 name 的擴展,就編譯不過了:
extension Nameable { var name: String { return "default name" } } extension Identifiable { var name: String { return "another default name" } } struct Person: Nameable, Identifiable { // let name: String let id: Int } // 無法編譯,name 屬性衝突此時必須在具體型別中明確提供實作:
struct Person: Nameable, Identifiable { let name: String let id: Int } Person(name: "onevcat", id: 123).name // onevcat這裡的行為形似菱形問題,但有本質差異:衝突發生的前提是同名元素且都提供了實作,而協議擴展對協議本身並非必需;同時,具體型別中提供的實作一定是安全且確定的。當然,菱形缺陷沒有被完全消滅,Swift 目前處理多協議衝突的能力仍有不足。
下半部分將展示筆者日常把 POP 思想與 Cocoa 開發結合的實作範例,並逐段解說。