RxJava(1)

一.简介

RxJava是ReactiveX的一种Java实现。 ReactiveX是Reactive Extensions的缩写，一般简写为Rx。微软给的定义是，Rx是一个函数库，让开发者可以利用可观察序列和LINQ风格查询操作符来编写异步和基于事件的程序。开发者可以通过Observables表示异步数据流，用LINQ操作符查询异步数据流，用Schedulers参数化异步数据流的并发处理：Rx = Observables + LINQ + Schedulers

对于异步操作，我们会想到Android的AsyncTask和Handler。但是随着请求数量的增多，并行数据流的增加，代码逻辑将会越来越复杂，而RxJava却可以保持清晰的逻辑。其原理就是创建一个Observable对象来干活，然后使用各种操作符建立链式操作，就像流水线一样将你想要处理的数据一步一步加工成你想要的样子然后发射给Subscriber处理。RxJava有四个角色Observable、Observer、Subscriber和Subject，Observable和Observer通过subscribe方法实现订阅关系，被观察者Observable就会在需要的时候通知Observer。

二.基本实现

先导入RxJava的仓库：

dependencies {
    ...
    implementation 'io.reactivex:rxjava:1.2.0'
    implementation 'io.reactivex:rxandroid:1.2.1'//RxJava在Android平台的扩展，包含了一些能够简化Android开发的工具
}

1.创建Observer(观察者)

Subscriber<String> subscriber = new Subscriber<String>() {
    @Override
    public void onCompleted() {
        Log.e("tag", "completed");
    }

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

    @Override
    public void onNext(String s) {
        Log.e("tag", s);
    }

    @Override
    public void onStart() {
        Log.e("tag", "start");
    }
};

其中onCompleted、onError和onNext是必须要实现的方法，其含义如下：

onCompleted：事件队列完结。RxJava不仅把每个事件单独处理，其还会把它们看做一个队列，当不会再有新的onNext发出时需要触发onCompleted方法作为完成标志

onError：事件队列异常。在事件处理过程中出现异常时，onError（）会被触发，同时队列自动终止，不允许再有事件发出

onNext：普通的事件。将要处理的事件添加到事件队列中

onStart：它会在事件还未发送之前被调用，可以用于做一些准备工作。例如数据的清零或重置，这是一个可选择是否重写的方法，默认情况下它是空实现

另外，Subscriber是接口Observer的抽象实现类，他在Observer的基础上拓展了一些方法，onStart就是其中之一。所以我们也可以通过直接实现Observer接口来创建观察者，它只有必须实现的onCompleted、onError和onNext三个方法：

Observer<String> observer = new Observer<String>() {
    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(String s) {

    }
};

2.创建Observable(被观察者)

它决定了触发事件的时机以及类型，并且规定了触发事件的规则：

Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("1");
        subscriber.onNext("2");
        subscriber.onNext("3");
        subscriber.onCompleted();
    }
});

对于同一类型的若干事件发射，RxJava为我们提供了快捷方法：

//just方法
Observable<String> observable1 = Observable.just("1", "2", "3");

//from方法
String[] arr = new String[]{"1", "2", "3"};
Observable<String> observable2 = Observable.from(arr);

3.subscribe(订阅)

只需要一句代码就可以完成订阅：

observable.subscribe(subscriber);

//执行之后打印结果：
//2022-02-11 16:20:34.888 13273-13273/com.pivot.myandroiddemo E/tag: start
//2022-02-11 16:20:34.888 13273-13273/com.pivot.myandroiddemo E/tag: 1
//2022-02-11 16:20:34.888 13273-13273/com.pivot.myandroiddemo E/tag: 2
//2022-02-11 16:20:34.888 13273-13273/com.pivot.myandroiddemo E/tag: 3
//2022-02-11 16:20:34.889 13273-13273/com.pivot.myandroiddemo E/tag: completed

4.不完整定义回调

前面说事件触发之后的事件回调可以依赖于Subscriber或者Observer来完成，如果你只需要onCompleted、onError和onNext三个事件中的onNext触发回调那么你的想法可能是让不需要回调的另外两个方法空实现，这样是可以的，但是RxJava为我们提供了另一种回调方式-不完整回调。说之前先要了解Action接口：

public interface Action0 extends Action {
    void call();
}

public interface Action1<T> extends Action {
    void call(T t);
}

public interface Action2<T1, T2> extends Action {
    void call(T1 t1, T2 t2);
}

... ...

public interface Action9<T1, T2, T3, T4, T5, T6, T7, T8, T9> extends Action {
    void call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9);
}

public interface ActionN extends Action {
    void call(Object... args);
}

Action后面的数字代表回调方法形参的类型数量，那么我们的订阅逻辑就可以改为：

Action1<String> onNextAction = new Action1<String>() {
    @Override
    public void call(String s) {
        Log.e("tag", s);
    }
};

Action1<Throwable> onErrorAction = new Action1<Throwable>() {
    @Override
    public void call(Throwable throwable) {
        Log.e("tag", throwable.getMessage());
    }
};

Action0 onCompletedAction = new Action0() {
    @Override
    public void call() {
        Log.e("tag", "completed");
    }
};

observable.subscribe(onNextAction);
//observable.subscribe(onNextAction, onErrorAction);
//observable.subscribe(onNextAction, onErrorAction, onCompletedAction);

也可以实现next和error的回调，或者三个事件都实现回调，这样就不需要再单独去实现Observer接口了