RxSwift--核心逻辑分析完整版

一、相关概念

1.Observable可观察序列

2.Observer观察者

二、核心逻辑分析

1.创建序列

        let ob = Observable<Any>.create { (obserber) -> Disposable in
            obserber.onNext(“Hello RxSwift")
            obserber.onCompleted()
            obserber.onError(NSError.init(domain: "coocieeror", code: 10087, userInfo: nil))
            return Disposables.create()
        }

流程分析：
  1.首先我们进入create源码，直接command进不去，我们可以在工程导航栏搜索Create.swift类文件进入。在Create.swift类中，其实就是定义了一个继承自Producer的匿名序列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)
    }
}

  其主要工作就是保存了外部订阅的代码块：self._subscribeHandler = subscribeHandler。该代码块正是ViewController.swift中的create闭包.create，将创建序列时的闭包中据进行保存，供随时取用。
  恰当地运用了函数式编程思想保存属性_subscribeHandler。

2.订阅序列

//订阅序列
        let _ = ob.subscribe(onNext: { (text) in
            print("Subscribed:\(text)")
        }, onError: { (error) in
            print("Error: \(error)")
        }, onCompleted: {
            print("Finished")
        }) {
            print("Dealloced")
        }

流程分析：
  我们进入subscribe源码：因为Obserable继承自ObservableType，所以会进入ObservableType+Extensions.swift类。

• 创建关键函数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() : []
            
            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
            )
    }
}

  我们只关心匿名订阅者AnonymousObserver的创建。后边对event作为一个闭包接收并转发相应的事件：onNext、onError、onCompleted、onDisposed，后续发送响应时会直接传入该event事件。

• 创建AnonymousObserver对象，在其初始化AnonymousObserver时创建并保存了一个_eventHandler：self._eventHandler = eventHandler，作为所有onNext、onError、onCompleted的回调，用于在第3部分发送响应时将onNext、onError、onComplete回调至ViewController.swift中的sucribe块。
• 只要有event出现便进入switch判断，判断是.next、.error、.completed等，并执行对应的闭包方法onNext、onError、onCompleted。但具体是如何传递数据到ViewController.swift的.subscribe闭包中的呢？我们继续分析。
• 在最后的return中调用create，执行self.asObservable().subscribe(observer) 。将创建的observer传递下去。

  asObservable( ) 为Observable本身，见Observeable.swift类中：

public func asObservable() -> Observable<E> {
        return self
    } 

  subscribe( )：找一下Create.swift类，没有。那么进入其父类Producer.swift中查找，Producer.swift定义了subscribe 函数（其实是重写了Producer.swift的父类的该函数）。

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

3.发送响应
流程分析：

• 发送响应起步于ViewController.swift中.create闭包中的obserber.onNext，只要有onNext命令就回发起响应。
• 然后调用Create.swift中AnonymousObservableSink的on函数：

func on(_ event: Event<E>) {
        #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()
            }
        }
    }

  判断switch case .onNext条件，执行self.fowardOn(event)。forwardOn函数定义于AnonymousObservableSink的父类Sink中。

• 然后执行Sink中on函数：

final func forwardOn(_ event: Event<O.E>) {
        #if DEBUG
            self._synchronizationTracker.register(synchronizationErrorMessage: .default)
            defer { self._synchronizationTracker.unregister() }
        #endif
        if isFlagSet(self._disposed, 1) {
            return
        }
        self._observer.on(event)
    }

  此处_observer为AnonymousObserver类型常量。

• 接着回调至subscribe的 AnonymousObserver中的event闭包块执行响应的条件.onNext。

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

• 最终便会将value回调至ViewController.swift中的sucribe闭包块，完成onNext的操作。

  onNext完成后，接着执行onCompleted操作，流程同onNext。

  以上，我们分析了整个订阅创建序列create、订阅序列sucribe、发送响应的全过程。其设计思想高度结合了函数响应式编程思想，这样正是RxSwift框架的强大之处。
  时间原因，后续会针对上述流程绘制思维导图，帮助我们更直观、全面地理解整个逻辑流程。