概述

在RxSwift的任何序列中，都可以用Observable描述，创建 -> 订阅 -> 信号发送 -> 信号接收。

Observable<Any>.create { (observer) -> Disposable in
            observer.onNext("信号1")
            return Disposables.create()
        }.subscribe(onNext: { (val) in
            print("信号接收：\(val)")
        }).disposed(by: disposeBag)

Observable是通用序列的描述符，调用.onNext，.onError，onCompleted来发送信号，具有很强的通用性。但是，当有业务需要特殊需求的时候，有可能会很复杂、繁琐，所以，针对这种情况，RxSwift还为我们提供了一些特征序列，这些特征序列都是Observable序列的变种，能够帮助我们更准确的去描述序列，比如有：Driver、Signal、ControlEvent、Single、Completable这些，这次，我们只介绍Driver这一个特征序列。

Driver

老司机带带我，有老司机带你，让你开车永远不会出错，RxSwift提供的Driver序列不会提供error事件，而且一定是在主线程中监听，会向新的订阅者发送上一次发送出的元素，主要就是为了简化UI层的代码，咱们来撸撸，为什么需要Driver的序列的存在。

比如说，咱们有一个这样的需求：搜索框中每次输入一个文本，就会获取一次网络请求，请求成功后将数据渲染到UI界面。

先来创建一个简单的UI界面：

let textField = UITextField.init(frame: CGRect(x: 100, y: 100, width: 200, height: 40))
        textField.borderStyle = .roundedRect
        textField.placeholder = "请输入搜索内容"
        self.view.addSubview(textField)
        let label1 = UILabel.init(frame: CGRect(x: 100, y: 160, width: 200, height: 40))
        label1.backgroundColor = .groupTableViewBackground
        label1.textAlignment = .center
        self.view.addSubview(label1)
        let label2 = UILabel.init(frame: CGRect(x: 100, y: 210, width: 200, height: 40))
        label2.backgroundColor = .groupTableViewBackground
        label2.textAlignment = .center
        self.view.addSubview(label2)

UI界面上，创建了一个textField，2个label用来展示。

接下来我们创建了一个网络请求，代码就不展示了，网络请求一直以来都是耗时操作，所以，我们需要在异步线程中来完成网络请求，直接发送序列，假如我们请求了一次网络。

然后，我们需要实现textField输入的监听，并且调取了网络请求方法。
非Driver的实现：

let result = textField.rx.text.orEmpty.skip(1)
            .flatMap{return self.network(text: $0)
                .observeOn(MainScheduler.instance)
                .catchErrorJustReturn("网络请求失败")
            }.share(replay: 1, scope: .whileConnected)
        //网络请求将发送多次请求
        result.subscribe(onNext: { (val) in print("订阅一：\(val) 线程：\(Thread.current)")
        }).disposed(by: disposeBag)
        
        result.subscribe(onNext: { (val) in print("订阅二：\(val) 线程：\(Thread.current)")
        }).disposed(by: disposeBag)
        
        result.map{"\(($0 as! String).count)"}.bind(to: label1.rx.text).disposed(by: disposeBag)
        result.map{"\($0)"}.bind(to: label2.rx.text).disposed(by: disposeBag)

• observeOn选择在哪个线程执行
• catchErrorJustReturn错误处理，将onError事件转为onNext事件
• share为多个观察者共享资源，网络请求只发送了一次，否则多个订阅将会触发多个请求

我们来看看Driver的实现：

let result = textField.rx.text.orEmpty
            .asDriver()
            .flatMap {return self.network(text: $0).asDriver(onErrorJustReturn: "网络请求失败")
        }
        result.map{"长度：\(($0 as! String).count)"}
            .drive(label1.rx.text).disposed(by: disposeBag)
        result.map{"\($0)"}.drive(label2.rx.text).disposed(by: disposeBag)

• asDriver()将序列转换为Driver序列
• map重新组合并生成新的序列
• driver将元素在主线程中绑定到label1和label2上
• 相比非Driver下的代码实现，Driver序列省去了线程的设置，share数据共享设置。

我们断点查看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
        }
    }
}

这是一个ControlProperty的扩展方法，返回了一个Driver，它是SharedSequence的别名，是用来描述不同类型的序列，最后它又调用了self.asDriver方法，此方法是定义在ObservableConvertibleType的扩展方法中，追踪下去，你会发现，很多的类都是继承于ObservableConvertibleType。

/**
    Converts observable sequence to `Driver` trait.
    
    - parameter onErrorRecover: Calculates driver that continues to drive the sequence in case of error.
    - returns: Driver trait.
    */
    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方法，用于指定线程DriverSharingStrategy.scheduler，继续往里面走，你就会发现，它的内部就是指定的主线程，这也说明了Driver的执行就是在主线程。