阅读 197

RxSwift原理之序列与观察者

我就不讲RxSwift的思想了,网上很多文章讲的都很好,我就不献丑了,咱们就直接进入正题,先看个栗子:

Observable<Int>.create { observe in
            observe.onNext(1)
            observe.onCompleted()
            return Disposables.create()
        }.subscribe(onNext: { res in
            print(res)
        }).disposed(by: disposeBag)
复制代码

代码很简单,问大家一个问题,什么是可观察序列、什么是观察者,我们又是怎么创建的序列,怎么创建的观察者,哪部分是序列,哪部分又是观察者呢? 带着这几个疑问,我们开始吧!

创建可观察序列 创建函数如下:

public static func create(_ subscribe: @escaping (AnyObserver<Element>) -> Disposable) -> Observable<Element> {
        AnonymousObservable(subscribe)
    }
复制代码

creat返回了一个匿名的序列AnonymousObservable, 也就是说creat创建的就是一个序列,但是它有个内部有个AnyObserver,它才是发送数据的源。

继承链: AnonymousObservable -> Producer -> Observable -> ObservableType

ObservableType:是一个协议,有一个必须实现的订阅函数subscribe,也就是所有遵守自这个协议的类都要实现这个订阅函数。它还有一个asObservable默认实现函数,把'ObservableType'转换为'Observable'

Observable:是一个类型擦除的ObservableType,为了统一管理序列,所有的序列都继承自它,还有一个比较重要的功能就是计算订阅数,debug模式下方便处理Rx内存泄漏问题。

Producer:实现了subscribe函数,这个很重要一会再说。还有一个抽象函数run,所有继承自它的都需要实现run函数。子类并不要实现订阅函数,统一通过它处理

AnonymousObservable中有个闭包:subscribeHandler = (AnyObserver<Element>) -> Disposable,这个东西就是创建时候带进来的subscribe,还有个函数run,上面说过父类的run函数是抽象函数,

到此,creat函数 和 Producer中的subscribe函数都有了,来看看它具体是怎么传数据的。看个栗子:

开始的时候我们简要分析了creat函数,内部有发送数据的源AnyObserver,现在我们看看订阅函数subscribe函数做了什么,为什么有两个subscribe函数呢,接着往下看:

public func subscribe(
        onNext: ((Element) -> Void)? = nil,
        onError: ((Swift.Error) -> Void)? = nil,
        onCompleted: (() -> Void)? = nil,
        onDisposed: (() -> Void)? = nil
    ) -> Disposable {
            let disposable: Disposable
            if let disposed = onDisposed {
                disposable = Disposables.create(with: disposed)
            }
            else {
                disposable = Disposables.create()
            }
            let observer = AnonymousObserver<Element> { event in
                switch event {
                case .next(let value):
                    onNext?(value)
                case .error(let error):
                    if let onError = onError {
                        onError(error)
                    }
                    disposable.dispose()
                case .completed:
                    onCompleted?()
                    disposable.dispose()
                }
            }
            return Disposables.create(
                self.asObservable().subscribe(observer),
                disposable
            )
    }
复制代码

继承链: AnonymousObserver -> ObserverBase -> Disposable, ObserverType self.asObservable().subscribe(observer)执行Producer中的subscribe函数,可能有人会问这个self是哪个对象呢?看上面的creat函数,没错,就是AnonymousObservable,而self.asObservable()也什么都没做,就是返回了自己。此时就明白了为什么有两个subscribe函数,这是因为两个函数是顺序调用关系,那么也就可以理解为是一个函数。这个函数有个条件分支,用于线程问题上,一般会走else分支,所以直接看这里就行:

override func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
       return CurrentThreadScheduler.instance.schedule(()) { _ in
                let disposer = SinkDisposer()
                let sinkAndSubscription = self.run(observer, cancel: disposer)
                disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
                return disposer
        }
}
复制代码

先看一下ObserverType是什么,它是一个协议,有必须实现的函数func on(_ event: Event<Element>),用于发送数据,函数还有三个默认实现函数:onNext、onCompleted、onError,分别用于发送event事件,event是一个枚举,如下:

enum Event<Element> {
    case next(Element)
    case error(Swift.Error)
    case completed
}
复制代码

没错,默认实现的函数分别发送就是这是三个事件。 这里有个self,它是谁呢?他就是creat创建的AnonymousObservable,简单的逻辑问题不要混了,调用的run函数,回到AnonymousObservable看看run函数做了什么:

let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
let subscription = sink.run(self)
return (sink: sink, subscription: subscription)
复制代码

继承链:AnonymousObservableSink -> Sink、ObserverType, Sink -> Disposable, 看一下AnonymousObservableSinkrun函数做了什么,实现如下:

func run(_ parent: Parent) -> Disposable {
     parent.subscribeHandler(AnyObserver(self))
}
复制代码

Sink中有个属性observer,它就是上面subscribe函数中用于接收数据的AnonymousObserver,还有一个final函数forwardOn。然后接着分析sink.run(self)干了什么,parent实际上就是AnonymousObservable,subscribeHandler这个闭包就是creat的闭包。AnyObserver(self) 这个玩意是啥呢? 上面也说过, subscribeHandler = (AnyObserver<Element>) -> Disposable,那就明白了呀,看上面的例子,发送事件 observe.onNext(1)和observe.onCompleted(),这个observe其实就是AnyObserver(self) ,那也就是说我们再把AnyObserver(self) 弄明白了,就一切真相大白了。先看看AnyObserver这个结构体里面有啥:

struct AnyObserver<Element> : ObserverType {
    public typealias EventHandler = (Event<Element>) -> Void
    private let observer: EventHandler
    public init(eventHandler: @escaping EventHandler) {
        self.observer = eventHandler
    }
    public init<Observer: ObserverType>(_ observer: Observer) where Observer.Element == Element {
        self.observer = observer.on
    }
    public func on(_ event: Event<Element>) {
        self.observer(event)
    }
    public func asObserver() -> AnyObserver<Element> {
        self
    }
}
复制代码

我们可以知道AnyObserver(self) 中self是AnonymousObservableSink这个类。所以会执行这个:self.observer = observer.on,也就是说AnyObserver中的observer就是AnonymousObservableSink中的on函数,on函数之前也说过它是发送事件的函数。看一下实现:

func on(_ event: Event<Element>) {
     switch event {
       case .next:
           self.forwardOn(event)
       case .error, .completed:
           if fetchOr(self.isStopped, 1) == 0 {
               self.forwardOn(event)
               self.dispose()
           }
      }
 }
复制代码

每个case分支都执行了forwardOn函数,再看一下它干了什么:

final func forwardOn(_ event: Event<Observer.Element>) {
      if isFlagSet(self.disposed, 1) {
          return
      }
      self.observer.on(event)
 }
复制代码

上面已经分析了Sink中的属性observer就是上面subscribe函数中的AnonymousObserver,我们进入类文件中一探究竟,有一个闭包:eventHandler = (Event<Element>) -> Void,还有一个onCore函数,没找到on函数,那再进入父类中看一下ObserverBase,😄一眼就看到了on函数:

func on(_ event: Event<Element>) {
        switch event {
        case .next:
            self.onCore(event)
        case .error, .completed:
            self.onCore(event)
        }
}
复制代码

它还有一个抽象函数onCore,必须由子类实现,正好在AnonymousObserver类中重写了这个函数。我们再看看onCore干了什么:

override func onCore(_ event: Event<Element>) {
    self.eventHandler(event)
}
复制代码

那么你是否已经明白self.eventHandler(event)会执行到哪呢?,看subscrebe中创建的观察者:

let observer = AnonymousObserver<Element> { event in
                switch event {
                case .next(let value):
                    onNext?(value)
                case .error(let error):
                    if let onError = onError {
                        onError(error)
                    }
                    disposable.dispose()
                case .completed:
                    onCompleted?()
                    disposable.dispose()
                }
            }
复制代码

这个大闭包就是eventHandler,self.eventHandler(event)发送的就是枚举事件。

终于捋顺了 创建、订阅、发送、接收的所有逻辑了。当然了,这个只是RxSwift基础中的一小部分,其他的我也会在之后的学习过程中记录下来。 如果哪说的有问题欢迎大家指正,不要让我一直错下去😄,还有我以前很少写文章,有什么不好的地方欢迎大家提意见或者建议。那么开头说的几个小问题你是否明白了呢?

总结: 我使用了RxSwift一年多了,以前也跟着网上的文章看了源码,但是这种方式我感觉对我没啥用,有点牵着鼻子走的感觉。过了一段时间又忘了,而且之后再看源码还是不知道从何下手。这次我完全不依赖文章,独立看源码,捋逻辑,感觉还行, RxSwift的源码并没有那么难懂,就是很绕,绕来绕去就懵了,还得从头捋,太难受了。

还有我要提醒一下大家,我最近面试了一个用RxSwift的公司,问的也不深,无奈自己没准备,RxSwift连基本的思想都忘了,其实也不觉得可惜,也是预料之中的事。我大约每隔两三个月就会面试一两次,一来看看机会,而来看看自己啥水平😄,不出所料,每次不复习,一些概念的东西都不记得,概念性质的东西总是忘,技术水平还是菜菜的😄。

话说回来,不管你这份工作怎么样,我都建议你每隔一段时间去中大厂面面。面试其实也是学习!各位加油!

文章分类
iOS