簡單分析RxSwift源碼，這段代碼到底做了什么凤巨？
let disposeBagTwo = DisposeBag()
Observable.just("??")
.subscribe { event in
print(event)
}
.disposed(by: disposeBagTwo)
RxSwift中有這些基礎(chǔ)的東西：Observable视乐、Observer、序列（好抽象敢茁，這個是Rx重點佑淀，本文只帶過），那在上面的代碼中到底對應(yīng)的是什么彰檬？它們是怎么聯(lián)系在一起的呢伸刃？先來看看它們的抽象類(進(jìn)行了簡化)
這是Observable所需要的。注意我把Just的父類跳過Producer修改為了Observable逢倍，這是為了主干分析時不被細(xì)枝影響捧颅，也可不修改，對于上面的代碼塊沒有任何影響
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標(biāo)識（在下面源碼中已經(jīng)用`***`標(biāo)記）亮蒋。后面的修改是不必需的扣典，移除ObserverBase遵循Disposable協(xié)議，還是為了方便分析宛蚓，如果你也一樣在源碼進(jìn)行了修改，那會出現(xiàn)兩處錯誤设塔，處理方式是修改報錯處的返回代碼為return (sink: Disposables.create(), subscription: subscription)
public protocol ObserverType {
associatedtype E
func on(_ event: Event<E>)
}
//移除了Disposable協(xié)議
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)
}
}
這些是輔助代碼塊凄吏，可能它就解開了所有的聯(lián)系??
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)
}
}
現(xiàn)在我們就來改寫最開始的代碼，讓所有的對象顯示出來：
第一階段
//通過 ObservableType 協(xié)議擴(kuò)展的 just 方法創(chuàng)建 Just 對象->observable
let observable = Observable.just("??")
//定義一個閉包,這個閉包的內(nèi)容和開始代碼段subscribe后的一致
let onCall : ((RxSwift.Event<String>) -> Swift.Void) = { event in
print(event)
}
/*改寫 .subscribe { event in
print(event)
}
這里為尾閉包闰蛔，我們還原回去
注意：這里返回的是Disposable對象痕钢，我們的Observer去哪了？下面會進(jìn)一步分解*/
let disposable = observable.subscribe(onCall)
//最后一步都很熟悉
disposable.disposed(by: disposeBagTwo)
我們那找說好的Observer去哪里序六。從observable.subscribe(onCall)分析
第二階段
let disposable = observable.subscribe(onCall)
//注意這里的`subscribe`方法是通過`ObservableType`協(xié)議擴(kuò)展的方法（前面提到的輔助代碼塊??）任连，
//注意與`Observable`類中`subscribe`方法進(jìn)行區(qū)別(多態(tài)性)。
//分解為
let observer = AnonymousObserver(onCall)
let disposable = observable.asObservable().subscribe(observer)
//注意在此例中observable就是Observable類對象例诀，asObservable返回的也是self随抠，因此還可以簡化為
let disposable = observable.subscribe(observer)
Final版本出現(xiàn)了
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)
終結(jié)：
所有的關(guān)系現(xiàn)在已經(jīng)很清楚了裁着，在Just對象的subscribe方法中
observer.on(.next(_element))
observer.on(.completed)
return Disposables.create()
這里的Observer沒有進(jìn)行存放，Disposable也沒有進(jìn)行任何處理拱她。
序列是什么呢二驰？在哪？這里的序列就是【"??"】秉沼，只有一個元素桶雀。
其它由簡入繁，提示:修改的源碼注意還原錯誤處請指正??
