一、引序

• 任何序列都可以用 Observable 描述，創(chuàng)建序列 -> 訂閱序列 -> 信號(hào)發(fā)送 -> 信號(hào)接收：

Observable<Any>.create { (observer) -> Disposable inobserver.onNext("信號(hào)1")return Disposables.create()}.subscribe(onNext: { (val) inprint("信號(hào)接收區(qū)：\(val)")}).disposed(by: disposeBag)

• Observable 是通用序列的描述符，調(diào)用 .onNext，.onError，onCompleted 來發(fā)送信號(hào)，通用性強(qiáng)，但針對(duì)特殊需求可能會(huì)覺得繁瑣，因此 RxSwift 還提供了一組特征序列，是 Observable 序列的變種，它能夠更準(zhǔn)確的描述序列，即 Single、Completable、Maybe、Driver、Signal、ControlEvent，binder 等。

二、Single

① Single 的使用

• Single 單元素序列，信號(hào)只發(fā)送一次，響應(yīng)信號(hào)或錯(cuò)誤信號(hào)。
• Single 是 Observable 的另外一個(gè)版本，不像 Observable 可以發(fā)出多個(gè)元素，它要么只能發(fā)出一個(gè)元素，要么產(chǎn)生一個(gè) error 事件。
• Single 發(fā)出一個(gè)元素，或一個(gè) error 事件，不會(huì)共享附加作用。

let singleOB = Single<Any>.create { (single) -> Disposable inprint("singleOB 是否共享")single(.success("good"))single(.error(NSError.init(domain: "com.ydw.cn",code: 10086, userInfo: nil)))return Disposables.create()}singleOB.subscribe { (reslut) inprint("訂閱:\(reslut)")}.disposed(by: disposeBag)// 輸出結(jié)果singleOB 是否共享訂閱:success("good")

• 說明：
• • sinngle(.success(data)) -> onSuccess 發(fā)送響應(yīng)元素到成功觀察者；
• • sinngle(.error(error)) -> error 發(fā)送錯(cuò)誤元素到錯(cuò)誤觀察者。
• 響應(yīng)元素和錯(cuò)誤元素分開處理，此時(shí)可以聯(lián)想到應(yīng)用中的網(wǎng)絡(luò)請(qǐng)求，成功數(shù)據(jù)用來渲染，錯(cuò)誤數(shù)則據(jù)彈出提示框。

② Single 的源碼分析

• Single 定義：定位到 Single.swift 文件，可以看到 Single 是 PrimitiveSequence 結(jié)構(gòu)體類型的別名，SingleEvent 是事件枚舉，有 success 和 error 兩個(gè)成員變量，如下所示：

// Sequence containing exactly 1 elementpublic enum SingleTrait { }// Represents a push style sequence containing 1 element.public typealias Single<Element> = PrimitiveSequence<SingleTrait, Element>public enum SingleEvent<Element> {// One and only sequence element is produced. (underlying observable sequence emits: `.next(Element)`, `.completed`)case success(Element)// Sequence terminated with an error. (underlying observable sequence emits: `.error(Error)`)case error(Swift.Error)}

• Single 的 create 創(chuàng)建序列（1??），如下所示：

extension PrimitiveSequenceType where TraitType == SingleTrait {public typealias SingleObserver = (SingleEvent<ElementType>) -> Void// 此處省略部分代碼......public static func create(subscribe: @escaping (@escaping SingleObserver) -> Disposable) -> Single<ElementType> {let source = Observable<ElementType>.create { observer inreturn subscribe { event inswitch event {case .success(let element):observer.on(.next(element))observer.on(.completed)case .error(let error):observer.on(.error(error))}}} return PrimitiveSequence(raw: source)}}

• 可以看到參數(shù)是一個(gè)帶 Disposable 類型返回值的閉包，交由外部（業(yè)務(wù)層）實(shí)現(xiàn)，內(nèi)部調(diào)用向外傳入一個(gè) SingleObserver 閉包，以上寫法不太好理解，可以換一種寫法：
• • 內(nèi)部實(shí)現(xiàn)一個(gè)閉包 block，用來接收外界傳入的 SingleEvent 信號(hào)，接著做進(jìn)一步的信號(hào)發(fā)送；
• • 調(diào)用外部實(shí)現(xiàn)的閉包方法，將內(nèi)部實(shí)現(xiàn)的閉包 block 發(fā)送出去，起連接作用；
• • 創(chuàng)建 PrimitiveSequence 對(duì)象并保存 Observable 序列對(duì)象 source，返回 PrimitiveSequence 對(duì)象；

public static func create(subscribe: @escaping (@escaping SingleObserver) -> Disposable) -> Single<ElementType> {let source = Observable<ElementType>.create { observer in// 內(nèi)部實(shí)現(xiàn)一個(gè)閉包，用來接收外界傳入的SingleEvent信號(hào)，接著做進(jìn)一步的信號(hào)發(fā)送let block = { (event:SingleEvent<ElementType>) -> Void inswitch event {case .success(let element):observer.on(.next(element))observer.on(.completed)case .error(let error):observer.on(.error(error))}}// 調(diào)用外部實(shí)現(xiàn)的閉包方法，向外部發(fā)送內(nèi)部實(shí)現(xiàn)的閉包方法做連接作用let disposable = subscribe(block) // 返回值Disposable對(duì)象 return disposable}return PrimitiveSequence(raw: source) // 創(chuàng)建PrimitiveSequence對(duì)象并保存Observable序列對(duì)象}

• 在 create 方法內(nèi)部實(shí)際上實(shí)現(xiàn)了一個(gè) Observable 序列，由此可見 Single 序列是對(duì) Observable 序列的封裝，Disposable 對(duì)象通過閉包交由業(yè)務(wù)層創(chuàng)建，Single 序列在實(shí)現(xiàn)上，方式方法與 Observable 保持一致。Observable 序列的信號(hào)傳遞流程，請(qǐng)參考我的博客：RxSwift之深入解析核心邏輯Observable的底層原理。
• 訂閱序列，也是在同 PrimitiveSequenceType 擴(kuò)展中定義（2??），如下：

public func subscribe(onSuccess: ((ElementType) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil) -> Disposable {#if DEBUGlet callStack = Hooks.recordCallStackOnError ? Thread.callStackSymbols : []#elselet callStack = [String]()#endifreturn self.primitiveSequence.subscribe { event inswitch event {case .success(let element):onSuccess?(element)case .error(let error):if let onError = onError {onError(error)} else {Hooks.defaultErrorHandler(callStack, error)}}}}

• 方法中先調(diào)用了 self.primitiveSequence 方法，返回了 self，方法是在遵循 PrimitiveSequenceType 協(xié)議的 PrimitiveSequence 的擴(kuò)展中，為了保證協(xié)議的一致性，如下所示：

extension PrimitiveSequence: PrimitiveSequenceType {// Additional constraintspublic typealias TraitType = Trait// Sequence element typepublic typealias ElementType = Element// Converts `self` to primitive sequence.//// - returns: Observable sequence that represents `self`.public var primitiveSequence: PrimitiveSequence<TraitType, ElementType> {return self}}

• 接著調(diào)用另一個(gè) subscribe 方法（3??），self.primitiveSequence -> asObservable() -> subscribe，此處截?cái)嗔?completed 信號(hào)的向上傳遞，因此 Single 序列只能收到響應(yīng)信號(hào)和錯(cuò)誤信號(hào)，如下：

public func subscribe(_ observer: @escaping (SingleEvent<ElementType>) -> Void) -> Disposable {var stopped = falsereturn self.primitiveSequence.asObservable().subscribe { event inif stopped { return }stopped = trueswitch event {case .next(let element):observer(.success(element))case .error(let error):observer(.error(error))case .completed:rxFatalErrorInDebug("Singles can't emit a completion event")}}}

• subscribe 方法也調(diào)用了 self.primitiveSequence 方法，接著調(diào)用 asObservable() 方法，查看代碼發(fā)現(xiàn)此處是為了獲取 source 對(duì)象，即 Observable 可觀察序列。再查看 subscribe 的方法（4??）：

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

• 代碼創(chuàng)建了一個(gè)觀察者，當(dāng)前觀察者將會(huì)收到發(fā)送過來的消息，并由此通過閉包一層層傳到業(yè)務(wù)層：4?? -> 3?? -> 2?? -> 1?? ->業(yè)務(wù)層；
• 當(dāng)前 self 指向的是1??處創(chuàng)建并保存的 Observable 類型的 source 對(duì)象，因此該處 subscribe 所調(diào)用的即是 Produce 類中的 subscribe 方法，在方法內(nèi)部創(chuàng)建了 sink 對(duì)象，來觸發(fā)創(chuàng)建序列時(shí)實(shí)現(xiàn)的閉包，即代碼1??處所 create 后的閉包；
• 此時(shí)就到了業(yè)務(wù)層，通過 create 內(nèi)部實(shí)現(xiàn)的閉包 single 向內(nèi)部發(fā)送消息，再有 observer 調(diào)用 on 來向觀察者發(fā)送信號(hào)；
• 信號(hào)發(fā)送不做贅述，最終會(huì)到達(dá)4??處代碼的觀察者，此時(shí)再由閉包一層層向上傳遞，直到業(yè)務(wù)層的監(jiān)聽閉包。
• 序列的產(chǎn)生，訂閱，發(fā)送，接收還是由 Observable 來實(shí)現(xiàn)的，Single 只是對(duì) Observable 做了封裝，去除了 onCompleted 的消息監(jiān)聽及消息發(fā)送。

三、Completable

• Completable 是 Observable 的另外一個(gè)版本，不像 Observable 可以發(fā)出多個(gè)元素，它要么只能產(chǎn)生一個(gè) completed 事件，要么產(chǎn)生一個(gè) error 事件：
• • 發(fā)出零個(gè)元素；
• • 發(fā)出一個(gè) completed 元素，或一個(gè) error 事件；
• • 不會(huì)共享附加作用；
• Completable 只能產(chǎn)生 completed 事件和 error 事件，沒有序列元素值產(chǎn)生。適用于只關(guān)心任務(wù)是否完成，而不需要在意任務(wù)返回值的情況，它和 Observable 有點(diǎn)相似。

let completableOB = Completable.create { (completable) -> Disposable inprint("completableOB 是否共享")completable(.completed)completable(.error(NSError.init(domain: "com.ydw.cn",code: 10086, userInfo: nil)))return Disposables.create()}completableOB.subscribe { (reslut) inprint("訂閱:\(reslut)")}.disposed(by: disposeBag)// 輸出結(jié)果completableOB 是否共享訂閱:completed

• 在 Competable.swift 下，在 PrimitiveSequenceType 擴(kuò)展中實(shí)現(xiàn)了序列的創(chuàng)建和訂閱，即信號(hào)轉(zhuǎn)發(fā)。Competable 的定義如下：

// Sequence containing 0 elementspublic enum CompletableTrait { }// Represents a push style sequence containing 0 elements.public typealias Completable = PrimitiveSequence<CompletableTrait, Swift.Never>public enum CompletableEvent {// Sequence terminated with an error. (underlying observable sequence emits: `.error(Error)`)case error(Swift.Error)// Sequence completed successfully.case completed}

• 同樣，Completable 類也是 PrimitiveSequence 的別名，并聲明一個(gè)枚舉包含，error 和 completed 成員變量，限定了事件產(chǎn)生類型，都是對(duì) Observable 序列的封裝，和 Single 一致，只是在訂閱階段對(duì) .next 事件做了攔截。

四、Maybe

• Maybe 是 Observable 的另外一個(gè)版本，它介于 Single 和 Completable 之間，它要么只能發(fā)出一個(gè)元素，要么產(chǎn)生一個(gè)completed 事件，要么產(chǎn)生一個(gè) error 事件。
• • 發(fā)出一個(gè)元素或者一個(gè) completed 事件或者一個(gè) error 事件；
• • 不會(huì)共享附加作用。
• 如果可能需要發(fā)出一個(gè)元素，又可能不需要發(fā)出時(shí)，就可以使用 Maybe。

let maybeOB = Maybe<Any>.create { (maybe) -> Disposable inprint("maybe 是否共享")maybe(.success("A"))maybe(.completed)maybe(.error(NSError.init(domain: "com.ydw.cn",code: 10086, userInfo: nil)))return Disposables.create()}maybeOB.subscribe { (reslut) inprint("訂閱:\(reslut)")}.disposed(by: disposeBag)// 輸出結(jié)果maybe 是否共享訂閱:success("A")

五、Driver

① Driver 使用

• Driver 是一個(gè)精心準(zhǔn)備的特征序列，它主要是對(duì)需要在 UI 上做出響應(yīng)的序列進(jìn)行了封裝，簡(jiǎn)化 UI 層的代碼。不過如果遇到的序列具有以下特征，也可以使用它：
• • Driver 序列不會(huì)產(chǎn)生 error 事件；
• • 在主線程中監(jiān)聽（一定要在 MainScheduler 中），會(huì)向新訂閱者發(fā)送上次發(fā)送過的元素，簡(jiǎn)化 UI 層的代碼；
• • 共享序列。

let result = self.textFiled.rx.text.orEmpty.asDriver() // 普通序列轉(zhuǎn)化.throttle(.milliseconds(500)).flatMap {self.dealwithData(inputText: $0).asDriver(onErrorJustReturn: "檢測(cè)到錯(cuò)誤")}// 綁定到label上面result.map { "長(zhǎng)度:\(($0 as! String).count)" }.drive(self.label.rx.text).disposed(by: disposeBag)// 綁定到button上面result.map { ($0 as! String) }.drive(self.btn.rx.title()).disposed(by: disposeBag)

• 說明：
• • asDriver() 將序列轉(zhuǎn)換為 Driver 序列；
• • map 重新組合并生成新的序列；
• • driver 將元素在主線程中綁定到 label 和 button 上。
• 相比非 driver 下的代碼實(shí)現(xiàn)，Driver 序列省去了線程的設(shè)置，share 數(shù)據(jù)共享設(shè)置。

② Driver 的源碼分析

• 查看 asDriver() 方法，是 ControlProperty 的擴(kuò)展方法，返回了一個(gè)Driver類：

extension ControlProperty {// Converts `ControlProperty` to `Driver` trait.//// `ControlProperty` already can't fail, so no special case needs to be handled.public func asDriver() -> Driver<E> {return self.asDriver { _ -> Driver<E> in#if DEBUGrxFatalError("Somehow driver received error from a source that shouldn't fail.")#elsereturn Driver.empty()#endif}} }

• Driver 是 SharedSequence 的別名，用來描述不同類型的序列，最后又調(diào)用了 asDriver 方法，而該方法在 ObservableConvertibleType 的擴(kuò)展中，一直追蹤會(huì)發(fā)現(xiàn)很多類都是繼承自 ObservableConvertibleType 下：

extension ObservableConvertibleType {public func asDriver(onErrorRecover: @escaping (_ error: Swift.Error) -> Driver<E>) -> Driver<E> {let source = self.asObservable().observeOn(DriverSharingStrategy.scheduler).catchError { error inonErrorRecover(error).asObservable()}return Driver(source)}}

• 如上，代碼也設(shè)置了 observerOn 方法，來指定線程，繼續(xù)深入能夠發(fā)現(xiàn) DriverSharingStrategy.scheduler 內(nèi)部指定的就是主線程，印證了上面所說的 Driver 的執(zhí)行是在主線程的，最后初始化一個(gè) Driver 對(duì)象返回，看一下初始化過程，及對(duì) SharedSequence 類的初始化，代碼如下：

public struct SharedSequence<S: SharingStrategyProtocol, Element> : SharedSequenceConvertibleType {public typealias E = Elementpublic typealias SharingStrategy = Slet _source: Observable<E>init(_ source: Observable<E>) {self._source = S.share(source)}}

• 此處調(diào)用了 share 并傳入了可觀察序列，感覺好像在哪見過，此處猜想它是用來共享序列的，使用 lldb：po S.self 查找 share 所在位置：RxCocoa.DriverSharingStrategy，cmd + 點(diǎn)擊進(jìn)入，代碼如下：

public typealias Driver<E> = SharedSequence<DriverSharingStrategy, E>public struct DriverSharingStrategy: SharingStrategyProtocol {public static var scheduler: SchedulerType { return SharingScheduler.make() }public static func share<E>(_ source: Observable<E>) -> Observable<E> {return source.share(replay: 1, scope: .whileConnected)}}

• 在此處傳入的序列用來掉用 share，使得當(dāng)前序列作為共享序列，即 driver 序列為共享序列。

六、Signal

• Signal 和 Driver 相似，唯一的區(qū)別是，Driver 會(huì)對(duì)新觀察者回放（重新發(fā)送）上一個(gè)元素，而 Signal 不會(huì)對(duì)新觀察者回放上一個(gè)元素。
• • 不會(huì)產(chǎn)生 error 事件；
• • 一定在 MainScheduler 監(jiān)聽（主線程監(jiān)聽）；
• • 會(huì)共享附加作用。

let result = self.textFiled.rx.text.orEmpty.asSignal(onErrorJustReturn: "沒有值") // 普通序列轉(zhuǎn)化為signle.throttle(.milliseconds(500)).flatMap {self.dealwithData(inputText: $0).asSignal(onErrorJustReturn: "檢測(cè)到錯(cuò)誤")}// 綁定到label上面result.map { "長(zhǎng)度:\(($0 as! String).count)" }.emit(to: self.label.rx.text).disposed(by: disposeBag)// 綁定到button上面result.map { ($0 as! String) }.emit(to: self.btn.rx.title()).disposed(by: disposeBag)

• 說明：
• • catchErrorJustReturn(onErrorJustReturn) 保證了無錯(cuò)誤信號(hào)；
• • observeOn(DriverSharingStrategy.scheduler) 保證了調(diào)度環(huán)境在主線程；
• • source.share(scope: .whileConnected) 序列狀態(tài)共享。

七、ControlEvent

• ControlEvent: 專門用于描述 UI 控件所產(chǎn)生的事件，它具有以下特征：
• • 不會(huì)產(chǎn)生 error 事件；
• • 一定在 MainScheduler 訂閱（主線程訂閱）；
• • 一定在 MainScheduler 監(jiān)聽（主線程監(jiān)聽）；
• • 會(huì)共享附加作用。

let controlEventOB = button.rx.controlEvent(.touchUpInside)controlEventOB.subscribe { (reslut) inprint("訂閱:\(reslut) \n \(Thread.current)")}.disposed(by: disposeBag)controlEventOB.subscribe { (reslut) inprint("訂閱:\(reslut) \n \(Thread.current)")}.disposed(by: self.disposeBag)

• 監(jiān)聽點(diǎn)擊事件：

let event : ControlEvent<Void> = button.rx.tap.asControlEvent()event.bind(onNext: {print("controllerEvent")}).disposed(by: disposeBag)

• 監(jiān)聽點(diǎn)擊事件并綁定數(shù)據(jù)到其他 UI：

let event : ControlEvent<Void> = button.rx.tap.asControlEvent()event.map{"yahibo"}.bind(to: label1.rx.text).disposed(by: disposeBag)

八、binder

• 不會(huì)處理錯(cuò)誤事件；
• 確保綁定都是在給定 Scheduler 上執(zhí)行（默認(rèn) MainScheduler）；
• 一旦產(chǎn)生錯(cuò)誤事件，在調(diào)試環(huán)境下將執(zhí)行 fatalError，在發(fā)布環(huán)境下將打印錯(cuò)誤信息。

let observer : AnyObserver<Bool> = AnyObserver { (event) inprint("observer當(dāng)前線程:\(Thread.current)")switch event{case .next(let isHidden) :print("label的狀態(tài)")self.label.isHidden = isHiddencase .error(let error) :print("\(error)")case .completed :print("完成")}}let binder = Binder<Bool>(self.label) { (lab, isHidden) inprint("Binder當(dāng)前線程:\(Thread.current)")lab.isHidden = isHidden}let observable = Observable<Bool>.create { (ob) -> Disposable inob.onNext(true)ob.onError(NSError.init(domain: "com.ydw.cn", code: 10086, userInfo: nil))ob.onCompleted()return Disposables.create()}.observeOn(ConcurrentDispatchQueueScheduler(queue: DispatchQueue.global()))// observable.bind(to: observer).disposed(by: self.disposeBag)observable.bind(to: binder).disposed(by: self.disposeBag)

• RxSwift 里面也封裝了很多的 binder，開發(fā)使用很直接：

extension Reactive where Base: UIButton {// Reactive wrapper for `setTitle(_:for:)`public func title(for controlState: UIControl.State = []) -> Binder<String?> {return Binder(self.base) { button, title -> Void inbutton.setTitle(title, for: controlState)}}// Reactive wrapper for `setImage(_:for:)`public func image(for controlState: UIControl.State = []) -> Binder<UIImage?> {return Binder(self.base) { button, image -> Void inbutton.setImage(image, for: controlState)}}// Reactive wrapper for `setBackgroundImage(_:for:)`public func backgroundImage(for controlState: UIControl.State = []) -> Binder<UIImage?> {return Binder(self.base) { button, image -> Void inbutton.setBackgroundImage(image, for: controlState)}}}

總結(jié)

以上是生活随笔為你收集整理的RxSwift之深入解析场景特征序列的使用和底层实现的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。