面向协议的MVVM

Protocol-Oriented Programming（POP）

关于面向协议编程的具体内容可以去看Session 408，这里只引用其中一句话：

Don't start with a class.  
Start with a protocol.

Protocol Extentions

Swift 2.0增加了Protocol Extentions这个强大的特性，也是这个特性让POP成为可能。看看这个特性是怎么运作的：

首先定义一个Animal Protocol和其中的属性：

protocol Animal {     var name: String { get }     var canFly: Bool { get }     var canSwim: Bool { get } }

并定义三种具体的动物：

struct Parrot: Animal {     let name: String     let canFly = true     let canSwim = false }  struct Penguin: Animal {     let name: String     let canFly = true     let canSwim = true }  struct Goldfish: Animal {     let name: String     let canFly = false     let canSwim = true }

这里对canFly和canSwim两个属性，每个具体的动物中都要实现一次，非常的不优雅，但利用Swift 2.0我们有了更好的实现方式。

定义Flyable、Swimable两个Protocol

protocol Flyable {      }  protocol Swimable {      }

利用Protocol Extensions给protocol增加默认实现

extension Animal {     var canFly: Bool { return false }     var canSwim: Bool { return false } }  extension Animal where Self: Flyable {     var canFly: Bool { return true } }  extension Animal where Self: Swimable {     var canSwim: Bool { return true } }

这里对于符合Flyable协议的Animal，就把canFly返回true

对于符合Swimable的Animal，就把canSwim返回true

改造三个具体动物的实现

struct Parrot: Animal, Flyable {     let name: String }  struct Penguin: Animal, Flyable, Swimable {     let name: String }  struct Goldfish: Animal, Swimable {     let name: String }

这么写是不是看上去优雅多了。

用Protocol Extentions来提供默认实现相比基类或抽象类有这些优势：

1. 类只能继承一个类，而一个类型可以符合多个Protocol，可以同时被多个Protocol装饰上多种默认行为。

2. Protocol可以被应用到类、结构体和枚举，而类继承只能在类中使用。或者说，Protocol Extensions能为值类型提供默认行为而不仅仅是类。

3. Protocol Extentions不会给类型引进任何额外的状态，它是高度解耦的。

MVVM

关于MVVM这里就不赘述了，可以参考MVVM核心概念

面向协议的MVVM

我们用一个小DEMO来讲述如何实现面向协议的MVVM架构，这个小DEMO就是Xcode提供的Master-Detail模板，里面默认实现了一个TableView列表，点击右上角的加号可以向列表中添加当前日期，我们在这个项目模板的基础上删除无用的代码，来实践我们的POMVVM。

MVVM的数据绑定部分我们采用了GitHub上一个开源库SwiftBond，这个库的优势用法简单方便，支持iOS7，维护者更新较为频繁，目前已经是v4.2.0版本。另外RxSwift这个库也是一个很好的选择。

建议大家阅读后面的内容之前先下载源码跑一下。

POP，一切从Protocol开始思考，用Protocol来提供最高级别的抽象。

MVVMBase

首先我们来抽象MVVM架构层面的东西

抽象出ViewModel

protocol ViewModel {      }

抽象出可绑定的视图，这里用了泛型协议

protocol BindableView {     typealias ViewModelType     var viewModel: ViewModelType! { get }     func bindViewModel(viewModel: ViewModelType) }

抽象出可绑定的TableViewCell，简单继承于BindableView，为了增强抽象性和描述性

protocol BindableTableCell: BindableView {      }

业务抽象

到每个具体界面，首先考虑不是界面的具体实现，而是先抽象出业务逻辑。

protocol MasterViewControllerDataSource {     var items: ObservableArray { get }     var openSwitchCount: Observable { get } }

业务逻辑Protocol：

protocol MasterViewControllerBusinessDelegate {     /// 插入当前日期     func insertNowDate()     /// 更新打开开关的个数     func updateOpenSwitchCount() }

对于主界面上的Cell：

抽象出它的数据源，并通过Protocol Extension给文字颜色提供一个默认的共享实现：

protocol DateCellDataSource {     var text: Observable { get }     var on: Observable { get set }     var textColor: Observable { get } }   extension DateCellDataSource {     var textColor: Observable {         return Observable(.greenColor())     } }

业务逻辑Protocol：

protocol DateCellBusinessDelegate {     mutating func openSwitch()     mutating func closeSwitch() }

对于Detail界面：

数据源Protocol:

protocol DetailViewControllerDataSource {     var on: Observable { get set }     var text: Observable { get set } }

业务逻辑Protocol：

protocol DetailViewControllerBusinessDelegate {     func openSwitch()     func closeSwitch() }

可以发现Cell和Detail拥有相同的业务逻辑，我们后面会说这个问题。

ViewModel

实现主界面的ViewModel:

struct MasterViewModel: MasterViewControllerDataSource {     var items: ObservableArray = ObservableArray([Item]())     var openSwitchCount: Observable = Observable(0) } extension MasterViewModel: MasterViewControllerBusinessDelegate {     /// 插入当前日期     func insertNowDate() {         let item = Item(text: NSDate().description, on: false)         items.insert(item, atIndex: 0)     }          /// 更新打开开关的个数     func updateOpenSwitchCount() {         openSwitchCount.next(currentOpenSwitchCount())     }          /// 获取当前打开开关的个数     private func currentOpenSwitchCount() -> Int {         print(items.array)         let count = items.array.filter { $0.on.value }.count         return count     } } extension MasterViewModel: ViewModel {}

实现Cell的ViewModel:

这里我们为每一个Cell都创建一个ViewModel，把cell中的业务逻辑放到cell的ViewModel中，有效的减少了ViewController中的代码数量。

struct DateCellViewModel: DateCellDataSource {          // -------------------------     // MARK: - Public Properties     // -------------------------          private(set) var text: Observable = Observable(nil)     var on: Observable = Observable(false)          // ------------------------     // MARK: - Underlying Model     // ------------------------          private var item: Item {         didSet {             configureBinding()         }     }          private func configureBinding() {         item.text.bidirectionalBindTo(text)         item.on.bidirectionalBindTo(on)     }          // -----------------     // MARK: - Lifecycle     // -----------------          init(item: Item) {         self.item = item         configureBinding()     }      } extension DateCellViewModel: ViewModel {}

View/ViewController

typealias ViewModelType = protocol

这样就不用关心它具体是哪个类型，只要是符合这些协议的类型都可以。

借助SwiftBond强大的数据绑定功能，对于UITableView和UICollectionView，我们不用再去实现繁琐的UITableViewDataSource中的方法，只要做一下绑定操作后，只要修改了数据（插入、修改、删除），TableView的界面会立刻随之更新。

var viewModel: ViewModelType! func bindViewModel(viewModel: ViewModelType) {     viewModel.dates.lift().bindTo(tableView) { indexPath, dataSource, tableView in         let cell = tableView.dequeueReusableCellWithIdentifier("DateCell", forIndexPath: indexPath) as! DateCell         if let cellViewModel = self.viewModel.cellViewModelAtIndex(indexPath.row) {             cell.bindViewModel(cellViewModel)         }         return cell     } } func insertNewObject(sender: AnyObject) {     viewModel.insertNowDate() }

可以看到这里我们都是用ViewModelType这个类型来调用接口，并不关心具体实现。

Cell中的实现：

class DateCell: UITableViewCell, BindableTableCell {     typealias ViewModelType = DateCellViewModel          var viewModel: ViewModelType?          func bindViewModel(viewModel: ViewModelType) {         self.viewModel = viewModel         viewModel.date.bindTo(textLabel!.bnd_text)         textLabel?.textColor = viewModel.textColor.value     } }

现在基本的实现已经写好了，我们点击主界面右上角的加号时，就会往主界面的MasterViewModel中的items数组中添加一条当前日期的数据，随之界面会自动更新来展现出这条数据。

这里我们会遇到一个问题，如果每个Cell中都有一个开关，在改变开关的时候会去更新CellViewModel，那么这个更新如何同步到整个列表的ViewModel的Items数组中呢？如果是用Objective-C实现，那么可能这个问题不是一个问题，但是我们用的是Swift实现，总所周知，Swift中的数组是值类型的，就是说，如果我们这样操作：

let array = ["a", "b", "c"] var item = array[1] item = "new"

从数组里通过下标去取一个值，然后改变这个值，这个改变是不会作用到原数组中的。

我们可以借助SwiftBond库提供的双向绑定功能来解决这个问题

// 把数据绑定到TableView上 viewModel.items.lift().bindTo(tableView) { indexPath, dataSource, tableView in     let cell = tableView.dequeueReusableCellWithIdentifier("Cell", forIndexPath: indexPath) as! DateCell     let item = dataSource[indexPath.section][indexPath.row]          // 为每个cell绑定cellViewModel     let cellViewModel = DateCellViewModel(item: item)     cell.bindViewModel(cellViewModel)          return cell }

这里通过下标从dataSource中取出了item，按道理说对item的属性进行赋值是不会改变viewModel的items数组中对应的item的值的。但是Swift对值类型的拷贝时机是有优化的，一般来说，拷贝操作会尽量推迟到真正需要拷贝的时候。所以我们可以在真正的拷贝发生前对其进行双向绑定，就能解决这个问题了。

这里在cell.bindViewModel中去进行双向绑定：

func bindViewModel(var viewModel: ViewModelType) {     self.viewModel = viewModel          bnd_bag.dispose()          // ViewModel中关于text的属性单向绑定到label的相关属性上     viewModel.text.bindTo(label.bnd_text)     viewModel.textColor.bindTo(label.bnd_textColor)          // ViewModel的on和UISwitch的on双向绑定     viewModel.on.bidirectionalBindTo(cellSwitch.bnd_on)          cellSwitch.bnd_on         .distinct()         .observeNew { switchOn in             if switchOn {                 viewModel.openSwitch()             } else {                 viewModel.closeSwitch()             }         }.disposeIn(bnd_bag) }

我们可以在cell中的开关切换状态时，去读取一下items数组中on为true的项目的个数，并且显示在tableHeaderView中，经测试是没有问题的。

然后，用同样的方法，在点击cell后进入详情时，同样也是从items数组中取出一个item，并用其创建一个DetailViewModel，传给DetailViewController，代码如下：

override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {     if segue.identifier == "showDetail" {         if let indexPath = self.tableView.indexPathForSelectedRow {             let controller = segue.destinationViewController as! DetailViewController                                          // 取出viewModel.items中对应的Item，创建一个DetailViewModel             let detailViewModel = DetailViewModel(item: viewModel.items[indexPath.row])             controller.viewModel = detailViewModel         }     } }

在DetailViewController中进行绑定操作：

func bindViewModel(viewModel: ViewModelType) {     // ViewModel的text和TextField的text双向绑定     viewModel.text.bidirectionalBindTo(detailTextField.bnd_text)     // ViewModel的text单项绑定到Label上     viewModel.text.bindTo(detailDescriptionLabel.bnd_text)          // ViewModel的on和UISwitch的on双向绑定     viewModel.on.bidirectionalBindTo(detailSwitch.bnd_on)          detailSwitch.bnd_on.observeNew { switchOn in         if switchOn {             viewModel.openSwitch()         } else {             viewModel.closeSwitch()         }     } }

进入详情界面后，会发现对Switch进行开关，或者修改TextField中的内容，这些变化都会反馈到主列表界面中。

抽取公共逻辑

首先创建Switchable协议，符合这个协议的结构就是可以支持开关切换的。它的实现如下：

protocol Switchable {     var on: Observable { get set }     mutating func openSwitch()     mutating func closeSwitch() } extension ViewModel where Self: Switchable {     func openSwitch() {         print("I have opened the switch.")     }          func closeSwitch() {         print("I have closed the switch.")     } }

我们对ViewModel这个Protocol进行了扩展，凡是实现了Protocol协议，并且也实现了Switchable协议的结构，会自动获得openSwitch()和closeSwitch()这两个默认的实现。

然后把DateCellViewModel和DetailViewModel都去符合一下Switchable协议，这两个ViewModel就都获得了默认实现，不需要分别各自实现了。

DateCellViewModel:

extension DateCellViewModel: DateCellBusinessDelegate, Switchable {}

DetailViewModel:

extension DetailViewModel: DetailViewControllerBusinessDelegate, Switchable {}

这样POMVVM的结构就基本完成了。

总结

可以看到它相比普通的MVVM：

• 能提供更高的抽象。

• 面向接口编程实现解耦。

• 更符合Swift的写法，更加优雅。

• 可以用Protocol Extentions抽取公共的业务逻辑。

• 利用Protocol Extentions给类型添加/去除功能而不引进额外状态。

参考资料

本文源代码下载地址： https://github.com/liuduoios/POMVVMDemo

参考资料：