前言
Driver（老司机？），它是一个精心准备的特征序列，它主要是为了简化 UI 层的代码，也即是提供一种简便的方式在 UI 层编写响应式代码。
Driver
在学习Driver之前，先来看一段rx的代码：
let result = inputTF.rx.text.skip(1)
.flatMap { [weak self](input) -> Observable<Any> in
return (self?.dealwithData(inputText:input ?? ""))!
}
result.subscribe(onNext: { (element) in
print("订阅到 \(element)")
})
result.subscribe(onNext: { (element) in
print("订阅到 \(element)----\(Thread.current)")
})
func dealwithData(inputText:String)-> Observable<Any>{
print("开始请求网络 \(Thread.current)")
return Observable<Any>.create({ (ob) -> Disposable in
if inputText == "123456" {
ob.onError(NSError.init(domain: "com.henry", code: 10010, userInfo: nil))
}
DispatchQueue.global().async {
print("发送信号之前: \(Thread.current)")
ob.onNext("发送的内容:\(inputText)")
ob.onCompleted()
}
return Disposables.create()
})
}
这段代码的目的是：写了一个网络请求的方法（返回得到的是一个序列），然后利用UITextField输入的内容，请求网络，返回得到的请求数据（这里假装请求了网络，实际是将inputText的内容返回了），然后将这个值发送出去。
现在在UITextField中输入1,来看看会打印出什么？
从结果可以看到写的两次订阅都成功订阅到了，那么问题就来了，
问题1：这里订阅了两次，但是也请求了两次网络，很明显如果订阅次数非常多次，网络请求也就会非常多次，这样的话会浪费网络资源，占用带宽。
问题2：从第二次订阅的时候打印的线程可以看出来，网络请求完数据，订阅到数据还在子线程，如果在这里面进行UI刷新的话，会出现问题。
问题3：在这里没有对error事件进行订阅，如果产生了error,会报错误而崩溃。
为了解决这几个问题，我们可以将序列调用一个高阶函数share(share会将观察者共享序列),同时把序列放到主线程去，同时检测error事件。
let result = inputTF.rx.text.skip(1)
.flatMap { [weak self](input) -> Observable<Any> in
return (self?.dealwithData(inputText:input ?? ""))!
.observeOn(MainScheduler())
//发生错误的处理
.catchErrorJustReturn("错误事件")
}.share(replay: 1, scope: .whileConnected)
这样的话就解决了上面的问题;
下面来看一下利用Driver怎么来处理这部分代码：
//asDriver()将普通序列转换成Driver序列
let result = inputTF.rx.text.orEmpty
.asDriver()
.flatMap {
return self.dealwithData(inputText: $0)
// 仅仅提供发生错误时的备选返回值
.asDriver(onErrorJustReturn: "检测到了错误事件")
}
//drive()方法绑定UI
result.map { "\($0 as! String)"}
.drive(self.btn.rx.title())
可以看到Driver完美的解决了上面的一系列问题，而且绑定UI必然实在主线程中，且不会因为网络请求出错而产生错误事件，而且是默认的序列共享。
那么也就是说，如果我们的序列满足如下特征，就可以使用Driver：
- 不会产生 error 事件
- 一定在主线程监听（MainScheduler）
- 共享状态变化（shareReplayLatestWhileConnected）
Driver源码
那么Driver的底层到底是怎么实现的呢？下面来看一下Driver的源码实现：从前面已经知道是asDriver()方法将源序列转换成Driver序列的，那么先来看下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
}
}
可以看到调用asDriver()方法是返回了self.asDriver的闭包，点击此处的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()方法。最后返回一个Driver对象。
observerOn()方法是用来指定线程的，这里指定为DriverSharingStrategy.scheduler这个DriverSharingStrategy.scheduler内部指定的就是主线程。
跟进去这个DriverSharingStrategy.scheduler的这个scheduler方法来看一下：
public struct DriverSharingStrategy: SharingStrategyProtocol {
public static var scheduler: SchedulerType { return SharingScheduler.make() }
}
这里返回了SharingScheduler.make()，好像不太明白，那就在跟进去这个make()方法来看下：
public private(set) static var make: () -> SchedulerType = { MainScheduler() }
可以看到在make()方法中调用了主线程。
这里就解决了Driver的执行是在主线程的问题。
catchError()方法是用来处理错误事件的，当接收到错误事件信号后，可以把错误信号的备选值变成一个onNext:事件发送出去。
最后再来看一下返回的Driver对象，跟进去Driver看一下源码：
public typealias Driver<Element> = SharedSequence<DriverSharingStrategy, Element>
这里Driver是取了别名的，它实际上就是SharedSequence(共享序列)，再次进入到SharedSequence
public struct SharedSequence<SharingStrategy: SharingStrategyProtocol, Element> : SharedSequenceConvertibleType {
let _source: Observable<Element>
init(_ source: Observable<Element>) {
self._source = SharingStrategy.share(source)
}
在SharedSequence的init()方法中，调用了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()方法，返回的source.share(replay: 1, scope: .whileConnected),有没有感觉这句代码很眼熟，没错就是在最开始优化序列订阅的时候写的share()方法，实现序列的共享状态，防止多次网络请求。这里就解决了多次订阅，序列不共享状态的问题。
总结
关于老司机Driver的学习就到这里，当我们需要利用序列来驱动程序的时候，Driver的使用还是非常有必要的。通过上面我们知道Driver就是把主线程，错误事件，共享状态这三者封装到一起了，确保了在写代码的过程中因为遗漏了某一步而导致程序崩溃。最后要注意的是：在绑定UI元素的时候我们使用的是drive而不是bindTo ，因为 drive 方法只能被 Driver 调用，这意味着，如果代码存在 drive，那么这个序列不会产生错误事件并且一定在主线程监听。这样我们就可以安全的绑定 UI 元素。
