隨著函數(shù)響應式編程成為現(xiàn)在很多編程語言的主流編程思想蝶押，我們越發(fā)的感嘆這種思想的魅力踱蠢，他極大的減少了我們的膠水代碼，使得我們可以更好的編寫業(yè)務邏輯代碼。而作為我們iOS程序員來說茎截，RAC以及RxSwift框架使用的也越來越多苇侵，我們不再需要寫大量的代理方法來作為方法回調(diào)，我們可以將一個功能模塊代碼寫在一起企锌，通過鏈式來表達榆浓，使代碼邏輯給人一種清晰可見的感覺。
RxSwift
作為ReactiveX家族之一的RxSwift在Github截止現(xiàn)在Star:16K.為什么這個框架如此受歡迎撕攒，作為函數(shù)響應式框架典型代表陡鹃，底層實現(xiàn)又是如何實現(xiàn)的呢？這一篇文章全面解密
RxSwift核心流程
Rxswift的優(yōu)秀之處在于他為開發(fā)人員提供了非常精簡的API抖坪，讓我們可以快速上手來使用萍鲸，它的使用公有三個步驟：
- 1.創(chuàng)建序列
- 2.訂閱序列
- 3.發(fā)送序列
//1.創(chuàng)建序列
let ob = Observable<Any>.create { (obserber) -> Disposable in
// 3:發(fā)送序列
obserber.onNext("AAA")
obserber.onCompleted()
return Disposables.create()
}
//2.訂閱序列
let _ = ob.subscribe(onNext: { (text) in
print("訂閱到:\(text)")
}, onError: { (error) in
print("error: \(error)")
}, onCompleted: {
print("完成")
}) {
print("銷毀")
}
image.png
這里我們肯定很疑惑為什么我們的AAA字符串會被傳入subscribe的閉包當中，從這里我們開始一步步的分析它里邊到底是如何實現(xiàn)的擦俐。
創(chuàng)建序列
extension ObservableType {
// MARK: create
public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
//AnonymousObservable.init(subscribe)
return AnonymousObservable(subscribe)
}
}
我們看到 可觀察序列的創(chuàng)建是通過ObservableType的協(xié)議拓展功能的create方法實現(xiàn)的脊阴，并且返回了一個匿名內(nèi)部類AnonymousObservable,而AnonymousObservable中保存了外界傳入的subscribe閉包，下面是一附類的繼承關(guān)系圖
image.png
如上圖所示
AnonymousObservable繼承了Producer可觀察序列生產(chǎn)者
final private class AnonymousObservable<Element>: Producer<Element> {
typealias SubscribeHandler = (AnyObserver<Element>) -> Disposable
let _subscribeHandler: SubscribeHandler
//保存外界傳入的觀察者對象
init(_ subscribeHandler: @escaping SubscribeHandler) {
self._subscribeHandler = subscribeHandler
}
}
-
Producer類繼承自Observable可觀察序列,并保存了_subscribeHandler -
SubscribeHandler為外部傳入的觀察者對象AnyObserver<Element>
public class Observable<Element> : ObservableType {
/// Type of elements in sequence.
public typealias E = Element
init() {
#if TRACE_RESOURCES
_ = Resources.incrementTotal()
#endif
}
public func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E {
rxAbstractMethod()
}
public func asObservable() -> Observable<E> {
return self
}
-
Observable又遵循了ObservableConvertibleType和ObservableType協(xié)議
ObservableType
所以AnonymousObservable匿名內(nèi)部類擁有Observable非常重要的方法subscrible
訂閱序列
我們先看下subscribe內(nèi)部實現(xiàn)
image.png
public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
-> Disposable {
//這里省略部分代碼蚯瞧，我們只分析observer(觀察者的創(chuàng)建)
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
)
}
代碼說明：
- 我們創(chuàng)建了一個
AnonymousObserver匿名內(nèi)部觀察者嘿期，通過初始化閉包，保存了外部傳入的onNext,onError,onCompleted,onDisposed事件埋合。 我們先看一下觀察者的繼承鏈
image.png
-
self.asObserverable()這個函數(shù)來保持一致性的寫法 -
self.asObservable().subscribe(observer)通過可觀察序列的繼承關(guān)系秽五，我們可以快速的定位producer訂閱代碼
image.png
image.png
image.png
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
}
}
}
- 這里的
self.run代碼最終由我們的生產(chǎn)者producer延伸到我們的具體事務代碼AnonymousObservable.run中
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)
}
}
-
sink.run（self）將業(yè)務處理下沉，讓分工更具明確
func run(_ parent: Parent) -> Disposable {
return parent._subscribeHandler(AnyObserver(self))
}
parent為我們傳入的AnonymousObservable對象這里我們就可以清晰的看到
AnonymousObservable._subscribeHandler的執(zhí)行饥悴，我們的疑惑終于在此時解開了，這就是為什么我們的subscrible訂閱序列會執(zhí)行我們創(chuàng)建序列里的observer觀察者序列閉包,是的是的繞了一大圈終于回來了盲再。西设。。
let ob = Observable<Any>.create { (observer) -> Disposable in
// 3:發(fā)送信號
observer.onNext("AAA")
observer.onCompleted()
// obserber.onError(NSError.init(domain: "coocieeror", code: 10087, userInfo: nil))
return Disposables.create()
}
-
AnyObserver(self)的初始化方法里保存了一個非常重要的函數(shù)AnonymousObservableSink .on 函數(shù)
public init<O : ObserverType>(_ observer: O) where O.E == Element {
self.observer = observer.on
}
發(fā)送事件響應
從上述流程我們清晰的得知答朋，observer.onNext("AAA")的本質(zhì)是調(diào)用了AnyObserver.onNext("AAA"),我們來看下源碼
public struct AnyObserver<Element> : ObserverType {
public init<O : ObserverType>(_ observer: O) where O.E == Element {
self.observer = observer.on
}
public func on(_ event: Event<Element>) {
return self.observer(event)
}
}
-
self.observer構(gòu)造初始化就是：AnonymouservableSink.on函數(shù) - 這樣我們就可以將
self.observer(event)變形：->AnonymousObservableSink.on(event)->AnonymousObservableSink.on(.next("AAA"))
*AnonymousObservableSink我們這里把它就先稱為管子贷揽，來說說管子它都干了些啥，看源碼：
class AnonymousObservableSink<O: ObserverType>: Sink<O>, ObserverType {
func on(_ event: Event<E>) {
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()
}
}
}
}
-
self.forwardOn(event)我們先看下這句代碼的父類做了什么事
class Sink<O : ObserverType> : Disposable {
final func forwardOn(_ event: Event<O.E>) {
if isFlagSet(self._disposed, 1) {
return
}
self._observer.on(event)
}
}
- 其中
self._observer就是我們初始化保存的AnonymousObserver匿名觀察者梦碗，怎么樣禽绪？發(fā)現(xiàn)了嗎？激動嗎洪规？我們又回到了訂閱序列創(chuàng)建時AnonymousObserver里的閉包調(diào)用里
let observer = AnonymousObserver<E> { event in
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()
}
}
- 通過調(diào)用
onNext?(value),此時value的值就是我們外界傳入的AAA啊印屁。。
繞了這么一大圈斩例，我們通過對可觀察序列的創(chuàng)建雄人，訂閱序列，發(fā)送事件最外層的調(diào)用念赶，再到他們內(nèi)部各種協(xié)議的配合础钠，下沉業(yè)務邏輯恰力，接口隔離讓我們著實體會了RxSwift是多么優(yōu)秀的框架，相信通過這篇對RxSwift的核心邏輯的探究旗吁，會讓各位小伙伴對RxSwift的設計思路有一個清晰的認知踩萎。最后貼給小伙伴們整個RxSwift的分析圖
image.png
