函数响应式编程思想
函数响应式编程思想即是将函数式编程和响应式编程相结合。
函数式编程
顾名思义，就是像函数一样的编程。
简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。
它属于"结构化编程"的一种，主要思想是把运算过程尽量写成一系列嵌套的函数调用
如下：
let array = [1,2,3,4,5,6,7]
array.filter{ $0 > 3}
.filter{ ($0+1) % 2 == 0}
.forEach{print($0)}
像函数一样条例清晰，便于理解，代码简洁，开发快速，方便管理代码。即使注释掉其中一行也不会影响到后面的运行等特点。
其中， Masnory/ SnapKit函数式编程的一个经典的代表作。
make.centerY.equalTo(self.view).offset(100);
响应式编程
简称RP（Reactive Programming）
响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。
响应式编程最初是为了简化交互式用户界面的创建和实时系统动画的绘制而提出来的一种方法，但它本质上是一种通用的编程范式。
- 例如，在MVC软件架构中，响应式编程允许将相关模型的变化自动反映到视图上，反之亦然。
例如,在命令式编程环境中, a = b + c 表示将表达式的结果赋给 a，而之后改变 b 或 c 的值不会影响 a。但在响应式编程中，a的值会随着 b 或 c 的更新而更新，a = b + c 声明的是一种绑定关系。
RxSwift 核心逻辑
RxSwift即是运用了函数响应式编程思想。
简单来说，核心思想是：它将所有事物都看作是一个可观察的序列：
- 当还有下一个任务的时候，就继续执行下一个任务。
- 当发生错误的时候，就发送出去一个Error信号，并被观察到以执行其他操作。
- 当执行完成过后，就发送出去一个Complete信号。
其中Error信号和Complete信号不能同时存在，只能有一个响应。
图解如下：
代码实现如下：
// 创建序列
// AnonymousObservable -> producer.subscriber -> run
// 保存闭包 - 函数式 保存 _subscribeHandler
// 1:创建序列
let ob = Observable<Any>.create { (obserber) -> Disposable in
// 3:发送信号
obserber.onNext("框架班级")
obserber.onCompleted()
// obserber.onError(NSError.init(domain: "coocieeror", code: 10087, userInfo: nil))
return Disposables.create()
}
// 2:订阅信号
// AnonymousObserver - event .next -> onNext()
// _eventHandler
// AnonymousObservable._subscribeHandler(observer)
// 销毁
let _ = ob.subscribe(onNext: { (text) in // let _ 忽略返回值
print("订阅到:\(text)")
}, onError: { (error) in
print("error: \(error)")
}, onCompleted: {
print("完成")
}) {
print("销毁")
}
分析：
在创建序列的let ob = Observable<Any>.create这句代码中，结合下面的原来来看：
public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
return AnonymousObservable(subscribe)
}
是返回了一个匿名的可观察序列AnonymousObservable，并将订阅方法的实现（subscribe），即上面create后面大括号中的所有内容传了过去。
再结合下面的源码：
final private class AnonymousObservable<Element>: Producer<Element> {
typealias SubscribeHandler = (AnyObserver<Element>) -> Disposable // 起个别名为SubscribeHandler
let _subscribeHandler: SubscribeHandler
init(_ subscribeHandler: @escaping SubscribeHandler) { // 带了一个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)
}
}
AnonymousObservable初始化的时候，将订阅方法的实现保存在了常量_subscribeHandler中。
点击let _ = ob.subscribe(onNext: { (text) in这句代码进去，看源码：
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 // 保存了事件，这整个大括号是作为一个逃逸闭包参数，初始化传递给了AnonymousObserver。并且将其赋值给新的常量observer，保存起来
#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), // self.asObservable() 这个即是序列ob。这句代码回到上面的 ob序列者的闭包
disposable
)
}
}
再点击AnonymousObserver进入源码：
final class AnonymousObserver<ElementType> : ObserverBase<ElementType> {
typealias Element = ElementType
typealias EventHandler = (Event<Element>) -> Void
private let _eventHandler : EventHandler
init(_ eventHandler: @escaping EventHandler) {
#if TRACE_RESOURCES
_ = Resources.incrementTotal()
#endif
self._eventHandler = eventHandler // 保存了事件管理者
}
override func onCore(_ event: Event<Element>) {
return self._eventHandler(event)
}
#if TRACE_RESOURCES
deinit {
_ = Resources.decrementTotal()
}
#endif
}
从上分析可以看出ob.subscribe括号后的代码，在AnonymousObserver初始化的时候，被赋予了别名EventHandler，并且被保存在了常量_eventHandler中。
然后AnonymousObserver初始化时，将后面整个大括号里包括对各种事件的处理的代码作为逃逸闭包，传递给了AnonymousObserver，并将其赋值给了常量observer保存了起来。
最后self.asObservable().subscribe(observer)这句代码中，self.asObservable()即表示的是上面代码中的序列ob，因为
public func asObservable() -> Observable<E> {
return self
}
返回的是它本身序列。
而subscribe(observer)方法即是调用了上面创建的可观察序列AnonymousObservable的父类Producer的方法。源码如下：
class Producer<Element> : Observable<Element> {
override init() {
super.init()
}
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
}
}
}
func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == Element {
rxAbstractMethod()
}
}
最后在run方法将observer传递过去，子类AnonymousObservable实现方法：
func run(_ parent: Parent) -> Disposable {
return parent._subscribeHandler(AnyObserver(self))
}
即实现了从下面的订阅，走到上面发送信号那里面的代码。
总结如下图：
