一、函数响应式编程思想

（一）概念

这里借用百度百科的官方定义

函数式编程是种编程方式，它将电脑运算视为函数的计算。函数编程语言最重要的基础是λ演算（lambda calculus），而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。

简言之，即将一个函数作为另一个函数的输入或者输出参数

（二）示例

当我们使用函数时，一般使用形如y = f(x)的结构，x为自变量，y为因变量。函数式是将x转化为一个函数f(x)，那么就形成了如下的表达式

y = f(f(x))

f(x)为自变量，y为因变量

（三）与其他编程方式的差异

和指令式编程相比，函数式编程强调函数的计算比指令的执行重要。
和过程化编程相比，函数式编程里函数的计算可随时调用。

二、RxSwift核心逻辑

（一）RxSwift介绍

RxSwift 是 ReactiveX 家族的重要一员, ReactiveX 是 Reactive Extensions 的缩写，一般简写为Rx。

ReactiveX 官方给Rx的定义是，Rx是一个使用可观察数据流进行异步编程的编程接口。

ReactiveX 不仅仅是一个编程接口，它是一种编程思想的突破，它影响了许多其它的程序库和框架以及编程语言。它拓展了观察者模式，使你能够自由组合多个异步事件，而不需要去关心线程，同步，线程安全，并发数据以及I/O阻塞。

RxSwift 是 Rx 为 Swift 语言开发的一门函数响应式编程语言，它可以代替iOS系统的 Target Action / 代理 / 闭包 / 通知 / KVO ….. 同时还提供网络、数据绑定、UI事件处理、UI的展示和更新、多线程……

（二）RxSwift优势

鉴于swift日渐增长的影响力，ios开发者不可避免的要学习和使用swift这门语言进行编程开发。而RxSwift对使用swift的帮助有如下几点：

swift为值类型，在传值与方法回调上有影响，RxSwift一定程度上弥补swift的灵活性
RxSwift使得代码复用性较强，减少代码量
RxSwift因为声明都是不可变更，增加代码可读性
RxSwift使得更易于理解业务代码，抽象异步编程，统一代码风格
RxSwift使得代码更易于编写集成单元测试，增加代码稳定性

（三）RxSwift使用

下面为不同业务场景下的RxSwift的使用demo

    //MARK: - RxSwift应用-网络请求
    func setupNextwork() {
        let url = URL(string: "https://www.baidu.com")
        URLSession.shared.rx.response(request: URLRequest(url: url!))
            .subscribe(onNext: { (response,data) in
                print(response)
        }).disposed(by: disposeBag)
    }
    
    //MARK: - RxSwift应用-timer定时器
    func setupTimer() {
        timer = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
        timer.subscribe(onNext: { (num) in
            print(num)
        })
        .disposed(by: disposeBag)
    }
    
    //MARK: - 通知
    func setupNotification(){
        NotificationCenter.default.rx.notification(UIResponder.keyboardWillShowNotification)
            .subscribe(onNext: { (noti) in
                print(noti)
            })
        .disposed(by: disposeBag)
        
    }
    
    //MARK: - 手势
    func setupGestureRecognizer(){
        let tap = UITapGestureRecognizer()
        self.label.addGestureRecognizer(tap)
        self.label.isUserInteractionEnabled = true
        tap.rx.event.subscribe(onNext: { (tap) in
            print(tap.view)
        })
        .disposed(by: disposeBag)
    }
    
    //MARK: - RxSwift应用-scrollView
    func setupScrollerView() {
        scrollView.rx.contentOffset
            .subscribe(onNext: { [weak self](content) in
                self?.view.backgroundColor = UIColor.init(red: content.y/255*0.8, green: content.y/255*0.6, blue: content.y/255*0.3, alpha: 1)
            })
        .disposed(by: disposeBag)
    }
    
    //MARK: - RxSwift应用-textfiled
    func setupTextFiled() {
        self.textFiled.rx.text.orEmpty
            .subscribe(onNext: { (text) in
               print(text)
            })
            .disposed(by: disposeBag)
    }
    
    //MARK: - RxSwift应用-button响应
    func setupButton() {
        self.button.rx.tap
            .subscribe(onNext: { () in
                print("点击来了")
            })
            .disposed(by: disposeBag)
    }
    
    //MARK: - RxSwift应用-KVO
    func setupKVO() {
        self.person.rx.observeWeakly(String.self, "name")
            .subscribe(onNext: { (value) in
                print(value as Any)
            })
            .disposed(by: disposeBag)
    }

（三）RxSwift核心逻辑

RxSwift核心流程如下

整个流程大致分为三步

创建序列create
订阅序列subscribe
发送信号onNext

3.1 创建序列

注意： 下面的代码示例是经过删减的，只保留主要的方法逻辑

调用如下代码创建私有类AnonymousObservable，保存外部的闭包为self._subscribeHandler

extension ObservableType {
    public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
        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
    }
    
    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)
    }
}

final private class AnonymousObservableSink<O: ObserverType>: Sink<O>, ObserverType {
    func run(_ parent: Parent) -> Disposable {
        return parent._subscribeHandler(AnyObserver(self))
    }
}

继承关系如下 AnonymousObservable -> Producer -> Observable -> ObservableType
ObservableType协议中定义的subscribe方法由Producer实现

final private class AnonymousObservable<Element>: Producer<Element> {

}

class Producer<Element> : Observable<Element> {
    override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        let sinkAndSubscription = self.run(observer, cancel: disposer)
    }
}

public class Observable<Element> : ObservableType {

}

public protocol ObservableType : ObservableConvertibleType {
    func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E
}

3.2 订阅序列subscribe

调用subscribe创建 AnonymousObserver；
AnonymousObserver保存外部的eventHandler；
subscribe中的Disposables调用self.asObservable().subscribe(observer)时，走上面的AnonymousObservable调用父类Producer的subscribe实现流程

extension ObservableType {
        public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> 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
            )
    }
}

final class AnonymousObserver<ElementType> : ObserverBase<ElementType> {
    typealias Element = ElementType
    typealias EventHandler = (Event<Element>) -> Void
    private let _eventHandler : EventHandler
    
    init(_ eventHandler: @escaping EventHandler) {
        self._eventHandler = eventHandler
    }

    override func onCore(_ event: Event<Element>) {
        return self._eventHandler(event)
    }
}

3.3 发送信号onNext

调用ObserverType协议的OnNext，onNext调用子类ObserverBase的self.on;
ObserverBase.on调用子类AnonymousObserver的self.onCore事件
AnonymousObserver.onCore调用self._eventHandler，该事件即为创建AnonymousObserver时的订阅事件

AnonymousObserver继承关系如下 AnonymousObserver -> ObserverBase -> Disposable,ObserverType

extension ObserverType {
    public func onNext(_ element: E) {
        self.on(.next(element))
    }
}

class ObserverBase<ElementType> : Disposable, ObserverType {
    typealias E = ElementType
    func on(_ event: Event<E>) {
        switch event {
        case .next:
            self.onCore(event)
    }

    func onCore(_ event: Event<E>) {
        rxAbstractMethod()
    }
}

final class AnonymousObserver<ElementType> : ObserverBase<ElementType> {
    typealias Element = ElementType
    typealias EventHandler = (Event<Element>) -> Void
    private let _eventHandler : EventHandler
    
    init(_ eventHandler: @escaping EventHandler) {
        self._eventHandler = eventHandler
    }

    override func onCore(_ event: Event<Element>) {
        return self._eventHandler(event)
    }
}

至此，完整流程走完，里面还有很多细节需要细致分析，后面一篇将细致分析RxSwift流程

函数响应式编程思想&RxSwift核心逻辑