RxSwift（2）— 核心逻辑源码分析

时间  2019-11-07
标签 rxswift 核心 逻辑 源码 分析 繁體版
原文   原文链接

就问此时此刻还有谁？45度仰望天空，该死！我这无处安放的魅力！git

RxSwift 目录直通车 --- 和谐学习，不急不躁！github

做为ReactiveX家族之一的RxSwift在Github截止如今Star:16K.为何这个框架如此受欢迎，做为函数响应式框架典型表明，底层实现又是如何实现的呢？这一篇文章全面解密，但愿个人解读给你带来更多捷径swift

RxSwift核心流程

RxSwift这个优秀的框架，设计的api也是很是精简，让陌生的用户也能很是快速上手api

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

// 控制台打印：“订阅到:Cooci - 框架班级”
复制代码

我刚开始在探索的时候，我是比较好奇的：为何咱们的Cooci - 框架班级这个字符串会在订阅序列的subscribe的闭包打印。下面是个人代码分析闭包

分析代码：

  • 1：建立序列的代码 Create 后面的 闭包A 里面有 3：发送信号，若是要执行 发送信号 ，必然要来到这个闭包A
  • 2：咱们执行 2: 订阅序列 跟了 闭包B
  • 3：经过结果咱们显然知道，先执行 闭包A 把 Cooci - 框架班级 传给了 闭包B
  • 猜想：代码里面嵌套了闭包的执行调用！猜想的真实性，咱们开始解读源码来验证

PS: 说实话 RxSwift框架的源码的确比较复杂而且不少，不少基础薄弱或者耐性不够的小伙伴很容易放弃。可是你看到这篇博客，你有福了：我会快速简短给你介绍，在最后面会附上我绘制的思惟导图！框架

RxSwift核心逻辑

建立序列

extension ObservableType {
    // MARK: create
    public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
        return AnonymousObservable(subscribe)
    }
}
复制代码

你们能够很清晰看到咱们的 可观察序列 的建立是利用协议拓展功能的create方法实现的，里面建立了一个 AnonymousObservable（匿名可观察序列） 命名仍是体现了做者的思惟 ：这个类就是一个内部类，具有一些通用特性（具备本身功能的类才会命名） 下面我贴出这个类的继承关系ide

从上面的图，咱们能够清晰的看到的继承关系。那么这么多的内容还有那么多层嵌套，这个地方咱们须要掌握什么：函数

  • create 方法的时候建立了一个内部对象 AnonymousObservable
  • AnonymousObservable 保存了外界的闭包
  • AnonymousObservable继承了 Producer 具备很是重要的方法 subscribe

订阅序列

这里说明这个订阅方法 subscribe 和咱们上面所说的 subscribe 不是同一个方法源码分析

来自于对 ObservableType 的拓展功能post

extension ObservableType {
    public func subscribe(onNext: ((E) -> Void)? = nil, ...) -> Disposable {
           // 由于篇幅 省略不影响咱们探索的代码
            let observer = AnonymousObserver<E> { 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
            )
    }
}
复制代码

代码说明：

  • E 这里的意思是 Swift 的关联类型，这个若是仔细看过可观察序列的继承链源码应该不可贵出：这个E 就是咱们的 序列类型，咱们这里就是String
public class Observable<Element> : ObservableType {
    /// Type of elements in sequence.
    public typealias E = Element
复制代码
  • 建立了一个 AnonymousObserver (匿名内部观察者) 手法和咱们的 AnonymousObservable 差很少，它这里的初始化是闭包参数，保存了外界的 onNext, onError , onCompleted , onDisposed 的处理回调闭包的调用,下面我仍是给你们贴出 观察者 的继承链关系，帮助你们理解

  • self.asObservable() 这个是咱们的 RxSwift 为了保持一致性的写法
  • self.asObservable().subscribe(observer)其实本质就是 self.subscribe(observer),经过可观察序列的继承关系，咱们能够很是快速的定位 Producer 订阅代码
override func subscribe(_ observer: O) -> Disposable where O.E == Element {
        if !CurrentThreadScheduler.isScheduleRequired {
            // 篇幅缘由，咱们省略一些代码，方便咱们理解
            ...
            return disposer
        }
        else {
            return CurrentThreadScheduler.instance.schedule(()) { _ in
                let disposer = SinkDisposer()
                let sinkAndSubscription = self.run(observer, cancel: disposer)
              // 篇幅缘由，咱们省略一些代码，方便咱们理解
              ...
                return disposer
            }
        }
    }
复制代码
  • 关于销毁代码和调度者代码这里不分析
  • self.run 这个代码最终由咱们生产者 Producer 延伸到咱们具体的事务代码 AnonymousObservable.run
override func run (...) {
    let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
    let subscription = sink.run(self)
    return (sink: sink, subscription: subscription)
}
复制代码
  • sink.run的写法也是比较好的，业务处理的仍是下沉了，让分工更加明确
func run(_ parent: Parent) -> Disposable {
    return parent._subscribeHandler(AnyObserver(self))
}
复制代码
  • parent 就是上面传过来的AnonymousObservable对象
  • 咱们很是兴奋的看到 AnonymousObservable._subscribeHandler,从这句代码咱们解惑了为何咱们的序列订阅的时候流程会执行咱们 序列闭包，而后去执行 发送响应
  • 发送响应的代码等会分析，这里还有一个比较重要的家伙 AnyObserver(self)
public init<O : ObserverType>(_ observer: O) where O.E == Element {
    self.observer = observer.on
}
复制代码
  • 在这个构造方法里面，咱们建立了一个结构体 AnyObserver 保存了一个信息 AnonymousObservableSink .on 函数，不是 AnonymousObservableSink,这个地方通常初次来到这里的人都会犯错误。不知道你是否意识到了！

发送响应

咱们从上面的分析，很是清晰: obserber.onNext("Cooci - 框架班级") 的本质是： AnyObserver.onNext("Cooci - 框架班级")

这时候发现咱们的AnyObserver 是没有这个方法，这很正常！通常思路，找父类，找协议

extension ObserverType {
    public func onNext(_ element: E) {
        self.on(.next(element))
    }
}
复制代码
  • 外界 obserber.onNext("Cooci - 框架班级") 再次变形 ：AnyObserver.on(.next("Cooci - 框架班级")) ,这里你们必定要主要，这个AnyObserver调用了 on 里面传的是 .next函数, .next函数带有咱们最终的参数
public struct AnyObserver<Element> : ObserverType {
    public init<O : ObserverType>(_ observer: O) where O.E == 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("Cooci - 框架班级") 最终咱们的核心逻辑又回到了 sink 这个神奇的管子，看到这里不由拍案叫绝， RxSwift这个设计能力，还有谁~~~
class AnonymousObservableSink<O: ObserverType>: Sink<O>, ObserverType {
    func on(_ event: Event<E>) {
        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<O : ObserverType> : Disposable {
    final func forwardOn(_ event: Event<O.E>) {
        if isFlagSet(self._disposed, 1) {
            return
        }
        self._observer.on(event)
    }
}
复制代码
  • 其中 self._observer 就是咱们初始化保存的 观察者：AnonymousObserver
  • 那么咱们变形得出本质就是：AnonymousObserver.on（.next("Cooci - 框架班级")）,个人天啊! 这里逻辑展转回到了咱们 订阅序列 时候建立的 AnonymousObserver 的参数闭包的调用！全部的一切感受是这样的啰嗦，但又是这么的顺其资源。
let observer = AnonymousObserver<E> { 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()
    }
}
复制代码
  • 判断 event 进而调用 onNext?(value) ,由于枚举的关联值（Swift很强大的功能）value = "Cooci - 框架班级", 接下来就是外界 onNext闭包的调用传参，那么这个时候源码解析到这里，我相信你已经彻底掌握了RxSwift的核心逻辑，最后这里附上咱们的分析图解

总结：RxSwift的结构

  • 1：就是序列感念 满世界都是序列 - 编码统一 ，随时随地享用
  • 2：经过函数式思想吧一些列的需求操做下沉（把开发者不关心的东西封装） - 优化代码，节省逻辑
  • 3：RxSwift最典型的特点就是解决Swift这门静态语言的响应能力，利用随时间维度序列变化为轴线，用户订阅关心能随轴线一直保活，达到订阅一次，响应一直持续~

就问此时此刻还有谁？45度仰望天空，该死！我这无处安放的魅力！

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程