你好，我是Emma，说到swift中的响应式编程框架，比较典型的就是RxSwift，RxSwift的功用，我们可以类比OC中的RAC。
1.函数式编程（FRP）function reactive programe
函数式编程是种编程范式，它需要我们将函数作为参数传递，或者作为返回值返还。y = f(x) x = f(x) -> y = f(f(x))
2.函数式编程的一个实现场景：
一方响应，另一方也跟着响应。
3.响应式框架实现思路：
响应式框架，它指的是能够支持响应式编程范式的框架。使用了响应式框架，你在编程时就可以使用数据流传播数据的变化，响应这个数据流的计算模型会自动计算出新的值，将新的值通过数据流传给下一个响应的计算模型，如此反复下去，直到没有响应者为止。
KVO如何实现其响应式编程的？思路：对值进行监听，当一方值变化的时候，我们可以监听到，然后产生反应。
Tips：
KVO的使用来自于OC中的运行时机制，而swift是一门静态语言，我们要使用运行时编译的话，得加上@objc。
RxSwift是如何实现响应式编程的？
思想：创建序列+订阅+回收
4.rx是如何封装的？
rx，匿名空间，rx相当于OC中的NSObject，协议扩展
协议最基本的属性是扩展功能。
关联属性，关联值，遵守这个协议的人都有关联的功能。
5.RxSwift实现响应式编程详解
5.1代码总览
1.创建序列
let ob = Observable.create { (obserber) -> Disposable in
// 3:订阅中心发送信号
obserber.onNext("框架班级")
obserber.onCompleted()
// obserber.onError(NSError.init(domain: "coocieeror", code: 10087, userInfo: nil))
return Disposables.create()
}
2.订阅信号
let _ = ob.subscribe(onNext: { (text) in
print("订阅到:\(text)")
}, onError: { (error) in
print("error: \(error)")
}, onCompleted: {
print("完成")
}) {
print("销毁")
}
5.2代码问题
看着上面代码的使用方式，我们进行一下思考：
5.2.1obserber.onNext("框架班级")代码是怎么产生的？
类比RAC，控件的事件响应的是Rx的内部类，而内部类中响应sendNext的方法。
5.2.2序列中发送了信号，那在订阅中是如何订阅到的呢？
1）创建部分：
create通过一个构建函数完整的创建一个 Observable（可监听序列）。
使用上：
在构建函数里面描述事件（next，error，completed）的产生过程。
源码分析上：
- parameter subscribe: Implementation of the resulting observable sequence's `subscribe` method.我的理解是：可监听序列的“subscribe”方法的实现
- returns: The observable sequence with the specified implementation for the `subscribe` method.具有指定的'subscribe'方法实现的可观察序列。
public static func create(_ subscribe: @escaping (AnyObserver) -> Disposable) -> Observable {
return AnonymousObservable(subscribe)
}
AnonymousObservable的初始化方法中保存了传过来的闭包。
final private class AnonymousObservable: Producer {
typealias SubscribeHandler = (AnyObserver) -> Disposable
let _subscribeHandler: SubscribeHandler
init(_ subscribeHandler: @escaping SubscribeHandler) {
self._subscribeHandler = subscribeHandler
}
override func run(_ 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)
}
}
AnonymousObservableSink点击进来的这段初始化了可监听序列，并且对（next，error，completed）也进行了初始化。
override init(observer: O, cancel: Cancelable) {
super.init(observer: observer, cancel: cancel)
}
func on(_ event: Event) {
#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()
}
}
}
2）订阅部分
Subscribes an element handler, an error handler, a completion handler and disposed handler to an observable sequence.
订阅一个元素处理程序，一个错误处理程序，一个完成处理程序，一个回收处理程序到一个可观察序列。
- parameter onNext: Action to invoke for each element in the observable sequence.
- parameter onError: Action to invoke upon errored termination of the observable sequence.
- parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
- parameter onDisposed: Action to invoke upon any type of termination of sequence (if the sequence has
gracefully completed, errored, or if the generation is canceled by disposing subscription).
- returns: Subscription object used to unsubscribe from the observable sequence.
创建了一个序列监听类AnonymousObserver,并保存了事件的回调。
回调里面根据不同的事件类型，来执行相应的事件。
let observer = AnonymousObserver { 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()
}
}
然后用资源管理器Disposables将可监听序列(observable)和序列监听者（observer）关联起来：
return Disposables.create(
self.asObservable().subscribe(observer),
disposable
)
5.2.3资源管理器Disposables将可监听序列(observable)和序列监听者（observer）关联起来的？
subscribe--->create中
class Producer : Observable {
override init() {
super.init()
}
override func subscribe(_ 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
}
}
}
func run(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == Element {
rxAbstractMethod()
}
}
这里是sink和subscription等变量的存储和初始化
func setSinkAndSubscription(sink: Disposable, subscription: Disposable) {
self._sink = sink
self._subscription = subscription
let previousState = fetchOr(self._state, DisposeState.sinkAndSubscriptionSet.rawValue)
if (previousState & DisposeState.sinkAndSubscriptionSet.rawValue) != 0 {
rxFatalError("Sink and subscription were already set")
}
if (previousState & DisposeState.disposed.rawValue) != 0 {
sink.dispose()
subscription.dispose()
self._sink = nil
self._subscription = nil
}
}
而外部onnext变化是具体：
final private class AnonymousObservableSink: Sink, ObserverType {
typealias E = O.E
typealias Parent = AnonymousObservable
// state
private let _isStopped = AtomicInt(0)
#if DEBUG
fileprivate let _synchronizationTracker = SynchronizationTracker()
#endif
override init(observer: O, cancel: Cancelable) {
super.init(observer: observer, cancel: cancel)
}
func on(_ event: Event) {
#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()
}
}
}
func run(_ parent: Parent) -> Disposable {
return parent._subscribeHandler(AnyObserver(self))
}
}
在AnonymousObservable类调用subscribe调用时，实际上是创建了一个sink对象。在sink调用我们保存的闭包的时候，也把闭包内的onNext方法方法作为event事件保存起来。并在调用observer对象时，把event做为参数传了进来。AnonymousObserver和AnonymousObservableSink这样就关联在一起了，然后对里面的event进行（next，error，completed）的分发。
总结：
核心思想：创建序列-》订阅序列-》事件关联。
参考资料：
RxSwift 中文文档
RxSwift Github地址