RxJava2.x学习教程（一）基本概念

RxJava是什么、优点

RxJava (本文所有RxJava全都代指RxJava2)在 GitHub 主页上的自我介绍是:RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.
核心就是一个基于事件的异步的程序库！
好处就是解决原生异步回调，造成的代码冗长、可读性可维护性差的问题，将其以一种链式的平铺的写法呈现，更方便维护！（有点类似前端Promise的作用）

依赖
可以去RxJava github官网直接copy最新版

implementation 'io.reactivex.rxjava2:rxjava:2.1.12'
implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'

观察者与被观察者
简单的说, 被观察者用于发送事件，观察者用于接收事件，两者建立订阅关系后，就可以实现，被观察者在需要的时候发送事件来通知观察者！
关于观察者模式不用过于纠结，只需简单的理解，被观察者属于上游事件来源，用来发送事件，观察者属于下游，用于接收事件就ok了！
RxJava中有两种观察者模式：

Observable ( 被观察者 ) / Observer ( 观察者 )
Flowable （被观察者）/ Subscriber （观察者）

前者不支持背压（Backpressure），后者支持！
背压是指在异步场景中，被观察者发送事件速度远快于观察者的处理速度的情况下，一种告诉上游的被观察者降低发送速度的策略。官方对于背压的解释

来一个例子

    /*
         RxJava 的三部曲：
         初始化 Observable（被观察者 事件来源）
         初始化 Observer（观察者 事件接收）
         建立订阅关系（将两者建立联系 被观察者可以通过发射事件通知观察者）

    */
    private void testRxJava1() {
       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);
                Log.e("TAG", "emitter on...");
                emitter.onComplete();
                Log.e("TAG", "emitter complete and on...");
                emitter.onNext(4);
            }
        });
       Observer<Integer> observer = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                //Disposable可以做到切断的操作，让Observer观察者不再接收上游事件
                Log.d("TAG", "subscribe");
            }

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

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

            @Override
            public void onComplete() {
                Log.d("TAG", "onComplete");
            }
        };
        observable.subscribe(consumer);//建立订阅关系
    }

05-19 11:50:57.050 2321-2321/com.example.rxjava.rxjavademo E/TAG: subscribe
05-19 11:50:57.050 2321-2321/com.example.rxjava.rxjavademo E/TAG: integer = 1
05-19 11:50:57.050 2321-2321/com.example.rxjava.rxjavademo E/TAG: integer = 2
05-19 11:50:57.050 2321-2321/com.example.rxjava.rxjavademo E/TAG: integer = 3
05-19 11:50:57.050 2321-2321/com.example.rxjava.rxjavademo E/TAG: emitter on...
05-19 11:50:57.050 2321-2321/com.example.rxjava.rxjavademo E/TAG: onComplete
05-19 11:50:57.050 2321-2321/com.example.rxjava.rxjavademo E/TAG: emitter complete and on...

从上面的结果可以看出，事件发射执行的一些顺序，规则！如被观察者调用emitter.onComplete();之后，虽然下面的事件继续发射，但是观察者并没有接收！

ObservableEmitter 事件发射器它可以通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)分别发出next事件、complete事件和error事件，它有以下几点需要注意的地方：

官方推荐当调用onComplete或者onError，作为结束标志后，不应再发射事件
onComplete或者onError应当只调用一次
其实你违背了上述原则，也没事，如调用onComplete之后，可以继续发射事件，但是下游观察者无法接收

Disposable，可以通过调用他的dispose()方法，让下游观察者无法继续接收事件！

    //将上面那个例子链起来 就是RxJava经典写法链式操作
    private void testRxJava1() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                Log.e("TAG", "emitter on...");
                emitter.onComplete();
                Log.e("TAG", "emitter complete and on...");
                emitter.onNext(4);
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("TAG", "subscribe");
            }

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

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

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

另外， 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) {}

带有一个Consumer参数的subscribe：

     Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.e("TAG", "emmiter 1");
                emitter.onNext(1);
                Log.e("TAG", "emmiter 2");
                emitter.onNext(2);
                Log.e("TAG", "emmiter 3");
                emitter.onNext(3);
                emitter.onComplete();
                Log.e("TAG", "emmiter 4");
                emitter.onNext(4);
                Log.e("TAG", "emmiter 5");
                emitter.onNext(5);
            }
        }).subscribe(new Consumer<Integer>() {//只处理onNext
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e("TAG", "accept integer = " + integer);
            }
        });

上面这个例子，可以用java8的箭头函数，进一步简化：

  Observable.create((ObservableOnSubscribe<Integer>) emitter -> {
            Log.e("TAG", "emmiter 1");
            emitter.onNext(1);
            Log.e("TAG", "emmiter 2");
            emitter.onNext(2);
            Log.e("TAG", "emmiter 3");
            emitter.onNext(3);
            emitter.onComplete();
            Log.e("TAG", "emmiter 4");
            emitter.onNext(4);
            Log.e("TAG", "emmiter 5");
            emitter.onNext(5);
        }).subscribe(integer -> Log.e("TAG", "accept integer = " + integer));

05-19 15:25:11.290 7170-7170/com.example.rxjava.rxjavademo E/TAG: emmiter 1
05-19 15:25:11.290 7170-7170/com.example.rxjava.rxjavademo E/TAG: accept integer = 1
05-19 15:25:11.290 7170-7170/com.example.rxjava.rxjavademo E/TAG: emmiter 2
05-19 15:25:11.290 7170-7170/com.example.rxjava.rxjavademo E/TAG: accept integer = 2
05-19 15:25:11.290 7170-7170/com.example.rxjava.rxjavademo E/TAG: emmiter 3
05-19 15:25:11.290 7170-7170/com.example.rxjava.rxjavademo E/TAG: accept integer = 3
05-19 15:25:11.290 7170-7170/com.example.rxjava.rxjavademo E/TAG: emmiter 4
05-19 15:25:11.290 7170-7170/com.example.rxjava.rxjavademo E/TAG: emmiter 5

带有两个参数的subscribe() ：

   Observable.just(1, "2")
             .cast(Integer.class)//将被观察者发送的事件数据类型强转为Integer
             .subscribe(new Consumer<Integer>() {//只处理onNext
                 @Override
                 public void accept(Integer integer) throws Exception {
                     Log.e("TAG", "" + integer);
                 }
             }, new Consumer<Throwable>() {//捕获异常
                 @Override
                 public void accept(Throwable throwable) throws Exception {
                     Log.e("TAG", throwable.getMessage());
                 }
             });

当然它也可以用java8的箭头函数改写：

    Observable.just(1, "2")
              .cast(Integer.class)
              .subscribe(integer -> Log.e("TAG", "" + integer), 
                         throwable -> Log.e("TAG", throwable.getMessage()));

运行结果

05-22 15:15:54.405 6034-6034/com.example.rxjava.rxjavademo E/TAG: 1
05-22 15:15:54.405 6034-6034/com.example.rxjava.rxjavademo E/TAG: java.lang.String cannot be cast to java.lang.Integer

这里只是对基本概念的介绍，对RxJava有一个基本了解，后续会进行详细的用法解读！
RxJava2.x学习教程（二）常用操作符

参考
RxJava Github官网
 给 Android 开发者的 RxJava 详解（RxJava1时代的神作）
给初学者的RxJava2.0教程系列
 这可能是最好的RxJava 2.x 教程系列
 RxJava常见的使用场景总结

RxJava2.x学习教程（一）基本概念

猜你喜欢