阅读 2465

RxSwift源码分析(一)-核心逻辑解析

前言:这几篇关于RxSwift源码分析的文章主要是对源码进行解析,不涉及到RxSwift的具体使用。具体使用可以查看RxSwift中文文档或者github

在RxSwift的使用中,我们需要先创建序列,然后订阅信号、发送信号来实现一个完整的流程。先举一个简单的例子:

        // 1:创建序列
        let observable = Observable<Any>.create { (obserber) -> Disposable in
            // 3:发送信号
            obserber.onNext("发送信号")
            obserber.onCompleted()
//            obserber.onError(NSError.init(domain: "fail", code: 10087, userInfo: nil))
            return Disposables.create()
        }
        
        // 2:订阅信号
        let _ = observable.subscribe(onNext: { (text) in
            print("订阅到信号:\(text)")
        }, onError: { (error) in
            print("error: \(error)")
        }, onCompleted: {
            print("完成")
        }) {
            print("销毁")
        }
复制代码

我们需要重点关注的是:

  1. 第一行代码中的create的闭包什么时候执行
  2. 订阅信号subscribe的闭包什么时候执行
  3. 信号从发送出去到接收流程是怎样的

下面针对这几个问题来一一探索

第一步create函数

首先来看看create函数,它返回一个AnonymousObservable对象,AnonymousObservable是匿名可观察者,用来存储产生事件的闭包(self._subscribeHandler = subscribeHandler)和激活处理事件闭包的入口(run方法)。

public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
    return AnonymousObservable(subscribe)
}
复制代码
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)
    }
}
复制代码

AnonymousObservableObservable的子类,它们的继承关系是:AnonymousObservable -> Producer -> Observable -> ObservableType -> ObservableConvertibleType

第二步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对象,在初始化时传递了一个闭包作为参数并且保存下来self._eventHandler = eventHandlerAnonymousObserver是匿名观察者,用于存储和处理事件的闭包。

然后在最后有self.asObservable().subscribe(observer)这样一行代码,asObservable返回的是对象本身,然后调用subscribe这个函数并且把创建的AnonymousObserver对象传递过去,会来到AnonymousObservable这个类里面,但是发现这个类里面没有subscribe方法,我们往父类Producer里面找到这个方法,源码如下:

    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
            }
        }
    }
复制代码

在这里调用了run方法,也就是AnonymousObservable这个类里面的run方法,把observer作为参数传过来。

    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)
    }
复制代码

run方法中,先创建一个AnonymousObservableSink对象并持有observer,然后调用这个对象的run方法把self传递过去,也就是把observable作为参数。 AnonymousObservableSink这个类将可观察者Observable和观察者Observer链接起来,实现事件的传递,起到一个桥梁的作用。

    func run(_ parent: Parent) -> Disposable {
        return parent._subscribeHandler(AnyObserver(self))
    }
复制代码

在这里触发了_subscribeHandler的调用,这里的_subscribeHandler就是之前create函数的闭包。到这里就解决了第一个问题“第一行代码中的create的闭包什么时候执行”。 在这个方法中把self转换成AnyObserver对象,也就是把AnonymousObservableSink对象转换成AnyObserver对象。那么,具体是怎么转换的呢?我们来看看源码

public struct AnyObserver<Element> : ObserverType {
    /// The type of elements in sequence that observer can observe.
    public typealias E = Element
    
    /// Anonymous event handler type.
    public typealias EventHandler = (Event<Element>) -> Void

    private let observer: EventHandler

    /// Construct an instance whose `on(event)` calls `eventHandler(event)`
    ///
    /// - parameter eventHandler: Event handler that observes sequences events.
    public init(eventHandler: @escaping EventHandler) {
        self.observer = eventHandler
    }
    
    /// Construct an instance whose `on(event)` calls `observer.on(event)`
    ///
    /// - parameter observer: Observer that receives sequence events.
    public init<O : ObserverType>(_ observer: O) where O.E == Element {
        self.observer = observer.on
    }
    
    /// Send `event` to this observer.
    ///
    /// - parameter event: Event instance.
    public func on(_ event: Event<Element>) {
        return self.observer(event)
    }

    /// Erases type of observer and returns canonical observer.
    ///
    /// - returns: type erased observer.
    public func asObserver() -> AnyObserver<E> {
        return self
    }
}
复制代码

可以看到在构造函数中有一行代码self.observer = observer.on,就是把AnonymousObservableSink类的on函数赋值给AnyObserver类的observer变量。从这里就可以明白为什么这行代码observer.onNext("发送信号") 最终会触发AnonymousObservableSink.on事件。

// 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()
            }
        }
    }
复制代码

然后进入到Sink类的forwardOn方法

    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就是第二步调用subscribe函数里面创建的observer对象。 会先进入到父类的ObserverBaseon方法

    func on(_ event: Event<E>) {
        switch event {
        case .next:
            if load(self._isStopped) == 0 {
                self.onCore(event)
            }
        case .error, .completed:
            if fetchOr(self._isStopped, 1) == 0 {
                self.onCore(event)
            }
        }
    }
复制代码
    override func onCore(_ event: Event<Element>) {
        return self._eventHandler(event)
    }
复制代码

这里的_eventHandler闭包就是第二步调用subscribe函数传入的闭包。 到这里就可以理解第二个和第三个问题了。

总结

从整个流程来看,我们可以体会到函数响应式编程的魅力,代码简介,思路非常的清晰。

梳理一下整个流程:

RxSwift主要核心流程.png

tips:由于在RxSwift中广泛的使用了协议和泛型,还有很多抽象方法和同名方法,导致在刚开始阅读源码的时候可能有些不是很习惯,再加上Xcode跟踪代码不是很强大,阅读起来有一些障碍。所以在阅读源码的时候需要耐心一点,不要找错了地方,可以找一些重点代码阅读,不要盲目的从头看到尾。

有问题或者建议和意见,欢迎大家评论或者私信。

喜欢的朋友可以点下关注和喜欢,后续会持续更新文章。

文章分类
iOS
文章标签