基本介绍
-
Driver可以说是最复杂的 trait，它的目标是提供一种简便的方式在 UI 层编写响应式代码。 - 如果我们的序列满足如下特征，就可以使用它：
- 不会产生 error 事件
- 一定在主线程监听（
MainScheduler） - 共享状态变化（
shareReplayLatestWhileConnected）
为什么要使用 Driver?
-
Driver最常使用的场景应该就是需要用序列来驱动应用程序的情况了，比如：通过CoreData模型驱动 UI，使用一个 UI 元素值（绑定）来驱动另一个 UI 元素值。 - 与普通的操作系统驱动程序一样，如果出现序列错误，应用程序将停止响应用户输入。
- 在主线程上观察到这些元素也是极其重要的，因为 UI 元素和应用程序逻辑通常不是线程安全的。
- 此外，使用构建 Driver 的可观察的序列，它是共享状态变化。
使用样例
我们来实现这样一个需求：根据一个输入框的关键字，来请求数据，然后将获取到的结果同时绑定到label和button上。
- 普通序列的实现
override func viewDidLoad() {
super.viewDidLoad()
let result = inputTF.rx.text.orEmpty
.flatMap {
return self.request(text: $0)
.observeOn(MainScheduler.instance) // 将返回结果切换到到主线程上
.catchErrorJustReturn("网络请求失败") // 错误被处理了，这样至少不会终止整个序列
}.share(replay: 1, scope: .whileConnected) // //HTTP 请求是被共享的，当序列绑定多次市防止重复发送同一个请求
result.map{ "\($0 as! String)" }
.bind(to: textLabel.rx.text)
.disposed(by: disposeBag)
result.map{ "\($0 as! String)" }
.bind(to: btn.rx.title())
.disposed(by: disposeBag)
}
// 模拟请求网络
func request(text: String) -> Observable<Any> {
print("开始请求网络\(Thread.current)")
return Observable<Any>.create({ (ob) -> Disposable in
if text == "110" {
ob.onError(NSError.init(domain: "网络请求错误", code: 111, userInfo: nil))
}
DispatchQueue.global().async {
print("请求完成\(Thread.current)")
ob.onNext("请求结果:\(text)")
ob.onCompleted()
}
return Disposables.create()
})
}
如上面的代码注释所示：为了解决一些可能存在的问题，我们都需要去加额外的加一些处理，保证程序正常运行，这是非常不友好的，因为对于一个大型的项目来说，如果都这么干也太麻烦了，而且容易遗漏出错。所以我们需要用另外一种方式来实现同样的功能。
- 通过
Driver这个高阶函数实现
override func viewDidLoad() {
super.viewDidLoad()
let result = inputTF.rx.text.orEmpty
.asDriver() // 将序列转换为Driver序列
.flatMap {
return self.request(text: $0)
.asDriver(onErrorJustReturn: "检测到了错误事件")
}
// 将结果绑定到textLabel显示，注意这里使用的是drive而不是bindTo
let _ = result.map { "\($0 as! String)" } // 映射
.drive(self.textLabel.rx.text)
.disposed(by: disposeBag)
// 将结果绑定到btn显示
let _ = result.map { "\($0 as! String)" }
.drive(self.btn.rx.title())
.disposed(by: disposeBag)
}
相比第一张实现方式，使用Driver实现简单很多，那么，我们一起来看看Driver是如何帮我们实现这些问题的。
首先先对源序列调用了asDriver方法进行转换，进入到asDriver方法里面查看源码
public func asDriver() -> Driver<Element> {
return self.asDriver { _ -> Driver<Element> in
#if DEBUG
rxFatalError("Somehow driver received error from a source that shouldn't fail.")
#else
return Driver.empty()
#endif
}
}
此方法返回的是一个Driver<Element>类型的实例，然后调用了self.asDriver方法，继续跟踪进去
public func asDriver(onErrorRecover: @escaping (_ error: Swift.Error) -> Driver<Element>) -> Driver<Element> {
let source = self
.asObservable()
.observeOn(DriverSharingStrategy.scheduler)
.catchError { error in
onErrorRecover(error).asObservable()
}
return Driver(source)
}
从上面的代码可以看出，先对源序列调用了observeOn方法和catchError方法。observerOn方法是用来指定线程的，这里指定了DriverSharingStrategy.scheduler内部指定的就是主线程，这里就解决了Driver的执行是在主线程的，我们可以为所欲为的刷新UI，不用担心线程问题。catchError方法是用来处理错误信号的，当接收到错误信号后，可以把错误信号处理成一个onNext信号发送出去。最后初始化一个Driver对象返回，Driver只是一个别名，实际上是一个SharedSequence<DriverSharingStrategy, Element>对象。
进入到SharedSequence类的初始化方法
public struct SharedSequence<SharingStrategy: SharingStrategyProtocol, Element> : SharedSequenceConvertibleType {
let _source: Observable<Element>
init(_ source: Observable<Element>) {
self._source = SharingStrategy.share(source)
}
......
}
在初始化的时候调用了SharingStrategy.share(source)这个方法，那SharingStrategy是什么类型呢，它是SharedSequence类型的一个类类型参数，然后通过public typealias Driver<Element> = SharedSequence<DriverSharingStrategy, Element>这行代码可以知道SharingStrategy其实就是DriverSharingStrategy类型。所以我们进入到DriverSharingStrategy结构体，代码如下：
public struct DriverSharingStrategy: SharingStrategyProtocol {
public static var scheduler: SchedulerType { return SharingScheduler.make() }
public static func share<Element>(_ source: Observable<Element>) -> Observable<Element> {
return source.share(replay: 1, scope: .whileConnected)
}
}
可以看到执行了share方法，这个方法的功能就是共享状态，防止重复发送请求。
到此，我们就知道了Driver是如何解决一些可能存在的问题的。
总结
如果我们的序列满足如下特征，就可以使用它：
- 不会产生 error 事件
- 一定在主线程监听（
MainScheduler） - 共享状态变化（
shareReplayLatestWhileConnected）
