前言
RXSwift是一個使用可觀察序列和函數式操作符編寫異步和基于事件的代碼的庫。今天我們從一個簡單的例子出發，來簡單探究下其中的原理。
RXSwift簡單使用
let ob = Observable<Any>.create { (obserber) -> Disposable in
// 3:發送信號
obserber.onNext("消息來了")
obserber.onCompleted()
// obserber.onError(NSError.init(domain: "coocieeror", code: 10087, userInfo: nil))
return Disposables.create()
}
let _ = ob.subscribe(onNext: { (text) in
print("訂閱到:\(text)")
}, onError: { (error) in
print("error: \(error)")
}, onCompleted: {
print("完成")
}) {
print("銷毀")
}
Observable.create初始化
Observable：sequence，Observable表示可監聽或者可觀察的序列。
首先我們來看下.create到底做了啥：
public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
return AnonymousObservable(subscribe)
}
在Create.h文件找到.create方法，可以看出返回的是一個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的初始化工作只是將.create方法帶進來的閉包作為屬性保存下來。
subscribe訂閱
接著我們拉到了subscribe方法中：
extension ObservableType {
public func subscribe(_ on: @escaping (Event<E>) -> Void)
-> Disposable {
let observer = AnonymousObserver { e in
on(e)
}
return self.asObservable().subscribe(observer)
}
public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
-> Disposable {
let disposable: Disposable
if let disposed = onDisposed {
disposable = Disposables.create(with: disposed)
}
else {
disposable = Disposables.create()
}
#if DEBUG
let synchronizationTracker = SynchronizationTracker()
#endif
let callStack = Hooks.recordCallStackOnError ? Hooks.customCaptureSubscriptionCallstack() : []
let observer = AnonymousObserver<E> { event in
#if DEBUG
synchronizationTracker.register(synchronizationErrorMessage: .default)
defer { synchronizationTracker.unregister() }
#endif
switch event {
case .next(let value):
onNext?(value)
case .error(let error):
if let onError = onError {
onError(error)
}
else {
Hooks.defaultErrorHandler(callStack, error)
}
disposable.dispose()
case .completed:
onCompleted?()
disposable.dispose()
}
}
return Disposables.create(
self.asObservable().subscribe(observer),
disposable
)
}
}
其中生成一個觀察者observer（AnonymousObserver類型），初始化過程中也是將后面閉包作為屬性保存下來留給后面調用時候使用。
最后self.asObservable().subscribe(observer)，將observer作為參數帶入.subscribe，那么.subscribe方法在哪里呢？
我們來看self.asObservable()，此處的self為AnonymousObservable，但在上面AnonymousObservable源碼中沒看見，但是它繼承自Producer，查看Producer源碼：
class Producer<Element> : Observable<Element> {
override init() {
super.init()
}
override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
if !CurrentThreadScheduler.isScheduleRequired {
// 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()
}
}
可知，.subscribe方法是從Producer繼承過來的，查看.subscribe方法，其中self.run(observer, cancel: disposer)，調用自己的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)
}
run方法中生成一個AnonymousObservableSink類型的對象，我們稱之為管子，那這個所謂的管子是干嘛的呢？
AnonymousObservableSink 管子
從上面的run方法中看出，AnonymousObservableSink初始化中將之前subscribe方法中的observer（觀察者）和cancel（銷毀者）作為屬性保存進去：
//AnonymousObservableSink
override init(observer: O, cancel: Cancelable) {
super.init(observer: observer, cancel: cancel)
}
//Sink
fileprivate let _observer: O
fileprivate let _cancel: Cancelable
init(observer: O, cancel: Cancelable) {
#if TRACE_RESOURCES
_ = Resources.incrementTotal()
#endif
self._observer = observer
self._cancel = cancel
}
接著調用AnonymousObservableSink.run方法，并且將自身帶進去：
//typealias Parent = AnonymousObservable<E>
func run(_ parent: Parent) -> Disposable {
return parent._subscribeHandler(AnyObserver(self))
}
其中Parent即為AnonymousObservable，此時sink里面已經獲取到了observer（觀察者）、cancel（銷毀者）、obserberable（序列），即sink擁有了RXSwift最關鍵的三要素。
然后調用之前初始化保存的_subscribeHandler閉包，將AnyObserver(self)作為參數。那為啥這里是傳入的AnyObserver(self)，看起來像是將self(AnonymousObservableSink)包裝了一層，查看AnyObserver源碼，初始化函數為
public typealias EventHandler = (Event<Element>) -> Void
private let observer: EventHandler
public init<O : ObserverType>(_ observer: O) where O.E == Element {
self.observer = observer.on
}
初始化方法中參數observer即為AnonymousObservableSink，然后將AnonymousObservableSink.on給到self.observer，此時AnyObserver.observer為一個函數塊。查看此時AnonymousObservableSink中的on方法：
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()
}
}
}
sink.on方法中看起來像是是對我們外部訂閱者的事件調用，不急，慢慢來，現在我們需要看的是我們的猜想是不是正確的，回到_subscribeHandler(AnyObserver(self))這句代碼，可知是將AnyObserver類型作為外界.create后閉包中參數obserber的類型，那是不是obserber.onNext()就應該去AnyObserver中去找？
首先在AnyObserver中沒找到.onNext()方法，但AnyObserver遵守了OberverType協議，
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>)
}
/// Convenience API extensions to provide alternate next, error, completed events
extension ObserverType {
/// Convenience method equivalent to `on(.next(element: E))`
///
/// - parameter element: Next element to send to observer(s)
public func onNext(_ element: E) {
self.on(.next(element))
}
/// Convenience method equivalent to `on(.completed)`
public func onCompleted() {
self.on(.completed)
}
/// Convenience method equivalent to `on(.error(Swift.Error))`
/// - parameter error: Swift.Error to send to observer(s)
public func onError(_ error: Swift.Error) {
self.on(.error(error))
}
}
由此可知.onNext方法self.on(.next(element))，即回到AnyObserver中的.on方法：
public func on(_ event: Event<Element>) {
return self.observer(event)
}
即將當前的具體任務event(.next(element))作為參數放進self.observer（一個函數塊）去執行，即又回到了AnonymousObservableSink.on方法，針對不同訂閱事件都回去調用self.forwardOn(event)，此時來到了Sink源碼：
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)
}
self._observer即為sink（管子）初始化時候保存下來的觀察者，即AnonymousObserver，由此可以看出，為啥叫“管子”了吧，它是將訂閱者和觀察者連在一起的這么一種中間工具。
AnonymousObserver繼承自ObserverBase，在ObserverBase中找到了.on方法：
func on(_ event: Event<E>) {
switch event {
case .next:
if load(self._isStopped) == 0 {
self.onCore(event)
}
case .error, .completed:
if fetchOr(self._isStopped, 1) == 0 {
self.onCore(event)
}
}
}
回到AnonymousObserver中找到.onCore方法：
override func onCore(_ event: Event<Element>) {
return self._eventHandler(event)
}
所以一切就回到了AnonymousObservable.subscribe()方法中生成observer（AnonymousObserver）保存的閉包：
switch event {
case .next(let value):
onNext?(value)
case .error(let error):
if let onError = onError {
onError(error)
}
else {
Hooks.defaultErrorHandler(callStack, error)
}
disposable.dispose()
case .completed:
onCompleted?()
disposable.dispose()
}
最終對應的事件做對應的處理。斷點打印此時的event：
總結
本文通過逐步查看 RxSwift 中的部分源碼，一窺其背后的設計思路。從中我們也看到了其對函數式編程的應用，以及其所呈現出來的流編程模式的底層實現原理。
