最简单易懂的RxJava2.0学习教程之RxJava2的基本使用（一）

去年RxJava2就发布了，在这之后一直做项目都在使用Rxjava2，觉得特别好用，目前网上的的资料很多，对于以前使用过RxJava1的朋友来说只需要看看更新文档就知道怎么使用了，但还有一些以前没用过RxJava的朋友可能就不知道怎么办了，不知道该看RxJava1还是直接学习RxJava2。如果你以前学过RxJava1，那么对于RxJava2只需要看看更新了哪些东西就行了，RxJava2相对于RxJava1最核心的思想并没有变化，如果你没学过RxJava1，没有关系，直接学习RxJava2。所以在这里和朋友们分享一下RxJava2的知识，希望对大家有所帮助。

一、配置

要在Android中使用RxJava2, 在app的build.gradle中添加依赖：

compile 'io.reactivex.rxjava2:rxjava:2.x.y'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

一个是Rxjava的库，一个是RxJava基于Android的库。

二、原理

下边就来说下RxJava的原理。网上有很多介绍RxJava原理的博客，一般文章都从观察者模式开始，先讲观察者，被观察者，订阅关系等。当我第一次看到这些文章的时候完全是一脸懵逼的，需要先去看一遍观察者模式，然后还要在观察者模式基础上去理解RxJava。总之，需要花很长的时间去理清楚它们之间的关系。

我觉得这样更容易理解：用一条河的上游和下游代替被观察者和观察者, 上游和下游之间有个水闸，建立连接的情况下水闸是打开的，上游每发送一个事件，下游就能收到该事件。RxJava的使用都是分三步

第一步：创建被观察者

//创建上游 Observable（被观察者）
        Observable<Integer> observable = 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();
            }
        });

第二步：创建观察者

//创建下游 Observer（观察者）
        Observer<Integer> observer = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "onNext=" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete");
            }
        };

第三步：建立订阅关系

        //建立连接
        observable.subscribe(observer);

运行结果:

这里的事件发送的顺序是1,2,3, 事件接收的顺序也是1,2,3的顺序。
上游和下游就分别对应着RxJava中的Observable和Observer，它们之间的连接就对应着subscribe()。
只有当(上游)Observable和(下游)Observer建立连接之后, 上游才会开始发送事件. 也就是调用了subscribe() 方法之后才开始发送事件.
把这段代码连起来写就成了被大家所熟知的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, "onSubscribe");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "onNext=" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete");
            }
        });

解释一下两个关键词：ObservableEmitter和Disposable

ObservableEmitter：

Emitter就是发射器的，这个就是用来发出事件的，它可以发出三种类型的事件，通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。
这里需要注意的是：
1、上游可以发送无限个onNext, 下游也可以接收无限个onNext。当上游发送了一个onComplete后, 上游onComplete之后的事件将会继续发送, 而下游收到onComplete事件之后将不再继续接收事件。
2、当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续接收事件。上游可以不发送onComplete或onError。
3、发送多个onComplete是可以正常运行的, 但是收到第一个onComplete就不再接收了, 但若是发送多个onError, 则收到第二个onError事件会导致程序会崩溃。

我们就来一一试验一下：

1、发送多个onComplete

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emitter=1");
                emitter.onNext(1);
                Log.d(TAG, "emitter=2");
                emitter.onNext(2);
                Log.d(TAG, "emitter=3");
                emitter.onNext(3);
                Log.d(TAG, "emitter=complete=1");
                emitter.onComplete();
                Log.d(TAG, "emitter=complete=2");
                emitter.onComplete();
                Log.d(TAG, "emitter=complete=3");
                emitter.onComplete();
                Log.d(TAG, "emitter=4");
                emitter.onNext(4);
            }
        }).subscribe(new Observer<Integer>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "onNext: " + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete");
            }
        });

运行结果：

可以看到，发送多个onComplete是可以的，只是接收到一个onComplete之后就不在接收事件，但是上游依旧在发送事件。

2、发送多个onError事件

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emitter=1");
                emitter.onNext(1);
                Log.d(TAG, "emitter=2");
                emitter.onNext(2);
                Log.d(TAG, "emitter=3");
                emitter.onNext(3);
//                Log.d(TAG, "emitter=complete=1");
//                emitter.onComplete();
//                Log.d(TAG, "emitter=complete=2");
//                emitter.onComplete();
//                Log.d(TAG, "emitter=complete=3");
//                emitter.onComplete();
                Log.d(TAG, "emitter=error=1");
                emitter.onError(new Throwable("no message"));
                Log.d(TAG, "emitter=error=2");
                emitter.onError(new Throwable("no message"));
                Log.d(TAG, "emitter=error=3");
                emitter.onError(new Throwable("no message"));
                Log.d(TAG, "emitter=4");
                emitter.onNext(4);
            }
        }).subscribe(new Observer<Integer>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "onNext: " + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError="+e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete");
            }
        });

运行结果：

从这个结果中可以看到，当收到第一个onError()后,打印了error信息但是程序并没有崩溃，然后第二个onError()程序就崩溃了。

Disposable：

这个单词的意思：是一次性的,用后就抛弃的. 那么在RxJava中怎么去理解它呢, 对应于上面的例子, 我们可以把它理解成水闸, 当调用它的dispose()方法时, 水闸关闭, 下游就收不到事件。
但是调用dispose()并不会让上游停止继续发送事件, 相反上游会继续发送剩余的事件.

上游依次发送1,2,3,complete,4,在下游收到第二个事件之后, 关闭水闸, 看看运行结果:

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emitter=1");
                emitter.onNext(1);
                Log.d(TAG, "emitter=2");
                emitter.onNext(2);
                Log.d(TAG, "emitter=3");
                emitter.onNext(3);
                Log.d(TAG, "emitter=complete");
                emitter.onComplete();
                Log.d(TAG, "emitter=4");
                emitter.onNext(4);
            }
        }).subscribe(new Observer<Integer>() {
            private Disposable disposable;
            private int i;

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe");
                disposable = d;
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "onNext: " + value);
                i++;
                if (i == 2) {
                    disposable.dispose();
                    Log.d(TAG, "isDisposed : " + disposable.isDisposed());
                }
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete");
            }
        });

运行结果为:

从运行结果我们看到, 在收到onNext(2)这个事件后, 关闭水闸, 但是上游仍然发送了onNext(3), complete, onNext(4)这几个事件, 而且上游并没有因为发送了onComplete而停止. 同时可以看到下游的onSubscribe()方法是最先调用的。
另外, 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() 表示下游不关心上游发送的是什么。
第二个带有一个Consumer参数的方法表示下游只关心onNext事件, 其他的事件不关心, 因此我们如果只需要onNext事件可以这么写，代码如下:

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emitter=1");
                emitter.onNext(1);
                Log.d(TAG, "emitter=2");
                emitter.onNext(2);
                Log.d(TAG, "emitter=3");
                emitter.onNext(3);
                Log.d(TAG, "emitter=complete");
                emitter.onComplete();
                Log.d(TAG, "emitter=4");
                emitter.onNext(4);
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "accept: " + integer);
            }
        });

运行结果如下：

接下来的几个方法的使用和第二个是一样的，就不多说了，最后一个方法的话，在文章前面就使用了，也不介绍了。

点击下载Demo

最简单易懂的RxJava2.0学习教程之RxJava2的基本使用（一）

一、配置

二、原理

第一步：创建被观察者

第二步：创建观察者

第三步：建立订阅关系

ObservableEmitter：

1、发送多个onComplete

2、发送多个onError事件

Disposable：

lightdb hash index的性能和限制

最完整的Windows下React Native開發環境搭建與第一個程序HelloWorld

最簡單易懂的RxJava2.0學習教程之RxJava2的基本使用（一）

Android各種學習資料（Rxjava、動畫、UI效果、開源庫、算法、面試）資源鏈接

簡單易懂的Java設計模式之單例模式

Android集合SparseArray的使用及源碼解析

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結