本文详细剖析了RxSwift中的核心逻辑，包括Observable的创建、订阅过程和响应发送。通过分析`create`、`subscribe`及`onNext`等关键步骤，展示了RxSwift如何运用函数响应式编程思想实现数据流的管理。
一、相关概念
1.Observable可观察序列
2.Observer观察者
二、核心逻辑分析
1.创建序列
let ob = Observable<Any>.create { (obserber) -> Disposable in
obserber.onNext(“Hello RxSwift")
obserber.onCompleted()
obserber.onError(NSError.init(domain: "coocieeror", code: 10087, userInfo: nil))
return Disposables.create()
}
流程分析：
1.首先我们进入create源码，直接command进不去，我们可以在工程导航栏搜索Create.swift类文件进入。在Create.swift类中，其实就是定义了一个继承自Producer的匿名序列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)
}
}
其主要工作就是保存了外部订阅的代码块：self._subscribeHandler = subscribeHandler。该代码块正是ViewController.swift中的create闭包.create，将创建序列时的闭包中据进行保存，供随时取用。
恰当地运用了函数式编程思想保存属性_subscribeHandler。
2.订阅序列
//订阅序列
let _ = ob.subscribe(onNext: { (text) in
print("Subscribed:\(text)")
}, onError: { (error) in
print("Error: \(error)")
}, onCompleted: {
print("Finished")
}) {
print("Dealloced")
}
流程分析：
我们进入subscribe源码：因为Obserable继承自ObservableType，所以会进入ObservableType+Extensions.swift类。
- 创建关键函数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() : []
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
)
}
}
我们只关心匿名订阅者AnonymousObserver的创建。后边对event作为一个闭包接收并转发相应的事件：onNext、onError、onCompleted、onDisposed，后续发送响应时会直接传入该event事件。
- 创建AnonymousObserver对象，在其初始化AnonymousObserver时创建并保存了一个_eventHandler：self._eventHandler = eventHandler，作为所有onNext、onError、onCompleted的回调，用于在第3部分发送响应时将onNext、onError、onComplete回调至ViewController.swift中的sucribe块。
- 只要有event出现便进入switch判断，判断是.next、.error、.completed等，并执行对应的闭包方法onNext、onError、onCompleted。但具体是如何传递数据到ViewController.swift的.subscribe闭包中的呢？我们继续分析。
- 在最后的return中调用create，执行self.asObservable().subscribe(observer) 。将创建的observer传递下去。
asObservable( ) 为Observable本身，见Observeable.swift类中：
public func asObservable() -> Observable<E> {
return self
}
subscribe( )：找一下Create.swift类，没有。那么进入其父类Producer.swift中查找，Producer.swift定义了subscribe 函数（其实是重写了Producer.swift的父类的该函数）。
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
}
}
}
3.发送响应
流程分析：
- 发送响应起步于ViewController.swift中.create闭包中的obserber.onNext，只要有onNext命令就回发起响应。
- 然后调用Create.swift中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()
}
}
}
判断switch case .onNext条件，执行self.fowardOn(event)。forwardOn函数定义于AnonymousObservableSink的父类Sink中。
- 然后执行Sink中on函数：
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)
}
此处_observer为AnonymousObserver类型常量。
- 接着回调至subscribe的 AnonymousObserver中的event闭包块执行响应的条件.onNext。
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()
}
}
- 最终便会将value回调至ViewController.swift中的sucribe闭包块，完成onNext的操作。
onNext完成后，接着执行onCompleted操作，流程同onNext。
以上，我们分析了整个订阅创建序列create、订阅序列sucribe、发送响应的全过程。其设计思想高度结合了函数响应式编程思想，这样正是RxSwift框架的强大之处。
时间原因，后续会针对上述流程绘制思维导图，帮助我们更直观、全面地理解整个逻辑流程。
扫一扫
235
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
