RxJava入门(一)

最新推荐文章于 2024-08-21 13:30:00 发布

SkylakeXun

最新推荐文章于 2024-08-21 13:30:00 发布

阅读量329

点赞数

分类专栏：代码库

本文链接：https://blog.csdn.net/SkylakeXun/article/details/78489429

版权

代码库专栏收录该内容

33 篇文章 0 订阅

订阅专栏

什么是RxJava

Rx是Reactive Extensions的简写，翻译为响应的扩展。也就是通过由⼀一⽅方发出信息，另⼀一⽅方响应信息并
作出处理理的核⼼心框架代码。
该框架由微软的架构师Erik Meijer领导的团队开发，并在2012年年11⽉月开源。
Rx库⽀支持.NET、JavaScript和C++等，现在已经⽀支持⼏几乎全部的流⾏行行编程语⾔言了了。
Rx的⼤大部分语⾔言库由ReactiveX这个组织负责维护，⽐比较流⾏行行的有RxJava/RxJS/Rx.NET，社区⽹网站是
reactivex.io。
RxJava作为⼀一个流⾏行行的框架，其源码依托在GitHub,除了了⽀支持RxJava，针对安卓系统也除了了⼀一个⽀支持框
架RxAndroid

RxJava简化代码

比如有⼀一次考试成绩出来后，我们告诉班⻓长，找出班⾥里里最好的⼥女女同学的成绩，代码⼤大概如下，下⾯面我们来看

//java,多层嵌套
if(班长在这里里){
    for (检查每个同学){
        if (同学是女的){
            存储最高的成绩;
        }
        汇报成绩
    }
}

//RxJava,链式编程
通知班长
.查所有同学;
.判断是否是女的;
.找出最高的成绩;
.回来通知我;

导包

    compile "io.reactivex.rxjava2:rxjava:2.0.1"
    compile "io.reactivex.rxjava2:rxandroid:2.0.1"

什么是响应式

所谓的响应式，⽆无⾮非就是存在这样的2个部分，⼀一部分负责发送事件/消息，另⼀一部分负责响应事件/消息。

举个栗子

以前如果我们想看新闻，⼀一般需要通过看报纸。⽐比如，你对某个报刊杂志⽐比较感兴趣，那么你⾸首先要做3件
事：
1. 提供你家的地址
2. 找到对应的报社
3. 去报社订阅整个⽉月的报纸
经过了了上⾯面的流程，以后每天只要有新的报刊资料料出来了了，报社都会将杂志发送到你家。

示意图
对例子进行抽象

1. 提供观察者(因为你是关⼼心杂志内容的⼈人 所以你是观察该事件的⼈人)
2. 提供被观察者(只要有新的杂志出来 就需要通知关⼼心的⼈人 所以报社是被观察的对象)
3. 订阅(也就是 观察者&被观察者之间要相互关联 以便便被观察的对象⼀一变化 就会⻢马上通知观察该事件的对
象)

RxJava代码

        //被观察者
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                /**有三种事件
                 *emitter.onNext();
                 *emitter.onComplete();
                 *emitter.onError();
                 */
                emitter.onNext("宋丹丹丹丹批⼩小鲜⾁肉攀⽐比⼼心重");
                emitter.onNext("《⽣生化危机:终章》曝删减⽚片段");
                emitter.onNext("张铁林林张国⽴立王刚如何维持铁三⻆角关系");
                emitter.onComplete();
            }
        });
        //观察者
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("meee",getClass()+":\n"+"订阅时调用");
            }

            @Override
            public void onNext(String value) {
                Log.d("meee",getClass()+":\n"+"接收事件时调用");
            }

            @Override
            public void onError(Throwable e) {
                Log.d("meee",getClass()+":\n"+"出现错误时调用");
            }

            @Override
            public void onComplete() {
                Log.d("meee",getClass()+":\n"+"接收错误事件");
            }
        };
        //由被观察者 订阅 观察者(为了事件处理的逻辑,但总觉得有哪里不对)
        observable.subscribe(observer);

只表示成功或者失败的订阅关系

有些时候,我们只需要执行一次任务即可
Single SingleObserver便实现了该需求

        //只表示成功或者失败的订阅关系
        Single<String> singleObservable = Single.create(new SingleOnSubscribe<String>() {
            @Override
            public void subscribe(SingleEmitter<String> emitter) throws Exception {
                /**
                 * 只能调用一次方法,成功或失败,之后订阅关系结束
                 * emitter.onSuccess();
                 * emitter.onError();
                 */
                emitter.onSuccess("成功了");
            }
        });
        SingleObserver<String> singleObserver = new SingleObserver<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onSuccess(String value) {

            }

            @Override
            public void onError(Throwable e) {

            }
        };
        singleObservable.subscribe(singleObserver);

简化的观察者

有时候我们只关系onNext事件,但Observer需要实现四个方法,看起太难受了

        //被观察者
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("宋丹丹丹丹批⼩小鲜⾁肉攀⽐比⼼心重");
                emitter.onNext("《⽣生化危机:终章》曝删减⽚片段");
                emitter.onNext("张铁林林张国⽴立王刚如何维持铁三⻆角关系");
                emitter.onComplete();
            }
        });
        //简化的观察者
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d("meee",getClass()+":\n"+s);
            }
        };
        //由被观察者 订阅 观察者(为了事件处理的逻辑,但总觉得有哪里不对)
        observable.subscribe(consumer);

分别处理各种事件

我们也可以不需要在同一个类中处理所有事件

        observable.subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {

            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {

            }
        }, new Action() {
            @Override
            public void run() throws Exception {

            }
        }, new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {

            }
        });

既可以做观察者又可以做被观察者的类

做观察者使用

        //做观察者
        Subject.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("你好啊");
                emitter.onNext("见到你很高兴");
                emitter.onNext("今天吃什么呢");
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d("meee",getClass()+":\n"+s);
            }
        });

做被观察者使用

        //单纯的做被观察者
        Observable<String> observable = Subject.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("你好啊");
                emitter.onNext("见到你很高兴");
                emitter.onNext("今天吃什么呢");
            }

        });
        observable.subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
//                Log.d("meee",getClass()+":\n"+s);
            }
        });

既作观察者又做被观察者

        //被观察者
        AsyncSubject<String> asyncSubject = AsyncSubject.create();
        asyncSubject.subscribe(new Subject<String>() {
            @Override
            public boolean hasObservers() {
                return false;
            }

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

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

            @Override
            public Throwable getThrowable() {
                return null;
            }

            @Override
            protected void subscribeActual(Observer<? super String> observer) {

            }

            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String value) {
                Log.d("meee",getClass()+":\n"+value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d("meee",getClass()+":\n"+"Throwable");
            }

            @Override
            public void onComplete() {
                Log.d("meee",getClass()+":\n"+"onComplete");
            }
        });
        //异步发布事件
        asyncSubject.onNext("你好");

AsyncSubject

那么便来介绍下AsyncSubject的特点:
⼀一个AsyncSubject只在原始Observable完成后，发射来⾃自原始Observable的最后⼀一个值。它会把这最后⼀一个值发射给任何后续的观察者。

        //被观察者
        AsyncSubject<String> asyncSubject = AsyncSubject.create();
        asyncSubject.subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d("meee",getClass()+":\n"+s);
            }
        });
        asyncSubject.onNext("你好1");
        asyncSubject.onNext("你好2");
        asyncSubject.onNext("你好3");
        asyncSubject.onComplete();
//---------------------------------------日志---------------------------------------  
11-09 14:18:04.601 20506-20506/? D/meee: class com.junx.rxjava.RxJavaActivity$3:
                                         你好3

如果原始的Observable因为发⽣生了了错误⽽而终⽌止，AsyncSubject将不不会发射任何数据，只是简单的向前
传递这个错误通知;
简单来说,如果出现了Error,那么就只响应观察者只响应onError();

BehaviorSubject

当观察者订阅BehaviorSubject时，他会将订阅前最后⼀一次发送的事件和订阅后的所有发送事件都打印出来

        BehaviorSubject<String> behaviorSubject = BehaviorSubject.create();
        behaviorSubject.onNext("你好啊1");
        behaviorSubject.onNext("你好啊2");
        behaviorSubject.subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d("meee",getClass()+":\n"+s);
            }
        });
        behaviorSubject.onNext("你好啊3");
        behaviorSubject.onNext("你好啊4");
        behaviorSubject.onNext("你好啊5");

//---------------------------------------日志--------------------------------------- 
11-09 14:24:14.865 20628-20628/? D/meee: class com.junx.rxjava.RxJavaActivity$4:
                                         你好啊2
11-09 14:24:14.865 20628-20628/? D/meee: class com.junx.rxjava.RxJavaActivity$4:
                                         你好啊3
11-09 14:24:14.865 20628-20628/? D/meee: class com.junx.rxjava.RxJavaActivity$4:
                                         你好啊4
11-09 14:24:14.865 20628-20628/? D/meee: class com.junx.rxjava.RxJavaActivity$4:
                                         你好啊5

PublishSubject

PublishSubject只会把在订阅发⽣生的时间点之后来⾃自原始Observable的数据发射给观察者。
需要注意的是，PublishSubject可能会⼀一创建完成就⽴立刻开始发射数据，因此这⾥里里有⼀一个⻛风险：在Subject被
创建后到有观察者订阅它之前这个时间段内，⼀一个或多个数据可能会丢失。

        PublishSubject<String> publishSubject = PublishSubject.<String>create();
        publishSubject.onNext("你好啊1");
        publishSubject.onNext("你好啊2");
        publishSubject.subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d("meee",getClass()+":\n"+s);
            }
        });
        publishSubject.onNext("你好啊3");
        publishSubject.onNext("你好啊4");
        publishSubject.onNext("你好啊5");
//---------------------------------------日志--------------------------------------- 
11-09 14:28:09.444 20739-20739/? D/meee: class com.junx.rxjava.RxJavaActivity$5:
                                         你好啊3
11-09 14:28:09.444 20739-20739/? D/meee: class com.junx.rxjava.RxJavaActivity$5:
                                         你好啊4
11-09 14:28:09.444 20739-20739/? D/meee: class com.junx.rxjava.RxJavaActivity$5:
                                         你好啊5

ReplaySubject

ReplaySubject会发布订阅前后的所有消息,不论他们是何时被订阅

        ReplaySubject<String> replaySubject = ReplaySubject.<String>create();
        replaySubject.onNext("你好啊1");
        replaySubject.onNext("你好啊2");
        replaySubject.subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                                Log.d("meee",getClass()+":\n"+s);
            }
        });
        replaySubject.onNext("你好啊3");
        replaySubject.onNext("你好啊4");
        replaySubject.onNext("你好啊5");
//---------------------------------------日志--------------------------------------- 
11-09 14:29:56.711 20844-20844/? D/meee: class com.junx.rxjava.RxJavaActivity$6:
                                         你好啊1
11-09 14:29:56.711 20844-20844/? D/meee: class com.junx.rxjava.RxJavaActivity$6:
                                         你好啊2
11-09 14:29:56.712 20844-20844/? D/meee: class com.junx.rxjava.RxJavaActivity$6:
                                         你好啊3
11-09 14:29:56.712 20844-20844/? D/meee: class com.junx.rxjava.RxJavaActivity$6:
                                         你好啊4
11-09 14:29:56.712 20844-20844/? D/meee: class com.junx.rxjava.RxJavaActivity$6:
                                         你好啊5

Subject总结

AsyncSubject⽆无论何时订阅 只会接收最后⼀一次onNext()事件，如果最后出现异常，则不不会打印任何
onNext()
BehaviorSubject会从订阅前最后⼀一次oNext()开始打印直⾄至结束。如果订阅前⽆无调⽤用onNext(),则调⽤用默
认creat(T)传⼊入的对象。如果异常后才调⽤用，则不不打印onNext()
PublishSubject只会打印订阅后的任何事件。
ReplaySubject⽆无论订阅在何时都会调⽤用发送的事件