文章导航

1.简介

RxJava是响应式编程(Reactive Extensions)在JVM平台上的实现，即用Java语言实现的一套基于观察者模式的异步编程接口。

1.1 RxJava简述

RxJava是一个在Java虚拟机上，使用可观察的序列构成基于事件的，异步的程序库。

1.2 RxAndroid简述

RxAndroid是基于RxJava开发出的一套适用于Android开发的辅助库。

1.3 设计模式中的观察者模式

观察者模式就是RxJava使用的核心点，掌握这个模式，可以理解RxJava更简单，观察者模式简单的说就是”订阅-发布”的模式，举一例子说，当你订阅某家牛奶店的早餐奶（订阅过程），只要牛奶店生产牛奶，便会给你送过去（发布过程）。这里的牛奶店只有一家，但是订阅的人可以很多，这是一种一对多的关系，只要牛奶店发布牛奶，那么订阅的人就会收到牛奶。换做RxJava里面的话，牛奶店就是被观察者（Observable），订阅的人就是观察者（Observer）。对观察者模式不了解的可以参考Java设计模式 — 观察者模式（Observer）

1.4 RxJava中的观察者模式

RxJava中的观察者模式也是跟例子中的大同小异，也是通过创建出观察者和被观察者，然后进行订阅事件，只不过这里的观察者和被观察者已经不在是我们自定义的两个接口类，而是通过RxJava提供好的观察者和被观察者。

public static void main(String[] args) {
    //拿到被观察者
    Observable<String> observable = getObservable();
    //拿到观察者
    Observer<String> observer = getObserver();
    //订阅
    observable.subscribe(observer);
}

public static Observable<String> getObservable() {
    return Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
            e.onNext("1");
            e.onNext("2");
            e.onNext("3");
            e.onNext("4");
            e.onComplete();
        }
    });
}

public static Observer<String> getObserver() {
    return new Observer<String>() {

        Disposable disposable = null;

        @Override
        public void onSubscribe(Disposable d) {
            disposable = d;
        }

        @Override
        public void onNext(String s) {
            System.out.println("onNext=" + s);
            if (s.equals("取消关注")) {
                //断开订阅
                disposable.dispose();
            }
        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {
            System.out.println("onComplete");
        }
    };
}

输出

onNext=1
onNext=2
onNext=3
onNext=4
onComplete

2.基本使用

2.1 添加依赖

dependencies {
    implementation 'io.reactivex.rxjava3:rxandroid:3.0.0'
    // Because RxAndroid releases are few and far between, it is recommended you also
    // explicitly depend on RxJava's latest version for bug fixes and new features.
    // (see https://github.com/ReactiveX/RxJava/releases for latest 3.x.x version)
    implementation 'io.reactivex.rxjava3:rxjava:3.0.0'

2.2 代码混淆

# RxJava RxAndroid
-dontwarn sun.misc.**
-keepclassmembers class rx.internal.util.unsafe.*ArrayQueue*Field* {
    long producerIndex;
    long consumerIndex;
}
-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueProducerNodeRef {
    rx.internal.util.atomic.LinkedQueueNode producerNode;
}
-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueConsumerNodeRef {
    rx.internal.util.atomic.LinkedQueueNode consumerNode;
}

2.3 事件发射

被观察者中有个Emitter（发射器），发射器的位置位于subscribe回调参数ObservableEmitter e中，RxJava的事件通知就是通过它来进行发送的，发射器能发送的事件有onNext()，onComplete()，onError()，在观察者的回调中，分别对应着相同方法名进行回调。

onSubscribe()：当观察者被订阅时回调
onNext()：当观察者收到onNext事件时回调
onComplete()：当观察者收到onComplete事件时回调
onError()：当观察者收到onError事件时回调

2.4 链式调用

上面对Rxjava的使用做了简单的示例，而Rxjava还可以使用链式调用，这样更简洁更炫酷。创建Observer过程中，会将所有的接收方法都创建出来，如果此时程序发生异常，RxJava默认会将异常信息try-catch。

public static void main(String[] args) {
    //创建被观察者
    Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        //默认在主线程里执行该方法
        public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
            e.onNext("1");
            e.onNext("2");
            e.onNext("3");
            e.onNext("4");
            e.onComplete();
        }
    })
            //创建观察者并订阅
            .subscribe(new Observer<String>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(String s) {
                    System.out.println("onNext=" + s);
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {

                }
            });
}

2.5 选择调用

下面这段代码中，实现的方法跟上面的实现方法是对应起来的，你可以通过创建Consumer，不需要实现的方法你可以不写，看上去更简洁。这里需要注意的是，创建Consumer过程中，如果没有将第二个Throwable的Consumer创建出来，如果此时程序发生异常，程序将会崩溃。

public static void main(String[] args) {
    Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
            e.onNext("1");
            e.onNext("2");
            e.onNext("3");
            e.onNext("4");
            e.onComplete();
        }
    }).subscribe(
            new Consumer<String>() {
                @Override
                public void accept(@NonNull String s) throws Exception {
                    //对应onNext()
                    System.out.println("accept=" + s);
                }
            }, new Consumer<Throwable>() {
                @Override
                public void accept(@NonNull Throwable throwable) throws Exception {
                    //对应onError()
                }
            }, new Action() {
                @Override
                public void run() throws Exception {
                    //对应onComplete()
                }
            }, new Consumer<Disposable>() {
                @Override
                public void accept(@NonNull Disposable disposable) throws Exception {
                    //对应onSubscribe()
                }
            });
}

2.6 线程切换

在RxJava中的线程切换特别简单，只要下面这两句话就能自由的在子线程和UI线程中自由切换。

public static void main(String[] args) {
    //创建被观察者
    Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        //默认在主线程里执行该方法
        public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
            e.onNext("1");
            e.onNext("2");
            e.onNext("3");
            e.onNext("4");
            e.onComplete();
        }
    })
            //将被观察者切换到子线程
            .subscribeOn(Schedulers.io())
            //将观察者切换到主线程  需要在Android环境下运行
            .observeOn(AndroidSchedulers.mainThread())
            //创建观察者并订阅
            .subscribe(new Observer<String>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(String s) {
                    System.out.println("onNext=" + s);
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {

                }
            });
}

2.7 线程调度器

在RxJava中也内置了多种线程选线供我们使用。这些内置的Scheduler已经足够满足我们开发的需求，因此我们应该使用内置的这些选项,，在RxJava内部使用的是线程池来维护这些线程, 所以效率也比较高。

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

2.8 事件调度器

RxJava事件发出去并不是置之不顾，要有合理的管理者来管理它们，在合适的时机要进行释放事件，这样才不会导致内存泄漏，这里的管理者我们称为事件调度器(或事件管理者)CompositeDisposable。

public class Main {

    private static CompositeDisposable mRxEvent = new CompositeDisposable();

    public static void main(String[] args) {
        Disposable subscribe = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("俊俊俊很帅");
                e.onNext("你值得拥有");
                e.onNext("取消关注");
                e.onNext("但还是要保持微笑");
                e.onComplete();
            }
        }).subscribe(
                new Consumer<String>() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {
                        //对应onNext()
                        System.out.println("accept=" + s);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(@NonNull Throwable throwable) throws Exception {
                        //对应onError()
                    }
                }, new Action() {
                    @Override
                    public void run() throws Exception {
                        //对应onComplete()
                    }
                }, new Consumer<Disposable>() {
                    @Override
                    public void accept(@NonNull Disposable disposable) throws Exception {
                        //对应onSubscribe()
                    }
                });
        
        mRxEvent.add(subscribe);
        mRxEvent.clear();
    }
}