我们会有这样的需求: 在搜索框中输入搜索关键字,然后发起请求，将请求的结果分别显示在2个不同的控件上。
这个需求需要满足以下条件:
1.输入框内容改变一次,需要请求一次网络获取结果。
2.结果绑定到UI,对于UI的操作需要在主线程执行。
3.处理错误,防止序列终止

实现方法一:

 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)

        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 dealwithData(inputText:String)-> Observable<Any>{
        print("请求网络了 \(Thread.current)") // data
        return Observable<Any>.create({ (ob) -> Disposable in
            if inputText == "1234" {
                ob.onError(NSError.init(domain: "xxx", code: 10086, userInfo: nil))
            }
            DispatchQueue.global().async {
                print("发送之前看看: \(Thread.current)")
                ob.onNext("已经输入:\(inputText)")
                ob.onCompleted()
            }
            return Disposables.create()
        })
    }

这种方法虽然能实现这个需求,但是代码相对比较恶心,每一次都要指定主线程,指定请求共享等等。 对于这种实现方法,我们肯定是不会满意的。那么RxSwift有没有提供一套应对类似这样需求的方案呢? 答案是肯定的,那就是RxSwift-Driver。

RxSwift-Driver

1、Driver 可以说是最复杂的 trait，它的⽬标是提供一种简便的⽅式在 UI 层编写响应式代码。

2、如果我们的序列满⾜如下特征，就可以使用它:
(1)、不会产⽣ error 事件
(2)、一定在主线程监听(MainScheduler)
(3)、共享状态变化(shareReplayLatestWhileConnected)

3、为什要使⽤Driver?
(1)Driver 最常使⽤的场景应该就是需要⽤序列来驱动应用程序的情况了，⽐如:
• 通过 CoreData 模型驱动 UI
• 使用⼀个 UI 元素值(绑定)来驱动另⼀个 UI 元素值
(2)与普通的操作系统驱动程序⼀样，如果出现序列错误，应⽤程序将停⽌响应⽤户输入。
(3)在主线程上观察到这些元素也是极其重要的，因为 UI 元素和应用程序逻辑通常不是线程安全的。
(4)此外，使⽤构建 Driver 的可观察的序列，它是共享状态变化。

RxSwift-Driver的实现:

  let result  = inputTF.rx.text.orEmpty
            .asDriver()
            .flatMap {
                return self.dealwithData(inputText: $0)
                    .asDriver(onErrorJustReturn: "检测到了错误事件")
            }
        result.map { "长度: \(($0 as! String).count)"}.drive(self.textLabel.rx.text)
        result.map { "\($0 as! String)"}
            .drive(self.btn.rx.title())

RxSwift-Driver源码分析

以asDriver作为源码分析切入点:

extension ControlProperty {
    /// Converts `ControlProperty` to `Driver` trait.
    ///
    /// `ControlProperty` already can't fail, so no special case needs to be handled.
    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
        }
    }
}

进入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)
    }

返回是Driver(source),看看Driver

public typealias Driver<Element> = SharedSequence<DriverSharingStrategy, Element>

Driver并不是一个类，而是一个序列的别名。RxSwift的类都比较恶心,为了方便记忆，弄个别名也正常。
进入具体类型SharedSequence

public struct SharedSequence<SharingStrategy: SharingStrategyProtocol, Element> : SharedSequenceConvertibleType {
    let _source: Observable<Element>

    init(_ source: Observable<Element>) {
        self._source = SharingStrategy.share(source)
    }

进入share

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)
    }
}

SharingStrategy是一个关联类型,它实际类型是DriverSharingStrategy。因此来到DriverSharingStrategy.share，DriverSharingStrategy.share中调用了source.share,就是方法一调用的.share(replay: 1, scope: .whileConnected)

接下来继续分析self.asDriver中的source

 let source = self
            .asObservable()
            .observeOn(DriverSharingStrategy.scheduler)
            .catchError { error in
                onErrorRecover(error).asObservable()
            }

1.调用了asObservable,说明是一个序列
2.指定调度者DriverSharingStrategy.scheduler

public static var scheduler: SchedulerType { return SharingScheduler.make() }
public enum SharingScheduler {
    /// Default scheduler used in SharedSequence based traits.
    public private(set) static var make: () -> SchedulerType = { MainScheduler() }
}
public final class MainScheduler : SerialDispatchQueueScheduler {

    private let _mainQueue: DispatchQueue
    /// Initializes new instance of `MainScheduler`.
    public init() {
        self._mainQueue = DispatchQueue.main
        super.init(serialQueue: self._mainQueue)
    }
}

使用了主队列,指定在主线程中执行.
3.catchError调用外部error处理,这里不再展开说明。

.drive(self.btn.rx.title()),使用drive将内容订阅到UI上,

  public func drive<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
        MainScheduler.ensureRunningOnMainThread(errorMessage: errorMessage)
        return self.asSharedSequence().asObservable().subscribe(observer)
    }

将self.btn.rx.title()作为观察者,订阅序列。

总结

RxSwift-Driver 其实就是对方法一的封装,将指定主线程执行、错误处理、共享状态变化共享状态变化进行封装, 外界只需要使用。