简介

相关网站：GitHub地址、官方文档、中文文档。
RxJava2 通过一种扩展的 观察者模式 来实现异步执行任务。
RxJava2 能方便地进行线程切换。
RxJava2 能方便地把异步执行的代码写在一处。

基础知识

简单示例

1. 普通示例

1. 定义`Observable`

Observable observable = Observable.create(emitter -> {
    // Todo: 执行后台请求，请求后的结果通过onNext()发送给Observer
    // 发送消息
    emitter.onNext(1);
    emitter.onNext(2);
    emitter.onNext(3);
    // 消息发送完毕
    emitter.onComplete();
});

2. 定义`Observer`

Observer observer = new Observer() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "subscribe");
        // 订阅时
        // Disposable对象可以保存，日后通过调用Disposable.dispose()来中断订阅。
    }

    @Override
    public void onNext(Integer value) {
        Log.d(TAG, "" + value);
        // 接收到事件时
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "error");
        // 接收到错误时
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "complete");
        // 事件接收完毕时
    }
};

3. 订阅

注意：此处代码的书写顺序看起来不符合直觉，这样设计是为了便于 链式调用 。

observable.subscribe(observer);

2. 链式示例

Observable.create((ObservableOnSubscribe) emitter -> {
    // Todo: 执行后台请求，请求后的结果通过onNext()发送给Observer
    // 发送消息
    emitter.onNext(1);
    emitter.onNext(2);
    emitter.onNext(3);
    // 消息发送完毕
    emitter.onComplete();
}).subscribe(new Observer() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "subscribe");
        // 订阅时
        // Disposable对象可以保存，日后通过调用Disposable.dispose()来中断订阅。
    }

    @Override
    public void onNext(Integer value) {
        Log.d(TAG, "" + value);
        // 接收到事件时
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "error");
        // 接收到错误时
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "complete");
        // 事件接收完毕时
    }
});

3. 无`Observer`示例

`subscribe()`的所有重载形式

public final Disposable subscribe() {}
public final Disposable subscribe(Consumer onNext) {}
public final Disposable subscribe(Consumer onNext, Consumer onError) {}
public final Disposable subscribe(Consumer onNext, Consumer onError, Action onComplete) {}
public final Disposable subscribe(Consumer onNext, Consumer onError, Action onComplete, Consumer onSubscribe) {}
public final void subscribe(Observer observer) {}

代码

Observable.create((ObservableOnSubscribe) emitter -> {
    emitter.onNext(1);
    emitter.onNext(2);
    emitter.onNext(3);
    emitter.onComplete();
    emitter.onNext(4);
}).subscribe(
        integer -> Log.d(TAG, "onNext: " + integer),
        throwable -> Log.d(TAG, "onError"),
        () -> Log.d(TAG, "onComplete"));

示例解说

emitter是ObservableEmitter类型，用于发射onNext()，onComplete()，onError()消息。
Disposable对象可以保存，日后通过调用Disposable.dispose()来 中断订阅 ， 中断订阅 以后发送的消息无法被Observer接收到。
Observable可以不发送onComplete()或onError()。
当Observable发送了一个onComplete()后，Observable在onComplete()之后的onNext()将会继续发送，而Observer收到onComplete()之后将不再继续接收onNext()。
当Observable发送了一个onError()后，Observable在onError()之后的onNext()将继续发送，而Observer收到onError()之后将不再继续接收onNext()。
onComplete()和onError()必须唯一并且互斥，即只能发送一个onComplete()或onError()。

事件流向图

事件流向	示意图
只发送`onNext()`事件
发送`onComplete()`事件
发送`onError()`事件

线程相关

切换线程示例

subscribeOn()：控制observable在什么线程中发送事件。
observeOn()：控制observer在什么线程中处理事件。

// observable的链式操作中
observable.subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(observer);

线程种类

线程种类	描述
`Schedulers.newThread()`	新线程。
`Schedulers.computation()`	用于CPU计算密集型的操作的线程。
`Schedulers.io()`	用于IO操作的线程，如网络IO，文件IO，数据库IO。
`AndroidSchedulers.mainThread()`	Android 的 UI主线程。

注意事项

Observable和Observer默认是在 UI主线程 中运行的。
Observable多次切换线程的话，只有第一次有效。
Observer多次切换线程的话，只有最后一次生效。

过滤操作符

`Sample`

简介

Sample操作符定时查看一个Observable，然后发射自上次采样以来它最近发射的数据。
会导致某些事件丢失。

示意图

变换操作符

`Map`

示意图

简介

用于将一种类型的事件转换为另一种类型的事件。

啰嗦示例

Observable.create((ObservableOnSubscribe) emitter -> {
    emitter.onNext(1);
}).map(new Function() {
    @Override
    public String apply(@NonNull Integer integer) throws Exception {
        return "This is result " + integer;
    }
}).subscribe(new Consumer() {
    @Override
    public void accept(@NonNull String s) throws Exception {
        Log.d(TAG, s);
    }
});

简洁示例

Observable.create((ObservableOnSubscribe) emitter -> emitter.onNext(1))
        .map(integer -> "This is result " + integer)
        .subscribe(s -> Log.d(TAG, s));

`FlatMap`

示意图

简介

FlatMap将单个事件或 事件队列 变换为一个发送单个事件或 事件队列 的Observable。
可以通过FlatMap将事件变换为Observable来实现链式中连接多个Observable： Observable->事件->Observable->事件...->Observer 。
FlatMap并不保证事件的顺序，如果需要保证顺序则使用ConcatMap，使用方法同FlatMap。

啰嗦示例

Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter emitter) throws Exception {
        emitter.onNext(1);
    }
}).flatMap(new Function>() {
    @Override
    public Observable apply(Integer integer) throws Exception {
        final List list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            list.add("I am value " + integer);
        }
        return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS);
    }
}).subscribe(new Consumer() {
    @Override
    public void accept(String s) throws Exception {
        Log.d(TAG, s);
    }
});

简洁示例

Observable.create((ObservableOnSubscribe) emitter -> emitter.onNext(1))
        .flatMap(new Function>() {
            @Override
            public Observable apply(Integer integer) throws Exception {
                final List list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("I am value " + integer);
                }
                return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS);
            }
        })
        .subscribe(s -> Log.d(TAG, s));

`ConcatMap`

ConcatMap保证事件的顺序，使用方法同FlatMap。
示例省略，参考FlatMap。

`Zip`

示意图

简介

组合多个Observable发送的事件，然后发送这个 事件组合 。
事件组合 的顺序是严格按照事件发送的顺序来进行的。
发送事件的数量，与所有Observable中事件数量最少的那个一样。
注意：这多个Observable在同一个线程时无法将事件组合发送，即发送一个Observable的所有事件以后，再发送另一个Observable。
应用场景：一个界面需要展示用户的一些信息，而这些信息分别要从两个服务器接口中获取，而只有当两个都获取到了之后才能进行展示。

啰嗦示例

Observable observable1 = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter emitter) throws Exception {
        Log.d(TAG, "emit 1");
        emitter.onNext(1);

        Log.d(TAG, "emit complete1");
        emitter.onComplete();
    }
}).subscribeOn(Schedulers.io());

Observable observable2 = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter emitter) throws Exception {
        Log.d(TAG, "emit A");
        emitter.onNext("A");

        Log.d(TAG, "emit complete2");
        emitter.onComplete();
    }
}).subscribeOn(Schedulers.io());

Observable.zip(observable1, observable2, new BiFunction() {
    @Override
    public String apply(@NonNull Integer integer, @NonNull String s) throws Exception {
        return integer + s;
    }
}).subscribe(new Consumer() {
    @Override
    public void accept(@NonNull String s) throws Exception {
        Log.d(TAG, "onNext: " + value);
    }
});

简洁示例

Observable observable1 = Observable.create((ObservableOnSubscribe) emitter -> {
    Log.d(TAG, "emit 1");
    emitter.onNext(1);

    Log.d(TAG, "emit complete1");
    emitter.onComplete();
}).subscribeOn(Schedulers.io());

Observable observable2 = Observable.create((ObservableOnSubscribe) emitter -> {
    Log.d(TAG, "emit A");
    emitter.onNext("A");

    Log.d(TAG, "emit complete2");
    emitter.onComplete();
}).subscribeOn(Schedulers.io());

Observable.zip(observable1, observable2, (integer, s) -> integer + s).subscribe(s -> Log.d(TAG, "onNext: " + s));

特殊情况处理

对于Observer在 UI主线程 进行事件处理，但是接收到事件时，所在的Activity或Fragment已经退出的情况，需要通过调用Disposable.dispose()或Subscription.cancel()来 中断订阅 。

1. 创建`CompositeDisposable`

CompositeDisposable对象是储存Disposable对象的容器。

作为Activity或Fragment的成员：

CompositeDisposable mCompositeDisposable = new CompositeDisposable();

2. 保存`Disposable`

在Observer.onSubscribe(...)中：

@Override
public void onSubscribe(Disposable d) {
    mCompositeDisposable.add(d);
}

3. 中断订阅

在Activity或Fragment的onDestroy()中：

mCompositeDisposable.clear();

`Flowable`

简介

Flowable类似Observable，但是性能不如Observable。
Flowable为解决 Backpressure问题 而生。

Backpressure问题简介

Backpressure问题 ：当事件的发送远远快于事件的消耗时，未消耗的事件会堆积起来，最终可能发生 OOM 。
出现 Backpressure问题 可能是因为两个原因：
- 某个Observable发送事件的速度太快，或数量太多。
- 某个Observer处理事件的速度太慢。
事件的发送和接收在同一个线程的时候不会出现这种问题，因为必定会处理完一个事件以后才能继续发送下一个事件。

简洁示例

Flowable upstream = Flowable.create(emitter -> {
    // 直到下游开始请求事件
    while (emitter.requested() == 0) {
        if (emitter.isCancelled())
            break;
    }
    Log.d(TAG, "emit 1");
    emitter.onNext(1);
    Log.d(TAG, "emit complete");
    emitter.onComplete();
}, BackpressureStrategy.ERROR);

Subscriber downstream = new Subscriber() {
    @Override
    public void onSubscribe(Subscription s) {
        Log.d(TAG, "onSubscribe");
        s.request(10);
    }

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

    @Override
    public void onError(Throwable t) {
        Log.w(TAG, "onError: ", t);
    }

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

示例解说

BackpressureStrategy（ 背压策略 ），表示事件发送速度快于消耗速度时说使用的策略，有以下几种：
- MISSING：多出来的事件直接丢弃。
- ERROR：抛出MissingBackpressureException异常。
- BUFFER：全部事件缓存直到被消耗，注意 OOM 问题。也可以通过Flowable.onBackpressureBuffer()设置。
- DROP：丢弃最近发送的事件。也可以通过Flowable.onBackpressureDrop()设置。
- LATEST：只保留一个最近的事件覆盖前一个事件。也可以通过Flowable.onBackpressureLatest()设置。
Subscription.cancel()：可以用于 取消订阅关系 。
Subscription.request(..)：告知Flowable，Observer的 事件请求量 ，可以多次调用，每次调用累加 事件请求量 计数器。
FlowableEmitter.requested()：得知Observer的 事件请求量 。

★42.RxJava2

简介

基础知识

相关概念

相关方法

简单示例

1. 普通示例

1. 定义Observable

2. 定义Observer

3. 订阅

2. 链式示例

3. 无Observer示例

subscribe()的所有重载形式

代码

示例解说

事件流向图

线程相关

切换线程示例

线程种类

注意事项

过滤操作符

Sample

简介

示意图

变换操作符

Map

示意图

简介

啰嗦示例

简洁示例

FlatMap

示意图

简介

啰嗦示例

简洁示例

ConcatMap

Zip

示意图

简介

啰嗦示例

简洁示例

特殊情况处理

1. 创建CompositeDisposable

2. 保存Disposable

3. 中断订阅

Flowable

简介

Backpressure问题简介

简洁示例

示例解说

你可能感兴趣的:(★42.RxJava2)

1. 定义`Observable`

2. 定义`Observer`

3. 无`Observer`示例

`subscribe()`的所有重载形式

`Sample`

`Map`

`FlatMap`

`ConcatMap`

`Zip`

1. 创建`CompositeDisposable`

2. 保存`Disposable`

`Flowable`