RxJava2.0基础用法（一）

最新推荐文章于 2024-01-30 18:33:58 发布

西西里大律师

最新推荐文章于 2024-01-30 18:33:58 发布

阅读量850

点赞数 1

分类专栏： RxJava

本文链接：https://blog.csdn.net/baiaihan/article/details/87713694

版权

RxJava 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

RxJava是一个在Java VM上使用可观测的序列来组成异步的、基于事件的程序的库。

虽然，在Android中，我们可以使用AsyncTask来完成异步任务操作，但是当任务的梳理比较多的时候，我们要为每个任务定义一个AsyncTask就变得非常繁琐。
RxJava能帮助我们在实现异步执行的前提下保持代码的清晰。
它的原理就是创建一个Observable来完成异步任务，组合使用各种不同的链式操作，来实现各种复杂的操作，最终将任务的执行结果发射给Observer进行处理。
当然，RxJava不仅适用于Android，也适用于服务端等各种场景。
我们总结以下RxJava的用途：

简化异步程序的流程；
使用近似于Java8的流的操作进行编程：因为想要在Android中使用Java8的流编程有诸多的限制，所以我们可以使用RxJava来实现这个目的。

要在Android中使用RxJava2, 先添加Gradle配置:

   compile 'io.reactivex.rxjava2:rxjava:2.0.1'
   compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

RxJava链式操作：

Observable.create(new ObservableOnSubscribe<Integer>() {
          @Override
          public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
              emitter.onNext(1);
              emitter.onNext(2);
              emitter.onNext(3);
              emitter.onComplete();
          }
      }).subscribe(new Observer<Integer>() {
          @Override
          public void onSubscribe(Disposable d) {
              Log.d(TAG, "subscribe");
          }
          @Override
          public void onNext(Integer value) {
              Log.d(TAG, "" + value);
          }
          @Override
          public void onError(Throwable e) {
              Log.d(TAG, "error");
          }
          @Override
          public void onComplete() {
              Log.d(TAG, "complete");
          }
      });

ObservableEmitter和Disposable：

ObservableEmitter： Emitter是发射器的意思，这个就是用来发出事件的，它可以发出三种类型的事件，通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。

发射事件，需要满足一定的规则：

1.Observable可以发送无限个onNext, Observer也可以接收无限个onNext.
2.当Observable发送了一个onComplete后, Observable onComplete之后的事件将会继续发送, 而Observer收到onComplete事件之后将不再继续接收事件.
3.当Observable发送了一个onError后, Observable onError之后的事件将继续发送, 而Observer收到onError事件之后将不再继续接收事件.
4.Observable 可以不发送onComplete或onError.
5.最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError, 反之亦然

注: 关于onComplete和onError唯一并且互斥这一点, 是需要自行在代码中进行控制, 如果你的代码逻辑中违背了这个规则,并不一定会导致程序崩溃. 比如发送多个onComplete是可以正常运行的, 依然是收到第一个onComplete就不再接收了, 但若是发送多个onError, 则收到第二个onError事件会导致程序会崩溃.

Disposable： 这个单词的字面意思是一次性用品,用完即可丢弃的.

在RxJava中怎么去理解它呢, 我们可以把它理解Observable 和Observer之间的一个机关, 当调用它的dispose()方法时, 它就会将其切断, 从而导致Observer收不到事件.

注意: 调用dispose()并不会导致Observable 不再继续发送事件, Observable 会继续发送剩余的事件.


     Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emit 1");
                emitter.onNext(1);
                Log.d(TAG, "emit 2");
                emitter.onNext(2);
                Log.d(TAG, "emit 3");
                emitter.onNext(3);
                Log.d(TAG, "emit complete");
                emitter.onComplete();
                Log.d(TAG, "emit 4");
                emitter.onNext(4);
            }
        }).subscribe(new Observer<Integer>() {
            private Disposable mDisposable;
            private int i;
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "subscribe");
                mDisposable = d;
            }
            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "onNext: " + value);
                i++;
                if (i == 2) {
                    Log.d(TAG, "dispose");
                    mDisposable.dispose();
                    Log.d(TAG, "isDisposed : " + mDisposable.isDisposed());
                }
            }
            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "error");
            }
            @Override
            public void onComplete() {
                Log.d(TAG, "complete");
            }
        });

运行结果为:

12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: subscribe
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 1
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: onNext: 1
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 2
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: onNext: 2
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: dispose
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: isDisposed : true
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 3
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit complete
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 4

subscribe()有多个重载的方法:

    public final Disposable subscribe() {}

    public final Disposable subscribe(Consumer<? super T> onNext) {}

    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {}

    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}

    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}

    public final void subscribe(Observer<? super T> observer) {}

不带任何参数的subscribe() 表示Observer不关心任何事件
带有一个Consumer参数的方法表示下游只关心onNext事件
其他方法同理

do系列方法

public final Observable doAfterNext(Consumer<? super T> onAfterNext)，会在onNext方法之后触发；
public final Observable doAfterTerminate(Action onFinally)，会在Observable终止之后触发；
public final Observable doFinally(Action onFinally)，当onComplete或者onError的时候触发；
public final Observable doOnDispose(Action onDispose)，当被dispose的时候触发；
public final Observable doOnComplete(Action onComplete)，当complete的时候触发；
public final Observable doOnEach(final Observer<? super T> observer)，当每个onNext调用的时候触发；
public final Observable doOnError(Consumer<? super Throwable> onError)，当调用onError的时候触发；
public final Observable doOnLifecycle(final Consumer<? super Disposable> onSubscribe, final Action onDispose)
public final Observable doOnNext(Consumer<? super T> onNext)，会在onNext的时候触发；
public final Observable doOnSubscribe(Consumer<? super Disposable> onSubscribe)，会在订阅的时候触发；
public final Observable doOnTerminate(final Action onTerminate)，当终止之前触发

这些方法可以看作是对操作执行过程的一个监听，当指定的操作被触发的时候会同时触发这些监听方法。

以 doOnNext方法分析为例：
Observable每发射一项数据就会调用它一次，但是它的Action不是接受一个Notification参数，而是接受发射的数据项。

 Observable.just("oooo")
                .subscribeOn(Schedulers.io())
                .doOnNext(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {

                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        
                    }
                    @Override
                    public void onNext(String s) {
                        Log.i(TAG, "maptesst----" + s);
                    }
                    @Override
                    public void onError(Throwable e) {

                    }
                    @Override
                    public void onComplete() {

                    }
                });

doOnNext一般用于在subscribe之前对数据的一些处理，比如数据的保存等；

西西里大律师

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RxJava2.0基础用法（一）

要在Android中使用RxJava2, 先添加Gradle配置:compile ‘io.reactivex.rxjava2:rxjava:2.0.1’compile ‘io.reactivex.rxjava2:rxandroid:2.0.1’RxJava链式操作：Observable.create(new ObservableOnSubscribe&amp;amp;amp;lt;Integer&amp;amp;amp;gt;() {...
复制链接

扫一扫