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

基於徹底解耦的實驗性 iOS 架構:EventMVVM

編輯:iOS 開發基礎

  • 本文由 CocoaChina 譯者 @ALEX吳浩文 翻譯,歡迎指正。

  • 作者:Chris

  • 原文:An Experimental iOS Architecture Based on Radical Decoupling


這周我決定做一個關於徹底解耦的應用架構實驗,想探究的主題是:

「如果應用的所有內部通訊都通過一個事件流來完成,會怎樣?」

我構造了一個待辦事項應用,因為這是我一時興起所能想到的最原始微型的項目。我會大概介紹架構背後的思路,展示實現中的一些代碼片段,並給出幾點利弊結論。整個項目已放上 GitHub,本文基於 0.1 標籤下的代碼。

應用演示

架構總述

為方便稱呼,我把這個架構叫做 EventMVVM。它借鑑了少量 MVVM(Model-View-ViewModel)思想,並用 ReactiveCocoa 作為事件流的管道(後面會說到其他工具也能勝任)。它用 Swift 編寫,這點有點重要,因為 Swift 的枚舉關聯值特性以及易於定義、使用值類型。

解釋架構最好的方式是命名並列舉參與者,給出定義,再列出規則:

  • Event

  • EventsSignal & EventsObserver

  • Server

  • Model

  • ViewModel

  • View

Event

一個 Event 是消息的構建代碼塊,定義為枚舉,每種情況最多帶一個關聯值(注意:這與 ReactiveCocoa 的 Event 不同)。你可以把它看作強類型的 NSNotification,約定每種情況以 Request 或 Response 開頭。示例:

/// Event.swift enum Event {     // Model     case RequestReadTodos     case ResponseTodos(Result)     case RequestWriteTodo(Todo)      // ...      // ViewModel     case RequestTodoViewModels     case ResponseTodoViewModels(Result)     case RequestDeleteTodoViewModel(TodoViewModel)      // ... }
  • Model 和 ViewModel「類型」的事件都包含在 Event 枚舉中(注解 1)。

  • RequestReadTodos 沒有參數,因為本應用無需預先篩選或排序(注解 2)。

  • 用 Result 封裝返回值或異常(注解 3)。

  • 所有枚舉項的關聯值都是值類型,這對保證系統健全很重要,因為同一 Event 可能被任意線程上的多個對象接收。

EventsSignal & EventsObserver

二者將作為我們共享的事件流。注入到類裡後,這些類既能附加觀察者塊到 eventsSignal,也能發送新 Event 到 eventsObserver。

/// AppContext.swift class AppContext {     let (eventsSignal, eventsObserver) = Signal.pipe()     // ... }

我們把這個元組放進一個叫 AppContext 的類裡,它用 ReactiveCocoa 的 Signal 及一對通過 .pipe() 創建的觀察者來實現。簡化後的語法如下:

// 在流中創建新的觀察者 eventsSignal.observeNext { event in print(event) } // 在流中發送一個新的事件 eventsObserver.sendNext(Event.RequestTodoViewModels)

Server

Server 是長存活的類,它包含觀察者並能發送消息。示例應用中有兩個 Server——ViewModelServer 和 ModelServer,都由 AppDelegate 創建並持有。顧名思義,ViewModelServer 負責處理與 ViewModel 相關的職責:接收請求並滿足它們,要麼改變 Event 中的 ViewModel,要麼發送新 Event 去請求所需數據(注解 4、5)。Server 是應用中的「智能」對象,是協調器,負責創建、操縱 ViewModel 與 Model 值類型,並通過創建帶值的 Event 與其他 Server 交流。

Model

Model 是包含基礎數據的值類型,在標準 MVVM 中不應包含任何針對底層數據庫的東西。示例中用擴展把 Todo 序列化為 TodoObject 以存入 Realm 數據庫。模型層只知道自己,不知道 ViewModel 和 View。

ViewModel

ViewModel 是值類型,包含在 View 層裡並可直接使用。例如 UILabel 顯示的文本就該是 String。ViewModel 在 init 中接收並存儲 Model,將其轉為 View 可用的形式,也可組合其他 ViewModel 供子視圖使用。按此解釋(注解 6),ViewModel 完全惰性,不能異步操作、也不向事件流發消息,這確保了它們能安全地跨線程傳遞。ViewModel 不知道 View 層,只操作其他 ViewModel 和 Model。

View

View 層即 UIKit,包括 UIViewControllers、UIViews 及其子類。我本想探索讓 View 層也通過事件流發送自己的事件,但在這個簡單實現裡並無必要,反而最易分散注意力(注解 7)。View 層只允許與 View 和 ViewModel 交互,對 Model 一無所知。

實現

了解了各組件後,我們深入代碼看它如何運作。

The Spec(軟件規格說明書)

我們的待辦列表有哪些特性?這對應著我們的 Event,也是最令我興奮的部分。Event.swift:

  • RequestTodoViewModels:希望按預設順序、過濾掉已刪除項,查看所有待辦。

  • RequestToggleCompleteTodoViewModel:能在列表視圖把待辦標記為完成。

  • RequestDeleteTodoViewModel:能在列表視圖刪除它們。

  • RequestNewTodoDetailViewModel:能創建新的待辦。

  • RequestTodoDetailViewModel:能漂亮地查看/編輯一個待辦。

  • RequestUpdateDetailViewModel:能提交我們的更改。

這些都是來自 View 層的請求。由於只是廣播的事件/消息,不一定有一對一的響應,這帶來了正反兩面影響。正面之一是:我們需要更少類的響應事件。RequestTodoViewModels 會有一對一響應,但 RequestToggleCompleteTodoViewModel、RequestDeleteTodoViewModel 和 RequestUpdateDetailViewModel 都由 ResponseTodoViewModel 響應。這簡化了 view 代碼,也保證了一個 view 能獲得並傳遞被另一個 view 改變的 ViewModel,無需額外處理。

RequestNewTodoDetailViewModel 和 RequestTodoDetailViewModel(即新建與編輯)由 ResponseTodoDetailViewModel 響應。有趣的是,RequestUpdateDetailViewModel 必須由 ResponseUpdateDetailViewModel 和 ResponseTodoViewModel 響應,因為其底層待辦 Model 改變了。

為滿足來自 View 層的請求,ViewModelServer 需要向 Model 數據發出自己的請求,這些是一對一的:

  • RequestReadTodos -> ResponseTodos

  • RequestWriteTodo -> ResponseTodo

我們通過設置一個標誌位來實現待辦的刪除,這種做法讓應用各層之間的協調變得更簡單。下圖展示了四個主要對象如何發送和觀察事件:

系統設置

/// AppDelegate.swift class AppDelegate: UIResponder, UIApplicationDelegate {     var appContext: AppContext!     var modelServer: ModelServer!     var viewModelServer: ViewModelServer!     // ...     func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {                  self.appContext = AppContext()         self.modelServer = ModelServer(configuration: Realm.Configuration.defaultConfiguration, appContext: appContext)         self.viewModelServer = ViewModelServer(appContext: appContext)         let todoListViewModel = TodoListViewModel()         let todoListViewController = TodoListViewController(viewModel: todoListViewModel, appContext: appContext)         let navigationController = UINavigationController(rootViewController: todoListViewController)         //...      } }

如前所述,AppContext 包含元組 eventSignal 與 eventObserver,我們把它注入到所有其他高層組件,允許它們交流。必須保留 ModelServer 和 ViewModelServer,因為它們沒有 view 層、也不互相直接引用(注解 8)。記得 TodoListViewModel 只是惰性結構。雖然這個簡單應用可以讓 TodoListViewController 自建 ViewModel,但注入是更好的實踐途徑——你很容易想象給應用加上「列表的列表」功能,那樣我們(可能?)無需改動任何接口。

View 層:列表

我們的系統邊界很清晰:View 層負責處理所有 ViewModel 請求並觀察所有 ViewModel 響應。這部分的主角是 TodoListViewController:

// TodoListViewController.swift final class TodoListViewController: UITableViewController {     let appContext: AppContext     var viewModel: TodoListViewModel     // ... }

我們發送第一個事件,請求 TodoViewModels 來填充視圖出現時的列表:

// TodoListViewController.swift     override func viewWillAppear(animated: Bool) {         super.viewWillAppear(animated)         appContext.eventsObserver.sendNext(Event.RequestTodoViewModels)     }

接著設置一個觀察者來響應事件。View 層的觀察者總放在 viewDidLoad 裡,其生命周期與 UIViewController 一致。

    override func viewDidLoad() {         // ...         appContext.eventsSignal             //...             .observeNext { _ in                 //...             }     }

剖析一個觀察者

我們所有觀察者的結構非常相似:生命周期、過濾、拆箱、映射、錯誤處理、輸出。對 View 層而言,輸出通常是副作用(如更新 ViewModel 並刷新列表);對其他 Server 而言,輸出通常是發送另一個 Event。以 Event.ResponseTodoViewModels 為例:

    appContext.eventsSignal         .takeUntilNil { [weak self] in self }  // #1         .map { event -> Result? in  // #2             if case let .ResponseTodoViewModels(result) = event {                 return result             }             return nil         }         .ignoreNil()  // #2         .promoteErrors(NSError)  // #3         .attemptMap { $0 }  // #3         .observeOn(UIScheduler())  // #4         .flatMapError { [unowned self] error -> SignalProducer in  // #3             self.presentError(error)             return .empty         }         .observeNext { [unowned self] todoViewModels in  // #5             let change = self.viewModel.incorporateTodoViewModels(todoViewModels)             switch change {             case .Reload:                 self.tableView.reloadData()             case .NoOp:                 break             }         }
  • #1:這是 ReactiveCocoa 的實現細節(相當於注解 9),把觀察者生命周期限制在 self 生命周期內,即 TodoListViewController 消失時停止處理。

  • #2:這裡從事件中過濾、拆包。我們觀察的是整個應用的 Event 消防帶,只想要 ResponseTodoViewModels,其他事件會被映射為 nil 再由 ignoreNil() 丟棄。

  • #3:這是錯誤處理。promoteErrors 把無法報錯的信號轉為可發送指定類型錯誤的信號;attemptMap 從 Result 拆包,配合內建錯誤處理;flatMapError 是錯誤的副作用,此處以警報呈現。若改用 observeError,觀察者會在第一個錯誤後被處理掉,這並非我們想要的(注解 10)。

  • #4:Event 可能被交付到任意線程,因此關鍵工作需指定目標調度器。此處關鍵工作是 UI 相關,故用 UIScheduler。注意只有 observeOn 之後的操作才能在 UIScheduler 上執行(注解 11)。

  • #5:最後拿到正確事件的非錯值,用它完全取代 TodoListViewModel,並在列表有真正變化時有條件地刷新。

更多操作

我們用 UITableViewRowAction API 發送事件,為待辦標記完成或刪除:

// TodoListViewController.swift     override func tableView(tableView: UITableView, editActionsForRowAtIndexPath indexPath: NSIndexPath) -> [UITableViewRowAction]? {         let todoViewModel = viewModel.viewModelAtIndexPath(indexPath)         let toggleCompleteAction = UITableViewRowAction(style: UITableViewRowActionStyle.Normal, title: todoViewModel.completeActionTitle) { [unowned self] (action, path) -> Void in             self.appContext.eventsObserver.sendNext(Event.RequestToggleCompleteTodoViewModel(todoViewModel))         }         // ...         return [deleteAction, toggleCompleteAction]     }

這些 Event 只修改 ViewModel,View 層只關心 TodoViewModel 粒度級的變化。我們想觀察 ResponseTodoViewModel,讓視圖始終顯示最準確的待辦,並加上好看的動畫:

// TodoListViewController.swift - viewDidLoad()     appContext.eventsSignal         // Event.ResponseTodoViewModel         //...         .observeNext { [unowned self] todoViewModel in             let change = self.viewModel.incorporateTodoViewModel(todoViewModel)             switch change {             case let .Insert(indexPath):                 self.tableView.insertRowsAtIndexPaths([indexPath], withRowAnimation: .Top)             case let .Delete(indexPath):                 self.tableView.deleteRowsAtIndexPaths([indexPath], withRowAnimation: .Left)             case let .Reload(indexPath):                 self.tableView.reloadRowsAtIndexPaths([indexPath], withRowAnimation: .Fade)             case .NoOp:                 break             }         }

這些都是基本的 View 層。再看 ViewModelServer 如何響應這些請求並發出新的 Event。

ViewModel:列表

ViewModelServer 是一個巨大的、配置觀察者的 init 函數:

// ViewModelServer.swift final class ViewModelServer {     init(appContext: AppContext) {         //... 所有觀察者都在這裡     } }

Event.RequestTodoViewModels 很簡單,它只是從 model 層創建一個對應請求(注解 12):

    appContext.eventsSignal         //... Event.RequestTodoViewModels         .map { _ in Event.RequestReadTodos }         .observeOn(appContext.scheduler)         .observe(appContext.eventsObserver)

我們把事件發回 eventsObserver 來派遣新 Event。注意必須在特定調度器裡派遣,否則會死鎖。

Event.ResponseTodos 是對剛發出的 Model 事件的響應:

    appContext.eventsSignal         //... Event.ResponseTodos         .map { result -> Result in             return result                 .map { todos in todos.map { (todo: Todo) -> TodoViewModel in TodoViewModel(todo: todo) } }                 .mapError { $0 } // placeholder for error mapping         }         .map { Event.ResponseTodoViewModels($0) }         .observeOn(appContext.scheduler)         .observe(appContext.eventsObserver)

我們把 Result 映射後作為新 Event 返回。這裡有個占位符,用於將 Model 層的錯誤映射到更適合展示給用戶的形式(注解 13)。

其他 ViewModel 事件

View 層可能發送 RequestToggleCompleteTodoViewModel 和 RequestDeleteTodoViewModel 來動態改變個別 ViewModel。

用於刪除的 map 塊:

    .map { todoViewModel -> Event in         var todo = todoViewModel.todo         todo.deleted = true         return Event.RequestWriteTodo(todo)     }

用於標記已完成的 map 塊:

    .map { todoViewModel -> Event in         var todo = todoViewModel.todo         todo.completedAt = todo.complete ? nil : NSDate()         return Event.RequestWriteTodo(todo)     }

簡單轉換後發出消息。這兩個事件都將在 Event.ResponseTodo 接收響應:

    .map { result -> Result in         return result.map { todo in TodoViewModel(todo: todo) }     }     .map { Event.ResponseTodoViewModel($0) }

其他要點

我不會深究其他事件,只提幾個有趣點。

TodoDetailViewModel:TodoDetailViewController 接收一個 TodoDetailViewModel 以允許用戶改變屬性。當「完成」被點擊,它會用自己的 TodoDetailViewModel 向 ViewModelServer 發請求,後者驗證新參數後回覆響應。響應事件 Event.ResponseUpdateDetailViewModel 很有趣,它會被三個不同對象觀察:

  • TodoDetailViewController 觀察它的錯誤,若有驗證錯誤就在當前上下文呈現。

  • TodoListViewController 觀察非錯值,作為用戶結束編輯的信號去解釋它,並彈回 TodoDetailViewController。

  • ViewModelServer 觀察自己將發送的消息,因為現在它必須立即創建更新待辦 Model 並發送寫待辦 Event,其響應會通過正常 Event 流傳回,由 TodoListViewController 透明更新。

ResponseUpdateDetailViewModel:我有點想把通用化的 CRUD 新建與編輯集於一個接口,已保存與未保存的待辦都能同樣處理。驗證被視為異步,因此可輕鬆當作服務器端操作。

加載:我沒實現加載指示器,只因這是小事。ViewController 會觀察自己的 Request 事件並作為副作用打開加載指示器,再作為 Response 事件的副作用關閉它。

唯一標識符:你可能注意到,代碼庫中每個值類型都必須可比較。由於請求與響應不直接配對,唯一標識符是過濾和操作響應的關鍵。實際上有兩種相等概念:一是一般的相等(兩個 model 所有參數值是否相同),二是身份的相等(兩個 model 是否表示相同的底層資源,即 lhs.id == rhs.id)。身份相等在操作一個已被更新、想替換它的 model 時很有用。

測試:我認為測試明顯在 ViewModelServer 和 ModelServer 層。這些 Server 註冊的觀察者本質上是純函數,收到單個事件並派遣單個事件。單元測試示例:

// todostreamTests.swift     func testRequestToggleCompleteTodoViewModel() {         viewModelServer = ViewModelServer(appContext: appContext)         let todo = Todo()         XCTAssert(todo.complete == false)         let todoViewModel = TodoViewModel(todo: todo)         let event = Event.RequestToggleCompleteTodoViewModel(todoViewModel)         let expectation = expectationWithDescription("")         appContext.eventsSignal.observeNext { (e: todostream.Event) in             if case let todostream.Event.RequestWriteTodo(model) = e {                 XCTAssert(model.complete == true)                 expectation.fulfill()             }         }         appContext.eventsObserver.sendNext(event)         waitForExpectationsWithTimeout(1.0, handler: nil)     }

這測試了 ViewModelServer 中的一個觀察者,並在 ViewModelServer 與 ModelServer 邊界等待結果 Event。集成測試也非不可能,下面是不再等待 View 與 ViewModelServer 邊界的集成測試版本:

// todostreamTests.swift     func testIntegrationRequestToggleCompleteTodoViewModel() {         viewModelServer = ViewModelServer(appContext: appContext)         modelServer = ModelServer(configuration: Realm.Configuration.defaultConfiguration, appContext: appContext)         let todo = Todo()         XCTAssert(todo.complete == false)         let todoViewModel = TodoViewModel(todo: todo)         let event = Event.RequestToggleCompleteTodoViewModel(todoViewModel)         let expectation = expectationWithDescription("")         appContext.eventsSignal.observeNext { (e: todostream.Event) in             if case let todostream.Event.ResponseTodoViewModel(result) = e {                 let model = result.value!.todo                 XCTAssert(model.id == todo.id)                 XCTAssert(model.complete == true)                 expectation.fulfill()             }         }         appContext.eventsObserver.sendNext(event)         waitForExpectationsWithTimeout(1.0, handler: nil)     }

此時後台有兩個其他事件同時發送,但我們只等待最後一個。這兩個 Server 都處在表層,只對 EventSignal 有依賴性。

回顧

看完這個基本應用的實現,讓我們退一步,看看一路走來發現的利弊。

  • 利:一些在其他架構很難的事情變容易了!

  • 弊:一些在其他架構很簡單的事情變難了!

  • 利:這種代碼風格其實很有趣。

  • 弊:可能存在目前未知的性能影響,考慮到觀察者眾多、每個又接收大量必須過濾的事件。

  • 利:線程似乎很安全。

  • 弊:仍有很多未解問題。如何處理圖片加載?身份驗證?特定順序的多步操作?列表重排序?更複雜的視圖改變類型?其他異步 API 封裝?問題無窮無盡,一個半生不熟的待辦應用幾乎沒擴大系統複雜性的范圍。

  • 利:所有代碼(除 UIKit 外)風格相似且實用。

  • 弊:所有事件是全局的,系統規模與複雜性增長後,更多意想不到的後果可能發生。

  • 弊:觀察者聲明裡有相當數量格式雷同的套話。

  • 利:更容易理清對象的所有者和生命周期。

  • 弊:用 Result 做異常處理並不合適,直覺上另有更好的辦法(注解 14)。

  • 利:測試可說是相當無痛的過程。

  • 利:能「重放」用戶的整個會議過程——把 eventsSignal 序列化的輸出,通過管道灌入新會話的 eventsObserver。

  • 利:分析變得很容易,作為一個單獨的 Server-type 對象,監聽 Event、轉換並在必要時 POST 到服務器。

庫

完成這個待辦應用後,我意識到 ReactiveCocoa 不一定是實現 EventMVVM 的最佳工具,它的很多特性我並沒用到,還有一些怪癖(注解 15)。於是我決定試試能否自己寫一個為 EventMVVM 量身定做的庫。我花了一天與類型系統搏鬥,最終寫出約 100 行代碼。可惜它無法自動化所有我想要的東西,觀察過程仍有缺點。進展可見我的 GitHub。

總結

探索 EventMVVM 架構很有趣,我大概會作為兼職繼續探索,但絕不會建議用它實現任何重要項目。如果你有想法,歡迎通過 Twitter 告訴我。我確信這種風格已有名字(也許是觀察者模式?)。想想看,只要把下面這個觀察者加到 AppDelegate,就能拿到系統中傳遞的每個 Event 的日誌,多酷:

appContext.eventsSignal.observeNext { print($0) }

1. 未來 EventMVVM 的擴展可以是 ModelEvent 或 ViewModel 事件,各自有輸入流。這樣一個 View 對象只看到 ViewModel 流,而 ViewModelServers 會看到 ViewModel 和 Model 流。

2. 更複雜的應用需要一個 ReadTodosRequest 結構來封裝分類描述符和謂詞,或乾脆用一個更徹底的 TodoListViewModel 承載這些信息。

3. 實踐證明,在響應本身嵌入一個可選的錯誤參數會更好,否則無法知道錯誤與哪個請求相關。我們暫不考慮這個問題。

4. 你當然可以把 ViewModelServer 和 ModelServer 合併為一個 Server(或全放進 AppDelegate),但 MVVM 幫助我們分離關注點。

5. 我最大的未解問題是:若 Server 對象大量互相創建該怎麼辦?任何像樣的應用,一個 ViewModelServer 的流裡有成百上千觀察者都很笨拙,也可能過度消耗資源。若把每個 ViewModel 類型分離出 ViewModelServers,主 ViewModelServer 又該如何管理它們的生命周期?

6. 我大多數用 MVVM 的項目裡,有些 ViewModel 是類、承擔大部分異步工作與數據流組織的重擔,有些則是惰性值類型。這樣做是為了通過分離邏輯,讓 ViewControllers 顯得「遲鈍」一些。

7. 這類事件的例子有 ViewControllerDidBecomeActive(UIViewController) 和 ButtonWasTapped(UIButton)。可見這將打破「只通過流發送值類型」的假設,需要更深思熟慮。我在工作中把它與其他框架一起使用時發現,你可以跳過很多障礙來避免 UIKit 期望你做的事,雖然通常另闢蹊徑會更糟。

8. 在「經典」MVVM 裡,View 擁有 ViewModel,ViewModel 擁有 Model/Controller。

9. 準確來說,觀察者會在任何事件被發送且自身不再活躍時被轉換到完成狀態。就我們的目的而言這不算大事,雖有其他解法,但都需要更多語法要求。

10. 回想起來,讓 Result 一路穿過 observeNext 並在同一代碼塊內處理成功與錯誤,可能更清晰。

11. Scheduler 是 ReactiveCocoa 原生的,很巧妙。

12. 若不熟悉 MVVM,你可能想知道為何 View 層不直接發出 Event.RequestReadTodos,而是通過 ViewModelServer 傳送 Event.RequestTodoViewModels。這個間接層讓 View 層無需知道 Model 層的事務,為自己和他人引入可預測性——所有類型的對象都遵守同一套規則。這看似過於通用,但在大型項目裡我很少發現它是毫無根據的優化。

13. 不包括 Model 層枚舉類型錯誤是因為懶。我們搭建的轉換管道已能輕鬆在正確上下文正確表示它們。

14. 提示:這是給所有 model 和 ViewModel 添加一個 error 參數。

15. 它也可以用 NSNotificationCenter 實現(我沒試過),或用其他 Reactive Swift 庫。


  • 本文僅用於學習和交流,轉載請注明譯者、作者、出處及本文鏈接。

  • 感謝博文視點對本期翻譯活動的支持。

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