天天看點
傳回

Observable①可被監聽的序列-概念②訂閱 Observable③Observable 事件監聽④Observable 的Dispose

  • ①可被監聽的序列-概念
  • ②訂閱 Observable
  • ③Observable 事件監聽
  • ④Observable 的Dispose

①可被監聽的序列-概念

❶Observable了解

  • Observable<T> 類

     用于描述元素異步産生的序列，既可觀察序列，是 Rx 架構的基礎

  • 作用是

     :異步地産生一系列的

    Event

     （事件），即一個

    Observable<T>

     對象會随着時間推移不定期地發出

    event(element : T)
  • Event 還可以攜帶資料，它的泛型

    <T>

     就是用來指定這個 Event 攜帶的資料的類型
  • 每一個Observable的執行個體都是一個序列
  • Observable序列相比于Swift序列的關鍵優勢點在于它能夠

    異步地接收元素
  • 有可觀察序列，還需要一個

    Observer

     （訂閱者）來訂閱它，這個訂閱者才能收到

    Observable<T>

     不時發出的 Event
Observable(ObservableType) 等效于Sequence
observableType.subscribe(_:) 方法等效于Sequence.makeIterator()
ObservableType.subscribe(_:) 接收一個觀察者ObserverType參數,它将被訂閱自動接收由可觀察到的序列事件和元素，而不是在傳回的生成器上手動調用next()
  • 如果一個Observable發出一個next事件(Event.next(Element)),它還能夠繼續發出更多的事件
  • 如果一個Observable發出一個error事件(Event.error(ErrorType))或者一個completed事件(Event.completed)，那麼這個Observable序列就不能給訂閱者發送其他的事件了

❷建立序列

架構已經建立好了許多常用的序列。例如：

button

 的點選，

textField

 的目前文本，

switch

 的開關狀态，

slider

的目前數值等等

一些自定義的序列是需要自己建立的

  • 建立序列最直接的方法就是調用

    Observable.create
建立一個 [0, 1, ... 4] 的序列
  • 調用

    Observable.create

     ，在建構函數裡面描述元素的産生過程

  • observer.onNext(0)

     就代表産生了一個元素，他的值是 0
  • 又産生 4個元素分别是

    1, 2, ... 4
  • 最後，用

    observer.onCompleted()

     表示元素已經全部産生，沒有更多元素了 
let numbers: Observable<Int> = Observable.create { observer -> Disposable in
      observer.onNext()  
      observer.onNext()
      observer.onNext()
      observer.onNext()
      observer.onNext()
      observer.onCompleted()
     return Disposeable.create()
  }
複制代碼
可以用這種方式來封裝功能元件,例如:閉包回調
  • 在閉包回調中，如果任務失敗，就調用

    observer.onError(error!)
  • 如果擷取到目标元素，就調用

    observer.onNext(jsonObject)
  • 由于這個序列隻有一個元素，是以在成功擷取到元素後，就直接調用

    observer.onCompleted()

     來表示任務結束
  • 最後

    Disposables.create { task.cancel() }

     說明如果資料綁定被清除（訂閱被取消）的話，就取消網絡請求。 
typealias JSON = Any
let json: Observable<JSON> = Observable.create { (observer) -> Disposable in
    let task = URLSession.shared.dataTask(with: ...) { data, , error in
        guard error == nil else {
            observer.onError(error!)
            return
        }
        guard let data = data,
            let jsonObject = try? JSONSerialization.jsonObject(with: data, options: .mutableLeaves)
            else {
            observer.onError(DataError.cantParseJSON)
            return
        }
        observer.onNext(jsonObject)
        observer.onCompleted()
    }
    task.resume()
    return Disposables.create { task.cancel() }
}
複制代碼
以上就将傳統的閉包回調轉換成序列。然後用

subscribe

 方法來響應這個請求的結果 
json.subscribe(
    onNext: { json in
        print("取得 json 成功: \(json)")}, 
    onError: { error in
        print("取得 json 失敗 Error: \(error.localizedDescription)")},
    onCompleted: {
        print("取得 json 任務成功完成")}
    )
    .disposed(by: disposeBag)
複制代碼

❸Event

事件 Event 的定義
  • Event 就是一個枚舉，一個 Observable 是可以發出 3 種不同類型的 Event 事件 
public enum Event<Element>{
    case next(Element)
    case error(Swift.Error)
    case completed
}
複制代碼
next
  • next 事件就是那個可以攜帶資料 的事件，可以說它就是一個“最正常”的事件 
1--2--3--->
複制代碼
error
  • error 事件表示一個錯誤，它可以攜帶具體的錯誤内容，一旦 Observable 發出了 error event，則這個 Observable 就等于終止了，以後它再也不會發出 event 事件了 
-------1-----2------ x  
複制代碼
completed
  • completed：completed 事件表示 Observable 發出的事件正常地結束了，跟 error 一樣，一旦 Observable 發出了 completed event，則這個 Observable 就等于終止了，以後它再也不會發出 event 事件了 
------1 ------2--------3-------|
複制代碼

❹Observable 與 Sequence比較

  • 可以把每一個 Observable 的執行個體想象成于一個 Swift 中的 Sequence
  • 即一個 Observable（ObservableType）相當于一個序列 Sequence（SequenceType）
  • ObservableType.subscribe(_:) 方法其實就相當于 SequenceType.generate()
差別
  • Swift 中的 SequenceType 是同步的循環，而 Observable 是異步的
  • Observable 對象會在有任何 Event 時候，自動将 Event 作為一個參數通過 ObservableType.subscribe(_:) 發出，并不需要使用 next 方法

②訂閱 Observable

  • 有了Observable，還要用 subscribe() 方法來訂閱它，接收它發出的 Event

訂閱方法1

❶使用 subscribe() 訂閱一個 Observable 對象
  • 該方法的 block 的回調參數就是被發出的 event 事件，将其直接列印出來 
let observable = Observable.of("A","B","C")
observable.subscribe { event in
                     print(event)}
//print
next(A)
next(B)
next(C)
completed
複制代碼
❷如果擷取到事件裡的資料，通過 event.element 
let observable = Observable.of("A","B","C")
observable.subscribe{ event in
                    print(eventt.element)}????????????
//print
Optional("A")
Optional("B")
Optional("C")	q
nil
複制代碼

訂閱方法2

RxSwift還提供另一個subscribe 方法，它可以把 event 進行分類
  • 通過不同的 block 回調處理不同類型的 event（其中 onDisposed 表示訂閱行為被 dispose 後的回調）
  • 同時會把 event 攜帶的資料直接解包出來作為參數，友善我們使用 
let observable = Observable("A","B","C")
observable.subscribe(
    onNext:{ element in
              print(element) },
    onError:{error in
            print(error)},
    onCompleted:{
        print("completed")},
    onDisposed:{
        print("disposed")
    }
)
//print
A
B
C
completed
disposed
複制代碼
  • subscribe() 方法的 onNext、onError、onCompleted 和 onDisposed 這四個回調 block 參數都是有預設值的，即它們都是可選的。我們可以隻處理 onNext 而不管其他的情況 
let observable = Observable.of("A","B","C")
observable.subscribe(
   onNext:{element in
          print(element)}
)
//print
A
B
C
複制代碼

③Observable 事件監聽

監聽事件的生命周期

doOn 介紹

使用 doOn 方法來監聽事件的生命周期，它會在每一次事件發送前被調用

同時它和 subscribe 一樣，可以通過不同的 block 回調處理不同類型的 event

  • do(onNext:) 方法就是在 subscribe(onNext:) 前調用
  • 而 do(onCompleted:) 方法則會在 subscribe(onCompleted:) 前面調用
栗子 
let observable = Observable.of("A","B","C")
observable.do(
            onNext: { element in 
                    print("Intercepted Next：", element)},
            onError: {error in
                       print("Intercepted Error：", error)},
            onCompleted: {
                 print("Intercepted Completed")
            },
            onDispose: {
                print("Intercepted Disposed")
            }
            )
           .subscribe(
           onNext: {element in
                   print(element)},
               onError: {error in
                        print(error)},
               onCompleted:{
                   print("completed")},
               onDisposed:{
                   print("disposed")
               }
           )
複制代碼

④Observable 的Dispose

❶Observable 從建立到終結流程

一個 Observable 序列被建立出來後它不會馬上就開始被激活進而發出 Event，而是要等到它被某個人訂閱了才會激活它 而Observable序列激活之後要一直等到它發出了 .error 或者 .completed 的 event後，它才被終結

❷dispose() 方法

除了 dispose() 方法之外，更經常用 DisposeBag 的對象來管理多個訂閱行為的銷毀
  • 以把一個DisposeBag對象看成一個垃圾袋，把用過的訂閱行為都放進去，感覺有點像OC釋放池
  • 而這個DisposeBag就會在自己快要dealloc的時，對它裡面的所有訂閱行為都調用 dispose() 方法 
let disposeBag = DisposeBag()
//第1個Observable，和訂閱
let observable1 = Observable.of("A","B","C")
observable1.subscribe{ event in
                     print(event)}
           .disposed(by: disposeBag)
//第2個Observable，和訂閱
let observable2 = Obserable.of(,,)
observable2.subscribe{event in
                     print(event)}
           .disposed(by: disposeBag)
複制代碼

轉載于:https://juejin.im/post/5be80ac4e51d457844615d24

json swift RxSwift
上一篇: C++鈎子，HOOK程式設計，全局鈎子
下一篇: form元件 局部鈎子和全局鈎子 - 向往1

繼續閱讀