本文假設(shè)你已經(jīng)了解了Rxswift的基本概念,且對(duì)于Observable,Observer,Operator有一定的了解
來(lái)看看下圖這個(gè)完整的事件流是怎么"串"起來(lái)的(暫不考慮dispose)
_ = Observable<Int>.create { observer in
observer.onNext(2)
observer.onCompleted()
return Disposables.create()
}
.map{
$0 * 2
}.filter {
$0 < 1
}.subscribe {
print($0)
}
我們的代碼按照如下順序執(zhí)行
1.png
先看下面3張圖,是RxSwift對(duì)ObservableType提供的默認(rèn)方法,注意紅框內(nèi):
map方法和filter方法,create方法.png
- 我們調(diào)用的map和filter方法內(nèi)部其實(shí)都是直接返回了一個(gè)Map或者Filter對(duì)象(create也是直接返回了一個(gè)對(duì)象,但名字有些不一樣,為了方便理解,暫時(shí)先不管這個(gè))
- 先看第二個(gè)參數(shù),它只是保存了你寫在map或者filter后面的閉包
- 再來(lái)看在Map或者Filter中第一個(gè)參數(shù)source,指它的上游對(duì)象,對(duì)于Map來(lái)說(shuō),就是create返回的結(jié)果,即AnonymousObservable對(duì)象,不信可以打印出create操作之后的類型,能看到結(jié)果如下
let ob = Observable<Int>.create { observer in
observer.onNext(2)
observer.onCompleted()
return Disposables.create()
}
print(type(of: ob))
//打印值:AnonymousObservable<Int>
同理對(duì)于Filter來(lái)說(shuō),它的source就是Map返回的結(jié)果了,這應(yīng)該是個(gè)Map類型,下面驗(yàn)證一下
let ob = Observable<Int>.create { observer in
observer.onNext(2)
observer.onCompleted()
return Disposables.create()
}.map{
$0 * 2
}
print(type(of: ob))
//打印值:Map<Int, Int>
其實(shí)RxSwift中的操作符都是這個(gè)套路.
所以各個(gè)內(nèi)部生成的對(duì)象就會(huì)形成了對(duì)上游的引用鏈,這時(shí)如下圖:
接下來(lái)先看下面的圖
image.png
可以看到Rxswift中的操作符都繼承與Producer類,所以我們得先看下Producer類(為了方便理解,這里刪減了一些代碼)
class Producer<Element>: Observable<Element> {
override func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
//1
let disposer = SinkDisposer()
//2:run方法留給子類去實(shí)現(xiàn)
let sinkAndSubscription = self.run(observer, cancel: disposer)
//3
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
return disposer
}
}
其實(shí)Producer類也只是重寫了Observable的subscribe,而該方法里面的第2步的run方法,是需要由Producer的子類實(shí)現(xiàn)的,也就是說(shuō):Map,Filter,First等等操作符就是重寫run方法,在內(nèi)部實(shí)現(xiàn)自己的核心邏輯的.
這里拿Map舉例,其他操作符類似.
final private class Map<SourceType, ResultType>: Producer<ResultType> {
typealias Transform = (SourceType) throws -> ResultType
private let source: Observable<SourceType>
private let transform: Transform
init(source: Observable<SourceType>, transform: @escaping Transform) {
self.source = source
self.transform = transform
}
//重寫run方法實(shí)現(xiàn)自己的map邏輯
override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == ResultType {
//1:創(chuàng)建一個(gè)叫做MapSink類的對(duì)象,先知道這一點(diǎn),稍后來(lái)說(shuō)這個(gè)MapSink
let sink = MapSink(transform: self.transform, observer: observer, cancel: cancel)
//2 :注意這一步的self.source就是之前引用的它的上游對(duì)象
// 這一步就是使用一個(gè)叫做sink的對(duì)象去訂閱它上游事件
//同理它的上游操作符類的run方法里面也會(huì)使用這種方法訂閱它的上上游事件
//這樣它就把"訂閱"給串起來(lái)了
let subscription = self.source.subscribe(sink)
return (sink: sink, subscription: subscription)
}
}
說(shuō)完了訂閱是如何"串"起來(lái)的,下面來(lái)說(shuō)說(shuō)序列發(fā)出的事件是如何層層往下傳遞的
我們來(lái)看看create方法吧
public static func create(_ subscribe: @escaping (AnyObserver<Element>) -> Disposable) -> Observable<Element> {
AnonymousObservable(subscribe)
}
首先它返回的不是Create對(duì)象,而是AnonymousObservable對(duì)象
那么再看看AnonymousObservable
final private class AnonymousObservable<Element>: Producer<Element> {
typealias SubscribeHandler = (AnyObserver<Element>) -> Disposable
let subscribeHandler: SubscribeHandler
init(_ subscribeHandler: @escaping SubscribeHandler) {
self.subscribeHandler = subscribeHandler
}
//還是老套路,重寫了run
override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element {
//同樣的它也創(chuàng)建了一個(gè)叫做"某某Sink"的類,保存了observer
//這里的observer就是它的下游觀察者,還記得上面的MapSink嗎,不記得可以回去看看,它里面也有一個(gè)observer
//這個(gè)observer就是用來(lái)保存下游觀察者的
//其實(shí)每個(gè)操作符類的run方法里面都是這種套路:先創(chuàng)建一個(gè)"某某Sink"的類,而這個(gè)類就是該操作符真正實(shí)現(xiàn)邏輯并且傳遞到下游的地方
let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
let subscription = sink.run(self)
return (sink: sink, subscription: subscription)
}
}
同樣的它也創(chuàng)建了一個(gè)叫做"某某Sink"的類,保存了observer,這里的observer就是它的下游觀察者,還記得上面的MapSink嗎,不記得可以回去看看,它里面也有一個(gè)observer
其實(shí)每個(gè)操作符類的run方法里面都是這種套路:先創(chuàng)建一個(gè)"某某Sink"的類,而這個(gè)類就是該操作符真正實(shí)現(xiàn)邏輯并且傳遞到下游的地方
我們先來(lái)看看AnonymousObservableSink這個(gè)Sink類
//刪減了一些影響閱讀的代碼
final private class AnonymousObservableSink<Observer: ObserverType>: Sink<Observer>, ObserverType {
// 我們?cè)赾reate{}閉包里調(diào)用的observer.onNext(2)其實(shí)就是走了這個(gè)on方法
// _ = Observable<Int>.create { observer in
// observer.onNext(2)
// observer.onCompleted()
// return Disposables.create()
// }
func on(_ event: Event<Element>) {
switch event {
case .next:
if load(self.isStopped) == 1 {
return
}
//forwardOn方法就是向下游Observer發(fā)送事件
self.forwardOn(event)
case .error, .completed:
if fetchOr(self.isStopped, 1) == 0 {
//forwardOn方法就是向下游Observer發(fā)送事件
self.forwardOn(event)
self.dispose()
}
}
}
func run(_ parent: Parent) -> Disposable {
//subscribeHandler就是create閉包,這里就是執(zhí)行了這個(gè)閉包,并且把AnyObserver(self)作為參數(shù)傳到閉包
parent.subscribeHandler(AnyObserver(self))
}
}
public struct AnyObserver<Element> : ObserverType {
public typealias EventHandler = (Event<Element>) -> Void
private let observer: EventHandler
public init<Observer: ObserverType>(_ observer: Observer) where Observer.Element == Element {
//這里的on就是上面AnonymousObservableSink里面的on方法
// 我們?cè)赾reate{}閉包里調(diào)用的observer.onNext(2)其實(shí)就是走了這個(gè)on方法
// _ = Observable<Int>.create { observer in
// observer.onNext(2)
// observer.onCompleted()
// return Disposables.create()
// }
self.observer = observer.on
}
public func on(_ event: Event<Element>) {
self.observer(event)
}
}
on方法內(nèi)部的forwardOn方法就是向下游Observer發(fā)送事件
上面我們說(shuō)過(guò):每個(gè)操作符類的run方法都會(huì)創(chuàng)建一個(gè)叫做"某某Sink"的類用來(lái)處理操作符真正的邏輯
而這些"某某Sink"的類都遵循了ObserverType協(xié)議,這就意味著它們都必須實(shí)現(xiàn)一個(gè)自己的on方法
比如MapSink內(nèi)的on方法
final private class MapSink<SourceType, Observer: ObserverType>: Sink<Observer>, ObserverType {
typealias Transform = (SourceType) throws -> ResultType
typealias ResultType = Observer.Element
typealias Element = SourceType
private let transform: Transform
init(transform: @escaping Transform, observer: Observer, cancel: Cancelable) {
self.transform = transform
super.init(observer: observer, cancel: cancel)
}
func on(_ event: Event<SourceType>) {
switch event {
case .next(let element):
do {
//這個(gè)transform就是我們寫在map閉包里面的轉(zhuǎn)換邏輯
//先執(zhí)行轉(zhuǎn)換邏輯,然后調(diào)用forwardOn把結(jié)果轉(zhuǎn)交給下游的Observer
let mappedElement = try self.transform(element)
self.forwardOn(.next(mappedElement))
}
catch let e {
self.forwardOn(.error(e))
self.dispose()
}
case .error(let error):
self.forwardOn(.error(error))
self.dispose()
case .completed:
self.forwardOn(.completed)
self.dispose()
}
}
}
forwardOn定義在了Sink基類內(nèi)部,它只是調(diào)用了下游Observer的on方法而已,如下所示
//為了方便,刪除了一些代碼
class Sink<Observer: ObserverType>: Disposable {
fileprivate let observer: Observer
fileprivate let cancel: Cancelable
init(observer: Observer, cancel: Cancelable) {
self.observer = observer
self.cancel = cancel
}
final func forwardOn(_ event: Event<Observer.Element>) {
self.observer.on(event)
}
}
