介绍

我们都知道，RxSwift很强，作为一名开发者，阅读开源框架的源码，能让我们受益颇多，学习优秀的开发者的思路是很有必要的。

当我们写这么一份代码时，会疑惑为什么他两个闭包之间会能够联系起来。

Observable<String>.create { ob -> Disposable in
            ob.onNext("tets")
            return Disposables.create()
            }.subscribe(onNext: { str in
                print(str)
            }, onError: { error in
                print(error)
            }, onCompleted: {
                print("complete")
            })

本文结尾项目地址： github.com/GitHubYhb/R…
这是一份帮助阅读RxSwift底层运行流程原理的RxSwift源码我往其中加了一些打印的信息，从create到onNext每一步在哪里做了什么都很清楚。
下载项目之后 -> 运行 RxExample-iOS

那么废话不多说。直接开干。

Observable

Observable 原型是 Observable<Element>

public class Observable<Element> : ObservableType {
    // ...部分省略
    
    // ObservableType 协议定义的方法。       
    public func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
        rxAbstractMethod()
    }
    
    // ObservableConvertibleType 定义的方法。
    public func asObservable() -> Observable<Element> {
        return self
    }
}

它遵循了ObservableType协议。
在ObservableType协议中，要求遵循者需要有subscribe()方法。

public protocol ObservableType: ObservableConvertibleType {
    // ...省略一堆注释
    func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element
}
extension ObservableType {
    //遵循ObservableConvertibleType 的方法
    public func asObservable() -> Observable<Element> {
       // ...省略实现代码
    }
}

同时ObservableType协议，又遵循了ObservableConvertibleType协议。在ObservableConvertibleType协议中，创建了叫Element的关联类型。
以及要求遵循者要有 asObservable()方法

public protocol ObservableConvertibleType {
    associatedtype Element
    
    // E 重新命名 Element
    @available(*, deprecated, message: "Use `Element` instead.")
    typealias E = Element

    func asObservable() -> Observable<Element>
}

由下图我们可以看出来这三者之间的关系

看懂了Observable,我们再来看看create()，找到Create.swift文件

create()

extension ObservableType {
    // ... 省略一堆注释
    public static func create(_ subscribe: @escaping (AnyObserver<Element>) -> Disposable) -> Observable<Element> {
        return AnonymousObservable(subscribe)
    }
}

吐槽：这句代码是真的又长又难看懂。

create() 是什么

首先，create()是ObservableType的扩展
上文已经有提到ObservableType是一个protocol协议

所以，create()也是ObservableType下定义的一个方法，跟subscribe()一样。

解析

create()中有一个参数，名为subscribe的闭包，并且用_做了省略。
返回型是Disposable。
看上去就是一长串，很不友好，为了更好的理解，请看我下面的代码

// 仿照 ObservableType 创建一个协议，并定义一个create方法
protocol TestProtocol {
    func create(_ subscribeBlock: @escaping (String) -> String) -> UILabel
}
// UILabel遵循这个协议
extension UILabel: TestProtocol{
    func create(_ subscribeBlock: @escaping (String) -> String) -> UILabel {
        //调用block
        let newStr = subscribeBlock("block干活")
        print("block返回 == " + newStr)
        return UILabel.init()
    }
}

这份代码中
(String) -> String
------------ ↓ 对应 ------------
(AnyObserver<Element>) -> Disposable
然后来测试一下这段代码

let lb = UILabel.init()
lb.create { str in
    print("block传递出来 == " + str)
    return "test"
}

看打印结果

block传递出来 == block干活
block返回 == test

相信看到这里，大家心里已经有点明白的意思了。

在我们调用完create()之后，闭包先返回给我们一个AnyObserver<Element>类型的参数

我们通过这个参数做了操作之后，就会再返回给闭包一个Disposable，给它操作。

那么这个AnyObserver<Element> 是什么呢

`AnyObserver<Element>`

我们就看AnyObserver，它遵循了ObserverType协议
注意：这个协议跟上文的ObservableType不一样，字母位数都不一样的 - 0 -

public struct AnyObserver<Element> : ObserverType {
    //... 省略
}

先看看ObserverType

public protocol ObserverType {
    associatedtype Element
    @available(*, deprecated, message: "Use `Element` instead.")
    typealias E = Element
    func on(_ event: Event<Element>)
}
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))
    }
}

从代码中我们可以看到ObserverType同ObservableType都定义了一个关联类Element。
不同的地方在于定义的方法是func on(_ event: Event<Element>)，并且在拓展中定义了三个方便开发者使用的方法，也就是我们平时常用的onNext()、onCompleted() 、onError()。

也就是说，我们可以拐弯抹角的这么玩。

Observable<String>.create { ob -> Disposable in
    // 下面三行代码一个意思
    ob.on(Event<String>.next("any"))
    ob.on(.next("test"))
    ob.onNext("tets")
    return Disposables.create()
}

既然已经到了Event了，不如先进去一探究竟

public enum Event<Element> {
    case next(Element)

    case error(Swift.Error)

    case completed
}

Event是一个枚举，包含了我们熟悉的三个枚举值，next/error/completed
还有一系列的扩展方法比如map()这里先不一一列举了。

回到AnyObserver
看看完整的代码。

public struct AnyObserver<Element> : ObserverType {
    // 声明闭包 EventHandler
    public typealias EventHandler = (Event<Element>) -> Void
    // 私有常量 observer
    private let observer: EventHandler
    // 初始化方法 1
    public init(eventHandler: @escaping EventHandler) {
        self.observer = eventHandler
    }
    // 初始化方法 2
    public init<Observer: ObserverType>(_ observer: Observer) where Observer.Element == Element {
        self.observer = observer.on
    }
    // on 方法
    public func on(_ event: Event<Element>) {
        return self.observer(event)
    }
    // asObserver 方法
    public func asObserver() -> AnyObserver<Element> {
        return self
    }
}
extension AnyObserver {
    typealias s = Bag<(Event<Element>) -> Void>
}

那么create()方法声明的部分就先到这里。接下来我们看看，他后续返回了AnonymousObservable(subscribe)

AnonymousObservable()

AnonymousObservable 翻译过来就是 匿名观察序列
看下面代码能发现：

这是一个Create.swift中的私有类
AnonymousObservable继承自Producer<Element>
我们上文中就是return了AnonymousObservable()初始化方法。

final private class AnonymousObservable<Element>: Producer<Element> {
    ...先不看他都干了什么
}

既然是继承自Producer<Element>，那么不如先看看Producer<Element>

class Producer<Element> : Observable<Element> {
    ... 也先不看
}

最终，他还是Observable<Element>，函数要求的返回格式。

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

上文有说到create()中return了AnonymousObservable()初始化方法。
那么我们把注意力放到初始化方法
这里他把我们传进来的闭包保存了起来。
那么，我们是不是可以猜想，他保存起来之后，是不是可以想什么时候用就什么时候用呢。

所以当前，我们return了AnonymousObservable()初始化方法之后，create()已经执行完毕。

那么现在我们可以这么理解，下面这段代码

 Observable<String>
    .create { (ob) -> Disposable in
        ob.on(Event<String>.next("any"))
        return Disposables.create()
    }.subscribe(onNext: { str in
    }, onError: { (error) in
    }, onCompleted: {
    })

等同于

AnonymousObservable(subscribe)
    .subscribe(onNext: { str in
    }, onError: { (error) in
    }, onCompleted: {
    })

下一步就是subscribe()

subscribe()

在说之前，我得先跟大家说一下，接下来我们会遇到的subscribe()有两个，如图所示。

我们这里就先把他们标记一下。

然后开始吧。

我做了一些打印，帮助我能更好的理解整个订阅过程。
这张图上主要做了两点。

创建了AnonymousObserver，这个跟AnonymousObservable不一样，AnonymousObserver是观察者，而AnonymousObservable是被观察对象。虽然创建出来，但是并没有进行调用。
跟AnonymousObservable一样，把这个闭包作为一个临时变量。通过self.asObservable().subscribe(observer)传递出去。

那么被传递到哪里去了呢。我们看到self，这是我们当前的调用对象AnonymousObservable，他这里调用的subscribe(observer)是我们上面做过标记的2 。

AnonymousObservable的subscribe()继承自Producer

这里主要是调用了run方法，又把传进来的observer传到别的地方，然后在当前的Producer里面的run是个抽象方法，我们回到AnonymousObservable，他重写了这个run方法

可以看到他创建了一个AnonymousObservableSink，初始化时又传入了observer，一路跟进到Sink的初始化方法可以看到

跟AnonymousObservable时的操作类似，把observer保存了起来。

在初始化AnonymousObservableSink后，有调用了另外一个run方法。

在这个AnonymousObservableSink中，他重命名了AnonymousObservable
run方法接收到我们传递过来的Parent(AnonymousObservable)
parent执行先前保存起来的闭包，并将AnyObserver(self)传递了进去，这样才能让保存起来的闭包有一个观察者来执行Event。
这里的self是AnonymousObservableSink，通过AnyObserver转成观察者。

可以这么理解：通过AnyObserver()将先前保存起来的observer，提取出来
这时候，已经把两个保存起来的元素串联起来了。

开始执行闭包中的内容。
这是最开始我写好的闭包内容。

        let ob = Observable<String>.create { ob -> Disposable in
            print("开始在我们保存的闭包里面搞事,ob的值已经传进来了，就是AnyObserver(self)")
            ob.onNext("tets")
            return Disposables.create()
        }
        _ = ob.subscribe(onNext: { str in
            print(str)
        })

那么，这个onNext是什么时候执行的呢？

`onNext` 什么时候执行

ob.onNext("tets")的本质是AnyObserver(self).onNext("tets")
self是AnonymousObservableSink
我们需要看看AnyObserver(self)发生了什么

public struct AnyObserver<Element> : ObserverType {
    public typealias EventHandler = (Event<Element>) -> Void

    private let observer: EventHandler

    public init<Observer: ObserverType>(_ observer: Observer) where Observer.Element == Element {
        print("调用AnyObserver(self)")
        self.observer = observer.on
    }
    ...
}

初始化方法中，将observer.on保存了起来，也就是说
把AnonymousObservableSink的on方法保存了起来
那么这个on方法都做了什么呢

   func on(_ event: Event<Element>) {
        print("AnonymousObservableSink 的 on 方法 event == \(event.element!)")
        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()
            }
        }
    }

可以看到on方法又调用了一个forwardOn，再点进去看看

final func forwardOn(_ event: Event<Observer.Element>) {
        //...省略
        self._observer.on(event)
}

记得我们上文有提到在初始化AnonymousObservableSink时，把在subscribe()中创建的AnonymousObserver保存了起来，这里他就通过这个_observer，调用了on方法。
这时才跳到了AnonymousObserver。

回到创建AnonymousObserver的地方

let observer = AnonymousObserver<Element> { event in
    ...省略不看
}

看看AnonymousObserver的本身

final class AnonymousObserver<Element>: ObserverBase<Element> {
    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)
    }
}

AnonymousObserver继承自ObserverBase，贯彻到底

class ObserverBase<Element> : Disposable, ObserverType {
    private let _isStopped = AtomicInt(0)

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

    func onCore(_ event: Event<Element>) {
        rxAbstractMethod()
    }

    func dispose() {
        fetchOr(self._isStopped, 1)
    }
}

我们可以看到ObserverBase有一个on方法，还记得我们最上面说过的吗

Observable<String>.create { ob -> Disposable in
    // 下面三行代码一个意思
    ob.on(Event<String>.next("any"))
    ob.on(.next("test"))
    ob.onNext("tets")
    return Disposables.create()
}

这三行是同一个意思。也就是说，在我们调用onNext时，会先调用on方法，在调用.next，然后就走到了self.onCore,当前的onCore也是一个抽象方法。
我们回到AnonymousObserver重写onCore

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

self._eventHandler(event)就会执行这段红框代码

直到这里，才执行到了onNext，才会到我们自己在外部写的代码。

看起来可能很乱，这里做一下

总结

我们写的闭包中ob.onNext()调用时，首先调用了AnonymousObservableSink的on方法

AnonymousObservableSink的on方法调用了self.forwardOn(event)

forwardOn(event)通过先前保存起来的_observer，调用了AnonymousObserver的on方法

AnonymousObserver的on方法调用重写父类的self.onCore(event)

onCore(event)调用AnonymousObserver的self._eventHandler(event),这个_eventHandler就是上面红框里面的内容被保存了下来。

红框内接收到self._eventHandler(event)传递来的event，判断event类型，执行我们自己在外部写的内容。

或许还是很乱，我调整了一下我的打印内容，一步一步的都写得很清楚。

RxSwift底层核心逻辑、流程分析

介绍