【iOS】Swift系列三十四 - 响应式编程（RxSwift的使用）

响应式编程（Reactive Programming，简称RP）也是一种编程范式，于1997年提出，可以简化异步编程，提供更优雅的数据绑定。

一、初始响应式编程

响应式编程一般与函数式融合在一起，所以也会叫做：函数响应式编程（Functional Reactive Programming，简称FRP）。

比较著名的，成熟的响应式框架：

ReactiveCocoa
- 简称RAC，有OC、Swift版本
- 官网：http://reactivecocoa.io/
- github：https://github.com/ReactiveCocoa
ReactiveX
- 简称Rx，有众多编程语言的版本，比如RxJava、RxKotlin、RxJS、RxCpp、RxPHP、RxGo、RxDart、RxSwift等等
- 官网：http://reactivex.io
- github：https://github.com/ReactiveX

Swift响应式编程一般使用RxSwift框架。

二、RxSwift

2.1. 安装RxSwift

源码：https://github.com/ReactiveX/RxSwift

中文文档（非官方）：https://beethOven.github.io/RxSwift-Chinese-Documentation

RxSwift的github上已经有详细的安装教程，这里只演示CocoaPods方式的安装。

第一步：创建Podfile（可以直接在项目根目录执行pod init）

# Podfile
use_frameworks!

target 'YOUR_TARGET_NAME' do
    pod 'RxSwift', '~>5.0.1'
    pod 'RxCocoa', '~>5.0.1'
end

# RxTest and RxBlocking make the most sense in the context of unit/integration tests
target 'YOUR_TESTING_TARGET' do
    pod 'RxBlocking', '~>5.0.1'
    pod 'RxTest', '~>5.0.1'
end

第二步：命令行安装
注意把YOUR_TARGET_NAME替换为自己的工程名。然后在Podfile所在文件夹执行pod install。

第三步：导入模块

1 2	import RxSwift import RxCocoa

模块说明：

RxSwift：Rx标准API的Swift实现，不包括任何iOS相关的内容
RxCocoa：基于RxSwift，给iOS的UI控件扩展了很多Rx特性

2.2. RxSwift的核心角色

Observable：负责发送事件（Event）
Observer：负责订阅Observable，监听Observable发送的事件（Event）

每次发送的事件是枚举类型：

public enum Event<Element> {
    /// Next element is produced.
    case next(Element)

    /// Sequence terminated with an error.
    case error(Swift.Error)

    /// Sequence completed successfully.
    case completed
}

next：携带具体数据
error：携带错误信息，表明Observable终止，不会再发出事件
completed：表明Observable终止，不会再发出事件

2.2.1. 创建、订阅Observable

示例代码：

// 创建Observable第一种写法
var observable = Observable<Int>.create { observer in
    // 发消息
    observer.onNext(1)
    observer.onCompleted()
    return Disposables.create()
}
// 等价于
observable = Observable.just(1)
observable = Observable.of(1)
observable = Observable.from([1])

// 创建Observable第二种写法
var observable2 = Observable<Int>.create { observer in
    observer.onNext(1)
    observer.onNext(2)
    observer.onNext(3)
    observer.onCompleted()
    return Disposables.create()
}
// 等价于
observable2 = Observable.of(1, 2, 3)
observable2 = Observable.from([1, 2, 3])

// 订阅Observable
observable.subscribe { event in
    switch event {
    case .next(let element):
        print("switch next", element)
    case .error(let error):
        print("switch error", error)
    case .completed:
        print("switch completed")
    }
}.dispose()
// 等价于
observable.subscribe(onNext: {
    print("block next", $0)
}, onError: {
    print("block error", $0)
}, onCompleted: {
    print("block completed")
}, onDisposed: {
    print("block dispose")
}).dispose()

/*
 输出：
 switch next 1
 switch completed
 block next 1
 block completed
 block dispose
*/

只要有订阅Observable的地方，subscribe都会收到消息。

2.2.2. Disposable取消订阅

每当Observable被订阅时，都会返回一个Disposable实例，当调用Disposable的dispose，就相当于取消订阅。

在不需要再接收事件时，建议取消订阅，释放资源。有3种常见方式取消订阅：

第一种：立即取消订阅（一次性订阅）

1
2
3

observable.subscribe { event in
    print(event)
}.dispose()

第二种：当bag销毁（deinit）时，会自动调用Disposable实例的dispose

let bag = DisposeBag()
observable.subscribe { event in
    print(event)
}.disposed(by: bag)

第三种：self销毁（deinit）时，会自动调用Disposable实例的dispose

1
2
3

let _ = observable.takeUntil(self.rx.deallocated).subscribe { event in
    print(event)
}

2.2.3. 创建Observer

第一种：AnyObserver

let observer = AnyObserver<Int>.init { event in
    switch event {
    case .next(let data):
        print(data)
    case .completed:
        print("completed")
    case .error(let error):
        print("error", error)
    }
}
Observable.just(1).subscribe(observer).dispose() // 输出：1 completed

第二种：Binder

let label = UILabel.init()
let binder = Binder<String>(label) { label, text in
    label.text = text
}
Observable.just(1).map({ "数值是\($0)" }).subscribe(binder).dispose()
Observable.just(1).map({ "数值是\($0)" }).bind(to: binder).dispose()

2.3. 状态监听

2.3.1. 传统的状态监听

在开发中经常要对各种状态进行监听，传统的常见监听方案有：

KVO
Target-Action
Notification
Delegate
Block Callback

传统方案经常会出现错综复杂的依赖关系、耦合性高，还需要编写重复的非业务代码。

2.3.2. RxSwift的状态监听

示例代码一（Target-Action）：

let buttton = UIButton.init(type: .custom)
let btnObservable = buttton.rx.controlEvent(.touchUpInside)
btnObservable.subscribe(onNext: {
    print("按钮被点击")
}).dispose()
// 等价于
buttton.rx.tap.subscribe(onNext: {
    print("按钮被点击")
}).dispose()

示例代码二（KVO）：

class Dog: NSObject {
    @objc dynamic var name: String?
}
let dog = Dog()
dog.rx.observe(String.self, "name").subscribe(onNext: { name in
    print("name is", name ?? "nil")
    }).disposed(by: bag)
dog.name = "富贵"
dog.name = "旺财"
/*
 输出：
 name is nil
 name is 富贵
 name is 旺财
 */

使用KVO的本质是调用了addObserver:forKeyPath:，所以要使用runtime。并且初始化实例时对属性进行了赋值，因此也会监听到初始化值。

示例代码三（Notification）：

NotificationCenter.default.rx
    .notification(UIApplication.didEnterBackgroundNotification)
    .subscribe(onNext: { notification in
        print("App进入后台", notification)
    }).disposed(by: bag)

示例代码四（既是Observable，又是Observer）：

let slider = UISlider()
let textField = UITextField()
// slider作为Observer
Observable.just(0.2).bind(to: slider.rx.value).disposed(by: bag)
// slider作为Observable
slider.rx.value.map { "slider数值是\($0)" }.bind(to: textField.rx.text).disposed(by: bag)
// textField也可以既作为Observer，又作为Observable
textField.rx.text.subscribe(onNext: { text in
    print(text ?? "")
    }).disposed(by: bag)

label.rx.text返回的是Binder类型，而Binder本质是ObserverType，所以label只能作为Observer。

slider.rx.value返回的是ControlProperty类型，ControlProperty遵守了ControlPropertyType协议，ControlPropertyType协议遵守了ObservableType, ObserverType协议，所以既可以作为Observable，又可以作为Observer。

示例代码五（UITableView）：

let tableView = UITableView.init(frame: .zero, style: .plain)
struct Person {
    var name: String?
    var age: Int?
}
// 发送数据
let persons = Observable.just([
    Person(name: "Kiki", age: 10),
    Person(name: "DaBen", age: 20),
    Person(name: "Frank", age: 30)
])
// 数据绑定到tableView
persons.bind(to: tableView.rx.items(cellIdentifier: "cell", cellType: UITableViewCell.self)) { row, person, cell in
    cell.textLabel?.text = person.name
    cell.detailTextLabel?.text = "\(String(describing: person.age))"
}.disposed(by: bag)

// 选择cell
tableView.rx.itemSelected.subscribe(onNext: { path in
    print("点击了cell", path)
}).disposed(by: bag)

// 选择数据模型
tableView.rx.modelSelected(Person.self).subscribe(onNext: { person in
    print("点击了", person)
}).disposed(by: bag)

注意：如果使用RxSwift，就不要遵守代理和数据源协议，否则RxSwift就会失效。