【RxSwift进阶三】RxSwift核心逻辑(源码分析)

时间的救赎
550 阅读4分钟

该篇主要来讲述关于RxSwift核心逻辑的源码解析，彻底了解RxSwift封装的整个过程

首先我们来看下Rx从创建序列，订阅信号，发送信号的整个过程:

    let disposeBag = DisposeBag()
    override func viewDidLoad() {
        super.viewDidLoad()
       // 1.创建信号
        obs = Observable<Any>.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<Element>) -> Disposable) -> Observable<Element> {
        return AnonymousObservable(subscribe)
    }

AnonymousObservable 我们可以看到保存了闭包(self._subscribeHandler = subscribeHandler),以及激活处理事件闭包的入口run())

注意AnonymousObservable的继承关系

AnonymousObservable ->Producer->Observable->ObservableType->ObservableConvertibleType

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<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)
    }
}

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<Element> { 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<Element>: ObserverBase<Element> {
    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)
    }
    ...
}

在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: ObserverType>(_ 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: ObserverType>(_ 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<Element> : ObserverType {
    public typealias EventHandler = (Event<Element>) -> Void

    private let observer: EventHandler
    public init(eventHandler: @escaping EventHandler) {
        self.observer = eventHandler
    } events.
    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的实现:

// AnonymousObservableSink.swift
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()
            }
        }
    }

里面调用了self.forwardOn(event) 然后找到父类Sink里面forwardOn的实现

 final func forwardOn(_ event: Event<Observer.Element>) {
        #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<Element>) {
        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<Element>) {
        return self._eventHandler(event) 
    }

我们看到在onCore里面调用了eventHandle这个闭包.

献上Cooci的核心逻辑分析图：

avatar
文章
阅读
粉丝