RxSwift的核心流程从源码分析原理,分为三步
1.创建序列 -- create 2.订阅序列 -- subscribe 3.发送信号 -- onXX
//1.创建序列
let ob = Observable<Any>.create { (observer) -> Disposable in
//3.发送信号
observer.onNext("发送信号")
observer.onError(NSError.init(domain: "EpisodeError", 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("销毁")
}
那么问题来了,我们发送的信号,是如何被订阅到的呢?
从代码分析我们可以看出 1.我们发送信号的时候创建了闭包1 2.我们订阅的时候,会subscribe闭包2--onXX 3.闭包2的onXX会回掉闭包1的onXX,将闭包1的值传过来
底层又是如何实现这三步曲的呢,那么我们从源码一一剖析
1.创建序列 -- create
继承关系为: AnonymousObservable -> Producer -> Observable -> ObservableType -> ObservableConvertibleType 注:ObservableType中定义了subscribe方法,供接受协议的Observable及其子类重载-create 方法的时候创建了一个内部对象 AnonymousObservable -AnonymousObservable 保存了外界的subscribeHandler闭包
2.订阅序列 -- subscribe 订阅序列subscribe的源码在ObservableType的扩展中
extension ObservableType {
public func subscribe(onNext: ((Element) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
-> Disposable {
...
let observer = AnonymousObserver<Element> { 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()
}
}
return Disposables.create(
self.asObservable().subscribe(observer),
disposable
)
}
}
-Element 是 Swift 的关联类型,这里的这个Element就是我们的序列类型 -创建了一个 AnonymousObserver (匿名内部观察者) ,它这里的初始化是闭包参数,保存了外界的 onNext, onError , onCompleted , onDisposed 的处理回调闭包的调用
这里面还有一个很重要的起到调度作用的sink
3.发送信号 -- onXX 发送信号的源码存在ObserverType扩展中
可以看出onXX分别调用了self.on方法,而这个self.on方法又是ObserverType协议的协议方法总结:RxSwift的结构
1:序列 - 编码统一 ,随时随地享用 2:通过函数式思想吧一些列的需求操作下沉(把开发者不关心的东西封装) - 优化代码,节省逻辑 3:RxSwift最典型的特色就是解决Swift这门静态语言的响应能力,利用随时间维度序列变化为轴线,用户订阅关心能随轴线一直保活,达到订阅一次,响应一直持续~