RxSwift原理---详细流程在上一篇函数响应式编程思想&RxSwift核心逻辑中，已经分析了RxSwift的核心逻辑

在上一篇函数响应式编程思想&RxSwift核心逻辑中，已经分析了RxSwift的核心逻辑，这篇将详细赘述RxSwift的具体流程。

根据下面这个关系图，详细展开分析每一步的流程，进而理解函数式编程的思想。

子节点表示执行顺序、继承关系、方法实现、遵循协议，
虚线表示调用关联关系

大体流程分为以下三步：

一、创建序列

用户创建序列调用代码如下

let obsever = Observable<Any>.create { (obserber) -> Disposable in
    return Disposables.create()
}

搜索进入Create.swift文件，即可看到如下create方法，创建返回了一个匿名可观察序列AnonymousObservable，并且将subscribe传递进去

注意：此处说明外界调用获取上一步的let obsever是一个AnonymousObservable类型的对象

public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
    return AnonymousObservable(subscribe)
}

接着查看AnonymousObservable的实现方法

init中保存subscribe函数回调，
实现run方法，run中创建AnonymousObservableSink管道类建立与其他业务的联系，并且调用sink.run(self)，将自己也传参进去

final private class AnonymousObservable<Element>: Producer<Element> {

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

二、订阅信号

用户订阅调用代码如下

let _ = obsever.subscribe(onNext: { (text) in
    print("订阅到:\(text)")
}, onError: { (error) in
    print("error: \(error)")
}, onCompleted: {
    print("完成")
})

上述的obsever即为AnonymousObservable类型的对象，查看AnonymousObservable的subscribe的方法是在ObservableType协议扩展中，

public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
        -> Disposable {
    let observer = AnonymousObserver<E> { 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
        )
}

public class Observable<Element> : ObservableType {
    /// Type of elements in sequence.
    public typealias E = Element
    public func asObservable() -> Observable<E> {
        return self
    }
}

override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        let disposer = SinkDisposer()
        let sinkAndSubscription = self.run(observer, cancel: disposer)
        disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
        return disposer
    }
    
final private class AnonymousObservableSink<O: ObserverType>: Sink<O>, ObserverType {
    typealias E = O.E
    typealias Parent = AnonymousObservable<E>

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

    func on(_ event: Event<E>) {
        switch event {
        case .next:
            self.forwardOn(event)
        case .error, .completed:
            self.forwardOn(event)
            self.dispose()
        }
    }

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

订阅时，执行以下步骤，

创建一个AnonymousObserver类，并且将onNext事件以函数形式交由AnonymousObserver处理
self.asObservable在基类Observable的实现返回self，用于统一类型
self.asObservable().subscribe(observer)则是调用父类Producer的subscribe方法
Producer调用self.run则调用到AnonymousObservable的run
AnonymousObservable的run创建AnonymousObservableSink类，传递AnonymousObserver，调用run方法，传参self
AnonymousObservableSink的run方法创建AnyObserver，调用AnonymousObservable先前保存的用户create事件，

三、发送信号

用户调用发送信号代码如下

let obsever = Observable<Any>.create { (obserber) -> Disposable in
    // 发送信号
    obserber.onNext("测试信号")
    return Disposables.create()
}

用户使用订阅流程创建好的AnyObserver调用onNext发送信号，AnyObserver的实现如下

public struct AnyObserver<Element> : ObserverType {
    public typealias E = Element

    public init<O : ObserverType>(_ observer: O) where O.E == Element {
        self.observer = observer.on
    }
    
    public func on(_ event: Event<Element>) {
        return self.observer(event)
    }

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

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

class Sink<O : ObserverType> : Disposable {
    fileprivate let _observer: O
    init(observer: O, cancel: Cancelable) {
        self._observer = observer
    }

    final func forwardOn(_ event: Event<O.E>) {
        self._observer.on(event)
    }
}

class ObserverBase<ElementType> : Disposable, ObserverType {
    typealias E = ElementType
    func on(_ event: Event<E>) {
        switch event {
        case .next:
            self.onCore(event)
        case .error, .completed:
            self.onCore(event)
        }
    }
}

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

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

初始化时，

保存传递进来的self.observer=AnonymousObservableSink.on事件
AnonymousObservableSink.on调用AnonymousObservableSink的父类Sink.forwardOn事件
Sink.forwardOn调用初始化保存的AnonymousObserver.on事件
AnonymousObserver.on在父类ObserverBase.on实现调用self.onCore
AnonymousObserver.onCore则调用创建时的尾随闭包eventHandler

相当于AnyObserver.observer=AnonymousObserver._eventHandler

调用AnyObserver.onNext的流程如下

调用在ObserverType扩展的方法调用self.on，即AnyObserver.on
AnyObserver.on调用self.observer(event)事件，即上一步得出的AnonymousObserver._eventHandler
AnonymousObserver._eventHandler即调用外部订阅的onNext事件。

此时，完成流程走完。

RxSwift原理---详细流程

一、 创建序列

二、 订阅信号

三、 发送信号

一、创建序列

二、订阅信号

三、发送信号