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
。

第三步：导入模块

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种常见方式取消订阅：

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

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

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
就会失效。