一、RxSwift中心

1、observable可调查序列

创立一个工程RxSwift01 装备对应的podfile文件：

# Uncomment the next line to define a global platform for your project
# platform :ios, '9.0'
target 'RxSwift01' do
  # Comment the next line if you're not using Swift and don't want to use dynamic frameworks
  use_frameworks!
  pod 'RxSwift'
  pod 'RxCocoa'
  # Pods for RxSwift01
end
//在终端履行
pod install

中心问题：
什么是observable可调查序列呢？

当可调查序列（Observable）发送数据项或数据项序列时调查者得到触发。这种形式促进了并发操作，因为调查者等候发送数据项的过程中无需阻塞，而是为调查者创立一个岗兵，在可调查序列发送数据项时主动触发相应的行为。

observable可调查序列又分：有限序列和无限序列。

咱们通过代码来剖析：

//无限的
let ob = Observable<Int>.timer(.seconds(1), period: .seconds(2), scheduler: MainScheduler.instance)
ob.subscribe {num in
    print(num)
} onCompleted:{
  print("done")
}
.disposed(by: disposeBag)
//有限的
let ob1 = Observable.from([1,2,4,3])  //Observable.of(1,2,3,4) 都能到达意图
ob1.subscribe { num in
    print(num)
} onCompleted: {
    print("dnoe")
}.disposed(by: disposeBag)

运转有限序列：

iOS探索RxSwift核心

Observable创立：\

  1. empty：创立一个空的序列-可是只能订阅到comlete
  2. just：构建一个只需一个元素的Observable行列 – 订阅完信息主动complete
  3. of：创立一个固定数量元素的Observable序列
  4. from：从一个序列（如Array/Dictionary/Set）中创立一个Observable序列。
  5. deferred：为每个订阅者创立一个新的Observable序列
  6. generate：创立一个Observable序列，只需供给的条件值为true就可以生成值。
  7. error：创立一个不会发送任何条目并且当即停止过错的Observable序列
  8. range：创立一个Observable序列，它会宣布一个系列连续的整数，然后停止
  9. timer：获取计时器Observable序列
  10. interval：底层便是封装timer

所以RxSwift也有三部曲：创立，订阅，注销。

        //1.创立序列
    let ob = Observable<Any>.create { observable in
      // 3.发送信号
      observable.onNext("班长")
      observable.onError(NSError.init(domain: "myError", code: 10080, userInfo: nil))
      return Disposables.create()
    }
    //2.订阅信号
    ob.subscribe { text in
      print("订阅到了：\(text)")
    } onError: { error in
      print("error：\(error)")
    } onCompleted: {
      print("完成")
    } onDisposed: {
      print("毁掉")
    }

运转成果：

iOS探索RxSwift核心
那么为什么 observable.onNext(“班长”) 会响应到订阅中？

其实咱们在第三步发送信号的时候，发送了3种信号，onNext，onError，Disposables 被Observable 别离接收了。

2、中心三部曲剖析

  1. Observable<Any>.create其实是实现了 AnonymousObservable 匿名序列闭包->承继Producer->承继Observable->实现ObservableType 协议

  2. 订阅序列：subscribe ->创立一个AnonymousObservable订阅者->保存eventHandler->self.asObservable().subscribe(observer)->producer.subscribe->AnonymousObservableSink.run->parent.subscrbeHandler(AnyObserver(self))

  3. 发送信号：onNext->AnonymousObservable.onNext->ObserverBase.on[.next->.onCore .err\completed]->AnonymousObservable.onCore->self.eventHandler(event)

AnonymousObservableSink 中心代码:

final private class AnonymousObservableSink<Observer: ObserverType>: Sink<Observer>, ObserverType {
  typealias Element = Observer.Element
  typealias Parent = AnonymousObservable<Element>
  // state
  private let isStopped = AtomicInt(0)
    //-------------省掉--------------
  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 {
    parent.subscribeHandler(AnyObserver(self))
  }
}

中心流程图：

iOS探索RxSwift核心

3、序列承继链

先看一个小比如：

/**
    * 当用户输入用户名时，如果用户名缺乏 5 个字就给出赤色提示语，并且无法输入暗码，当用户名符合要求时才可以输入暗码。
    * 相同的，当用户输入的暗码缺乏 6 个字时也给出赤色提示语。当用户名和暗码有一个不符合要求时底部的登录按钮不可点击，只需当用户名和暗码一起有用时按钮才可点击。
    * 当点击登录按钮后弹出一个提示框，这个提示框仅仅用来做演示而已。
    */
    let usernameValid = usernameTextFiled.rx.text.orEmpty
      .map { text in
        return text.count >= minUsernameLength
      }
//    Binder
    usernameValid.bind(to: usernameValidLabel.rx.isHidden)
      .disposed(by: disposeBag)
    usernameValid.bind(to: passwordTextFiled.rx.isEnabled)
      .disposed(by: disposeBag)
    let passwordValid = passwordTextFiled.rx.text.orEmpty
      .map { text in
        return text.count >= minPasswordLength
      }
    passwordValid.bind(to: passwordValidLabel.rx.isHidden)
      .disposed(by: disposeBag)
    Observable.combineLatest(usernameValid, passwordValid) { $0 && $1 }
      .bind(to: loginBtn.rx.isEnabled)
      .disposed(by: disposeBag)
    loginBtn.rx.tap.subscribe { _ in
      print("登录")
    }.disposed(by: disposeBag)

运转效果:

iOS探索RxSwift核心
AnonymousObservable->producer(生产者)->Observable->遵循ObservableType协议 (不想贴过多的代码，能了解多少写多少)

总结

  1. 创立序列:一起创立匿名的AnonymousObservable（承继了Producer）实例_able，并保存闭包
  2. 订阅序列:Producer.subscribe创立一个_ob闭包，一起创立了AnonymousObserver(订阅者)实例_ob,并保存闭包
  3. 创立一个AnonymousObservableSink实例sink，存储了_ob
  4. sink履行run办法，调用了_able闭包, 一起创立一个AnyObserver实例anyOb-保存了sink的on办法
  5. 当_able闭包中发送信号.next .error .completed等，等于anyOb调用了on，最终回到_ob的onCore办法
  6. 履行AnonymousObserver.onCore办法，便是履行_ob闭包，根据事件类型回调咱们的订阅闭包