RXJava入门01

最新推荐文章于 2024-10-22 18:45:00 发布

piziliul

最新推荐文章于 2024-10-22 18:45:00 发布

阅读量274

点赞数

分类专栏： RXJava

本文链接：https://blog.csdn.net/piziliul/article/details/77530870

版权

RXJava 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1.RXJava概述:Rx是Reactive Extensions的简写，翻译为响应的扩展。也就是通过由⼀一⽅方发出信息，另⼀一⽅方响应信息并作出处理理的核⼼心框架代码RxJava作为⼀一个流⾏行行的框架，其源码依托在GitHub,除了了⽀支持RxJava，针对安卓系统也除了了⼀一个⽀支持框架RxAndroid
2.RXJava依赖的框架(这里介绍的是1.0版本的)
compile 'io.reactivex:rxandroid:1.2.1'

compile 'io.reactivex:rxjava:1.1.6

3.RXJava响应的核心(案例:订阅报社)

被观察者:

 // 1.报社 --->被观察者Observable(可观察的)
        final Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("被观察者发送信息1");
                // 每次发送完毕之后 最好调用onCompleted()告诉观察者 发送事件完毕了
                // 注意 : 只要调用subscriber.onCompleted();方法之后,name后面的事件就不会被调用
                subscriber.onNext("被观察者发送信息2");
                subscriber.onNext("被观察者发送信息3");
                subscriber.onNext("被观察者发送信息4");
                subscriber.onCompleted();
                //模拟一个空指针 只要调用onError() 那么后面的事件就不会被接收到了
                subscriber.onError(new NullPointerException("mock exception !"));
                subscriber.onNext("被观察者发送信息5");
            }
        });

观察者:

// 2.家--->观察者
        Observer<String> observer = new Observer<String>() {

            @Override
            public void onCompleted() {
                Log.e("TAG", "onCompleted: ");
            }

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

订阅:// 3.关联--->订阅(subscribe)
        // 原理:只要调用了这个subscribe()犯法,系统内部就会被调用被观察者的Observablede call()方法
        // 接着就会让被观察者发送事件 观察者就能够接收对应的事件
        observable.subscribe(observer);
4.特殊的被观察者Singlepublic static void test2() {
        // 1.报社 --->被观察者Observable(可观察的)
        // single对象只能调用onError(),onSuccess()两个方法,且只能调用一次
        Single<String> singleObservable = Single.create(new Single.OnSubscribe<String>() {
            @Override
            public void call(SingleSubscriber<? super String> singleSubscriber) {
//                singleSubscriber.onSuccess("调用onSuccess()方法");//系统内部就会调用观察者对象的onNext+onComplete()
//                singleSubscriber.onSuccess("调用onSuccess()方法");// 不会执行
                singleSubscriber.onError(new NullPointerException("mock exception !")); //系统内部就会调用观察者对象的onError()
            }
        });
        // 2.家--->观察者
        Observer<String> observer = new Observer<String>() {

            @Override
            public void onCompleted() {
                Log.e("TAG", "onCompleted: ");
            }

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

            @Override
            public void onNext(String s) {
                Log.e("TAG", "onNext: " + s);
            }
        };
        // 3.关联--->订阅(subscribe)
        singleObservable.subscribe(observer);
    }
5.Subscriber该对象本身继承了Observer,对象实现了了onNext()&onCompleted()&onError()事件,我们如果对哪个事件⽐比较关⼼心,只需要实现对应的⽅方法 public static void test3() {
        // 1.报社 --->被观察者Observable(可观察的)
        final Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("被观察者发送信息1");
                //subscriber.onCompleted();
                subscriber.onError(new NullPointerException("mock exception !"));
            }
        });
        // 2.家--->观察者Subscriber是Observer的子类 他还提供了取消订阅和判断是否订阅的方法
        Subscriber<String> SubscriberObserver = new Subscriber<String>() {

            @Override
            public void onCompleted() {
                Log.e("TAG", "onCompleted: ");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("TAG", "onError: " + e.getLocalizedMessage());
            }

            @Override
            public void onNext(String s) {
                Log.e("TAG", "onNext: " + s);
            }
        };
        // 3.关联--->订阅(subscribe)
        observable.subscribe(SubscriberObserver);
    }

针对上述代码,如果我们只关心onNext(),但是却不不得不不实现onCompleted()&onError()事件.这样的代码就显 得很臃肿。鉴于这种需求，RxJava框架在订阅⽅方⾯面做了了特定的调整，代码如下：
public static void test4() {
        final Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("test4   被观察者发送信息1");
                subscriber.onCompleted();
                //subscriber.onError(new NullPointerException("mock exception !"));
            }
        });
        // 如果只关心onNext()事件,而不关心onCompleted()/onError()
        //如果只关心onNext事件 那么被观察者发送了异常而没人处理 就会抛给系统
        //---->创建的异常会被抛出
        Action1<String> onNextAction = new Action1<String>() {

            @Override
            public void call(String s) {
                Log.e("TAG", "call: " + s);
            }
        };
        // 关心Error事件
        Action1<Throwable> onErrorAction = new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                Log.e("TAG", "call: " + throwable.getLocalizedMessage());
            }
        };
        Action0 onCompletedAction = new Action0() {
            @Override
            public void call() {
                Log.e("TAG", "call: " + "onCompletedAction");
            }
        };
        // 关心onComplete事件
        // 3.关联--->订阅(subscribe)
        observable.subscribe(onNextAction, onErrorAction, onCompletedAction);

        // 对Action的总结:
        // 所谓的Action就是只有一个内部方法的Action类,而且都没有返回值
        // Action0:没有参数,Action1: 有一个参数,Action2有两个参数
        // Action最对有九个参数--->Action9
        // ActionN : 一般不用,这个类,是由我们自己去创建的

        // 对应的技术还有Func
        //所谓的Func 内部只有一个方法 并且方法都是有返回值  返回值的类型就是最后一个泛型指定的数据类型。
        //Func是从Func0---->Func9(只有8个参数 最后一个参数给了返回值)
        new Func0<String>() {

            @Override
            public String call() {
                return null;
            }
        };


6.Subject既可以作为被观察者又可以作为观察者,这一点查看源码就可以发现Subject<T, R> extends Observable<R> implements Observer<T>
1.AsyncSubject作为被观察者在创建之后就可以直接发送数据(不用订阅之后擦发送数据),它只接受最后一个onNext()事件public static void test5() {
        //Subject<T, R> extends Observable<R> implements Observer<T>
        // 创建一个被观察者
        //AsyncSubject他在创建之后就可以发送数据（不用订阅之后再发送数据）它只接收最后一个onNext()事件(在onComplete调用之前)
        //只要没有onComplete被发送 那么观察者就接收不到任何信息
        AsyncSubject<String> asyncObservable = AsyncSubject.create();
        asyncObservable.onNext("Subject AsyncSubject1");
        asyncObservable.onNext("Subject AsyncSubject2");
        asyncObservable.onNext("Subject AsyncSubject3");
        asyncObservable.onNext("Subject AsyncSubject4");
        //asyncObservable.onCompleted();
        asyncObservable.onError(new NullPointerException("mock exception !"));
        // 直接蹦,报错

        // 创建一个观察者
        Action1<String> onNextAction = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("TAG", "test5 call: " + s);
            }
        };
        // 实现订阅
        asyncObservable.subscribe(onNextAction);
    }
2.behaviorSubject是以订阅方法

 public static void test6() {
        // 1.创建一个被观察者 BehaviorSubject是以订阅方法作为分界线的
        //只发送订阅前最后一个onNext事件和订阅后的所有onNext事件
        //如果订阅前没有发送数据 那么就会接收构造器里面默认的事件和订阅后的事件。
        BehaviorSubject<String> behaviorObservable = BehaviorSubject.create("DEFAULT");
//        behaviorObservable.onNext("1-Subject BehaviorSubject");
//        behaviorObservable.onNext("2-Subject BehaviorSubject");
//        behaviorObservable.onNext("3-Subject BehaviorSubject");
//        behaviorObservable.onNext("4-Subject BehaviorSubject");

        // 创建一个观察者
        Action1<String> onNextAction = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("TAG", "test6 call: " + s);
            }
        };
        // 实现订阅
        behaviorObservable.subscribe(onNextAction);
        behaviorObservable.onNext("Subject BehaviorSubject1");
        behaviorObservable.onNext("Subject BehaviorSubject2");
        behaviorObservable.onNext("Subject BehaviorSubject3");
        behaviorObservable.onNext("Subject BehaviorSubject4");
    }
 
3.PublishSubject 作为观察者只能接收订阅之后的消息public static void test7() {
        // 1.创建一个被观察者 PublishSubject
        // 它是在创建之后就可以发送事件
        // 作为观察者 只能接收到订阅后的所有事件
        PublishSubject<String> publishObservable = PublishSubject.create();
        publishObservable.onNext("1-Subject PublishSubject");
        publishObservable.onNext("2-Subject PublishSubject");
        publishObservable.onNext("3-Subject PublishSubject");
        publishObservable.onNext("4-Subject PublishSubject");

        // 创建一个观察者
        Action1<String> onNextAction = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("TAG", "test6 call: " + s);
            }
        };
        // 实现订阅
        publishObservable.subscribe(onNextAction);
        publishObservable.onNext("Subject PublishSubject1");
        publishObservable.onNext("Subject PublishSubject2");
        publishObservable.onNext("Subject PublishSubject3");
        publishObservable.onNext("Subject PublishSubject4");
    }
4.ReplaySubject:创建完毕的时候就可以发送数据public static void test8() {
        //1.创建一个被观察者ReplaySubject:
        //ReplaySubject刚创建完毕的时候就开始发送数据了
        //不管观察者是什么时候订阅 它都会接收ReplaySubject对象发出的任何事件。
        ReplaySubject<String> replayObservable = ReplaySubject.create();
        replayObservable.onNext("1-Subject replayObservable");
        replayObservable.onNext("2-Subject replayObservable");
        replayObservable.onNext("3-Subject replayObservable");
        replayObservable.onNext("4-Subject replayObservable");

        //2.创建一个观察者
        Action1<String> onNextAction = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("TAG", "call: " + s);
            }
        };

        //3.实现订阅
        replayObservable.subscribe(onNextAction);
        replayObservable.onNext("Subject replayObservable1");
        replayObservable.onNext("Subject replayObservable2");
        replayObservable.onNext("Subject replayObservable3");
        replayObservable.onNext("Subject replayObservable4");
    }
5.总结:

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


7.ConntectableObservable:中可连接的被观察者,可连接的被观察者与普通的被观察者差不多,区别在于可连接的Observable在被订阅的时候并不开始发送消息,只有在connect()被调用的时候才开始,使用该方法,可以实现其他订阅者都订阅了这个被观察者之后才开始发送消息

1.publish,RefCount:该操作符可以将普通的Observable转化成可连接的Observable
 public static void test9() {
        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                //相当于发报纸
                subscriber.onNext("ConnectableObservable1");
                subscriber.onNext("ConnectableObservable2");
                subscriber.onNext("ConnectableObservable3");
                subscriber.onNext("ConnectableObservable4");
            }
        });
        //observable.publish()--->将普通的被观察者 变成可连接的观察者
        ConnectableObservable<String> connectableObservable = observable.publish();
        //refCount--->将可连接的观察者转换成普通的观察者
        //Observable<String> stringObservable = connectableObservable.refCount();
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.e("TAG", "onCompleted: ");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("TAG", "onError: " + e.getLocalizedMessage());
            }
            //接受处理事件的方法
            @Override
            public void onNext(String s) {
                Log.e("TAG", "onNext: " + s);
            }
        };
        connectableObservable.subscribe(observer);
        //connect-->让可连接的被观察者调用内部的call方法(相当于发送了事件)
        connectableObservable.connect();
    }public static void test10() {
        //创建一个普通的被观察者
        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                //相当于发报纸
                subscriber.onNext("ConnectableObservable1");
                subscriber.onNext("ConnectableObservable2");
                subscriber.onNext("ConnectableObservable3");
                subscriber.onNext("ConnectableObservable4");
            }
        });

        //2.将普通的被观察者变成可连接的被观察者
        //publish()创建的被观察者之后在connect()之前订阅的观察者才能接收事件 如果在connect()之后订阅的观察者 是无法获取被观察者发送的事件
        //有没办法可以让 只要是观察者订阅了可连接的被观察者 都能打印出被观察者发送出来的数据 而不管订阅在connect()的前后顺序。-->replay()
        ConnectableObservable<String> connectableObservable = observable.replay();

        //3.实现订阅
        connectableObservable.subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("TAG", "call==1===: " + s);
            }
        });

        //4.让被观察者主动发送事件
        connectableObservable.connect();

        //5.再次订阅一个新的观察者
        connectableObservable.subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("TAG", "call==2===: " + s);
            }
        });
    }





8.冷Observable&热Observable
//有的被观察者 在创建之后就马上发送了数据-----》“热”Observable----》Subject的子类//有的被观察者 在订阅的时候才发送的数据------->"冷"Observable---》普通的Observable//还有一种特殊的被观察者 他可以在我们指定的时间点发送数据----->"冷"Observable---->可连接的Observable