把它當(dāng)做陌生人再一次去認(rèn)識

環(huán)境集成

首先廢話不多說，先把Rxjava集成到我們項目中來。

rxjava1和rxjava2

當(dāng)你在app項目的module setting中添加dependency的時候，會出現(xiàn)讓你選擇使用rx1還是2的窘境，那1和2有什么不一樣呢
在此，作為并沒有對rxjava有所了解的陌生者，我先告訴你，2是1的improvement，所以我們集成的時候使用 2即可。

    compile 'io.reactivex.rxjava2:rxjava:2.0.6'

OK,環(huán)境配置算是完成了。

先隨便擼一段代碼看看

首先你需要普及一段知識，這個所謂的rxjava是基于觀察者模式，或者子通俗一點，你總歸聽說這玩意兒使用來做響應(yīng)式編程的吧。
那么我接下去，所要寫的第一段代碼從Observer和Subscriber開始應(yīng)該可以理解了吧

• Observer

在MainActivity中直接開了一個private的方法，寫上Observer，選擇reactx的包，發(fā)現(xiàn)需要輸入一個泛型，先什么都不管，我們輸入一個String，然后new之后自動跳出來一大坨如下：

Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                
            }

            @Override
            public void onNext(String s) {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };

我們點到Observer的源碼看，發(fā)現(xiàn)這個“觀察者”是個接口，總共就上述的四個方法，具體用來干什么我們先放一放。

• Subscriber

國內(nèi)的rxjava魚龍混雜，絕大部分是基于rxjava1去進(jìn)行講解的，你就會發(fā)現(xiàn)他們會跟你這么講

Subscriber和Observer是一樣的接口，唯一不同的是，它里面有自己的兩個獨有的方法，onStart，unSubscribe方法

結(jié)果你在聽信了我的話導(dǎo)入了rxjava2之后發(fā)現(xiàn)結(jié)果是這樣的：

Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onSubscribe(Subscription s) {

            }

            @Override
            public void onNext(String s) {

            }

            @Override
            public void onError(Throwable t) {

            }

            @Override
            public void onComplete() {

            }
        };

沒錯，跟Observer一模一樣，你疑惑的點到源碼里面看，發(fā)現(xiàn)也是一模一樣。完全一樣的接口，完全一樣的四個接口方法。

這里我要告訴你，在rxjava1中確實是Subscriber這個類存在（rxjava1主包名為rx，rxjava2主包名為io.reactivex），存在于rx包下，但是我們在io.reactivex包下卻沒有發(fā)現(xiàn)Subscriber，我們使用的Subscriber實際上來自于org.reactivestreams.Subscriber,rxjava2已經(jīng)將Subscriber這個抽象類移除了，代替它的是具體的Subscriber,在io.reactivex.subscribers包下的比如DefaultSubscriber, ResourceSubscriber 和 DisposableSubscriber等抽象類。

• Observable

當(dāng)我們在前面想要創(chuàng)建Observer的時候，IDE會跳出來Observable，字面翻譯的意思是觀察者的東西，猜測應(yīng)該是用來傳遞的對象，我們來看一下，進(jìn)到源碼中我們發(fā)現(xiàn)，這個Observable是個抽象類，那照理來說應(yīng)該是被繼承而非直接創(chuàng)建實例才對。

這種時候我們一般怎么做，大家知道我們通常不去使用抽象類new對象，那么如果這個抽象類有其他的一些構(gòu)造方法，肯定就是在static方法中，結(jié)果我們發(fā)現(xiàn)他有個create方法，上面的注釋下的很明白，將相應(yīng)與回調(diào)聯(lián)系起來的一個API，我們不妨用用看

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                
            }
        });

我們可以看到create方法對傳參的描述

the emitter that is called when an Observer subscribes to the returned

翻譯成人話的意思是當(dāng)觀察者訂閱了之后所回調(diào)的一個發(fā)射器（這里的發(fā)射器我們就把他理解成一個相當(dāng)迅速的回調(diào)），我們再來看一下這個ObservableOnSubscribe接口，按照之前的理解，他就是觀察者做了訂閱動作之后返回的一個回調(diào)。
只有一個接口方法：

/**
     * Called for each Observer that subscribes.
     * @param e the safe emitter instance, never null
     * @throws Exception on error
     */
    void subscribe(ObservableEmitter<T> e) throws Exception;

我們看到每一個觀察者訂閱了之后都會觸發(fā)這個subscribe方法

繼續(xù)看這個ObservableEmitter，觀察者發(fā)射器，繼承Emitter，就是發(fā)射器，一看是個接口，接口里面有三個方法，onNext，onError, onComplete。是不是有點印象，沒錯跟之前的Observer和Subscriber接口的方法一模一樣。

那好，根據(jù)之前的注釋和接口里的方法，我們可以篤定，這幾個類之間一定是有關(guān)系的，主要是怎么把他們聯(lián)系起來。

• 把Observable，Observer，Subscriber聯(lián)系起來

  由于Observer和Subscriber都是接口，方法又都只有四個且都是onXXX這種非主動性方法，那我們只有從Observable入手，我們開始在Observable方法中全局搜索Observer類，看哪個方法的傳參類型是Observer，發(fā)現(xiàn)：

    public final void subscribe(Observer<? super T> observer) 

但是沒有發(fā)現(xiàn)Subscriber。不管了，我們先用用看，我們在剛才的Observer和Observable的方法中打上log。

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("hello on next");
                Log.e("observable", "subscribe    ");
            }
        });

結(jié)果發(fā)現(xiàn)，subscribe方法內(nèi)調(diào)什么，Observer就回調(diào)什么。

OK，這兩者的關(guān)系已經(jīng)很明顯了。那么到底Subscriber是和誰聯(lián)系起來的呢

• Flowable橫空出世

  想來想去不知道Subscriber被誰用，你如果之前不知道Rxjava，再或者你即使用過Rxjava1，到了這兒你也不知道怎么去用Subscriber。

  無奈，點開了github的Rxjava2目錄，你會在包的根目錄中發(fā)現(xiàn)如下四個跟Observable很像的類，分別是Completable，F(xiàn)lowable，Maybe，Single。

  
  
  Observable.png
  
  
  Completable.png
  
  
  Flowable.png
  
  
  Maybe.png
  
  
  Single.png

  我們?nèi)ヒ粋€一個的看這幾個類的subscribe方法，我們會發(fā)現(xiàn)Completable對應(yīng)的傳參是onComplete的action，Single對應(yīng)的是SingleObserver，Maybe對應(yīng)的是MaybeObserver，Flowable對應(yīng)的是Subscriber。終于找到了?。?！趕緊拿來用一用。

Flowable<String> flowable = Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> e) throws Exception {
                e.onNext("hello flowable1");
            }
        }, BackpressureStrategy.DROP);
flowable.subscribe(subscriber);

效仿Observable的構(gòu)造方法，我們同樣用create去創(chuàng)建Flowable對象，new了之后IDE幫我們自動生成，結(jié)果發(fā)現(xiàn)傳參有兩個，我們點到create方法中看到還需要傳一個BackpressureStrategy。。。

這是個啥

點開BackpressureStrategy，發(fā)現(xiàn)是個enum，先不管那么多了隨便傳一個進(jìn)去看看，我就用了BackpressureStrategy.DROP。

發(fā)現(xiàn)，發(fā)現(xiàn)，什么都沒出來??！

不過，我不管了，我把這個關(guān)系給找出來已經(jīng)很累了，先歇會兒，喝杯茶~~~

• 關(guān)于onNext，onError，onComplete要說的一些話

  • 你可以在Subscribe方法（我們可以稱之為上游）中發(fā)送無限個onNext，在onSubScribe方法中（我們稱之為下游）就可以接受無限個onNext。
  • 但是倘若你在上游發(fā)送了onComplete，或者是onError之后，下游接受到了，上游之后的事件下游就不再接受了。（這個想想就可以理解）
  • onComplete和onError是互相排斥的，你不能在上游發(fā)了onComplete之后又發(fā)onError，當(dāng)然你發(fā)了下游也接受不到，hohoho~
  • 你不能發(fā)送多個onComplete和多個onError，雖然后續(xù)都不會再接受。但是要注意哦。發(fā)送多個onComplete系統(tǒng)不會崩潰，發(fā)送多個onError，你試試~~

• Disposable，Subscription怎么用呢

  • Disposable
    我們在上面講Observer的時候并沒有涉及到Disposable的用法，我們點到這個類里看一下

/**

• Represents a disposable resource.
  /
  public interface Disposable {
  /*

  • Dispose the resource, the operation should be idempotent.
    */
    void dispose();

  /**

  • Returns true if this resource has been disposed.
  • @return true if this resource has been disposed
    */
    boolean isDisposed();
    }

   是個接口，只有兩個方法，Disposable字面意思是一次性東西。dispose我們看到注釋是處理這個資源，操作等冪。

   這個`idempotent`是什么鬼，這個詞語之后可能會在注釋中一直看見，表示這個方法你使用多次跟使用一次的效果是一樣的。

   其實很好理解，dispose就是銷毀這個資源，如果放在響應(yīng)式編程中，我猜，算了，不猜了，意思再明顯不過了，就是斷開觀察者和被觀察者之間的關(guān)系。也就是說接下去下游不會再收到上游的任何通知。

   使用過程中我們需要注意什么呢？

   如果我們的activity已經(jīng)退出了，如果上游和下游還連著，下游如果做UI改動，會導(dǎo)致程序崩潰。
    我們需要在onSubscribe中將Disposable進(jìn)行緩存，然后在activity退出的時候，調(diào)用它的Disposable.dispose方法斷開連接。如果有多個Disposable，那我們可以使用官方提供的容器類`CompositeDisposable`，這個類提供了add和clear方法，可以對Disposable群體進(jìn)行管理。
   * Subscription
    記得前面講Flowable的時候，什么東西都沒有出來么，現(xiàn)在看看好像只能從這個家伙入手了，讓我們一起點開它的源碼看個究竟。
   
     一看，是個接口，只有兩個方法，一個`request`,一個`cancel`。我又要猜了，一個是請求，一個是斷開。但是request后面還會跟著一個參數(shù)，這什么意思呢？

    來看下它的parm解釋，大體翻譯成老百姓看的懂得意思就是接受上游的事件數(shù)，你上游可以發(fā)很多事件，但是我這里就接受那么多個，接下去的我不接受。
 
    我們在Subscriber的onSubscribe方法中添加  `subscription.request(2)`這行代碼。（隨便寫了個2），然后程序一跑，發(fā)現(xiàn)onNext打印出來了。

     在經(jīng)過各種組合打印之后，最終得出的結(jié)論是，request傳入的個數(shù)是接受的onNext的個數(shù)，onComplete和onError不算在接受事件的個數(shù)之中。

* #####subscribe方法的重載
   無論是Observable或者是flowable，他們的subscrib方法都有相同的重載

public final Disposable subscribe() {}
public final Disposable subscribe(Consumer<? super T> onNext) {}
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} 
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
public final void subscribe(Observer/Subscriber<? super T> observer/subscriber) {}

   幾個重載的意思分別是，什么都不監(jiān)聽，就是只管上游發(fā)事件，沒有監(jiān)聽的下游；只監(jiān)聽onNext方法，其他不監(jiān)聽；只監(jiān)聽onNext和onError；。。。

-------

##電梯
  [抱著陌生的態(tài)度再看Rxjava（二）](http://www.itdecent.cn/p/f435dc51221f)
    [抱著陌生的態(tài)度再看Rxjava（三）](http://www.itdecent.cn/p/96df60fd35c6)
    [抱著陌生的態(tài)度再看Rxjava（四）](http://www.itdecent.cn/p/de8af3fadede)