Android 使用RxJava--基础篇

RxJava是什么

RxJava 是基于观察者模式写成的一套框架。具备快捷切换线程的能力。

RxJava可以做什么？

可以在指定线程去做业务处理，然后把处理结果返回到指定的另一个线程。

RxJava 怎么使用？

引入依赖库：

    implementation 'io.reactivex.rxjava3:rxjava:3.0.0'
    implementation 'io.reactivex.rxjava3:rxandroid:3.0.0'

创建Observable

方法1：一般来说，比较常用的创建方法：

        Observable.create(new ObservableOnSubscribe<String>() {
        	此处的subscribe方法主要用于你去处理业务逻辑，处理完之后调用emitter.onNext 把结果发送给监听者。
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Throwable {
                emitter.onNext("Observable.create");
            }
        }).subscribe(new Consumer<String>() {
        此处的accept方法主要用于接收到结果之后，你要做的业务逻辑
            @Override
            public void accept(String s) throws Throwable {
                Log.d(TAG, s);
            }
        });

方法2：快捷的创建方法，从数组里面创建

        Observable.fromArray(Arrays.asList(1,2,34,5)).subscribe(new Consumer<List<Integer>>() {
            @Override
            public void accept(List<Integer> integers) throws Throwable {
                Log.d(TAG, "integers:" + integers);
            }
        });

方法3：使用可变参数创建

        Observable.just("just1", "just2").delay(3, TimeUnit.SECONDS).subscribeWith(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull String s) {

                Log.d(TAG, s);
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        }).onSubscribe(new Disposable() {
            @Override
            public void dispose() {

            }

            @Override
            public boolean isDisposed() {
                return false;
            }
        });

指定线程

我们可以执行业务处理操作的线程，以及结果回调的线程。
比如在Android 里面，我们希望数据处理在子线程，更新Ui在主线程，那么我们可以这样做。

bservable.just("one", "two").subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread())

subscribeOn 表示订阅在哪个线程，我们写的业务处理代码就会在哪个线程。
observeOn 表示通知在哪个线程，处理结果完成后，会在指定的线程通知我们。
注意:如果你只是指定了subscribeOn 线程，没有指定observeOn 线程，那么默认RxJava 就会在你ObserveOn 的线程，直接回调结果给你。

取消操作

如果我们想要在业务处理过程中取消订阅，也是很简单的。
我们调用subscribe方法之后，会返回一个Disposable，我们调用dispose方法就可以取消订阅，就不会收到通知了。

        @NonNull Disposable subscribe1 = Observable.just("1,2,3", "4,5,6").subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Throwable {
                Log.d(TAG, "subscribe1" + s);
            }
        });
        //虽然这个取消了 但是已经执行了 所以取消没有什么用了
        subscribe1.dispose();

注意，上面这样写，dispose 方法虽然调用了，但是没有什么用，你会发现 accept() 方法还是会调用。是因为subscribe 方法就会执行你的业务处理逻辑的代码，比如上面的业务没有在子线程去执行，通知也没有在子线程通知，都是在当前线程，那么他就会走完accept方法之后，才能走到dispose方法。所以dispose方法就无效果。

下面的是有效果的：

        @NonNull Disposable subscribe1 = Observable.just("1,2,3", "4,5,6")
                .subscribeOn(Schedulers.io())
                .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Throwable {
                Log.d(TAG, "subscribe1" + s);
            }
        });
        subscribe1.dispose();

延迟执行

Observable.just("cao", "xin", "yu").delay(2, TimeUnit.SECONDS);

表示这个业务会延迟两秒去执行

定期做一件事情

        Observable.interval(5,5,TimeUnit.SECONDS).subscribe(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) throws Throwable {
                Log.d(TAG, "aLong:" + aLong);
            }
        });

上面的用法表示，5S 后，每5S执行一次accept 方法。

基本上这样就是RxJava 的使用，RxJava 的功能不止这些，有些如果需要可以自行深入了解。

RxJava几个关键类 UML 后续

参考链接：
RxJava Wiki链接

有一个wiki 链接，可以明白的查看到结果。