create

点击进入create方法，找到这样一个func，看不到实际实现，但是看注解发现create是一个路由，然后就全局搜索create，找到Create.swift。

在这里的create中创建了AnonymousObservable，并传入了subscribe闭包

在AnonymousObservable中可以看到保存了subscribeHandler闭包，并且重写了父类的run方法。
而AnonymousObservable继承于Producer。Producer中定义了run方法，重写了父类的subscribe方法，在这里是订阅方法的具体实现。

Producer则继承于Observable。Observable中定义了subscribe，实现了asObservable方法。asObservable实现了一切皆序列，随时随地都可以序列化然后订阅。

Observable遵守ObservableType协议。协议主要是提供subscribe方法，在遵守协议的类中要实现方法。

ObservableType遵守ObservableConvertibleType协议。提供了asObservable方法。

至此，create的流程出来一条线。AnonymousObservable - > Producer - > Observable - > ObservableType协议 - > ObservableConvertibleType协议。在这里Observable作为一个基类，定义了协议的方法。Producer作为父类实现重要的调度、订阅、观察者接收功能。AnonymousObservable则对外界传入闭包保存，调用闭包，承上启下。

subscribe

subscribe方法实现在subscribe方法中创建了AnonymousObserver对象，并对传入的event进行分类处理。在return的时候调起了Observable的subscribe方法。

AnonymousObserver：继承于ObserverBase，保存了event闭包，对父类的onCore方法重写。

ObserverBase：遵守了Disposable和ObserverType协议，实现了协议的on方法和dispose方法，定义了自己的onCore方法。

subscribe也形成一条class链。AnonymousObserver -> ObserverBase -> Disposable和ObserverType协议。

两条看似没有关联的链形成了，那么它们是怎么走到一起的呢？>>
在上图中第二个红框里的self.asObservable().subscribe(observer)为两条链联系的重点。

我们知道asObservable()之后就变成序列Observable对象，序列对象调用自己的subscribe方法，因没有具体实现，下沉到子类Producer中。在Producer的subscribe中通过调用子类的run->AnonymousObservable.run。

AnonymousObservable的run方法中创建了AnonymousObservableSink对象，并调用了sink.run。AnonymousObservableSink继承于Sink，并实现了on和run方法。

这里的parent为typealias Parent = AnonymousObservable<Element>，所以这里调用的是AnonymousObservable.subscribe，即为create时传入的闭包

在这里已经开始要执行发送信号的on事件，接下来，看on事件的执行AnyObserver

AnyObserver：继承于ObserverType，并在初始化的时候保存了observer.on，即上层传过来的AnonymousObservableSink.on，在.on中会进入到sink.forwardOn()

然后执行self._observer.on(event)，这里的obsrver在AnonymousObservableSink初始化的时候已经保存了，通过run方法传进来的订阅时创建的AnonymousObserver，所以可以为AnonymousObserver.on(event)，在其父类ObserverBase中找到on事件，通过onCore传递到下层，执行AnonymousObserver.onCore

在这里又执行了订阅时传入的事件闭包。

到这里，整个流程结束了。这个过程比较绕，需要一点点打断点来看，最好是动手自己画一画，把流程图梳理出来就容易明白。我刚开始会纠结于闭包的执行，以为是里边的执行完回到外边去执行闭包内容的，通过核心逻辑梳理才知道闭包会穿进去，在合适的时候调用执行。

还有里边的基类、父类的好多，每条链都会有好多个类继承，但是这些类又不多余，每个分工很明确，功能不累赘。对于方法的声明用协议；基类只提供必要的方法，实现协议方法；父类提供子类需要的方法，做一些调度统筹事情；子类去具体实现想要的功能。
多条链形成之后，会有一个类似Manager的类Sink来把要处理的东西融合在一起，进行事件分发调用。

End