簡單分析RxSwift源碼，這段代碼到底做了什么？

let disposeBagTwo = DisposeBag()

Observable.just("??")
          .subscribe { event in
               print(event)
           }
          .disposed(by: disposeBagTwo)

RxSwift中有這些基礎的東西：Observable、Observer、序列（好抽象，這個是Rx重點，本文只帶過），那在上面的代碼中到底對應的是什么？它們是怎么聯系在一起的呢？先來看看它們的抽象類(進行了簡化)
這是Observable所需要的。注意我把Just的父類跳過Producer修改為了Observable，這是為了主干分析時不被細枝影響，也可不修改，對于上面的代碼塊沒有任何影響

public protocol ObservableConvertibleType {
    associatedtype E

    func asObservable() -> Observable<E>
}

public protocol ObservableType : ObservableConvertibleType {
    func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E
}

public class Observable<Element> : ObservableType {
    /// Type of elements in sequence.
    public typealias E = Element
    
    init() {
    }
    
    public func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E {
        rxAbstractMethod()
    }
    
    public func asObservable() -> Observable<E> {
        return self
    }
    
    deinit {
    }
}


extension ObservableType {
    /**
     Returns an observable sequence that contains a single element.

     - seealso: [just operator on reactivex.io](http://reactivex.io/documentation/operators/just.html)

     - parameter element: Single element in the resulting observable sequence.
     - returns: An observable sequence containing the single specified element.
     */
    public static func just(_ element: E) -> Observable<E> {
        return Just(element: element)
    }
}

final fileprivate class Just<Element> : Observable <Element> {
    private let _element: Element
    
    init(element: Element) {
        _element = element
    }
    
    override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        observer.on(.next(_element))
        observer.on(.completed)
        return Disposables.create()
    }
}

下面是Observer所需要的。注意這些修改是需要的（為了后面修改的代碼能正常運行），AnonymousObserver修改為公共的類，需要在4處添加public標識（在下面源碼中已經用`***`標記）。后面的修改是不必需的，移除ObserverBase遵循Disposable協議，還是為了方便分析，如果你也一樣在源碼進行了修改，那會出現兩處錯誤，處理方式是修改報錯處的返回代碼為return (sink: Disposables.create(), subscription: subscription)

public protocol ObserverType {
    associatedtype E
    func on(_ event: Event<E>)
}

//移除了Disposable協議
class ObserverBase<ElementType> :  ObserverType {
    typealias E = ElementType

    private var _isStopped: AtomicInt = 0

    func on(_ event: Event<E>) {
        switch event {
        case .next:
            if _isStopped == 0 {
                onCore(event)
            }
        case .error, .completed:
            if AtomicCompareAndSwap(0, 1, &_isStopped) {
                onCore(event)
            }
        }
    }

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


//*** 添加public
public final class AnonymousObserver<ElementType> : ObserverBase<ElementType> {
    //*** 添加public
    public typealias Element = ElementType 
    
    //*** 添加public
    public typealias EventHandler = (Event<Element>) -> Void
    
    private let _eventHandler : EventHandler
    
    //*** 添加public
    public init(_ eventHandler: @escaping EventHandler) {
        _eventHandler = eventHandler
    }

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

這些是輔助代碼塊，可能它就解開了所有的聯系??

extension ObservableType {
    /**
     Subscribes an event handler to an observable sequence.
     
     - parameter on: Action to invoke for each event in the observable sequence.
     - returns: Subscription object used to unsubscribe from the observable sequence.
     */
    public func subscribe(_ on: @escaping (Event<E>) -> Void)
        -> Disposable {
            let observer = AnonymousObserver { e in
                on(e)
            }
            return self.asObservable().subscribe(observer)
    }
}

現在我們就來改寫最開始的代碼，讓所有的對象顯示出來：
第一階段

//通過 ObservableType 協議擴展的 just 方法創建 Just 對象->observable
let observable = Observable.just("??")  

//定義一個閉包,這個閉包的內容和開始代碼段subscribe后的一致
let onCall : ((RxSwift.Event<String>) -> Swift.Void) = { event in
            print(event)
        }

/*改寫 .subscribe { event in
                   print(event)
                  } 
  這里為尾閉包，我們還原回去
  注意：這里返回的是Disposable對象，我們的Observer去哪了？下面會進一步分解*/
let disposable = observable.subscribe(onCall)

//最后一步都很熟悉
disposable.disposed(by: disposeBagTwo)

我們那找說好的Observer去哪里。從observable.subscribe(onCall)分析
第二階段

let disposable = observable.subscribe(onCall)
//注意這里的`subscribe`方法是通過`ObservableType`協議擴展的方法（前面提到的輔助代碼塊??），
//注意與`Observable`類中`subscribe`方法進行區別(多態性)。

//分解為
let observer =  AnonymousObserver(onCall)  
let disposable  = observable.asObservable().subscribe(observer)

//注意在此例中observable就是Observable類對象，asObservable返回的也是self，因此還可以簡化為
let disposable  = observable.subscribe(observer)

Final版本出現了

let disposeBagTwo = DisposeBag()

//Observable
let observable = Observable.just("??")  

//事件處理
let onCall : ((RxSwift.Event<String>) -> Swift.Void) = { event in
    print(event)
}

//Observer
let observer =  AnonymousObserver(onCall)  

//Disposable
let disposable  = observable.subscribe(observer)

disposable.disposed(by: disposeBagTwo)

終結：
所有的關系現在已經很清楚了，在Just對象的subscribe方法中

observer.on(.next(_element))
observer.on(.completed)
return Disposables.create()

這里的Observer沒有進行存放，Disposable也沒有進行任何處理。
序列是什么呢？在哪？這里的序列就是【"??"】，只有一個元素。
其它由簡入繁，提示:修改的源碼注意還原錯誤處請指正??