(一)RxSwift 序列从创建到响应,经历了什么

357 阅读5分钟

今天就让我们来一起探究一下RxSwift从创建到响应,中间到底经历了些什么。

首先我们先通过一段简单的代码看一下序列三部曲:

一.创建序列

二.订阅信号

三.发送信号

//1.创建序列
let ob = Observable<Any>.create { (obserber) -> Disposable in
            // 3.发送信号
            obserber.onNext("马小撂")
            obserber.onCompleted()
           //obserber.onError(NSError.init(domain: "error", code: 10086, userInfo: nil))
            return Disposables.create()
        }
//2.订阅信号
let _ = ob.subscribe(onNext: { (text) in
            print("订阅到:\(text)")
        }, onError: { (error) in
            print("error: \(error)")
        }, onCompleted: {
            print("完成")
        }) {
            print("销毁")
        }

一.创建序列

let ob = Observable<Any>.create { (obserber) -> Disposable in
  //create里面的闭包
}       

让我们来看一下Observable<Any>.create是如何创建了一个可观察序列 Observable对象的

  • 查看create 的具体实现(直接点进去,是一个声明,具体实现在Create.swift中) 下面是 create方法的具体实现 :
public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
        return AnonymousObservable(subscribe)
}

可以看到该方法返回了一个匿名观察者 AnonymousObservable(subscribe) 下面来到 AnonymousObservable 方法中

final private class AnonymousObservable<Element>: Producer<Element> {
    typealias SubscribeHandler = (AnyObserver<Element>) -> Disposable

    let _subscribeHandler: SubscribeHandler
    //初始化 并保存闭包
    init(_ subscribeHandler: @escaping SubscribeHandler) {
        self._subscribeHandler = subscribeHandler
    }

    override func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == Element {
        let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
        let subscription = sink.run(self)
        return (sink: sink, subscription: subscription)
    }
}

这个方法进行了一次初始化,将 create 中的 闭包 赋值 给 self._subscribeHandler

到此处,就完成了第一步的操作,序列的创建 Observable<Any>.create。实际是创建了一个匿名的观察者 AnonymousObservable,并将 create中的闭包进行了保存。

创建序列

二.订阅信号

点进.subscribe 回来到 ObservableType+Extensions 中的 subscribe 函数(代码有一点长)

 public func subscribe(onNext: ((E) -> 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()
            }
            
            #if DEBUG
                let synchronizationTracker = SynchronizationTracker()
            #endif
            
            let callStack = Hooks.recordCallStackOnError ? Hooks.customCaptureSubscriptionCallstack() : []
            //※ 创建这个 observer 尾随闭包做参数
            let observer = AnonymousObserver<E> { event in
                
                #if DEBUG
                    synchronizationTracker.register(synchronizationErrorMessage: .default)
                    defer { synchronizationTracker.unregister() }
                #endif
                
                switch event {
                case .next(let value):
                    onNext?(value)
                case .error(let error):
                    if let onError = onError {
                        onError(error)
                    }
                    else {
                        Hooks.defaultErrorHandler(callStack, error)
                    }
                    disposable.dispose()
                case .completed:
                    onCompleted?()
                    disposable.dispose()
                }
            }
            return Disposables.create(
                self.asObservable().subscribe(observer),
                disposable
            )
    }

这里我们着重看一下let observer = AnonymousObserver<E> { event in初始化一个名为observer 的匿名观察者 AnonymousObserver 后面尾随闭包做参数。

那么AnonymousObserver 这个类里面做了什么呢?

final class AnonymousObserver<ElementType> : ObserverBase<ElementType> {
    typealias Element = ElementType
    
    typealias EventHandler = (Event<Element>) -> Void
    
    private let _eventHandler : EventHandler
    
    init(_ eventHandler: @escaping EventHandler) {
#if TRACE_RESOURCES
        _ = Resources.incrementTotal()
#endif
        self._eventHandler = eventHandler
    }

    override func onCore(_ event: Event<Element>) {
        return self._eventHandler(event)
    }
    
#if TRACE_RESOURCES
    deinit {
        _ = Resources.decrementTotal()
    }
#endif
}

它将上面创建时传过来的闭包保存为属性 self._eventHandler,此外还提供了一个onCore的方法

此时我们在创建序列的时候AnonymousObservable保存了 create的闭包,在订阅信号时AnonymousObserver又保存了subscribe闭包中的回调执行闭包_eventHandler

subscribe函数还有一个返回没有看完,它会返回一个Disposables的对象。 重点来了,这个返回尤其重要。

self.asObservable().subscribe(observer),
  • self.asObservable() 这个简单解释一下,ObservableType 继承于 ObservableConvertibleTypeObservableConvertibleType 中有一个 asObservable的函数,目的是为了返回一个可观察序列 Observable然后具有一些公共的方法。
  • .subscribe(observer),因为参数为AnonymousObserver类型,所以我们要去AnonymousObservable 这个类中去找 subscribe 这个函数,但是上面我们贴出的代码中并没有subscribe 函数 怎么办呢?

这时我们看见 AnonymousObservable 是继承于Producer 的,子类没有实现就去父类里面找。打个断点,果然来到了父类的subscribe 函数

 override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        if !CurrentThreadScheduler.isScheduleRequired {
            // The returned disposable needs to release all references once it was disposed.
            let disposer = SinkDisposer()
            let sinkAndSubscription = self.run(observer, cancel: disposer)
            disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)

            return disposer
        }
        else {
            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
            }
        }
    }

由于 if else 是关于线程的,所以我们只看公共部分

let sinkAndSubscription = self.run(observer, cancel: disposer)

self.run要回到子类的AnonymousObservablerun函数中,其中传入的参数observersubscribe函数中保存的_eventHandler对事件的响应。

override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element {
        let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
        let subscription = sink.run(self)
        return (sink: sink, subscription: subscription)
    }

这里面又创建了 AnonymousObservableSink对象,参数依旧是上面的observercancel

final private class AnonymousObservableSink<Observer: ObserverType>: Sink<Observer>, ObserverType {
    typealias Element = Observer.Element 
    typealias Parent = AnonymousObservable<Element>

    // state
    private let _isStopped = AtomicInt(0)

    #if DEBUG
        fileprivate let _synchronizationTracker = SynchronizationTracker()
    #endif

    override init(observer: Observer, cancel: Cancelable) {
        super.init(observer: observer, cancel: cancel)
    }

    func on(_ event: Event<Element>) {
        #if DEBUG
            self._synchronizationTracker.register(synchronizationErrorMessage: .default)
            defer { self._synchronizationTracker.unregister() }
        #endif
        switch event {
        case .next:
            if load(self._isStopped) == 1 {
                return
            }
            self.forwardOn(event)
        case .error, .completed:
            if fetchOr(self._isStopped, 1) == 0 {
                self.forwardOn(event)
                self.dispose()
            }
        }
    }

    func run(_ parent: Parent) -> Disposable {
        return parent._subscribeHandler(AnyObserver(self))
    }
}

sink.run(self)中调用了run函数,并将self传了过来,又将AnonymousObservable<E>起了别名Parent,返回parent._subscribeHandler(AnyObserver(self))AnyObserver(self)AnonymousObservableSink作为参数传到了AnonymousObservable_subscribeHandler(就是一开始创建序列create的闭包)。

public 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>) {
        return self.observer(event)
    }

    public func asObserver() -> AnyObserver<Element> {
        return self
    }
}

其中把AnonymousObservableSinkon函数赋值给AnyObserver的属性observer(EventHandler)。

捋一下订阅信号过程

subscribe -> AnonymousObserver(Producer).subscribe(observer) -> AnonymousObservablerun -> AnonymousObservableSinkrun -> AnonymousObservable_subscribeHandler(AnyObserver(self))

订阅信号

三.发送信号

cerate闭包中obserber.onNext("马小撂")点进去来到ObserverTypeonNext方法

public func onNext(_ element: Element) {
    self.on(.next(element))
}

AnonymousObservableSink中的on函数的.next分支self.forwardOn(event) -> SinkforwardOnself._observer.on(event)-> ObserverBaseself.onCore又回到AnonymousObserveronCore方法中self._eventHandler(event) 这就是subscribe中的闭包啊

发送信号: create闭包 ->AnyObserver -> AnonymousObservableSink -> AnonymousObserver -> subscribe闭包

最后附上一张文章中用到的类关系图