RxSwift核心邏輯（二）

一.序列繼承鏈

 

    Observable遵循了ObservableType，通過查看Create.swift文件的源碼發現ObservableType通過擴展添加了方法create。

extension ObservableType {
    public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
        return AnonymousObservable(subscribe)    //返回了一個匿名序列
    }
}

    create方法裏面返回了一個匿名序列：AnonymousObservable， 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<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)
    }
}

    AnonymousObservable是一個類（class），這個匿名序列繼承自Producer，這個 Producer很重要！！！

class Producer<Element> : Observable<Element> {
    override init() {
        super.init()
    }

    //重寫父類的subscribe方法，訂閱事件
    override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
       ...
    }
    //運行
    func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == Element {
        rxAbstractMethod()
    }
}

    Producer繼承於Observable，Observable是可觀察序列，遵循ObservableType協議，我們的終極序列，所有序列的基類,ObservableType協議定義了一個函數subscribe，所有遵循這個協議的序列都具有subscribe的功能。

public class Observable<Element> : ObservableType {
    /// Type of elements in sequence.
    public typealias E = Element
    
    init() {
#if TRACE_RESOURCES
        _ = Resources.incrementTotal()  //rxSwift自己的引用計數，創建就會提升，銷燬就會下降
#endif
    }
    
    //訂閱事件
    public func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E {
        rxAbstractMethod()    //抽象方法，沒有實現
    }
    
    public func asObservable() -> Observable<E> {    //？？？
        return self
    }
    
    deinit {
#if TRACE_RESOURCES
        _ = Resources.decrementTotal()   //根據這個可以知道是否存在內存問題
#endif
    }
   ...
}

    Observable類本來就是一個可觀察序列，爲什麼突然又出現一個asObservable函數呢？？

爲了統一管理，萬物皆序列。比如：UISwitch().rx.value，雖然UISwitch也可以.出rx.出value，但是查看value的底層

public var value: RxCocoa.ControlProperty<Bool> { get }   //是ControlProperty類型的

public struct ControlProperty<PropertyType> : ControlPropertyType {  //遵循了ControlPropertyType協議
    public typealias E = PropertyType
    ...
}

public protocol ControlPropertyType : ObservableType, ObserverType {   //遵循了ObservableType協議

    /// - returns: `ControlProperty` interface
    func asControlProperty() -> ControlProperty<E>
}

    遵循了ObservableType，也可以訂閱事件，但是它始終不是Observable對象，爲了規範統進行轉化。類似於“as”的強轉功能。

    綜述：序列Observable提供普遍功能，有asObservable，提供subscribe接口，使得所有繼承於Observable的序列都具有訂閱的功能。

二.訂閱者繼承鏈和訂閱流程

   上一篇文章《函數響應編程&RxSwift（一）》提到序列Observable在subscribe訂閱的時候會創建一個observer訂閱者。

 public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
        -> Disposable {
            let disposable: Disposable
           ...
            //創建一個匿名訂閱者，這個E是調用者傳過來的一個序列類型
            let observer = AnonymousObserver<E> { event in
                
                #if DEBUG
                    synchronizationTracker.register(synchronizationErrorMessage: .default)
                    defer { synchronizationTracker.unregister() }
                #endif
                
                ...
            }
            return Disposables.create(
                self.asObservable().subscribe(observer),
                disposable
            )
    }
}

    AnonymousObserver的源代碼：

final class AnonymousObserver<ElementType> : ObserverBase<ElementType> {
    typealias Element = ElementType
    
    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)
    }
    
#if TRACE_RESOURCES
    deinit {
        _ = Resources.decrementTotal()
    }
#endif
}

AnonymousObserver繼承於ObserverBase，ObserverBase源碼如下：

class ObserverBase<ElementType> : Disposable, ObserverType {
    typealias E = ElementType

    private let _isStopped = AtomicInt(0)

    func on(_ event: Event<E>) {    //實現協議ObserverType的方法，Event是一個枚舉類型
        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<E>) {
        rxAbstractMethod()
    }

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

ObserverBase具有不斷髮送信號的功能，ObserverType是一個協議，源碼如下

public protocol ObserverType {
    /// The type of elements in sequence that observer can observe.
    associatedtype E   //關聯類型

    /// Notify observer about sequence event.
    ///
    /// - parameter event: Event that occurred.
    func on(_ event: Event<E>)    //協議方法
}

    subscribe中的“self.asObservable().subscribe(observer)”到底有誰來進行調用呢？

    不知道它是什麼類型，但是爲了統一，所以調用了asObservable，調用subscribe方法。AnonymousObservable裏面沒有subscribe方法，那麼就開始去查找他的父類Producer，Producer繼承了Observable，並且實現了subscribe這個抽象類的實現。再看一下Producer的源碼：

class Producer<Element> : Observable<Element> {
    override init() {
        super.init()
    }

    //重寫父類的抽象方法subscribe
    override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        if !CurrentThreadScheduler.isScheduleRequired {  //CurrentThreadScheduler調度者
            // The returned disposable needs to release all references once it was disposed.
            let disposer = SinkDisposer()
            let sinkAndSubscription = self.run(observer, cancel: disposer)
            disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)

            return disposer //返回銷燬者
        }
        else {
            return CurrentThreadScheduler.instance.schedule(()) { _ in
                let disposer = SinkDisposer()
                let sinkAndSubscription = self.run(observer, cancel: disposer)
                disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)

                return disposer
            }
        }
    }

    func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == Element {
        rxAbstractMethod()
    }
}

    Producer統一處理避免子類的下發產生冗餘代碼，且並不影響基類，基類也不需要關心具體的實現。具體的run方法實現應該由子類單獨去處理，體現出RxSwift的分工非常的明確。這裏使用的AnonymousObersevable，所以具體的run實現源碼在AnonymousObersevable裏面，源碼如下：

final private class AnonymousObservable<Element>: Producer<Element> {
   ...
    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)
    }
}

三.核心重點

AnonymousObservable會調用父類Producer的subscribe函數，subscribe函數內，會調用AnonymousObservable具體的run方法，AnonymousObservable的run函數源碼：

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

AnonymousObservableSink繼承於Sink，Sink中就有observer和cancel這兩個屬性，在此進行保存。

class Sink<O : ObserverType> : Disposable {
    fileprivate let _observer: O
    fileprivate let _cancel: Cancelable
    fileprivate let _disposed = AtomicInt(0)
    ...
    init(observer: O, cancel: Cancelable) {
#if TRACE_RESOURCES
        _ = Resources.incrementTotal()
#endif
        self._observer = observer
        self._cancel = cancel
    }
    ...
}

run函數中，sink調用了AnonymousObservable本類重的run函數。

func run(_ parent: Parent) -> Disposable {
   return parent._subscribeHandler(AnyObserver(self))   //講當前的序列傳遞過去
}

typealias Parent = AnonymousObservable<E>

因此，Sink這個管子擁有了 訂閱者、銷燬者、序列、調度環境，處理的就是具體的業務邏輯。

查看AnonymousObservableSink的源碼：

final private class AnonymousObservableSink<O: ObserverType>: Sink<O>, ObserverType {
    typealias E = O.E
    typealias Parent = AnonymousObservable<E>

...

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

 public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
        //subscribe外界傳入進來的閉包,傳遞給AnonymousObservable
        return AnonymousObservable(subscribe)   
 }

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

這裏的parent就是我們的序列AnonymousObservable，調用_subscribeHandler函數就是我們一開始creat序列的時候外界傳入的閉包。

run函數中_subscribeHandler(AnyObserver(self))重的AnyObserver(self)是什麼呢？是不是AnonymousObserver呢？

答案不是的。

AnyObserver是一個結構體，相當於一個序列化器，源碼如下：

public struct AnyObserver<Element> : ObserverType {
    /// The type of elements in sequence that observer can observe.
    public typealias E = Element
    
    /// Anonymous event handler type.
    public typealias EventHandler = (Event<Element>) -> Void

    private let observer: EventHandler

...
    public init<O : ObserverType>(_ observer: O) where O.E == Element {
        //這裏的observer就是我們傳進來的sink，當前的observer是一個函數
        self.observer = observer.on   
    }
    
    /// Send `event` to this observer.
    ///
    /// - parameter event: Event instance.
    public func on(_ event: Event<Element>) {
        return self.observer(event)
    }

    /// Erases type of observer and returns canonical observer.
    ///
    /// - returns: type erased observer.
    public func asObserver() -> AnyObserver<E> {
        return self
    }
}

observer.on就是調用了管子的on函數，核心邏輯就在AnonymousObservableSink裏面，源碼：

final private class AnonymousObservableSink<O: ObserverType>: Sink<O>, ObserverType {
    typealias E = O.E
    typealias Parent = AnonymousObservable<E>

   ...
    func on(_ event: Event<E>) {
        #if DEBUG
            self._synchronizationTracker.register(synchronizationErrorMessage: .default)
            defer { self._synchronizationTracker.unregister() }
        #endif
        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()
            }
        }
    }
...
}

AnyObserver這個結構體遵循了ObserverType協議，因此它也有onNext這個方法，而onNext這個方法就是調用了on函數，而這個on函數也就是調用的傳進來的管子AnonymousObservableSink的on函數塊，訂閱者已經加載完畢。

extension ObserverType {

    public func onNext(_ element: E) {
        self.on(.next(element))
    }
   ...
}

管子中的self.forwardOn(event)函數調用了父類Sink的forwardOn函數：

final func forwardOn(_ event: Event<O.E>) {
        #if DEBUG
            self._synchronizationTracker.register(synchronizationErrorMessage: .default)
            defer { self._synchronizationTracker.unregister() }
        #endif
        if isFlagSet(self._disposed, 1) {
            return
        }
        self._observer.on(event)
    }

forwardOn函數中的_observer就是從訂閱的時候Producer調用subscribe傳過來的那個AnonymousObserver。

四.總結