今天就让我们来一起探究一下RxSwift从创建到响应,中间到底经历了些什么。
首先我们先通过一段简单的代码看一下序列三部曲:
一.创建序列
二.订阅信号
三.发送信号
//1.创建序列
let ob = Observable<Any>.create { (obserber) -> Disposable in
// 3.发送信号
obserber.onNext("马小撂")
obserber.onCompleted()
//obserber.onError(NSError.init(domain: "error", code: 10086, userInfo: nil))
return Disposables.create()
}
//2.订阅信号
let _ = ob.subscribe(onNext: { (text) in
print("订阅到:\(text)")
}, onError: { (error) in
print("error: \(error)")
}, onCompleted: {
print("完成")
}) {
print("销毁")
}
一.创建序列
let ob = Observable<Any>.create { (obserber) -> Disposable in
//create里面的闭包
}
让我们来看一下Observable<Any>.create
是如何创建了一个可观察序列 Observable
对象的
- 查看
create
的具体实现(直接点进去,是一个声明,具体实现在Create.swift中) 下面是create
方法的具体实现 :
public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
return AnonymousObservable(subscribe)
}
可以看到该方法返回了一个匿名观察者 AnonymousObservable(subscribe)
下面来到 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)
}
}
这个方法进行了一次初始化,将 create
中的 闭包 赋值 给 self._subscribeHandler
。
到此处,就完成了第一步的操作,序列的创建
Observable<Any>.create
。实际是创建了一个匿名的观察者AnonymousObservable
,并将create
中的闭包进行了保存。
二.订阅信号
点进.subscribe
回来到 ObservableType+Extensions
中的 subscribe
函数(代码有一点长)
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() : []
//※ 创建这个 observer 尾随闭包做参数
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
)
}
这里我们着重看一下let observer = AnonymousObserver<E> { event in
初始化一个名为observer
的匿名观察者 AnonymousObserver
后面尾随闭包做参数。
那么AnonymousObserver
这个类里面做了什么呢?
final class AnonymousObserver<ElementType> : ObserverBase<ElementType> {
typealias Element = ElementType
typealias EventHandler = (Event<Element>) -> Void
private let _eventHandler : EventHandler
init(_ eventHandler: @escaping EventHandler) {
#if TRACE_RESOURCES
_ = Resources.incrementTotal()
#endif
self._eventHandler = eventHandler
}
override func onCore(_ event: Event<Element>) {
return self._eventHandler(event)
}
#if TRACE_RESOURCES
deinit {
_ = Resources.decrementTotal()
}
#endif
}
它将上面创建时传过来的闭包保存为属性 self._eventHandler
,此外还提供了一个onCore
的方法
此时我们在创建序列的时候AnonymousObservable
保存了 create
的闭包,在订阅信号时AnonymousObserver
又保存了subscribe
闭包中的回调执行闭包_eventHandler
。
subscribe
函数还有一个返回没有看完,它会返回一个Disposables
的对象。
重点来了,这个返回尤其重要。
self.asObservable().subscribe(observer),
self.asObservable()
这个简单解释一下,ObservableType
继承于ObservableConvertibleType
,ObservableConvertibleType
中有一个asObservable
的函数,目的是为了返回一个可观察序列Observable
然后具有一些公共的方法。.subscribe(observer)
,因为参数为AnonymousObserver
类型,所以我们要去AnonymousObservable
这个类中去找subscribe
这个函数,但是上面我们贴出的代码中并没有subscribe
函数 怎么办呢?
这时我们看见 AnonymousObservable
是继承于Producer
的,子类没有实现就去父类里面找。打个断点,果然来到了父类的subscribe
函数
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
}
}
}
由于 if else 是关于线程的,所以我们只看公共部分
let sinkAndSubscription = self.run(observer, cancel: disposer)
self.run
要回到子类的AnonymousObservable
的run
函数中,其中传入的参数observer
是subscribe
函数中保存的_eventHandler
对事件的响应。
override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element {
let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
let subscription = sink.run(self)
return (sink: sink, subscription: subscription)
}
这里面又创建了 AnonymousObservableSink
对象,参数依旧是上面的observer
和cancel
。
final private class AnonymousObservableSink<Observer: ObserverType>: Sink<Observer>, ObserverType {
typealias Element = Observer.Element
typealias Parent = AnonymousObservable<Element>
// state
private let _isStopped = AtomicInt(0)
#if DEBUG
fileprivate let _synchronizationTracker = SynchronizationTracker()
#endif
override init(observer: Observer, cancel: Cancelable) {
super.init(observer: observer, cancel: cancel)
}
func on(_ event: Event<Element>) {
#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()
}
}
}
func run(_ parent: Parent) -> Disposable {
return parent._subscribeHandler(AnyObserver(self))
}
}
sink.run(self)
中调用了run函数,并将self
传了过来,又将AnonymousObservable<E>
起了别名Parent
,返回parent._subscribeHandler(AnyObserver(self))
,AnyObserver(self)
将AnonymousObservableSink
作为参数传到了AnonymousObservable
的_subscribeHandler
(就是一开始创建序列create的闭包)。
public struct AnyObserver<Element> : ObserverType {
public typealias EventHandler = (Event<Element>) -> Void
private let observer: EventHandler
public init(eventHandler: @escaping EventHandler) {
self.observer = eventHandler
}
public init<Observer: ObserverType>(_ observer: Observer) where Observer.Element == Element {
self.observer = observer.on
}
public func on(_ event: Event<Element>) {
return self.observer(event)
}
public func asObserver() -> AnyObserver<Element> {
return self
}
}
其中把AnonymousObservableSink
的on
函数赋值给AnyObserver
的属性observer
(EventHandler)。
捋一下订阅信号过程
subscribe
->AnonymousObserver(Producer)
的.subscribe(observer)
->AnonymousObservable
的run
->AnonymousObservableSink
的run
->AnonymousObservable
的_subscribeHandler(AnyObserver(self))
三.发送信号
从cerate
闭包中obserber.onNext("马小撂")
点进去来到ObserverType
的onNext
方法
public func onNext(_ element: Element) {
self.on(.next(element))
}
AnonymousObservableSink
中的on
函数的.next
分支self.forwardOn(event)
-> Sink
的forwardOn
的self._observer.on(event)
-> ObserverBase
的self.onCore
又回到AnonymousObserver
的onCore
方法中self._eventHandler(event)
这就是subscribe中的闭包啊
发送信号: create闭包 ->AnyObserver -> AnonymousObservableSink -> AnonymousObserver -> subscribe闭包
最后附上一张文章中用到的类关系图