RxJava2.0——入门教程

了解观察者模式

简单介绍一下，A和B两个，A是被观察者，B是观察者，B对A进行观察，B并不是需要时刻盯着A，而是A如果发生了变化，会主动通知B，B会对应做一些变化。举个例子，假设A是连载小说，B是读者，读者订阅了连载小说，当小说出现了新的连载的时候，会推送给读者。读者不用时刻盯着小说连载，而小说有了新的连载会主动推送给读者。这就是观察者模式。而RxJava正是基于观察者模式开发的

RxJava2.0 基本使用

首先引入RxJava2.0相关的类库

implementation 'io.reactivex.rxjava2:rxjava:2.2.14'
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'

第一步：创建连载小说（被观察者）

//被观察者
        Observable novel = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("连载一");
                emitter.onNext("连载二");
                emitter.onNext("连载三");
                emitter.onComplete();
            }
        });

Observable 中文意思就是被观察者，通过 create 方法生成对象，里面放的参数ObservableOnSubscribe<T>，可以理解为一个计划表，泛型 T 是要操作对象的类型，重写 subscribe 方法，里面写具体的计划，本文的例子就是推送连载1、连载2和连载3，在 subscribe 中的ObservableEmitter<String>对象的 Emitter 是发射器的意思。ObservableEmitter 有三种发射的方法，分别是void onNext(T value)、void onError(Throwable error)、void onComplete()，onNext 方法可以无限调用，Observer（观察者）所有的都能接收到，onError 和onComplete 是互斥的，Observer（观察者）只能接收到一个，OnComplete 可以重复调用，但是 Observer（观察者）只会接收一次，而 onError 不可以重复调用，第二次调用就会报异常。

第二步：创建读者（观察者）

//观察者
        Observer reader = new Observer() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                mDisposable=d;
                Log.e(TAG,"onSubscribe()");
            }

            @Override
            public void onNext(@NonNull Object o) {
                if ("2".equals(o)){
                    mDisposable.dispose();
                    return;
                }
                Log.e(TAG,"onNext()"+o);
            }

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

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

通过 new 创建接口，并实现其内部的方法，看方法其实就应该差不多知道干嘛的，onNext、onError、onComplete 都是跟被观察者发射的方法一一对应的，这里就相当于接收了。onSubscribe（Disposable d）里面的 Disposable 对象要说一下，Disposable 英文意思是可随意使用的，这里就相当于读者和连载小说的订阅关系，如果读者不想再订阅该小说了，可以调用 mDisposable.dispose()取消订阅，此时连载小说更新的时候就不会再推送给读者了

第三步：读者和连载小说建立订阅关系

//建立联系
novel.subscribe(reader);

在这里细心的你，可能已经发现了怎么是小说订阅了读者，之所以这样，是因为RxJava主要是想保持自己的链式编程，不得不把Observable(被观察者)放在前面，这里大家可以理解为小说被读者订阅了

运行结果

这就是RxJava2.0最最简单的用法

RxJava2.0的异步和链式编程

RxJava 是支持异步的，但是 RxJava 是如何做到的呢？这里就需要 Scheduler。Scheduler，英文名调度器，它是 RxJava 用来控制线程。当我们没有设置的时候，RxJava 遵循哪个线程产生就在哪个线程消费的原则，也就是说线程不会产生变化，始终在同一个。然后我们一般使用 RxJava 都是 后台执行，前台调用，本着这个原则，我们需要调用observeOn(AndroidSchedulers.mainThread())，observeOn 是事件回调的线程，AndroidSchedulers.mainThread() 一看就知道是主线程，subscribeOn(Schedulers.io())，subscribeOn 是事件执行的线程，Schedulers.io() 是子线程，这里也可以用Schedulers.newThread()，只不过 io 线程可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。前面的代码根据异步和链式编程的原则，我们可以写成

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("连载一");
                emitter.onNext("连载二");
                emitter.onNext("连载三");
                emitter.onComplete();
            }
        }).observeOn(AndroidSchedulers.mainThread())//回调在主线程
                .subscribeOn(Schedulers.io())//执行在io线程
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(@NonNull Disposable d) {
                        mDisposable = d;
                        Log.e(TAG, "onSubscribe()");
                    }

                    @Override
                    public void onNext(@NonNull Object o) {
                        if ("2".equals(o)) {
                            mDisposable.dispose();
                            return;
                        }
                        Log.e(TAG, "onNext()" + o);
                    }

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

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

这里就是 RxJava 最常用的写法，异步+链式编程，还要再说一下，subscribe 的方法重载，subscribe() 方法里什么参数也不放是空实现，也就是说连载小说无论出什么连载，读者都不关心，推送过来了也不读，如果读者只关心 onNext 方法里的内容，可以直接重载subscribe(Consumer<? spuer T> onNext)这个方法，会减少代码，当然如果是初学者还是建议创建Observer对象

参考文章：
RxJava2.0——从放弃到入门
Android Rxjava：这是一篇 清晰 & 易懂的Rxjava 入门教程

接下来可以继续学习
Android RxJava：最基础的操作符详解 - 创建操作符
作者写的Rxjava系列文章很好，先学完再说