返回

RxSwift

前言

RxSwift是一个基于响应式编程的Swift框架，它提供了一种简洁而强大的方式来处理异步和事件驱动的编程任务。在RxSwift中，核心流程包括观察者、可观察序列和订阅。

RxSwift核心流程三部曲

1
2
3
4
5
6
7
8
9
10

 // 1.创建序列
 _ = Observable<String>.create { ob in
   // 3.发送信号
    ob.onNext("你好")
    return Disposables.create()
   // 2.订阅序列
  }.subscribe(onNext: { text in
    print("订阅到了\(text)")
  })
}

• 1.创建序列
• 2.订阅序列
• 3.发送信号

上面三部曲的执行结果：

第一次玩RxSwift比较好奇为什么会打印订阅到了你好，明明是两个闭包里面的代码。
我们先简单分析下：

• 序列创建create后面带了闭包A，闭包A里面执行了发送信号的流程
• 订阅subsribe后面带了闭包B
• 根据结果我们知道一定是先执行了闭包A，再把闭包A的你好传给了闭包B,然后输出结果

RxSwift核心逻辑分析

创建序列

点进create函数可以看到它是拓展了ObservableType这个协议，同时创建了一个AnonymousObservable内部类（看名字是匿名序列，具备一些通用的特性）分析AnonymousObservable的继承链可以得到下面的关系图：

AnonymousObservable

AnonymousObservable是接受Element泛型的继承自Producer的类，他接受并保存一个闭包subscribeHandler的参数，这个其实就是上面我们说的闭包A，另外有一个run函数（后面会提到）

Producer

Producer是接受Element泛型的继承自Observable的类，有一个subscribe的实现，run的抽象方法，这个subscribe非常重要

Observable

Observable是接受Element泛型的实现ObservableType协议的类，有一个subscribe的抽象方法，asObservable的实现（返回self，统一万物皆序列）
同时Observable有统计引用计数的能力（Resources这个结构体在序列，观察者，销毁者等都用到，可以调试是否有内存泄露），其中的AtomicInt是一把NSLock的锁，保证数据的存取安全

ObservableType

ObservableType是拓展ObservableConvertibleType协议的协议，定义了subscribe协议方法，实现了asObservable()方法，所以这里我们得出结论，不一定要继承Observable的才是序列，只要是实现了ObservableType的subscribe的协议方法的也可以算是序列，进一步佐证万物接序列

ObservableConvertibleType

ObservableConvertibleType是个协议，关联了Element类型，定义asObservable的协议方法

订阅序列

点击subscribe函数

它是ObservableType的拓展能力，创建了一个AnonymousObserver（匿名观察者）
，接受的Element仔细查看继承链代码会发现跟序列创建的泛型是同一个

分析AnonymousObserver的继承链我们可以得到下图：

AnonymousObserver

AnonymousObserver是接受Element泛型的继承自ObserverBase的类
保存了一个eventHandler的闭包，这个我们定义是闭包C
同时也有统计引用计数的能力，有一个onCore的实现

ObserverBase

ObserverBase是接受Element泛型的实现Disposable和ObserverType两个协议的类，有一个on的实现，onCore的抽象方法

ObserverType

ObserverType关联了Element，定义了on的协议方法，拓展定义了onNext，onCompleted，onError的方法，这三个方法其实都是on一个Event

其中Event是个枚举，有三类事件：next事件、error事件和completed事件。

• next事件：next事件携带了一个值，表示数据的更新或新的事件。
• error事件：error事件表示发生了一个错误，中断了事件的正常流程。
• completed事件：completed事件表示事件流的结束，不再有新的事件产生。
  观察者通过订阅可观察序列来接收事件。

Disposable

Disposable这个协议比较简单，定义了dispose方法

订阅流程分析

• 1.调用self.asObservable().subscribe(observer)

  • 这个self是AnonymousObservable的实例
  • 调用asObservable方法通过继承链最终调用Observable的实现，返回self,也就还是AnonymousObservable的实例

• 2.调用AnonymousObservable的实例的subscribe方法，通过继承链调用Producer的subscribe方法

• 3.Producer的run方法在AnonymousObservable有实现

这个sink的处理是相当不错的，很好的做到了业务下沉，同时很好的运用了中间件和单一职责的设计模式，值得学习。

sink是管道的意思，下水道，什么东西都会往里面丢，这里面有订阅者，销毁者等

• 4. sink.run
• 5. parent.subscribeHandler(AnyObserver(self))这里的parent就是AnonymousObservable的实例，调用subscribeHandler这个也就是我们定义的闭包A
     这里解释了订阅的时候会来到我们的闭包A的原因。
     这里需要注意到AnyObserver这个类，他里面保存的observer属性其实是AnonymousObservableSink.on函数

发送信号

有了上两步的基础我们分析发送信号的流程应该比较清晰了

• 1. obserber.onNext 其实就是AnyObserver.onNext
• 2. ObserverType.onNext其实就是ObserverType.on
• 3. 其实就是AnyObserver.on

• 4.这个observer就是上面第二步最后的AnonymousObservableSink.on函数

• 5.父类Sink.forwardOn函数

这里的self.observer类型是 AnonymousObserver

• 6.调用AnonymousObserver的父类ObserverBase的on方法

• 7.调用AnonymousObserver的onCore方法

• 8.调用eventHandler，也就是我们定义的闭包C
• 9.闭包C根据Event调用闭包B，闭包B输出了控制台的结果，至此，整个链路执行完毕了。

把整个核心流程用思维导图描述出来：

总结

• 万物皆序列，序列的时间统一了编码
• 完整的继承了做到了业务分离，单一职责
• 中间价模式很好的做到了业务下沉