RxSwift-序列响应逻辑

StrikerLife
592 阅读4分钟

RxSwift篇章

RxSwift在Github截止现在Star:16K.为什么这个框架如此受欢迎，作为函数响应式框架典型代表，底层实现又是如何实现的呢？

序列API

api结构:

  • 创建序列
  • 订阅序列
  • 发送信号
// 1.创建序列
       _ = Observable<String>.create { (obserber) -> Disposable in
           // 3.发送信号
           obserber.onNext("测试")
           return Disposables.create()  // 这个销毁不影响我们这次的解读
           // 2.订阅序列
           }.subscribe(onNext: { (text) in
               print("订阅到:\(text)")
           })

分析代码

  • 1：创建序列的代码 Create 后面的 闭包A 里面有 3：发送信号，如果要执行 发送信号 ，必然要来到这个闭包A.

  • 2：我们执行 2: 订阅序列 跟了 闭包B.

  • 3: 通过结果我们可以肯定，先执行 闭包A 把 "测试" 传给了 闭包B.

  • 4: 进入源码,查看具体的实现逻辑.

实现逻辑,分析源码

创建序列

//creat函数

//subscribe为我们传入的发送信号闭包
public static func create(_ subscribe: @escaping (AnyObserver<Element>) -> Disposable) -> Observable<Element> {
        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
    }

代码说明

  • create 方法的时候创建了一个内部对象 AnonymousObservable ,其保存了外界的闭包(包含发送信号)

  • AnonymousObservable 继承了 Producer 具有订阅的方法 subscribe

订阅序列

//subscribe函数

//onNext为我们传入的订阅闭包
    public func subscribe(onNext: ((Element) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
        -> Disposable {
        //onNext走向: observer= AnonymousObserver(初始化包含onNext)
            let observer = AnonymousObserver<Element> { event in
                switch event {
                case .next(let value):
                    onNext?(value)
                case .error(let error):
                ...
                    disposable.dispose()
                case .completed:
                ...
                }
            }
            return Disposables.create(
            //observer走向
                self.asObservable().subscribe(observer),
                disposable
            )
    }

代码说明:

  • 创建了一个 AnonymousObserver (匿名内部观察者) 手法和我们的 AnonymousObservable 差不多，它这里的初始化是闭包参数，保存了外界的 onNext, onError , onCompleted 等事件.

  • self.asObservable() 这个是我们的 RxSwift 为了保持一致性的写法

  • self.asObservable().subscribe(observer) 其实本质就是self.subscribe(observer),通过可观察序列的继承关系，我们可以非常快速的定位 Producer 订阅代码

    //序列订阅
        override func subscribe<Observer: ObserverType>(_ observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element { 
          if !CurrentThreadScheduler.isScheduleRequired {
          ...
        }
        else {
            return CurrentThreadScheduler.instance.schedule(()) { _ in
                // 重点
                let sinkAndSubscription = self.run(observer, cancel: disposer)
                ...
            }
        }
    }
  • self.run 这个代码最终由我们生产者 Producer 延伸到我们具体的事务代码 AnonymousObservable.run 
override func run<Observer: ObserverType>(...){
        let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
        let subscription = sink.run(self)
        return (sink: sink, subscription: subscription)
    }
  • AnonymousObservableSink 保存了 观察者
  • sink.run(self) 处理业务.
func run(_ parent: Parent) -> Disposable {
    return parent._subscribeHandler(AnyObserver(self))
}

  • parent 就是上面传过来的AnonymousObservable对象

  • 我们可以开心的看到 AnonymousObservable._subscribeHandler(),从这句代码我们知道了为什么序列订阅的时候流程会执行创建序列的闭包，然后去执行发送响应(谜底开始呈现了).

  • 发送响应的代码等会分析，这里还有一个比较重要的家伙 AnyObserver(self) 

    public init<Observer: ObserverType>(_ observer: Observer) where Observer.Element == Element {
       self.observer = observer.on
   }
  • 在这个构造方法里面，我们创建了一个结构体 AnyObserver 保存了一个信息 AnonymousObservableSink.on 函数.

发送响应

我们从上面的分析，非常清晰:" obserber.onNext("测试")" 的本质是： AnyObserver.onNext("测试") 这时候发现我们的 AnyObserver 是没有这个方法，这很正常！ 一般思路，找父类，找协议 

extension ObserverType {
    public func onNext(_ element: Element) {
        self.on(.next(element))
    }
}
  • AnyObserver.onNext("测试") 再次变形: AnyObserver.on(.next("测试")) ,这里大家一定要主要，这个 AnyObserver 调用了 on 里面传的是.next函数 , .next函数 带有我们最终的参数.
public struct AnyObserver<Element> : ObserverType {
    /// - parameter observer: Observer that receives sequence 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)
    }
}
  • self.observer 构造初始化就是： AnonymousObservableSink .on 函数 看到这里又要变形咯：self.observer(event) -> AnonymousObservableSink .on(event) 其中 event = .next("测试") 最终我们的核心逻辑又回到了 sink 这个神奇的管子...
final private class AnonymousObservableSink<Observer: ObserverType>: Sink<Observer>, ObserverType {
    func on(_ event: Event<Element>) {
    ...
        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) 这也是执行的核心代码，因为 AnonymousObservableSink 继承 Sink 这里还有封装，请看下面的代码
class Sink<Observer: ObserverType> : Disposable {
    final func forwardOn(_ event: Event<Observer.Element>) {
    ...
        self._observer.on(event)
    }
}

  • 其中 self._observer 就是我们初始化保存的观察者： AnonymousObserver

  • 那么我们变形得出本质就是： AnonymousObserver.on（.next("测试") ）,这里逻辑辗转回到了我们 订阅序列 时候创建的 AnonymousObserver 的参数闭包的调用！( 设计啰嗦吗?合理吗?后续研究...) 。

let observer = AnonymousObserver<E> { event in
    ...
    switch event {
    case .next(let value):
        onNext?(value)
    case .error(let error):
       ...
    case .completed:
        onCompleted?()
    }
}
  • 判断 event 进而调用 onNext?(value) ,因为枚举的关联值（Swift很强大的功能）value = "测试", 接下来就是外界 onNext闭包 的调用传参,出现结果.

小结

  • 通过函数式思想把一系列的需求操作下沉（把开发者不关心的东西封装）,优化代码层次,简练各类逻辑.
avatar
文章
阅读
粉丝