03.RxSwift 核心逻辑

核心逻辑思维

Observable序列的创建

			 //1.创建信号
                let ob = Observable<Any>.create { (observer) -> Disposable in
                    //3.发送信号
                    observer.onNext("RxSwift核心原来")
                    //observer.onError("error的" as! Error)
                    observer.onCompleted()
        
                    return Disposables.create()
                }

• 首先： Observable -> 遵循ObservableType协议, ObservableType对外提供了：subscribe(信号订阅), 扩展了一个：asObservable(把非序列转化成序列)。
  
• 然后，通过crate方法返回了一个AnonymousObservable -> 继承Producer ->继承Observable, 在初始化AnonymousObservable的时候保存了创建Observable序列的闭包：_subscribeHandler
  

Observable序列的订阅

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

• 创建的序列ob，通过调用subscribe，直接就进入到ObservableType里的subscribe方法里，里边创建了一个AnonymousObserver对象，并且最后调用

  return Disposables.create(
  self.asObservable().subscribe(observer),
  disposable
  )

把这个AnonymousObserver传了进去，回到了ob本身的subscribe方法

• 而ob是AnonymousObservable对象，本身并为实现subscribe方法， 而是通过其父类：Producer 实现了subscribe方法
  
• 在subscribe的内部，调用了self.run,注意这时候self还在是AnonymousObservable对象，并且这个方法在AnonymousObservable内部有重写,
  
• 在Run方法内部，创建了一个sink管道，并且sink 又调用了自身的run方法，并且把当前ob传了进去，在sink的Run方法内部，通过传入的ob调用保存的_subscribeHandler
  
• 然后通过自身sink初始化了一个AnyObserver对象，AnyObserver内部通过observer属性保存了sink.on事件（这里的observer 就是初始化传进来的sink本身）
  

Observable序列发送信号

			   //1.创建信号
                let ob = Observable<Any>.create { (observer) -> Disposable in
                    //3.发送信号
                    observer.onNext("RxSwift核心原来")
                    //observer.onError("error的" as! Error)
                    observer.onCompleted()
        
                    return Disposables.create()
                }

• 这里有一个问题，我们发送信号的的这个observer是哪里来的，create尾随闭包带出来的没错吧，那这个闭包又是走哪里把这个observer带出来的呢。

• 请回忆： 我们创建序列的时候是不是通过AnonymousObservable 保存了一个_subscribeHandler闭包，在订阅序列的时候是不是调用了这个_subscribeHandler闭包，并创建了一个AnyObserver对象传了给了闭包，那我们订阅信号最后创建的AnyObserver 不就是创建序列时的这个闭包中的observer吗？

• 既然找到了observer 来自于哪里AnyObserver，那么我们发信号是不是会到AnyObserver里边去，但是你发觉AnyObserver类里本身没有onNext，onError，onCompleted等方法，那么这些是哪里来的呢，请看AnyObserver是不是接受了ObserverType协议，那么他自然就有这三个方法了
  

• 当我们调用者三个方法发送信号的时候，是不是就会走到ObserverType里边去，这三个方法内部都调用了on,
  

• AnyObserver本身是不是重写了这个on方法，并且调用observer，observer是不是又保存了我们初始化AnyObserver的时候传进来的sink.on事件，是不是就相当于这个时候调用了sink.on

• 我们回到sink.on看看又做了什么操作，是不是.next的时候又调用了forwardOn方法，forwardOn在哪呢，sink里是不是没有
  

• 那不就是在他父类或者协议里，找进去在他父类Sink -> ObserverType里边，里边调用self._observer, 那这个_observer哪里来的呢，我们回过头去看，初始化sink的时候干了啥
  

• 我们初始化的时候传了一个observer，这个observer又来自哪里，找回去，在我们订阅信号的时候是不是传进来的
  
  

• 是不是就我们subscribe的时候，ObservableType里的subscribe方法里创建的AnonymousObserver对象，

• 此时此刻我们的_observer是不是就是AnonymousObserver 对象，_observer.on就回到了AnonymousObserver 的.on方法里，

• 但是AnonymousObserver内并没有on方法，那么在他父类ObserverBase实现了
  

• 里边.next又调用了onCore，又回到了AnonymousObserver自身的onCore方法里
  

• 好，那这个_eventHandler是哪里来的，找回去，我们在subscribe订阅信号的时候ObservableType里创建AnonymousObserver的地方，

• 是不是这个_eventHandler就保存了我们订阅序列的时候那个闭包嘛，这里调用_eventHandler不就是调用了我们订阅序列时闭包里的onNext，onError，onCompleted么。

几个主要类的继承结构，方便大家更好的理解：

逻辑图如下：

总结：整个逻辑图看上去很复杂，很混乱，要认真细心的对照着源码才好理解。但是不管怎么复杂都离不开函数式响应。总的来说就是创建的时候带一个闭包A进去，订阅的时候又传一个闭包B进去，两个闭包在manager中通过一系列的处理后, 把闭包B保存到了A闭包的参数observer里，当observer发送信息的时候, 通过一系列的转化最终调用了B闭包。

通过核心逻辑最主要的就是学习Rx的逻辑思维，提高自己技能，在开发过程中能更好的使用RxSwift.