RxSwift源码分析(四)-特征序列Driver

基本介绍

• Driver能够说是最复杂的 trait，它的目标是提供一种简便的方式在 UI 层编写响应式代码。
• 若是咱们的序列知足以下特征，就可使用它：
  • 不会产生 error 事件
  • 必定在主线程监听（MainScheduler）
  • 共享状态变化（shareReplayLatestWhileConnected）

为何要使用 Driver?

• Driver 最常使用的场景应该就是须要用序列来驱动应用程序的状况了，好比：经过 CoreData 模型驱动 UI，使用一个 UI 元素值（绑定）来驱动另外一个 UI 元素值。
• 与普通的操做系统驱动程序同样，若是出现序列错误，应用程序将中止响应用户输入。
• 在主线程上观察到这些元素也是极其重要的，由于 UI 元素和应用程序逻辑一般不是线程安全的。
• 此外，使用构建 Driver 的可观察的序列，它是共享状态变化。

使用样例

咱们来实现这样一个需求：根据一个输入框的关键字，来请求数据，而后将获取到的结果同时绑定到label和button上。

1. 普通序列的实现

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()
    })
}
复制代码

如上面的代码注释所示：为了解决一些可能存在的问题，咱们都须要去加额外的加一些处理，保证程序正常运行，这是很是不友好的，由于对于一个大型的项目来讲，若是都这么干也太麻烦了，并且容易遗漏出错。因此咱们须要用另一种方式来实现一样的功能。

2. 经过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）