RXSwift:Observable的创建和订阅

RxSwift:Observable的创建和订阅

Observable是被观察者，也就是发出事件的事件（信号）源。一个观察者只有订阅了Observable，才能接收Observable发送的事件。Observable极其父类定义了创建一系列信号源的方法，及subscribe方法。

Observable决定了什么时候触发事件，以及触发怎样的事件。

---

在Observable的扩展类里提供了一系列创建被观察对象的工厂化方法。

• never

  创建一个Never序列，该序列不会发出任何事件，也不会终止。

  let disposeBag = DisposeBag()
  let neverSequence = Observable<String>.never()
  _ = neverSequence.subscribe {_ in
      print("This will never be printed")
  }.addDisposableTo(disposeBag)
  
  不会输出任何结果。

• empty

  创建一个Empty序列，该序列只发出completed事件。

  let disposeBag = DisposeBag()
      Observable<Int>.empty().subscribe {
          event in
          print(event)
      }.addDisposableTo(disposeBag)
  
  输出：
  completed

• error

  创建一个错误的序列，该序列以’error’事件终止。

  let disposeBag = DisposeBag()
      Observable<Int>.error(TestError.test)
          .subscribe { print($0) }
          .addDisposableTo(disposeBag)
  
  输出：
  error(test)

• just

  创建一个Just序列，该序列只包含一个元素。

  let disposeBag = DisposeBag()
  Observable.just("1").subscribe { event in
              print(event)
          }.addDisposableTo(disposeBag)
  
  输出：
  next(1)
  completed

• of

  创建一个新的被观察序列的对象，它包含可变数量的元素。

  let disposeBag = DisposeBag()
  Observable.of("1", "2", "3", "4").subscribe(onNext: { element in
       print(element)
  }).addDisposableTo(disposeBag)
  
  输出：
  1
  2
  3
  4

• from

  通过数组来创建一个被观察序列。

  let disposeBag = DisposeBag()
  Observable.from(["1", "2", "3", "4"]).subscribe(onNext: { print($0) }).addDisposableTo(disposeBag)
  
  输出：
  1
  2
  3
  4

• range

  在指定范围内生成一个被观察的整数序列，发出事件n次。

  let disposeBag = DisposeBag()
  Observable.range(start: 1, count: 10).subscribe { print($0) }.addDisposableTo(disposeBag)
  
  输出：
  next(1)
  next(2)
  next(3)
  next(4)
  next(5)
  next(6)
  next(7)
  next(8)
  next(9)
  next(10)
  completed
  

• repeatElement

  生成一个被观察的序列，重复发出指定元素n次。

  let disposeBag = DisposeBag()
  Observable.repeatElement("1")
  .take(3)
  .subscribe(onNext: { print($0) })
  .addDisposableTo(disposeBag)
  
  输出：
  1
  1
  1

• generate

  创建一个被观察的序列，只要提供的条件为真，就发出状态值。

  let disposeBag = DisposeBag()
  Observable.generate(
             initialState: 0,
             condition: { $0 < 3 },
             iterate: { $0 + 1 }
          )
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)
  
  输出：
  0
  1
  2

• deferred

  为每个订阅事件的观察者都创建一个新的被观察的序列。（一对一的关系）

  let disposeBag = DisposeBag()
      var count = 1
      let deferredSequence = Observable<String>.deferred {
          print("Creating \(count)")
          count += 1
  
          return Observable.create { observer in
              print("Emitting...")
              observer.onNext("1")
              observer.onNext("2")
              observer.onNext("3")
              return Disposables.create()
          }
      }
  
      deferredSequence
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)
  
      deferredSequence
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)
  
      输出：
      Creating 1
      Emitting...
      1
      2
      3
      Creating 2
      Emitting...
      1
      2
      3

• doOn

  在订阅的被观察者的事件执行之前，先执行do后面和要执行的订阅事件对应的方法。

  let disposeBag = DisposeBag()
  Observable.of("1", "2", "3", "4")
            .do(onNext: { print("Intercepted:", $0) }, 
                onError { print("Intercepted error:", $0) },
                onCompleted: { print("Completed")  })
            .subscribe(onNext { print($0) },
                       onCompleted: { print("结束") })
            .addDisposableTo(disposeBag)
  
  输出：
  Intercepted: 1
  1
  Intercepted: 2
  2
  Intercepted: 3
  3
  Intercepted: 4
  4
  Completed
  结束

• create

  通过指定的方法实现来自定义一个被观察的序列。

  let disposeBag = DisposeBag()
  let myJust = { (element: String) -> Observable<String> in
      return Observable.create { observer in  
      observer.on(.next(element))
      observer.on(.completed)
      return Disposables.create()
      }
  }
  myJust("1").subscribe { print($0) }.addDisposableTo(disposeBag)
  
  输出：
  next(1)
  completed

---

subscribe的实现

subscribe是ObservableType中定义的方法，并在ObservableType的extension中实现该方法，提供了两种实现：

• 只能订阅一个事件处理器，并且不能指定订阅的是哪一个事件（never/empty/just/error）

public func subscribe(_ on: @escaping (Event<E>) -> Void) -> Disposable {
    let observer = AnonymousObserver { e in
        on(e)
    }

    return self.subscribeSafe(observer)
}

• 可订阅多个事件处理器

public func subscribe(file: String = #file, line: UInt = #line, function: String = #function, 
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()
    }

    let observer = AnonymousObserver<E> { e in
        switch e {
        case .next(let value):
            onNext?(value)
        case .error(let e):
            if let onError = onError {
                onError(e)
            } else {
                print("Received unhandled error: \(file):\(line):\(function) -> \(e)") 
            }
            disposable.dispose()
        case .completed:
            onCompleted?()
            disposable.dispose()
        }
    }

    return Disposables.create( self.subscribeSafe(observer),disposable)
}

---

Tips:

1、Observable有个隐含规定，就是在一个信号处理完成之前，不会发送下一个信号，不管发送信号的线程是并发的还是串行的。