1.概念

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

查看rxandroid库，全部加起来大概三百行代码，作用就是为android提供切换主线程。（上面两个不一定要一致，>2.0就可以，rxandroid确实没什么需要更新）

官方地址解释：https://github.com/ReactiveX/RxJava

2.RxJava中的观察者模式

观察者模式（百科）：观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

小生对观察者模式的理解：

电视信号发射台和电视机的订阅关系

写法一：Observable

就比如电视信号发射台和电视机的关系。
Observable ：是被观察者（电视信号发射台）的意思
Observer：就是观察者（电视机）
明白了吧，当你收看某个电视台时，就相当于建立好了订阅关系，发射台往外发数据，电视机接收数据进行处理显示，这个时候就是你看到的电视了。
注意：多个电视机收听同一个电视台。同理，观察者可以是多个。

写法二：Flowable（2.0新增）

在RxJava 2.x中对于backpressure的处理进行了改动，为此将原来的Observable拆分成了新的Observable和Flowable。Flowable 中的操作符大多与旧有的 Observable 类似。
增加特性：支持背压
就比如在网页上看视频一样，写法一需要来一个数据处理一个数据，但是我们不可能看视频是根据你接收到多少就处理显示多少，但是不收我就丢失了你这次的数据。这时背压就相当于我们的缓冲效果，数据可以发，我也会收，解决了“发送速率>接收处理速率”的问题。原来以什么样的速度产生事件，现在还是什么样的速度不会变化，主要处理的是Subscriber接收事件的方式。
Flowable：就是被观察者（电视信号发射台）
Subscriber：就是观察者（电视机）
原理和上面一样。

3.RxJava的配置使用

Observable写法的简单使用（后续将会详细讲述更多简洁写法）

原来的new Thread 异步线程：

···
        new Thread() {
            @Override
            public void run() {
                super.run();
                SystemClock.sleep(2000);
                new Handler().post(new Runnable() {
                    @Override
                    public void run() {
                        Log.i(TAG, "run: " + Thread.currentThread().getName());
                    }
                });
            }
        }.start();
···

现在的Observable 异步写法

        Log.i(TAG, "run: " + Thread.currentThread().getName());
        Observable.empty()
                .doOnComplete(new Action() {
                    @Override
                    public void run() throws Exception {
                        Log.i(TAG, "run: " + Thread.currentThread().getName());
                        SystemClock.sleep(2000);
                        Log.i(TAG, "run: " + Thread.currentThread().getName());
                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .doOnComplete(new Action() {
                    @Override
                    public void run() throws Exception {
                        Log.i(TAG, "run: " + Thread.currentThread().getName());
                    }
                })
                .subscribe();

Observable 写法打印结果

Observable 写法打印结果

可以看到，很方便的实现了异步操作和线程切换。

Flowable写法的简单使用（后续也将详细讲述）

Flowable 中的操作符大多与旧有的 Observable 类似。

          实现简单异步代码，略
         （上面Observable 异步写法的代码直接Observable改成Flowable 即可。）

我就不拿上面的代码再写一遍了。
简单写一个Flowable 事件分发背压的写法

        //发射器
        Flowable<String> flowable = Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> e) throws Exception {
                String names[] = {"yangbin", "lizhangyan", "laopo", "laogong"};
                for (String name : names) {
                    e.onNext(name);
                }
                e.onComplete();
            }
        }, BackpressureStrategy.BUFFER);
        //接收器
        Subscriber subscriber = new Subscriber<String>() {
            @Override
            public void onSubscribe(Subscription s) {
                s.request(Long.MAX_VALUE);
            }
            @Override
            public void onNext(String s) {
                Log.i(TAG, "onNext: " + s);
            }
            @Override
            public void onError(Throwable t) {

            }
            @Override
            public void onComplete() {
                Log.i(TAG, "onComplete: ");
            }
        };
        flowable.subscribe(subscriber);

Flowable写法打印结果

Paste_Image.png

可以看到，很方便的实现了事件的分发。

感谢您的浏览，更多写法请看下期