作為一個iOS開發(fā)者，Swift語言已經(jīng)成為了標配，要想在蘋果生態(tài)里生存下去，不得不掌握這門語言。
Rx家族是一個非常牛逼的家族，相信是個程序員都知道這個家族，從今天開始，慢慢的更新文章，帶著大家一起小試牛刀一下RxSwift。

RxSwift.png

通過幾個例子 體現(xiàn)一下RxSwift的逼格有多高

------Button

添加事件:

 button.addTarget(self, action:#selector(clickButton) , for: .touchUpInside)

實現(xiàn)事件:

@objc func clickButton(){
     print("點了按鈕")
 }

直接用RxSwift來實現(xiàn)：

button.rx.tap
    .subscribe(onNext: { [weak self]() in
        print("進來了")
    }, onError: nil, onCompleted: nil)
.disposed(by: disposeBag)

默認就是實現(xiàn)touchUpInside事件，如果是想實現(xiàn)其他事件，舉例touchUpOutside事件：

button.rx.controlEvent(.touchUpOutside)
     .subscribe(onNext: { () in
          print("點擊了按鈕外面")
     })
.disposed(by: disposeBag)

------UITextField

原生的如果想監(jiān)聽某個textField變化后賦值給其他控件，比較繁瑣，需要實現(xiàn)textField的代理事件等方法，下面看下RxSwift如何簡單方便的實現(xiàn)

textField.rx.text.orEmpty
     .subscribe(onNext: { [weak self](text) in
          self?.showLabel.text=text
     })
 .disposed(by: disposeBag)

甚至可以更簡練：

textField.rx.text
     .bind(to: self.showLabel.rx.text)
     .disposed(by: disposeBag)

------KVO

原生的代碼就像下面如此的繁瑣，如果發(fā)現(xiàn)監(jiān)聽不到，Swift里面需要監(jiān)聽的屬性需要這樣:

@objc dynamic var name:String="小狗" //添加 @objc dynamic  前綴

// 添加監(jiān)聽的key
self.animal.addObserver(self, forKeyPath: "name", options: .new, context: nil)
// 監(jiān)聽的值變化的回調(diào)
override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
        print("監(jiān)聽到變化了")
        print(change as Any)
    }
// 釋放
deinit {
        self.removeObserver(self.animal, forKeyPath: "name", context: nil)
    }

如果使用RxSwift看看有多么簡單粗暴，原來需要寫在3個地方的代碼，全部一個閉包搞定?。?！

self.animal.rx.observeWeakly(String.self, "name")
      .subscribe(onNext: { (value) in
          print(value as Any)
      })
.disposed(by: disposeBag)

舉了這幾個例子，是不是發(fā)現(xiàn)如果使用RxSwift會上癮?。。?/p>

如何做到萬物皆Rx的...

點進去直接看源碼：

/// A type that has reactive extensions.
public protocol ReactiveCompatible {

    /// Extended type
    associatedtype ReactiveBase

    @available(*, deprecated, message: "Use `ReactiveBase` instead.")
    typealias CompatibleType = Self.ReactiveBase

    /// Reactive extensions.
    static var rx: RxSwift.Reactive<Self.ReactiveBase>.Type { get set }

    /// Reactive extensions.
    var rx: RxSwift.Reactive<Self.ReactiveBase> { get set }
}

直接來到最后幾行：
/// Extend NSObject with `rx` proxy.
extension NSObject : ReactiveCompatible {
}

NSObject遵循了ReactiveCompatible協(xié)議，所以NSObject及其子類都可以 .rx ...而NSObject又是基類所以萬物皆Rx了。

// UI -> target - event
// 1:創(chuàng)建序列
// AnonymousObservable -> producer.subscriber -> run
// 保存閉包  - 函數(shù)式 保存 _subscribeHandler
//
let ob = Observable<Any>.create { (obserber) -> Disposable in
    // 3:發(fā)送信號
    obserber.onNext("Box走起")
    obserber.onCompleted()
    obserber.onError(NSError.init(domain: "boxError", code: 10086, userInfo: nil))
   return Disposables.create()
 }
// 2:訂閱信號
// AnonymousObserver  - event .next -> onNext()
// _eventHandler
// AnonymousObservable._subscribeHandler(observer)
// 銷毀
let _ = ob.subscribe(onNext: { (text) in
            print("訂閱到:\(text)")
        }, onError: { (error) in
            print("error: \(error)")
        }, onCompleted: {
            print("完成")
        }) {
            print("銷毀")
        }

這是一個簡單的序列產(chǎn)生和訂閱的過程。
Observable實質(zhì)上就是一個Sequence。序列分為有窮序列和無窮序列，主要就是用來形成一條數(shù)據(jù)流。我們所有的操作產(chǎn)生的數(shù)據(jù)都會通過Observable傳輸。Observable<T> 稱為可觀察序列。可以異步地產(chǎn)生一系列的 Event（事件），即一個 Observable<T> 對象會隨著時間推移不定期地發(fā)出 event(element : T) 。

create.png

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<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == Element {
        let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
        let subscription = sink.run(self)
        return (sink: sink, subscription: subscription)
    }
}

final private class AnonymousObservableSink<Observer: ObserverType>: Sink<Observer>, ObserverType {
    typealias Element = Observer.Element 
    typealias Parent = AnonymousObservable<Element>

    // state
    private let _isStopped = AtomicInt(0)

    #if DEBUG
        fileprivate let _synchronizationTracker = SynchronizationTracker()
    #endif

    override init(observer: Observer, cancel: Cancelable) {
        super.init(observer: observer, cancel: cancel)
    }

    func on(_ event: Event<Element>) {
        #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類。在AnonymousObservable源碼里可以看到創(chuàng)建了保存了回調(diào)的序列AnonymousObservable。

1. 當序列被訂閱的時候會調(diào)用父類Producer的subscribe方法
2. 調(diào)用self的run方法
3. 創(chuàng)建AnonymousObservableSink同時將訂閱者observer傳進去
4. 調(diào)用AnonymousObservableSink實例的run
5. 調(diào)用AnonymousObservable的_subscribeHandler閉包，參數(shù)就是保存了所有事件的observer

你我互不分離.png