iOS开发进阶 - RxSwift之Observable

来自网络

RxSwift-Reactive Programming with Swift (Swift4.0)

Observables

ObservablesRx的核心,本节将花点时间学习如何创建和使用Observables。在RxSwift中,ObservablesObservables sequencesequence代表相同的意思,RxSwift的世界里,任何事物都是序列observable也是序列,它可以产生事件,事件可以包含值。

Observables三种状态和生命周期

Observables有三种状态分别是nexterrorcompleted。下面使用圆珠图(marble diagram)理解Observables的生命周期。

图片来自RxSwift

上图中从左到右的箭头代表时间,线上的圆珠代表序列事件元素。随着时间的推移线上的元素会被依次发射。observable发射元素产生next事件。

另一张圆珠图,它存在一个结束线。

来自RxSwift

observable发射三个tap事件,当结束时会发个completed事件作为序列的结束标志。例如:tap所在的界面销毁。在observable结束后不再发送任何事件,这种结束方式属于正常终止。

另外,存在一种非正常方式结束序列,如出现错误时,如下面这张图。


来自RxSwift

当错误发送时,observable发射error事件此时序列终止不再发射任何事件。

回顾一下上面三张图:

随着时间推移序列会根据元素依次发送next事件,两种情况导致序列结束,第一,发生错误发射error事件序列终止,第二,发射completed事件序列终止。序列一旦终止就不会再发射任何事件。

Swift中,事件是枚举类型的结构如下:

/// Represents a sequence event.
///
/// Sequence grammar: 
/// **next\* (error | completed)**
public enum Event<Element> {
    /// Next element is produced. ①
    case next(Element)

    /// Sequence terminated with an error. ②
    case error(Swift.Error)

    /// Sequence completed successfully. ③
    case completed
}
  • ① : next携带一个泛型Element
  • ②:error携带一个Swift.Error实例对象。
  • ③:completed表示序列结束不携带值。

创建Observables

了解了Observables概念接下学习如何创建和使用Observables

RxSwift提供多种方式创建Observables。例如:of, just, from, empty, neverrange等。

just: 创建单个事件的序列。of: 创建多个事件的序列。from: 通过数组创建多个事件的序列。empty创建一个空的序列,只发射completed事件。never创建一个不发射事件也不会结束的序列。range(start, count):创建包含多个事件的序列。

// 1. 创建Observables
example(of: "just of from") {
    // 1
    let one = 1
    let two = 2
    let three = 3
    // 2
    let observable1 = Observable.just(one)
    // 3 
    let observable2 = Observable.of(one, two, three)
    let observable3 = Observable.of([one, two, three]) // [Int]
    // 4 
    let observable4 = Observable.from([one, two, three])
    let observable5 = Observable<Void>.empty()
    let observable6 = Observable<Any>.never()
    let observable7 = Observable.range(start: 1, count: 5)
}
  1. 定义三个常量。
  2. 使用just创建只有一个元素的序列,此时序列类型为Observable<Int>
  3. 使用of创建序列,注意Observable2Observable<Int>,而observable3Observable<[Int]>类型 。
  4. 使用from创建序列,此时接收的参数是数组类型。注意:与of的区别。

除了前面的创建方式还可以使用create创建序列。

// Create方法,内部有一个observer
example(of: "Create") {
   // 1
    let disposeBag = DisposeBag()
    // 2 
    Observable<String>.create { observer in
       
        observer.onNext("1")
        observer.onCompleted()
        observer.onNext("2")
        // 3
        return Disposables.create()
    }
    // 4
    .subscribe(
               onNext: {print($0)},
               onError: {print($0)},
               onCompleted: {print("Completed")},
               onDisposed: {print("Disposed")}
    )
    // 5
    .disposed(by: disposeBag)
}
  1. 创建一个DisposeBag对象,用于管理序列
  2. create方法参数是一个逃逸闭包参数为AnyObserver返回值Disposable类型。AnyObserver是通用类型用来将值添加到序列中,在将来发射给订阅者。
  3. 返回disposable代表订阅,Disposables.create()创建了一个空的disposable
  4. 通过subscribe订阅,运行结果你会发现没有输出2,因为在onNext("2")之前,已经发送completed事件序列终止。
  5. 添加到bag中。

订阅序列

订阅序列使用.subscribe方法。直接看示例代码:

// 订阅
example(of: "subscrible") {
    let one = 1
    let two = 2
    let three = 3
    // 1
    let observable = Observable.from([one ,two, three])
    // 2 第一种
    observable.subscribe { event in
        print(event)  // 输出事件
        if let element = event.element {
            print(element)
        }
    }
     // 3 另一种方式
   observable.subscribe(onNext: { (element) in
        print(element)
    }, onError: { (error) in
        print(error)
    }, onCompleted: {
        print("completed")
    }, onDisposed: {
        print("disposed")
    })
}
  1. 创建有多个元素的序列。
  2. 使用func subscribe(_ on: @escaping (Event<Int>) -> Void) -> Disposable方法订阅序列,逃逸闭包参数是Int类型的事件。方法返回值是DisposableDisposable稍后会学到。闭包中参数是事件,通过事件的可选值element参数获取值。
  3. 另一个方法相对方便,直接可以获取到事件的值。注意:onErroronCompletedonDisposed是可选的。

清除和终止

Observable为被订阅时,不会发射任何事件,当出现错误或结束时才会终止。不过,也可以通过清除订阅来终止序列。

每一个订阅者都存在一个dispose方法,当调用该方法时会清除订阅者。示例代码:

// dispose 用于回收,防止内存泄露
example(of: "dispose") {
    let observable = Observable.of("A", "B", "C")
    let subscription = observable.subscribe {event in
        print(event)
    }
    subscription.dispose()
}

example(of: "DisposeBag") {
    let disposeBag = DisposeBag()
    Observable.of("A", "B", "C")
        .subscribe {
            print($0)
    }
    .disposed(by: disposeBag)
}
  • DisposeBag清除包,通过调用dispose方法,取消订阅并且释放内部资源。

三种特殊的Observable

  • Single:不同于Observable它只会发送nexterror事件。Observable通过调用asSingle方法可以转换成Single
    通常用于网络下载或者读取磁盘数据。
example(of: "Single") {
    // 1
    let disposeBag = DisposeBag()

    // 2
    enum FileError: Error {
        case  fileNotFound, unreadable, encodingFailed
    }
    // 3
    func loadText(from name: String) -> Single<String> {
        // 4
        return Single.create { single in
            let disposable = Disposables.create()

            guard let path = Bundle.main.path(forResource: name, ofType: "txt") else {
                single(.error(FileError.fileNotFound))
                return disposable
            }

            guard let data = FileManager.default.contents(atPath: path) else {
                single(.error(FileError.unreadable))
                return disposable
            }
            guard let content = String(data: data, encoding: .utf8) else {
                single(.error(FileError.encodingFailed))
                return disposable
            }
            single(.success(content))
            return disposable
        }
    }

    loadText(from: "Copyright")
        .subscribe {
            switch $0 {
            case .success(let str):
                print(str)
            case .error(let error):
                print(error)
            }
    }
    .disposed(by: disposeBag)
}
  • Completable:只会发送completederror事件。只关心任务是否完成不关心返回值,类似Observable<Void>
  • Maybe: 介于CompletableSingle之间,只会发送一个元素。

本节是对RxSwiftObservable概念和使用的初步学习,循序渐进逐步深入学习深层次内容。

小结

  • Observables是什么?生命周期?
  • Observables 创建方法有哪些?
  • 如何订阅Observable?
  • DisposeBag是什么?它的作用是什么?

参考

推荐阅读更多精彩内容