RxSwift（四）可监听序列Observavle的创建/订阅/

2019-08-22 本文已影响0人 Colbert_Z

Observable 是用于描述元素异步产生的序列，在使用时通常需要指定事件的携带数据类型：Observable<Element>，如：Observable<String>、Observable<Int>，如果不确定或者多类型可用Observable<Any>。

Observable有三种事件:

next(Element)
出现新数据(Element)时触发的事件，会携带这个新的数据对象。

error(Swift.Error)
触发一个错误事件，携带了具体错误内容，error事件被触发，Observable就会终止，不再触发任何事件。

completed
表示Observable的所有事件完成了，和error一样，只要completed触发后Observable就会终止，不再触发任何事件。

下面介绍一些Observable使用过程中各个阶段会使用的一些方法

更多操作方法请移步：如何选择操作符？

Observable的创建

create()
创建一个标准的序列，可以自定义设置发送响应消息。

        var createOb : Observable<Int>?
        createOb = Observable<Int>.create{ (observer) -> Disposable in
            observer.onNext(1)
            observer.onNext(2)
            observer.onNext(3)
            observer.onNext(4)
            observer.onNext(5)
            observer.onCompleted()
            return Disposables.create()
        }
        
        _ = createOb?.subscribe(onNext: { (number) in
            print("onNext:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("onCompleted")
        }) {
            print("销毁")
        }

打印：

onNext: 1
onNext: 2
onNext: 3
onNext: 4
onNext: 5
onCompleted
销毁

传入参数为一个闭包，在闭包里自定义事件（next，error，completed）。闭包需要传入一个AnyObserver观察者对象，返回一个Disposable，Disposable只有一个dispose方法，用来释放资源。create()方法返回一个匿名Observable：AnonymousObservable对象。

empty()
创建一个空的序列，只能订阅到complete。

        emptyOb = Observable.empty()
        _ = emptyOb?.subscribe(onNext: { (number) in
            print("onNext:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("onCompleted")
        }) {
            print("销毁")
        }

打印：

onCompleted
销毁

just()
创建一个单信号序列，订阅完一次信息自动complete。

//        justOb = Observable.just([1, 2])
        justOb = Observable.just("just")
        _ = justOb?.subscribe(onNext: { (number) in
            print("onNext:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("onCompleted")
        }) {
            print("销毁")
        }

onNext: [1, 2]
completed
销毁

onNext: just
onCompleted
销毁

of()
创建一个多数量元素的序列，参数必需是同类型的，是just()方法的升级。

        ofOb = Observable.of(1, 2, 3)
        _ = justOb?.subscribe(onNext: { (number) in
            print("onNext:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("onCompleted")
        }) {
            print("销毁")
        }

打印：

onNext: 1
onNext: 2
onNext: 3
onCompleted
销毁

from()
只接收数组(数组，集合)作为参数，并抽取数组中的元素作为数据流中的元素,结果和of()方法一样。

        fromOb = Observable.from(["A", "B", "C"])
        _ = fromOb?.subscribe(onNext: { (number) in
            print("onNext:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("onCompleted")
        }) {
            print("销毁")
        }

打印：

onNext: A
onNext: B
onNext: C
onCompleted
销毁

deferred()
直到订阅发生，才创建序列，并且为每位订阅者创建全新的序列。在某些情况下，直到订阅时才创建 Observable ，可以保证拿到的数据都是最新的。

        var subscribeA = true
        deferredOb = Observable.deferred {
            subscribeA = !subscribeA
            if subscribeA {
                return Observable.just("A")
            }else {
                return Observable.just("B")
            }
        }
        
        deferredOb?.subscribe { event in
            print(event)
        }
        deferredOb?.subscribe { event in
            print(event)
        }
        deferredOb?.subscribe { event in
            print(event)
        }
        deferredOb?.subscribe { event in
            print(event)
        }

打印：

next(B)
completed
next(A)
completed
next(B)
completed
next(A)
completed

range()
生成指定范围内的可观察序列，范围内的必须是整形数。

        rangeOb = Observable.range(start: 2, count: 5)
        _ = rangeOb?.subscribe(onNext: { (number) in
            print("onNext:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("onCompleted")
        }) {
            print("销毁")
        }

打印：

onNext: 2
onNext: 3
onNext: 4
onNext: 5
onNext: 6
onCompleted
销毁

generate()
创建一个当判断条件都为 true 的时候，才会给出动作的序列，可以理解为一个for循环。

        generateOb = Observable.generate(initialState: 1,       // 初始状态
                                         condition: { $0 < 5 }, // 判断条件
                                         iterate: { $0 + 1 })   // 迭代指令
        _ = generateOb?.subscribe(onNext: { (number) in
            print("onNext:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("onCompleted")
        }) {
            print("销毁")
        }

打印：

onNext: 1
onNext: 2
onNext: 3
onNext: 4
onCompleted
销毁

timer()
定时器序列，使用指定的调度器（scheduler）。

        // dueTime：延迟时间
        // period：定时周期，不传入就只执行一次
        //timerOb = Observable.timer(1, scheduler: MainScheduler.instance)
        timerOb = Observable.timer(1, period: 1, scheduler: MainScheduler.instance)
        _ = timerOb?.subscribe(onNext: { (number) in
            print("onNext:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("onCompleted")
        }) {
            print("销毁")
        }

打印：

onNext: 0
onCompleted
销毁

onNext: 0
onNext: 1
onNext: 2
onNext: 3
onNext: 4
······

interval()
定时器序列，和timer()差别在于timer()可以设置间隔时间和延迟时间，而interval()的间隔时间和延迟时间是一样的。

        intervalOb = Observable.interval(1, scheduler: MainScheduler.instance)
        _ = intervalOb?.subscribe(onNext: { (number) in
            print("onNext:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("onCompleted")
        }) {
            print("销毁")
        }

打印：

onNext: 0
onNext: 1
onNext: 2
onNext: 3
onNext: 4
······

repeatElement()
创建一个可以无限触发给定元素的序列，一直执行onNext。

        repeatElementOb = Observable.repeatElement(1)
        _ = repeatElementOb?.subscribe(onNext: { (number) in
            print("onNext:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("onCompleted")
        }) {
            print("销毁")
        }

打印：

onNext: 1
onNext: 1
onNext: 1
onNext: 1
onNext: 1
······

error()
创建一个只调用onError的序列。

        errorOb = Observable.error(NSError.init(domain: "error", code: 222, userInfo: ["OB":"errorOb"]))
        _ = errorOb?.subscribe(onNext: { (number) in
            print("onNext:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("onCompleted")
        }) {
            print("销毁")
        }

打印：

error: Error Domain=error Code=222 "(null)" UserInfo={OB=errorOb}
销毁

never()
创建一个不会产生任何事件的序列。

        neverOb = Observable.never()
        _ = neverOb?.subscribe(onNext: { (number) in
            print("onNext:",number)
        }, onError: { (error) in
            print("error:",error)
        }, onCompleted: {
            print("onCompleted")
        }) {
            print("销毁")
        }

打印：没有打印！

Observable的订阅

Subscribes event handler
默认按数据顺序调用.next 事件，等到数据都发送完毕，最终执行.completed 事件。

    public func subscribe(_ on: @escaping (Event<E>) -> Void)
        -> Disposable {

    }

        ob = Observable.of("A", "B", "C")
        _ = ob.subscribe { (event) in
            print(event)
        }

打印：

next(A)
next(B)
next(C)
completed

Subscribes element handler
自定义设置onNext、onError、onCompleted 和 onDisposed，它们都是可选的，可以任意组合。

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

    }

    let ob = Observable.of("A", "B", "C")

组合一：

        _ = ob.subscribe(onNext: { (text) in
            print(text)
        })

打印：

A
B
C

组合二：

        _ = ob.subscribe(onCompleted: {
            print("onCompleted")
        })

打印：

onCompleted

组合三：

        _ = ob.subscribe(onNext: { (text) in
            print(text)
        }, onCompleted: {
            print("onCompleted")
        }, onDisposed: {
            print("onDisposed")
        })

打印：

A
B
C
onCompleted
onDisposed

Observable的销毁

手动销毁：dispose()
当一个订阅结束不再需要了，就可以调用 dispose() 把这个订阅销毁，释放内部资源，防止内存泄漏。

        let disposable = ob.subscribe(onNext: { element in
            print(element)
        }, onError: { error in
            print(error)
        }, onCompleted: {
            print("completed")
        })
        
        disposable.dispose()

垃圾袋销毁：DisposeBag
创建一个DisposeBag对象来管理多个订阅的销毁, 在这个垃圾袋 DisposeBag对象将要销毁的时候，对它管理的所有订阅都调用 dispose() 方法。

        let disposeBag = DisposeBag()
        _ = ob.subscribe(onNext: { element in
            print(element)
        }, onError: { error in
            print(error)
        }, onCompleted: {
            print("completed")
        }).disposed(by: disposeBag)

总结：
篇幅较长，想快速了解请直接看这里。

创建序列：
- create()：创建一个标准的序列，可以自定义设置发送什么消息。
- empty()：创建一个空的序列，只能订阅到complete。
- just()：创建一个单信号序列，订阅完一次信息自动complete。
- of()：创建一个多数量元素的序列，参数必需是同类型的。
- from()：创建一个只接收数组(数组，集合)作为参数的序列。
- deferred()：直到订阅发生，才创建序列，并且为每位订阅者创建全新的序列。
- range()：生成指定范围内的可观察序列，范围内的必须是整形数。
- generate()：创建一个当判断条件都为 true 的时候，才会给出动作的序列。
- timer()：定时器序列，使用指定的调度器（scheduler）。
- interval()：定时器序列，和timer()差别在于timer()可以设置间隔时间和延迟时间，而interval()的间隔时间和延迟时间是一样的。
- repeatElement()：创建一个可以无限触发给定元素的序列，一直执行onNext。
- error()：创建一个只调用onError的序列。
- never()：创建一个不会产生任何事件的序列。
Observable的订阅
- Subscribes event handler：
  按数据顺序调用.next事件，等到数据都发送完毕，最终执行.completed 事件。传递的带数据的事件本身。
- Subscribes element handler：
  自定义设置onNext、onError、onCompleted 和 onDisposed，它们都是可选的，可以任意组合。传递的是数据。
Observable的销毁
- 手动销毁：dispose()
  当一个订阅结束不再需要了，就可以调用 dispose()立即把这个订阅销毁。
- 垃圾袋销毁：DisposeBag
  创建一个DisposeBag对象来管理多个订阅的销毁, 在这个垃圾袋 DisposeBag对象将要销毁的时候，对它管理的所有订阅都调用dispose()方法。

RxSwift（四）可监听序列Observavle的创建/订阅/

下面介绍一些Observable使用过程中各个阶段会使用的一些方法

猜你喜欢

热点阅读