一、函數(shù)響應式編程思想
（一）概念
這里借用百度百科的官方定義
函數(shù)式編程是種編程方式，它將電腦運算視為函數(shù)的計算。函數(shù)編程語言最重要的基礎是λ演算（lambda calculus），而且λ演算的函數(shù)可以接受函數(shù)當作輸入（參數(shù)）和輸出（返回值）。
簡言之，即將一個函數(shù)作為另一個函數(shù)的輸入或者輸出參數(shù)
（二）示例
當我們使用函數(shù)時，一般使用形如y = f(x)的結(jié)構(gòu)，x為自變量，y為因變量。
函數(shù)式是將x轉(zhuǎn)化為一個函數(shù)f(x)，那么就形成了如下的表達式
y = f(f(x))
f(x)為自變量，y為因變量
（三）與其他編程方式的差異
和指令式編程相比，函數(shù)式編程強調(diào)函數(shù)的計算比指令的執(zhí)行重要。
和過程化編程相比，函數(shù)式編程里函數(shù)的計算可隨時調(diào)用。
二、RxSwift核心邏輯
（一）RxSwift介紹
RxSwift 是 ReactiveX 家族的重要一員, ReactiveX 是 Reactive Extensions 的縮寫，一般簡寫為Rx。
ReactiveX 官方給Rx的定義是，Rx是一個使用可觀察數(shù)據(jù)流進行異步編程的編程接口。
ReactiveX 不僅僅是一個編程接口，它是一種編程思想的突破，它影響了許多其它的程序庫和框架以及編程語言。它拓展了觀察者模式，使你能夠自由組合多個異步事件，而不需要去關(guān)心線程，同步，線程安全，并發(fā)數(shù)據(jù)以及I/O阻塞。
RxSwift 是 Rx 為 Swift 語言開發(fā)的一門函數(shù)響應式編程語言， 它可以代替iOS系統(tǒng)的 Target Action / 代理 / 閉包 / 通知 / KVO …..
同時還提供網(wǎng)絡、數(shù)據(jù)綁定、UI事件處理、UI的展示和更新、多線程……
（二）RxSwift優(yōu)勢
鑒于swift日漸增長的影響力，ios開發(fā)者不可避免的要學習和使用swift這門語言進行編程開發(fā)。而RxSwift對使用swift的幫助有如下幾點：
swift為值類型，在傳值與方法回調(diào)上有影響，RxSwift一定程度上彌補swift的靈活性
RxSwift使得代碼復用性較強，減少代碼量
RxSwift因為聲明都是不可變更，增加代碼可讀性
RxSwift使得更易于理解業(yè)務代碼，抽象異步編程，統(tǒng)一代碼風格
RxSwift使得代碼更易于編寫集成單元測試，增加代碼穩(wěn)定性
（三）RxSwift使用
下面為不同業(yè)務場景下的RxSwift的使用demo
//MARK: - RxSwift應用-網(wǎng)絡請求
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核心流程如下
整個流程大致分為三步
創(chuàng)建序列create
訂閱序列subscribe
發(fā)送信號onNext
3.1 創(chuàng)建序列
- 注意： 下面的代碼示例是經(jīng)過刪減的，只保留主要的方法邏輯
調(diào)用如下代碼創(chuàng)建私有類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))
}
}
繼承關(guān)系如下 AnonymousObservable -> Producer -> Observable -> ObservableType
ObservableType協(xié)議中定義的subscribe方法由Producer實現(xiàn)
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
調(diào)用subscribe創(chuàng)建 AnonymousObserver；
AnonymousObserver保存外部的eventHandler；
subscribe中的Disposables調(diào)用self.asObservable().subscribe(observer)時，走上面的AnonymousObservable調(diào)用父類Producer的subscribe實現(xiàn)流程
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 發(fā)送信號onNext
調(diào)用ObserverType協(xié)議的OnNext，onNext調(diào)用子類ObserverBase的self.on;
ObserverBase.on調(diào)用子類AnonymousObserver的self.onCore事件
AnonymousObserver.onCore調(diào)用self._eventHandler，該事件即為創(chuàng)建AnonymousObserver時的訂閱事件
- AnonymousObserver繼承關(guān)系如下
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)
}
}
至此，完整流程走完，里面還有很多細節(jié)需要細致分析，后面一篇將細致分析RxSwift流程
