基础用法介绍

在上一篇的RXSwift基础介绍篇，我们已经知道RXSwift的基础用法大致分成三步：

1. 创建可观察序列

2. 监听序列（订阅序列发出的信号）

3. 销毁序列

//创建可观察序列
let ob = Observable.create { (observer) -> Disposable in
    //发送信号
    observer.onNext("RXSwift核心逻辑")
    observer.onCompleted()

    return Disposables.create()
}
//订阅信号
let _ = ob.subscribe(onNext: { (text) in
    print("订阅：\(text)")
}, onError: { (error) in
    print(error)
}, onCompleted: {
    print("完成")
}) {
    print("销毁")
}

控制台输出：

订阅：RXSwift核心逻辑
完成
销毁

底层流程解析

1. 类的继承关系

2. 底层流程

1.创建可观察序列

Observable通过create函数创建可观察序列AnoymousObservable(继承自Producer，Producer遵守ObservableType协议)，AnoymousObservable通过subscribeHandler属性保存了create函数传过来的闭包(包含onNext)，create函数返回了AnoymousObservable对象

create函数：

extension ObservableType {
    // MARK: create
    public static func create(_ subscribe: @escaping (AnyObserver<Element>) -> Disposable) -> Observable<Element> {
        AnonymousObservable(subscribe)
    }
}

create函数内部实际上是创建了一个AnonymousObservable匿名可观察序列对象。而之前的闭包也是给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<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)
    }
}

2. 订阅信号

AnoymousObservable调用subscribe方法传递闭包, 因为父类遵守了ObservableType协议，所以AnoymousObservable也遵守这个协议，所以调用的是ObservableType协议里的subscribe方法。在subscribe方法里创建了AnoymousObserver对象(什么是观察者，遵守ObserverType协议)，返回Disposable。

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()
            }
            
            #if DEBUG
                let synchronizationTracker = SynchronizationTracker()
            #endif
            
            let callStack = Hooks.recordCallStackOnError ? Hooks.customCaptureSubscriptionCallstack() : []
            
            let observer = AnonymousObserver<Element> { 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
            )
    }

在Disposables.create方法里调用Producer的subscribe，subscribe里放入的就是最终的观察者(AnoymousObserver)。

override func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == 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
            }
        }
    }

在Producer的subscribe里调用AnonymousObservable的run方法

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

在sink.run(self)里传入的self是AnonymousObservable，然后调用parent.subscribeHandler(AnyObserver(self))，

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

parent就是AnonymousObservable，调用AnonymousObservable存储的subscribeHandler回调。在这里会触发observer.onNext方法，这里的observer是AnyObserver，AnyObserver遵守ObserverType协议，所以调用的ObserverType的onNext方法，

extension ObserverType {

    public func onNext(_ element: Element) {
        self.on(.next(element))
    }
    
    public func onCompleted() {
        self.on(.completed)
    }
    
    public func onError(_ error: Swift.Error) {
        self.on(.error(error))
    }
}

触发了Anyobserver的on方法

public func on(_ event: Event<Element>) {
        self.observer(event)
 }

AnyObserver在初始化的时候走了self.observer = observer.on，observer.on就是AnonymousObservableSink的on方法，

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

然后调用Sink基类的forwardOn方法，

final func forwardOn(_ event: Event<Observer.Element>) {
        #if DEBUG
            self.synchronizationTracker.register(synchronizationErrorMessage: .default)
            defer { self.synchronizationTracker.unregister() }
        #endif
        if isFlagSet(self.disposed, 1) {
            return
        }
        self.observer.on(event)
    }

调用self.observer.on，sink的Observer是AnonymousObserver，AnonymousObserver没有on方法，所以会调用AnonymousObserver的基类ObserverBase的on方法，在on方法里调用onCore方法，

func on(_ event: Event<Element>) {
        switch event {
        case .next:
            if load(self.isStopped) == 0 {
                self.onCore(event)
            }
        case .error, .completed:
            if fetchOr(self.isStopped, 1) == 0 {
                self.onCore(event)
            }
        }
    }

然后调用AnonymousObserver的onCore方法，在onCore方法里调用存储ONext回调的eventHandler，这个eventHandler是什么？不就是AnonymousObserver初始化时保存的对subscribe闭包处理的闭包么！所以create闭包中的observer.onNext("...")就能触发subscribe闭包了, 最后调用subscribe传过来的回调，流程完毕。

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

3. 销毁序列

在subscribe的函数中我们可以看到，建立了相应的disposable销毁对象

let disposable: Disposable
            
if let disposed = onDisposed {
     disposable = Disposables.create(with: disposed)
   }
    else {
           disposable = Disposables.create()
 }

在出现错误或者完成的时候会调用相应的销毁方法

                case .error(let error):
                   if let onError = onError {
                        onError(error)
                    }
                    else {
                        Hooks.defaultErrorHandler(callStack, error)
                    }
                    disposable.dispose()
                case .completed:
                    onCompleted?()
                    disposable.dispose()
                }

接下来我们看看create函数做了什么

public static func create(with dispose: @escaping () -> Void) -> Cancelable {
        AnonymousDisposable(disposeAction: dispose)
    }

创建了用于执行dispose回调函数的对象AnonymousDisposable，在下面的函数段执行dispose函数回调

fileprivate func dispose() {
        if fetchOr(self.disposed, 1) == 0 {
            if let action = self.disposeAction {
                self.disposeAction = nil
                action()
            }
        }
    }

串联整个销毁过程的是这句代码Disposables.create(self.asObservable().subscribe(observer),disposable)，跟进去看到里面是一个二元销毁者BinaryDisposable(disposable1, disposable2)，在这里有对应的销毁方法dispose

func dispose() {
        if fetchOr(self.disposed, 1) == 0 {
            self.disposable1?.dispose()
            self.disposable2?.dispose()
            self.disposable1 = nil
            self.disposable2 = nil
        }
    }

我们可以知道disposable2是AnonymousDisposable，处理的是销毁回调相关的，那么disposable1是什么呢，根据上面的代码我们进入Producer类

let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)

return disposer

SinkDisposer对应的dipose销毁方法，对subscribe的回调函数和sink管道都进行了销毁，断开了整个流程。

func dispose() {
        let previousState = fetchOr(self.state, DisposeState.disposed.rawValue)

        if (previousState & DisposeState.disposed.rawValue) != 0 {
            return
        }

        if (previousState & DisposeState.sinkAndSubscriptionSet.rawValue) != 0 {
            guard let sink = self.sink else {
                rxFatalError("Sink not set")
            }
            guard let subscription = self.subscription else {
                rxFatalError("Subscription not set")
            }

            sink.dispose()
            subscription.dispose()

            self.sink = nil
            self.subscription = nil
        }
    }

sink管道和subscribe回调函数怎么传过来的呢，主要是通过上面代码里的这个方法：setSinkAndSubscription

func setSinkAndSubscription(sink: Disposable, subscription: Disposable) {
        self.sink = sink
        self.subscription = subscription

        let previousState = fetchOr(self.state, DisposeState.sinkAndSubscriptionSet.rawValue)
        if (previousState & DisposeState.sinkAndSubscriptionSet.rawValue) != 0 {
            rxFatalError("Sink and subscription were already set")
        }

        if (previousState & DisposeState.disposed.rawValue) != 0 {
            sink.dispose()
            subscription.dispose()
            self.sink = nil
            self.subscription = nil
        }
    }

这样整个销毁流程就走完了

综上，创建可观察序列 -> 监听序列（订阅序列发出的信号）-> 销毁序列整个流程的底层代码就分析完毕，感觉有用的话就点个star吧！

RXSwift进阶：RXSwift的底层核心逻辑解析

基础用法介绍

底层流程解析

1. 类的继承关系

2. 底层流程

猜你喜欢