RXJava入门01

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.特殊的被观察者Single
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);    }
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