首页 >Swift

面向协议的MVVM

2016-02-11 06:13 编辑: suiling 分类:Swift 来源:刘铎.Me的博客

70.jpg

苹果在WWDC2015上介绍了面向协议的编程思想,以及Swift 2.0中可以支持这一编程思想的新特性。
参见WWDC2015 Session 408 Protocol-Oriented Programming in Swift
然后女中豪杰NatashaTheRobot将其和MVVM结合起来,写了一篇文章介绍面向协议的MVVM(POMVVM),并在2015年底旧金山Swift峰会上作为一个主题分享。
本文主要基于以上两个资料,并参考其它一些资料,总结出一套最适合的自己项目的 POMVVM 架构方法。

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
}

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

如果想让某个动物可以飞并且具有飞的相关行为,只要让这个动物类去符合Flyable协议就行了,不需要往这个类里写任何代码,如果将来需求变动又不需要飞了,只要把Flyable协议去掉。
可能你说,我把Animal作为一个基类,把默认实现写在基类里,子类中覆盖基类的属性和方法来提供不同的实现。恩,这样写也行,这是面向对象编程的基本思路,但这样显然没有POP的方式简洁优雅,其次,如果在基类中增加了一个fly()的方法,那不会飞的动物也不得不获得了这个方法,显得有些冗余,所以对这些会飞的动物再写一个基类,增加一层继承,好,这个问题解决了,那么如果一个动物又有fly()方法又有swim()方法呢?
而使用Swift2.0的POP思路就能完美解决这些问题。

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

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

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

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

MVVM

mvvm1.png

mvvm1.png关于MVVM这里就不赘述了,可以参考MVVM核心概念

面向协议的MVVM

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

snapshot.png

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

DEMO源码下载地址:
https://github.com/liuduoios/POMVVMDemo

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

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
数据源Protocol:

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

主界面中的实现:
主界面MasterViewController,我们让它符合协议BindableView,然后来实现BindableView中的属性和方法。
首先对于泛型类型ViewModelType,把它实现成

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中的内容,这些变化都会反馈到主列表界面中。

抽取公共逻辑

现在我们开始用上Protocol Extentions的特性。
可以看到在列表的cell和详情界面中,都有Switch关闭的操作,我们用这个来代表某个相同的业务逻辑,因此他们有着相同的实现。
通过Protocol Extensions,我们就可以不必在每个ViewModel里都分别去实现这个逻辑,只要对符合某个协议的Protocol进行扩展即可。

首先创建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

参考资料:

搜索CocoaChina微信公众号:CocoaChina
微信扫一扫
订阅每日移动开发及APP推广热点资讯
公众号:
CocoaChina
我要投稿   收藏文章
上一篇:使用Web浏览器编译Swift代码,及Swift中的泛型
我来说两句
发表评论
您还没有登录!请登录注册
所有评论(0

综合评论

相关帖子

sina weixin mail 回到顶部