> 该篇主要来讲述关于RxSwift核心逻辑的源码解析，彻底了解RxSwift封装的整个过程首先我们来看下Rx从创建序列，订阅信号，发送信号的整个过程: let disposeBag = DisposeBag() override func viewDidLoad() { super.viewDidLoad() // 1.创建信号 obs = Observable.create { (observe) -> Disposable in // 3.发送信号 observe.onNext("框架班级"); observe.onError(NSError.init(domain: "gngjjb", code: 10086, userInfo: nil)) observe.onCompleted(); return Disposables.create() } // 2.订阅信号 obs?.subscribe(onNext: { (str) in print(str) }, onError: { (error) in print(error) }, onCompleted: { print("完成了") }, onDisposed: { print("销毁了") }) .disposed(by: disposeBag) } > 我们很好奇：为什么一订阅信号，发送信号onNext()的"框架班级"到了str这里 ### 核心逻辑(源码分析) **下面我们就一步步探索里面的奥妙吧** #### 1. create() 首先我们到Create.swift文件里面找到create() 返回了一个AnonymousObservable对象:匿名的可观察者，并将闭包参数subscribe传递了过去 public static func create(_ subscribe: @escaping (AnyObserver) -> Disposable) -> Observable { return AnonymousObservable(subscribe) } AnonymousObservable 我们可以看到保存了闭包(self.\_subscribeHandler = subscribeHandler),以及激活处理事件闭包的入口run()) **注意AnonymousObservable的继承关系** ```! AnonymousObservable ->Producer->Observable->ObservableType->ObservableConvertibleType ``` final private class AnonymousObservable: Producer { typealias SubscribeHandler = (AnyObserver) -> Disposable let _subscribeHandler: SubscribeHandler init(_ subscribeHandler: @escaping SubscribeHandler) { self._subscribeHandler = subscribeHandler } override func run(_ 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) } } #### 2.subscribe() subscribe创建了一个 AnonymousObserver 对象，在初始化时传递了一个闭包作为参数并且保存下来self.\_eventHandler = eventHandler 。 AnonymousObserver是匿名观察者,用于存储和处理事件的闭包。 public func subscribe(onNext: ((Element) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil) -> Disposable { ... let observer = AnonymousObserver { 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 ) } final class AnonymousObserver: ObserverBase { typealias EventHandler = (Event) -> Void private let _eventHandler : EventHandler init(_ eventHandler: @escaping EventHandler) { #if TRACE_RESOURCES _ = Resources.incrementTotal() #endif self._eventHandler = eventHandler } override func onCore(_ event: Event) { return self._eventHandler(event) } ... } 在create()里, 最后我们可以看到return Disposables.create(self.asObservable().subscribe(observer),disposable) 里面调用了self.asObservable().subscribe(observer) ，self.asObservable()其实就是当前的obs 序列对象，调用subscribe这个函数并且把创建的AnonymousObserver对象传递过去，会来到AnonymousObservable这个类里面，但是发现这个类里面没有subscribe方法，我们往父类Producer里面找到这个方法 override func subscribe(_ observer: Observer) -> Disposable where Observer.Element == 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 } } } 在父类Producer的subscribe里面调用了self.run(observer, cancel: disposer)，然后看里面的实现： override func run(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element { let sink = ObservableSequenceSink(parent: self, observer: observer, cancel: cancel) let subscription = sink.run() return (sink: sink, subscription: subscription) } ，先创建一个AnonymousObservableSink对象并持有observer，然后调用这个对象的run方法把self传递过去，也就是把observable作为参数。 AnonymousObservableSink这个类将可观察者Observable和观察者Observer链接起来,实现事件的传递，起到一个桥梁的作用。在里面调用了sink.run()，实际上是调用了 Create.swift里面的run() func run(_ parent: Parent) -> Disposable { return parent._subscribeHandler(AnyObserver(self)) } 到这为止，我们就知道了subscribe里面是调用了subscribeHandler这个闭包 #### 3.发送信号(.onNext) 在这个方法中把self转换成AnyObserver对象，也就是把AnonymousObservableSink对象转换成AnyObserver对象。那么，具体是怎么转换的呢？我们来看看源码构造函数中有一行代码self.observer = observer.on，就是把AnonymousObservableSink类的on函数赋值给AnyObserver类的observer变量 public struct AnyObserver : ObserverType { public typealias EventHandler = (Event) -> Void private let observer: EventHandler public init(eventHandler: @escaping EventHandler) { self.observer = eventHandler } events. public init(_ observer: Observer) where Observer.Element == Element { self.observer = observer.on } public func on(_ event: Event) { return self.observer(event) } public func asObserver() -> AnyObserver { return self } } 接下来我们看看AnonymousObservableSink里面on的实现: // AnonymousObservableSink.swift func on(_ event: Event) { #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() } } } 里面调用了self.forwardOn(event) 然后找到父类Sink里面forwardOn的实现 final func forwardOn(_ event: Event) { #if DEBUG self._synchronizationTracker.register(synchronizationErrorMessage: .default) defer { self._synchronizationTracker.unregister() } #endif if isFlagSet(self._disposed, 1) { return } self._observer.on(event) } self.\_observer就是第二步调用subscribe函数里面创建AnonymousObserver类型的observer对象。会先进入到父类的ObserverBase的on方法然后调用了onCore(), AnonymousObserver里面重写onCore方法 func on(_ event: Event) { switch event { case .next: if load(self._isStopped) == 0 { self.onCore(event) } case .error, .completed: if fetchOr(self._isStopped, 1) == 0 { self.onCore(event) } } } // AnonymousObserver.swift override func onCore(_ event: Event) { return self._eventHandler(event) } 我们看到在onCore里面调用了eventHandle这个闭包. **献上Cooci的核心逻辑分析图：** ![](https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2019/7/28/16c37f5300cafa78~tplv-t2oaga2asx-image.image#?w=2076\&h=918\&s=528854\&e=png\&b=ededf2)