RxSwift核心邏輯01 -- Observable Observer

思想

「一千個廚師作魚香肉絲，會作出一千種味道」——杜甫
作魚香肉絲的工序是固定的，可是隨着條件不一樣則會有不一樣的結果，甚至出現製做失敗的狀況（error）。
這個過程用用RxSwift寫的話基本是下面這個樣子：

let 切菜 = 工序<Any>.create { (廚師) -> 收拾廚房的人 in
            切菜();
            廚師.作.給下一我的("切好的菜");
            廚師.作.完成();
            廚師.作.失敗("沒有刀！");
            return 收拾廚房的人.create();
        }

        let  炒菜 = 工序<Any>.create { (廚師) -> 收拾廚房的人 in
            炒菜();
            廚師.作.給下一我的("炒好的菜");
            廚師.作.完成();
            廚師.作.失敗("沒有鍋！");
            return 收拾廚房的人.create();
        }
        
       let 魚香肉絲 = 切菜.flatMap{(Any) -> 工序<Any> in 
               return 炒菜;
        };
        
        魚香肉絲.製做(給下一我的: { (半成品) in
            裝盤(未裝盤的菜);
        }, 完成: {
             print(這個菜抄完了);
        }, 失敗: {(error) in 
             print(這個菜沒作完是由於:\(error));
            // 這個菜沒作完是由於：沒有刀 or 沒有鍋
        });
複製代碼

這裏咱們能夠知道RxSwift的一個基本思路是，建立一個任務，建立這個任務的時候要把任務的結果、是否完成 以及 善後考慮好。而後在要作這個任務的時候，直接開啓這個任務。就是在開啓這個任務的時候，內部會自動分配一個匿名的執行者去執行這個任務。
這裏面有3個主要成員：菜，廚師，收拾廚房的人。

而後看一段簡單的正宗RxSwift調用
代碼1.1：

let requestTask = Observable<Any>.create { (obserber) -> Disposable in
            obserber.on(.next("返回數據1"));
            obserber.onNext("返回數據2");
            return Disposables.create();
        }
        
        
        let _ = requestTask.subscribe(onNext: { (text) in
            print("執行結果:\(text)");
        });
複製代碼

結構

這裏面有三個核心

圖1

*注：該圖非官方，是筆者本身畫的
綠色：Swift語言中的extension。
紅色：枚舉類型
藍色：結構體

經過圖1咱們能夠看到RxSwift裏面主要有三個核心協議，即<ObservableConvertibleType>的子類<ObservableType>，<ObserverType>和< Disposable >。用通俗的話講就是「須要乾的活的協議」，「幹活的人的協議」 以及 「善後的人的協議」。

是否是被這麼多類嚇到了？其實稍微劃分一下就很明朗了：

圖2

總共有五大部分，每一個部分都有一個主要的類（用紅框標出的）。
下面咱們一個一個的來細細分析

注意：請必定要看清楚是observable仍是observer
注意：請必定要看清楚是observable仍是observer
注意：請必定要看清楚是observable仍是observer

分析

0 - asXXXX

整個Rx內部有着大量的asXXX的方法，這裏放在前面統一來講：
隨着不停地子類化，到後面履行該協議的類可能不止一個身份，也會有其餘身份。爲了可讀性和邏輯性這裏纔有了這個方法協議。
舉個例子：小明原先是程序員可是他轉行成了一名廚師，因此小明如今的身份是一名廚師，廚師敲代碼這很變扭可是：

小明.as程序員.敲代碼()
複製代碼

就很合理了。

1 - Event

經過箭頭的指向的個數能夠看出這個枚舉是一個核心。這個枚舉表示了一個事件的三種狀況，即next, complete, error。這裏面next和error都綁定了關聯值。

2.1 -

「幹活的人」的基本協議。

1. func on(_ event: Event<E>)
   做爲一個響應者（幹活的人）須要遵照的最基本協議，這裏面只包含了這一個方法,而參數則是上面咱們提到的Event。

2. public func onNext(_ element: E) ，public func onCompleted() ，public func onError(_ error: Swift.Error)
   對於2.1.1的擴展，經過源碼咱們能夠知道僅僅是在發送相應的枚舉值。而且在onNext和onError的時候，把參數賦值到枚舉的關聯值上。

2.2 - public struct AnyObserver

做爲本篇惟一的結構體，之因此用結構體是由於它不須要被繼承並且無需作析構處理。這裏只有一個屬性:(Event<Element>) -> Void類型的observer。

1. public init<O : ObserverType>(_ observer: O) where O.E == Element
   這個方法的實現是：

self.observer = observer.on
複製代碼

這裏很是巧妙，由於on方法的方法原型和observer的閉包類型都是

(Event<Element>) -> Void
複製代碼

因此是能夠賦值的。

1. public func on(_ event: Event<Element>)
   這裏實現了協議的on方法，就是以event爲參數調用本身的閉包對象observer。

3 - final class AnonymousObserver

基本屬於2.2的增強版，由於不是結構體而是類，因此有了析構處理，並且自己也是繼承自class ObserverBase<ElementType> 類。這裏基本邏輯和2.2基本相似，惟一不一樣的是他多了<Disposable>協議的實現，咱們會在後面的文章中專門講<Disposable>的，這裏不作過多贅述。

4.1 - < ObservableType >

「須要乾的活」的基本協議。

1. func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E
   -- 做爲全部Observable的最根本的協議，固然包含了最基本的功能subscribe。用上面作菜的例子說就是「一道菜(Observable)最起碼是能被一個廚子(Observer)製做(subscribe)出來的,而且返回一個收拾廚房的人(Disposable),在適當的時候收拾殘局」

2. public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E>
   -- 該協議擴展的簡單工廠方法，經過一個閉包來快速建立一個AnonymousObservable類的實例。（AnonymousObservable後面會講到）

3. public func subscribe(_ on: @escaping (Event<E>) -> Void) -> Disposable
   -- 對於方法1的擴展，經過一個(Event<E>) -> Void的逃逸閉包做爲參數，來創造一個實現了ObserverType的類AnonymousObserver的實例，而後調用方法1。

4. public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil) -> Disposable
   -- 看似很複雜，可是其實真正的核心代碼只有中間的AnonymousObserver建立，就是把做爲參數的onNext，onError，onCompleted的閉包在對應枚舉值的狀況下傳入關聯值而且回調。而onDisposed閉包則是用來建立對一個的disposable，在適當的時候調用disposable.dispose()。在最後建立Disposables時，將先前的AnonymousObserver的對象做爲參數調用本身的subscribe方法。

4.2 - class Producer

1. func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == Element
   -- 新添加的抽象方法。經過一個ObserverType的子類的對象和一個Cancelable（Disposable的子類）的對象爲參數，返回兩個Disposable的對象。

2. override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element
   -- 協議方法的具體實現，裏要注意的是下面這段代碼：

let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
複製代碼

這個方法本身生成了一個disposer，而後把這個disposer和observer做爲參數調用了一下本身的run方法。

4.3 - final private class AnonymousObservable

1. _subscribeHandler 和 init

這個final類添加了一個屬性

let _subscribeHandler: (AnyObserver<Element>) -> Disposable
複製代碼

而構造方法則是把這個屬性賦值

init(_ subscribeHandler: @escaping SubscribeHandler) {
        self._subscribeHandler = subscribeHandler
}
複製代碼

再結合4.1.2咱們就能夠知道這個_subscribeHandler，就是咱們調用creat的時候傳過來的block。也就是代碼1.1中的

obserber.on(.next("返回數據1"));
obserber.onNext("返回數據2");
return Disposables.create();
複製代碼

1. 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)
複製代碼

說明了兩點：
1） AnonymousObservable的run方法實際上是調用的AnonymousObservableSink的run方法。
2）第一行說明了AnonymousObservableSink類的實例對象中可能包含了observer以及dispose。第二行說明了AnonymousObservableSink類的實例對象中又可能包含了observeable。
換句話說AnonymousObservableSink類是上面說起到的<Observer Type>,< ObservableType > 以及後面會說起的< Disposable >的匯合點。他是把「要乾的活」，「幹活的人」以及「處理者」給匯合到一塊兒而且協調的那個樞紐

5. - final private class AnonymousObservableSink

當你們看到這個類的兩個方法run和on的時候，有沒有感受前面的一切都串聯到了這裏。由於run是Observable纔有的方法，而on則是Observer纔有的方法，這裏一個類就包含了這兩個方法，足以說明這個類做爲樞紐的身份。

1. func on(_ event: Event<E>)
   --經過父類的方法咱們能夠看出來，這個方法本質是調用observer的on，可是會根據上下文來適當的調用dispose。

2. func run(_ parent: Parent) -> Disposable
   --其實能夠拆成兩行代碼

let anyObserver = AnyObserver(self);
parent._subscribeHandler(observer);
複製代碼

你們注意，這裏的anyObserver和自身屬性的observer是有區別的。自身的observer是AnonymousObserver類（3）的對象。而anyObserver則是結構體AnyObserver（2.2）的對象。（具體區別在前邊講AnonymousObserver類的時候有提到）。
這兩句代碼就是生成一個AnyObserver的對象而且以其做爲參數調用上面的_subscribeHandler閉包。
仍是拿代碼1.1爲例。

let requestTask = Observable<Any>.create { (obserber) -> Disposable in
            obserber.on(.next("返回數據1"));
            obserber.onNext("返回數據2");
            return Disposables.create();
        }
複製代碼

這裏的obserber就是AnyObserver(self)。

總結

總體RxSwift的核心很繞也很迷人，其實只要記住
Obserable - subscribe(Observer) - run(Observer)；
⬆️
on(Event)---Sink-------run(AnyObserver)
⬆️
Observer - on(Event)；
而且結合源碼和UML圖仍是相對容易理清思路的。

做爲一個開發者，有一個學習的氛圍和一個交流圈子特別重要，這是個人 交流羣（111），你們有興趣能夠進羣裏一塊兒交流學習

收錄：原文地址

若是以爲寫得不錯 給我一個贊謝謝