美文网首页
RxSwift（四）可监听序列Observavle的创建/订阅/

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

作者: Colbert_Z | 来源:发表于2019-08-22 10:01 被阅读0次

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

    Observable有三种事件:

    • next(Element)
      出现新数据(Element)时触发的事件，会携带这个新的数据对象。
    • error(Swift.Error)
      触发一个错误事件，携带了具体错误内容，error事件被触发，Observable就会终止，不再触发任何事件。
    • completed
      表示Observable的所有事件完成了，和error一样，只要completed触发后Observable就会终止，不再触发任何事件。

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

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

    1. 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("销毁")
        }

    打印：没有打印！

    1. 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
    1. 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)

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

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

    相关文章

      网友评论

          本文标题：RxSwift（四）可监听序列Observavle的创建/订阅/

          本文链接：https://www.haomeiwen.com/subject/tpxbsctx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|RxSwift（四）可监听序列Observavle的创建/订阅/|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！