阅读 101

RxSwift学习--特征序列之Driver

前言

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 元素。

关注下面的标签,发现更多相似文章
评论