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: "); }
订阅:
4.特殊的被观察者Single// 3.关联--->订阅(subscribe) // 原理:只要调用了这个subscribe()犯法,系统内部就会被调用被观察者的Observablede call()方法 // 接着就会让被观察者发送事件 观察者就能够接收对应的事件 observable.subscribe(observer);
5.Subscriber该对象本身继承了Observer,对象实现了了onNext()&onCompleted()&onError()事件,我们如果对哪个事件⽐比较关⼼心,只需要实现对应的⽅方法public 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); }
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框架在订阅⽅方⾯面做了了特定的调整,代码如下:
6.Subject既可以作为被观察者又可以作为观察者,这一点查看源码就可以发现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; } };
1.AsyncSubject作为被观察者在创建之后就可以直接发送数据(不用订阅之后擦发送数据),它只接受最后一个onNext()事件Subject<T, R> extends Observable<R> implements Observer<T>
2.behaviorSubject是以订阅方法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); }
3.PublishSubject 作为观察者只能接收订阅之后的消息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"); }
4.ReplaySubject:创建完毕的时候就可以发送数据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"); }
5.总结: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"); }
AsyncSubject⽆无论何时订阅 只会接收后⼀一次onNext()事件,如果后出现异常,则不不会打印任何 onNext()
BehaviorSubject会从订阅前后⼀一次oNext()开始打印直⾄至结束。如果订阅前⽆无调⽤用onNext(),则调⽤用默 认creat(T)传⼊入的对象。如果异常后才调⽤用,则不不打印onNext()
PublishSubject只会打印订阅后的任何事件。
ReplaySubject⽆无论订阅在何时都会调⽤用发送的事件。
7.ConntectableObservable:中可连接的被观察者,可连接的被观察者与普通的被观察者差不多,区别在于可连接的Observable在被订阅的时候并不开始发送消息,只有在connect()被调用的时候才开始,使用该方法,可以实现其他订阅者都订阅了这个被观察者之后才开始发送消息
1.publish,RefCount:该操作符可以将普通的Observable转化成可连接的Observablepublic 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
RXJava入门01
最新推荐文章于 2024-10-22 18:45:00 发布