RxJava2

1.引入依赖

implementation "io.reactivex.rxjava2:rxjava:2.1.17"
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'

2.创建Observable

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);
       emitter.onComplete();
    }
});

3.创建Observer

Observer<Integer> observer = new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "onSubscribe: ");
   }

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

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

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

4.观察者观察被观察者

observable.subscribe(observer);

ObservableEmitter和Disposable

ObservableEmitter： Emitter是发射器的意思，这个就是用来发出事件的，它可以发出三种类型的事件，通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。

但是，请注意，并不意味着你可以随意乱七八糟发射事件，需要满足一定的规则：

上游可以发送无限个onNext, 下游也可以接收无限个onNext.
当上游发送了一个onComplete后, 上游onComplete之后的事件将会继续发送, 而下游收到onComplete事件之后将不再继续接收事件.
当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续接收事件.
上游可以不发送onComplete或onError.
最为关键的是onComplete和onError必须唯一并且互斥

Disposable：当调用它的dispose()方法时,下游将不再接收事件

public class MainActivity extends AppCompatActivity {

    private final static String TAG = "MainActivity";

    private Disposable disposable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        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);
                emitter.onComplete();
            }
        });
        Observer<Integer> observer = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: ");
                disposable = d;
            }

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

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

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

这里写图片描述

线程切换

正常情况下, 上游和下游是工作在同一个线程中的,要想让观察者和被观察者在不同的线程中执行，需要调用subscribeOn和observeOn方法来改变观察者与被观察者执行任务的线程、

observable.subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(observer);
//observeOn表示更改被观察者所在的线程，subscribeOn表示更改观察者所在的线程
//这里让被观察者在子线程中执行，观察者在主线程

多次调用subscribeOn() 只有第一次的有效, 其余的会被忽略.

每调用一次observeOn() , 下游的线程就会切换一次.

在RxJava中, 已经内置了很多线程选项供我们选择, 例如有

Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作
Schedulers.computation() 代表CPU计算密集型的操作, 例如需要大量计算的操作
Schedulers.newThread() 代表一个常规的新线程
AndroidSchedulers.mainThread() 代表Android的主线程

那如果有多个Disposable 该怎么办呢, RxJava中已经内置了一个容器CompositeDisposable, 每当我们得到一个Disposable时就调用CompositeDisposable.add()将它添加到容器中, 在退出的时候, 调用CompositeDisposable.clear() 即可切断所有的水管.

操作符

Map

map是RxJava中最简单的一个变换操作符了, 它的作用就是对被监管者发送的每一个事件应用一个函数, 使得每一个事件都按照指定的函数去变化.

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onComplete();
            }
        }).map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return "this is " + integer;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                throwable.getMessage();
            }
        });

这里写图片描述
FlatMap

FlatMap可以将被观察者发送的事件转化成多个事件
map只能将一个事件转化成一个事件

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onComplete();
            }
        }).flatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                List<String> list = new ArrayList<>();
                for(int i = 0; i < 2; i++){
                    list.add("i am " + integer);
                }
                return Observable.fromIterable(list);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                throwable.getMessage();
            }
        });

这里写图片描述
可以看到，这里

里面接收了一个新的参数，ObservableSource，调用他的Observable.fromIterable(list)可以遍历集合。
flatMap并不保证事件的顺序, 如果需要保证顺序则需要使用concatMap.

Zip

Zip通过一个函数将多个Observable发送的事件结合到一起，然后发送这些组合到一起的事件. 它按照严格的顺序应用这个函数。它只发射与发射数据项最少的那个Observable一样多的数据。

Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        });
        Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("A");
                emitter.onNext("B");
                emitter.onComplete();
            }
        });
        Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
            @Override
            public String apply(Integer integer, String s) throws Exception {
                return integer + s;
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {
                Log.d(TAG, s);
            }

            @Override
            public void onError(Throwable e) {

            }

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

这里写图片描述

filter

用来过滤Observable发送的事件

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 100; i++){
                    emitter.onNext(i);
                }
            }
        }).subscribeOn(Schedulers.newThread())
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer % 10 == 0;
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, integer + "");
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.d(TAG, throwable.getMessage());
                    }
                });

这里写图片描述

sample

这个操作符每隔指定的时间就从上游中取出一个事件发送给下游

sample(2, TimeUnit.SECONDS)

Flowable

Flowable<Integer> flowable = Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        }, BackpressureStrategy.ERROR);

Backpressure

这个参数是用来选择背压,也就是出现上下游流速不均衡的时候应该怎么处理的办法, 这里我们直接用BackpressureStrategy.ERROR这种方式, 这种方式会在出现上下游流速不均衡的时候直接抛出一个异常,这个异常就是著名的MissingBackpressureException
BackpressureStrategy.BUFFER：将被观察者中可存储的事件数量提高到无限大，对应Flowable.onBackpressureBuffer()
BackpressureStrategy.DROP：把存不下的事件丢掉，对应Flowable.onBackpressureDrop()
BackpressureStrategy.LATEST：只保留最新的事件，对应Flowable.onBackpressureLatest()

注意，观察者要用subscriber

Subscriber<Integer> subscriber = new Subscriber<Integer>() {
            @Override
            public void onSubscribe(Subscription s) {
                s.request(Long.MAX_VALUE);
            }

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

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

            @Override
            public void onComplete() {

            }
        };

Subscription
这里写图片描述
调用Subscription.cancel()也可以切断观察者与被观察者的联系,
调用Subscription.request()方法表示观察者告知被观察者自己处理事件的能力，接收相应数目的事件

interval

interval操作符发送Long型的事件, 从0开始, 每隔指定的时间就把数字加1并发送出来

FlowableEmitter.request()

被观察者可以通过这个方法得到观察者当前处理事件的能力
如果多次设置观察者request()，那么最终的能力为相加
每处理一个事件这个能力就会减少

在同步中会直接用观察者指定的request，
异步中会先用掉原本就有的128，再用request

猜你喜欢