RxSwift學習--可觀察序列Observable

時間  2019-11-24
標籤 rxswift 學習 觀察 序列 observable 简体版
原文   原文鏈接

前言

Observable英文直譯爲：可觀察的，可看見的。可是在RxSwift廣泛的稱它爲「可觀察序列」,它的做用主要用來造成一條數據流或者事件流，全部的操做產生的事件都會經過Observable進行傳輸。 git

Observable.png

在Observable裏有三種事件(Event: Event枚舉類型，有三個成員，next，error，completed ) Observable發送的全部事件都是一個Event:github

  • next事件主要是當Observable裏出現新的數據時會發出的事件，同時該事件會攜帶新的數據對象。api

  • completed事件是當Observable再也不有新的數據出現，Observable被標記完成,再也不產生數據.數組

  • error事件是當數據流遇到了錯誤會發出的事件，該事件也會致使Observable結束。bash

Observable(可觀察序列)

1. Observable的建立

在RxSwift中，能夠有多種建立Observable對象的方法,下面咱們逐一介紹：閉包

(1). create()方法

public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
        return AnonymousObservable(subscribe)
    }
複製代碼

create()方法的參數是一個函數(閉包),根據閉包來建立序列，在閉包裏面可自定義事件。函數須要傳入參數AnyObserver類型，返回的是Disposable,AnyObserver其實就是觀察者，Disposable是一個協議接口，裏面只有一個dispose方法，用來釋放一些資源。整個create()方法返回的是一個AnonymousObservable(匿名Observable).dom

create.png

例子：ide

let createOb = Observable<Int>.create{ (observer) -> Disposable in
        observer.onNext(1)
        observer.onCompleted()
        return Disposables.create()
    }
    
   let _ = createOb.subscribe(onNext: { (number) in
        print("訂閱:",number)
    }, onError: { (error) in
        print("error:",error)
    }, onCompleted: {
        print("完成回調")
    }) {
        print("釋放回調")
    }
複製代碼

(2). empty()方法

public static func empty() -> Observable<E> {
        return EmptyProducer<E>()
    }
    
final private class EmptyProducer<Element>: Producer<Element> {
    override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        observer.on(.completed)
        return Disposables.create()
    }
}
複製代碼

empty()方法返回一個EmptyProducer類，在這個類的內部實現了subscribe()訂閱方法，且只有一個.completed狀態，因此，empty()方法是一個空方法，裏面沒有onNext事件處理，只會處理onComplete事件。函數

empty.png

例子：學習

let emtyOb = Observable<Int>.empty()
let  _ = emtyOb.subscribe(onNext: { (number) in
        print("訂閱:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("完成回調")
        }) {
            print("釋放回調")
        }
複製代碼

(3). just()方法

public static func just(_ element: E) -> Observable<E> {
        return Just(element: element)
    }
複製代碼

just()方法是單個信號序列建立，只能處理單個事件，簡單來講，咱們使用just()方法時不能將一組數據一塊兒處理，只能一個一個數據進行處理。just() 根據傳入的一個參數來建立序列，它會向訂閱者發送兩個事件，第一個發送帶元素數據的.next事件，第二個發送 .completed事件。

just.png
例子： 

let array = ["You","Me"]
        Observable<[String]>.just(array)
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
    let _ = Observable<[String]>.just(array).subscribe(onNext: { (number) in
            print("訂閱:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("完成回調")
        }) {
            print("釋放回調")
        }
複製代碼

(4). of()方法

public static func of(_ elements: E ..., scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
        return ObservableSequence(elements: elements, scheduler: scheduler)
    }
複製代碼

of()方法能夠接受多個參數來建立實例，但這些參數必須是同類型，也就是說，of()方法是just()方法的升級版，它能夠將一序列的事情組合起來一塊兒處理。

of.png
例子： 

Observable<String>.of("Henry","Jeannie")
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
            
 // 字典
        Observable<[String: Any]>.of(["name":"HuGe","age":18])
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
        
 // 數組
        Observable<[String]>.of(["Peter","July"])
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
複製代碼

(5). from()方法

public static func from(optional: E?) -> Observable<E> {
    return ObservableOptional(optional: optional)
}
複製代碼

from()方法只接收數組(數組，集合)做爲參數，並抽取出數組裏的元素來做爲數據流中的元素,也就是說，from() 根據傳入的數組元素來建立序列。它會依次發出.next事件，最後發出.completed 事件，結果和of()方法同樣。

from.png
例子： 

Observable<[String]>.from(optional: ["Hu","Ge"])
            .subscribe { (event) in
                print(event)
            }.disposed(by: disposeBag)
複製代碼

(6). deferred()方法

public static func deferred(_ observableFactory: @escaping () throws -> Observable<E>)
        -> Observable<E> {
        return Deferred(observableFactory: observableFactory)
    }
複製代碼

deferred()方法是延時建立Observable對象，當subscribe的時候纔去建立，它爲每個bserver建立一個新的Observable；

deferred.png
例子： 

//用於標記是奇數、仍是偶數
var isOdd = true
//使用deferred()方法延遲Observable序列的初始化，經過傳入的block來實現Observable序列的初始化而且返回。
let factory : Observable<Int> = Observable.deferred {
    //讓每次執行這個block時候都會讓奇、偶數進行交替
    isOdd = !isOdd
    //根據isOdd參數，決定建立並返回的是奇數Observable、仍是偶數Observable
    if isOdd {
        return Observable.of(1, 3, 5 ,7)
    }else {
        return Observable.of(2, 4, 6, 8)
    }
}
//第1次訂閱測試
factory.subscribe { event in
    print("\(isOdd)", event)
}
//第2次訂閱測試
factory.subscribe { event in
    print("\(isOdd)", event)
}
複製代碼

(7). range()方法

public static func range(start: E, count: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
        return RangeProducer<E>(start: start, count: count, scheduler: scheduler)
    }
複製代碼

range()方法經過指定起始和結束數值，建立一個以這個範圍內全部值做爲初始值的 Observable 序列。range()方法其實和of()方法很類似，其功能和of()差很少，咱們只要輸出start和count而後就能生成一組數據，讓它們執行onNext。值得注意的是，range()方法只生成Observable類型。

range.png
例子： 

Observable.range(start: 2, count: 5)
    .subscribe { (event) in
        print(event)
    }.disposed(by: disposeBag)
複製代碼

(8). generate()方法

public static func generate(initialState: E, condition: @escaping (E) throws -> Bool, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance, iterate: @escaping (E) throws -> E) -> Observable<E> {
        return Generate(initialState: initialState, condition: condition, iterate: iterate, resultSelector: { $0 }, scheduler: scheduler)
    }
複製代碼

generate()方法建立一個只有當提供的全部的判斷條件都爲 true 的時候，纔會給出動做的Observable序列。generate()方法是一個迭代器，它一直循環onNext事件，直到condition不知足要求退出。generate()有四個參數，第一個是最開始的循環變量，第二個是條件，第三個是迭代器，這個迭代器每次運行都會返回一個E類型，做爲下一次是否執行onNext事件源，而是否正的要執行則看是否知足condition條件。其實咱們能夠理解generate()就是一個循環體，其內部實現也正是一個循環，相似於數組的遍歷，具體實現代碼在GenerateSink的run方法。

generate.png
例子： 

Observable.generate(initialState: 0,// 初始值
                    condition: { $0 < 10}, // 條件1
                    iterate: { $0 + 2 })  // 條件2 +2
        .subscribe { (event) in
                print(event)
        }.disposed(by: disposeBag)
複製代碼

(9). timer()方法

public static func timer(_ dueTime: RxTimeInterval, period: RxTimeInterval? = nil, scheduler: SchedulerType)
        -> Observable<E> {
        return Timer(
            dueTime: dueTime,
            period: period,
            scheduler: scheduler
        )
    }
複製代碼

timer()方法是建立的Observable 序列在通過設定的一段時間後，產生惟一的一個元素，或者每隔一段時間產生一個元素。這取決於period是否有值。

例子： 

let observable = Observable<Int>.timer(5, period: 1, scheduler: MainScheduler.instance)
observable.subscribe { event in
    print(event)
}
複製代碼

(10). interval()方法

public static func interval(_ period: RxTimeInterval, scheduler: SchedulerType)
        -> Observable<E> {
        return Timer(
            dueTime: period,
            period: period,
            scheduler: scheduler
        )
    }
複製代碼

interval()方法建立的 Observable 序列每隔一段設定的時間，會發出一個索引數的元素。並且它會一直髮送下去。差異在於timer()能夠設置間隔時間和持續時間，而interval()的間隔時間和持續時間是同樣的。

例子：

//下面方法讓其每 1秒發送一次，而且是在主線程（MainScheduler）發送。
let observable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable.subscribe { event in
    print(event)
}
複製代碼

(11). repeatElement()方法

public static func repeatElement(_ element: E, scheduler: ImmediateSchedulerType = CurrentThreadScheduler.instance) -> Observable<E> {
        return RepeatElement(element: element, scheduler: scheduler)
    }
複製代碼

repeatElement()方法建立一個能夠無限發出給定元素的Event的Observable序列，它是無限循環的，會一直循環onNext方法，不會終止。

repeatElement.png
例子： 

Observable<Int>.repeatElement(5)
    .subscribe { (event) in  
     print("訂閱:",event)
    }
    .disposed(by: disposeBag)
複製代碼

(12). error()方法

public static func error(_ error: Swift.Error) -> Observable<E> {
        return ErrorProducer(error: error)
}

final private class ErrorProducer<Element>: Producer<Element> {
    private let _error: Swift.Error
    
    init(error: Swift.Error) {
        self._error = error
    }
    
    override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        observer.on(.error(self._error))
        return Disposables.create()
    }
}
複製代碼

error()方法是返回一個只能調用onError方法的Observable序列。其中的onNext和OnCompleted方法是不會執行的。

error.png
例子： 

Observable<String>.error(NSError.init(domain: "ObservableError", code: 10010, userInfo: ["reason":"unknow"]))
            .subscribe { (event) in
                print("訂閱:",event)
            }
            .disposed(by: disposeBag)
複製代碼

(13). never()方法

public static func never() -> Observable<E> {
        return NeverProducer()
    }
    
final private class NeverProducer<Element>: Producer<Element> {
    override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        return Disposables.create()
    }
}
複製代碼

never()方法建立一個永遠不會發出 Event，也不會終止的 Observable序列。就是返回一個無終止的觀察者事件序列，能夠用來表示無限持續時間。

never.png
例子： 

let neverSequence = Observable<Int>.never()
    _ = neverSequence.subscribe { event in
        print(event)
   }
複製代碼

2. Observable的訂閱

建立完了 Observable，還要使用 subscribe() 方法來訂閱它，並接收它發出的 Event。

(1). Subscribes event handler

public func subscribe(_ on: @escaping (Event<E>) -> Void)
        -> Disposable {
        
        }
複製代碼

這種subscribe()方法訂閱了一個 Observable 對象，該方法的 block的回調參數就是被髮出的 event 事件.

例子：

let observable = Observable.of(1, 2, 3)
         
observable.subscribe { event in
    print(event)
    print(event.element)
}
複製代碼

這裏能夠看到初始化 Observable 序列時設置的默認值都按順序經過 .next 事件發送出來，等到數據都發送完畢，它還會自動發一個 .completed 事件出來。

(2). Subscribes element handler

public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
        -> Disposable {
        }
複製代碼

這種subscribe()預訂方法，它能夠把 event 進行分類：.next，.completed，.error以處理不一樣類型的event,同時會把 event 攜帶的數據直接解包出來做爲參數.

例子：

let observable = Observable.of("A", "B", "C")
         
observable.subscribe(onNext: { element in
    print(element)
}, onError: { error in
    print(error)
}, onCompleted: {
    print("completed")
}, onDisposed: {
    print("disposed")
})
複製代碼

onNext、onError、onCompleted 和 onDisposed 這四個回調參數都是有默認值的，即它們都是可選的。因此也能夠只處理 onNext而無論其餘的狀況。

3. Observable的事件生命週期

public func `do`(onNext: ((E) throws -> Void)? = nil, onError: ((Swift.Error) throws -> Void)? = nil, onCompleted: (() throws -> Void)? = nil, onSubscribe: (() -> Void)? = nil, onSubscribed: (() -> Void)? = nil, onDispose: (() -> Void)? = nil)
        -> Observable<E> {
            return Do(source: self.asObservable(), eventHandler: { e in
                switch e {
                case .next(let element):
                    try onNext?(element)
                case .error(let e):
                    try onError?(e)
                case .completed:
                    try onCompleted?()
                }
            }, onSubscribe: onSubscribe, onSubscribed: onSubscribed, onDispose: onDispose)
    }
複製代碼

當 Observable 的某些事件產生時，你可使用 do() 操做符來註冊一些回調操做。這些回調會被單獨調用，它們會和 Observable 本來的回調分離。

可使用 do() 方法來監聽事件的生命週期，它會在每一次事件發送前被調用，同時它和 subscribe() 同樣，能夠經過不一樣的回調處理不一樣類型的 event。

例子：

let observable = Observable.of("A", "B", "C")
 
observable.do(onNext: { element in
        print("Next：", element)
    }, onError: { error in
        print("Error：", error)
    }, onCompleted: {
        print("Completed")
    }, onDispose: {
        print("Disposed")
    })
   observable.subscribe(onNext: { element in
        print(element)
    }, onError: { error in
        print(error)
    }, onCompleted: {
        print("completed")
    }, onDisposed: {
        print("disposed")
    })
複製代碼

4. Observable的銷燬

經過上面的這些內容，咱們大概已經知道了，當一個Observable 序列被正常建立出來後它不會立刻就開始被激活從而發出 event，而是要等到它被訂閱了纔會激活它。而 Observable 序列激活以後要一直等到它發出了.error 或者 .completed的 event 後，它才被終結。

(1). 顯式銷燬--dispose() 方法

當一個訂閱結束了再也不須要了，就能夠調用 dispose() 方法把這個訂閱給銷燬掉，防止內存泄漏。訂閱行爲被 dispose 了，訂閱將被取消，而且內部資源都會被釋放，那麼以後 Observable若是再發出 event，這個已經 dispose 的訂閱就收不到消息了。一般狀況下，你是不須要手動調用 dispose 方法的。

例子： 

let observable = Observable.of("A", "B", "C")
let observableDispose = observable.subscribe { event in
    print(event)
}
observableDispose.dispose()
複製代碼

(2). 隱式銷燬--DisposeBag 方法

DisposeBag建立一個對象來管理多個訂閱行爲的銷燬，能夠把一個 DisposeBag 對象當作一個回收垃圾袋，把用過的訂閱行爲都放進去。 而這個 DisposeBag就會在本身快要銷燬 的時候，對它裏面的全部訂閱行爲都調用 dispose() 方法。

例子： 

let disposeBag = DisposeBag()

let observable = Observable.of(1, 2, 3)
observable.subscribe { event in
    print(event)
}.disposed(by: disposeBag)
複製代碼

總結

這篇內容簡單的介紹了Observable序列的建立，訂閱，和銷燬。這裏建立的序列都是最基本的序列，在RxSwift 裏面Observable也存在一些特徵序列，Driver，Single，ControlEvent...這些特徵序列能夠幫助咱們更準確的描述序列，讓咱們可以用更加優雅的方式書寫代碼，關於這些特徵序列後面我會再學習。關於Observable的銷燬好像還有一種方法，後面研究到了會回來補充。如文中有錯誤還請各位指正！

最後感謝RxSwift中文文檔.

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程