RxJava2.0實用操作符總結及原理簡析

歡迎關注微信公眾號「隨手記技術團隊」，檢視更多隨手記團隊的技術文章。
本文作者：周浩源
原文連結：mp.weixin.qq.com/s/OJCEyH1gJ…

大概從2015年開始，RxJava1.0開始快速流行起來，短短兩年時間，RxJava在Android開發中已經算是無人不知無人不曉了，加之它與Retrofit等流行框架的完美結合，已經成為Android專案開發的必備利器。隨手記作為一個大型專案，引入三方框架一直比較慎重，但也從今年初開始，正式引入了RxJava2.0，並配合Retrofit對專案的網路框架和繁瑣的非同步邏輯進行重構。RxJava雖然好用，但伴隨而來的是不可避免的學習成本，為了讓大家快速的瞭解RxJava的來龍去脈以及快速上手使用，特地總結該篇文章。本文將詳細講解如何快速理解RxJava的操作符，並從原始碼角度來分析RxJava操作符的原理。

RxJava的優點

簡單來講RxJava是一個簡化非同步呼叫的庫，但其實它更是一種優雅的程式設計方式和程式設計思想，當你熟悉RxJava的使用方式之後，會很容易愛上它。
我總結它的優點主要有兩個方面：

• 簡潔，免除傳統非同步程式碼邏輯中的callback hell
• 增加業務邏輯程式碼的可讀性

關於第一點大家應該都會認同，關於第二點可能有人會有疑惑，因為很多人覺得RxJava大量不明所以的操作符會讓程式碼的可讀性變得更差，其實產生這種印象恰恰就是因為沒有掌握RxJava操作符的使用和原理所導致的。
比如隨手記專案中繫結使用者QQ賬號的業務邏輯，這段邏輯的程式碼涉及三個非同步介面，兩個是QQ登入SDK的，一個是隨手記後臺的，在使用RxJava重構前，這段程式碼使用了3個AsyncTask，也就是三個巢狀的回撥，程式碼複雜，可讀性非常差。而改造之後，它變成了下面這樣子

如果你對這裡面的幾個RxJava操作符比較熟悉的話，你會迅速瞭解我這段程式碼做了什麼事情，而且不用再去梳理一堆巢狀回撥了，這就是RxJava帶來的可讀性。
所以，學習RxJava，理解和掌握操作符是不可避免的第一步。

RxJava2.0與RxJava1.0的關係

從RxJava1.0到RxJava2.0，基本思想沒有變化，但RxJava2.0按照Reactive-Streams規範對整個架構進行了重新設計，並變更了Maven倉庫依賴地址和包名。所以現在RxJava的github網站中，RxJava1.0和RxJava2.0是兩個獨立的分支，不相互相容 ，也不能同時使用，而且RxJava1.0再過一段時間也將不再維護。所以，目前還使用RxJava1.0的，建議儘早切換到RxJava2.0，而如果沒有接觸過RxJava1.0，直接使用和學習RxJava2.0就可以了。如果想了解RxJava1.0和RxJava2.0的詳細區別，請參考官方文件。
為行文方便，從此處開始，本文使用Rx來表示RxJava2.x。

Rx的操作符有哪些

剛接觸Rx的人面對一堆各式各樣的操作符會覺得不知如何去學習記憶，其實你只需要從整體上了解Rx操作符的類別和掌握一些使用頻率較高的操作符就足夠了，至於其他的操作符，你只需要知道它的使用場景和掌握如何快速理解一個操作符的方法，就可以在需要的時候快速拿來用了。
下圖是我根據官方文件總結的Rx操作符的分類及每個類別下的代表性操作符

從上圖可以看出，Rx的操作符主要十個大類別，每個類別下常用的操作符也就三五個左右，所以只要掌握這些，你就可以應付大部分的業務場景了。

如何快速理解一個Rx操作符

提到Rx操作符，相信很多人都會對描述Rx操作符的花花綠綠的寶石圖有很大印象。

要快速理解Rx操作符，看懂寶石圖是個快捷有效的方式，現在我們就來詳細分析一下構成寶石圖的各個主要元素。
首先，我們有必要回顧一下Rx中的幾個主要的基類

• io.reactivex.Flowable : 事件源(0..N個元素), 支援 Reactive-Streams and 背壓
  • io.reactivex.Observable:事件源(0..N個元素), 不支援背壓
  • io.reactivex.Single: 僅發射一個元素或產生error的事件源，
  • io.reactivex.Completable: 不發射任何元素，只產生completion或error的事件源
  • io.reactivex.Maybe: 不發射任何元素，或只發射一個元素，或產生error的事件源
  • Subject: 既是事件源，也是事件接受者
    可以看到Rx中最重要的概念就是事件源了，基本上所有的操作符都是針對事件源來進行一些轉換、組合等操作，而我們最常用的事件源就是Observable了。

本文中我們就以Observable事件源為例來講解Rx的操作符，Observable發射的事件我們統一稱之為item。首先我們需要詳細瞭解一下寶石圖中各個影象元素的含義：

• —>：Observable的時間線，從左至右流動
• ★：星星、圓、方塊等表示Observable發射的item
• |：時間線最後的小豎線表示Observable的事件流已經成功發射完畢了
• X：時間線最後的X符合表示由於某種原因Observable非正常終止發射，產生了error

上面幾種元素組合在一起代表一個完整的Observable，也可以稱為源Observable

-->方向朝下的虛線箭頭表示以及中間的長方框表示正在對上面的源Observable進行某種轉換。長方框裡的文字展示了轉換的性質。下面的Observable是對上面的源Observable轉換後的結果。

掌握了寶石圖的含義，我們就可以根據某個操作符的寶石圖快速理解這個操作符了。舉幾個例子：

1. map

可以看到，這幅圖表達的意思是一個源Observable先後發射了1、2、3的三個item，而經過map操作符一轉換，就變成了一個發射了10、20、30三個item的新的Observable。描述操作符的長方框中也清楚的說明了該map操作符進行了何種具體的轉換操作（圖中的10*x只是一個例子，這個具體的轉換函式是可以自定義的）。
於是，我們就很快速地理解了map操作符的含義和用法，簡單來講，它就是通過一個函式將一個Observable發射的item逐個進行某種轉換。
示例程式碼：

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
        e.onNext(1);
        e.onNext(2);
        e.onNext(3);
    }
}).map(new Function<Integer, Integer>() {
    @Override
    public Integer apply(@NonNull Integer integer) throws Exception {
        return integer * 10;
    }
}).subscribe(new Consumer<Integer>() {
    @Override
    public void accept(@NonNull Integer result) throws Exception {
        Log.i(TAG, "accept : " + result +"\n" );
    }
});複製程式碼

輸出結果：

2. zip

根據zip的寶石圖，可以知道zip操作符的作用是把多個源Observable發射的item通過特定函式組合在一起，然後發射組合後的item。從圖中還可以看到一個重要的資訊是，最終發射的item是對上面的兩個源Observable發射的item按照發射順序逐個組合的結果，而且最終發射的1A等item的發射時間是由組合它的1和A等item中發射時間較晚的那個item決定的，也正是如此，zip操作符經常可以用在需要同時組合處理多個網路請求的結果的業務場景中。
示例程式碼：

Observable.zip(Observable.just(1, 2, 3),
        Observable.just("A", "B", "C"),
        new BiFunction<Integer, String, String>() {
            @Override
            public String apply(@NonNull Integer integer, @NonNull String s) throws Exception {
                return integer + s;
            }
        })
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                Log.i(TAG, "zip : accept : " + s + "\n");
            }
        });複製程式碼

輸出結果：

3. concat

從寶石圖可以看出，concat操作符的作用就是將兩個源Observable發射的item連線在一起發射出來。這裡的連線指的是整體連線，被concat操作後產生的Observable會先發射第一個源Observable的所有item，然後緊接著再發射第二個源Observable的所有的item。
示例程式碼：

Observable.concat(Observable.just(1, 2, 3), Observable.just(4, 5, 6))
        .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(@NonNull Integer integer) throws Exception {
                Log.i(TAG, "concat : " + integer + "\n");
            }
        });複製程式碼

輸出結果：

大部分操作符都配有這樣的寶石圖，通過官方文件或者直接在Rx原始碼中檢視JavaDoc就可以找到，不再過多舉例。你也可以在rxmarbles這樣的網站上檢視更多可以動態互動的寶石圖。

Rx操作符的原理

要了解操作符的原理，肯定要從原始碼入手嘍。所以我們先來簡單擼一遍Rx的最基本的Create操作符的原始碼。
Rx的原始碼目錄結構是比較清晰的，我們先從Observable.create方法來分析

Observable.create(new ObservableOnSubscribe<String>() {
  @Override
  public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
      e.onNext("s");
  }
}).subscribe(new Observer<String>() {
  @Override
  public void onSubscribe(@NonNull Disposable d) {
    // 建立的Observer中多了一個回撥方法onSubscribe，傳遞引數為Disposable ，Disposable相當於RxJava1.x中的Subscription,用於解除訂閱。
  }

  @Override
  public void onNext(@NonNull String s) {

  }

  @Override
  public void onError(@NonNull Throwable e) {

  }

  @Override
  public void onComplete() {

  }
});複製程式碼

create方法如下

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
   ObjectHelper.requireNonNull(source, "source is null");
   return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}複製程式碼

程式碼很簡單，第一行判空不用管，第二行呼叫RxJavaPlugins的方法是為了實現Rx的hook功能，我們暫時也無需關注，在一般情況下，第二行程式碼會直接返回它的入參即ObservableCreate物件，ObservableCreate是Observable的子類，實現了Observable的一些抽象方法比如subscribeActual。事實上Rx的每個操作符都對應Observable的一個子類。
這裡create方法接受的是一個ObservableOnSubscribe的介面實現類：

/**
 * A functional interface that has a {@code subscribe()} method that receives
 * an instance of an {@link ObservableEmitter} instance that allows pushing
 * events in a cancellation-safe manner.
 *
 * @param <T> the value type pushed
 */
public interface ObservableOnSubscribe<T> {

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

通過註釋可以知道這個介面的作用是通過一個subscribe方法接受一個ObservableEmitter型別的例項，俗稱發射器。
Observable.create方法執行時，我們傳入的就是一個ObservableOnSubscribe型別的匿名內部類，並實現了它的subscribe方法，然後它又被傳入create方法的返回物件ObservableCreate，最終成為ObservableCreate的成員source

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }
    ...複製程式碼

接著我們來看Observable的subscribe方法，它的入參是一個Observer(即觀察者，也就是事件接收者)

@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer<? super T> observer) {
   ObjectHelper.requireNonNull(observer, "observer is null");
   try {
       observer = RxJavaPlugins.onSubscribe(this, observer);

       ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");

       subscribeActual(observer);
   } catch (NullPointerException e) { // NOPMD
       throw e;
   } catch (Throwable e) {
       Exceptions.throwIfFatal(e);
       // can't call onError because no way to know if a Disposable has been set or not
       // can't call onSubscribe because the call might have set a Subscription already
       RxJavaPlugins.onError(e);

       NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
       npe.initCause(e);
       throw npe;
   }
}複製程式碼

最終它會呼叫它的子類ObservableCreate的subscribeActual方法：

@Override
protected void subscribeActual(Observer<? super T> observer) {
   CreateEmitter<T> parent = new CreateEmitter<T>(observer);
   observer.onSubscribe(parent);

   try {
       source.subscribe(parent);
   } catch (Throwable ex) {
       Exceptions.throwIfFatal(ex);
       parent.onError(ex);
   }
}複製程式碼

在subscribeActual裡首先建立了用於發射事件的CreateEmitter物件parent，CreateEmitter實現了介面Emitter和Disposable，並持有observer。
這段程式碼的關鍵語句是source.subscribe(parent)，這行程式碼執行後，就會觸發事件源進行發射事件，即e.onNext("s")會被呼叫。細心的同學也會注意到這行程式碼之前，parent先被傳入了observer的onSubscribe()方法，而在上面我們說過，observer的onSubscribe()方法接受一個Disposable型別的引數，可以用於解除訂閱，之所以能夠解除訂閱，正是因為在觸發事件發射之前呼叫了observer的onSubscribe()，給了我們呼叫CreateEmitter的解除訂閱的方法dispose()的機會。
繼續來看CreateEmitter的onNext()方法，它最終是通過呼叫observer的onNext()方法將事件發射出去的

static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {


   private static final long serialVersionUID = -3434801548987643227L;

   final Observer<? super T> observer;

   CreateEmitter(Observer<? super T> observer) {
       this.observer = observer;
   }

   @Override
   public void onNext(T t) {
       if (t == null) {
           onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
           return;
       }
       // 在真正發射之前，會先判斷該CreateEmitter是否已經解除訂閱
       if (!isDisposed()) {
           observer.onNext(t);
       }
   }
   ...
}複製程式碼

至此，Rx事件源的建立和訂閱的流程就走通了。

下面我們從map操作符來入手看一下Rx操作符的原理，map方法如下

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
   ObjectHelper.requireNonNull(mapper, "mapper is null");
   return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}複製程式碼

map方法接受一個Function型別的引數mapper，返回了一個ObservableMap物件，它也是繼承自Observable，而mapper被傳給了ObservableMap的成員function,同時當前的源Observable被傳給ObservableMap的成員source，進入ObservableMap類

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends U> function;

    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        super(source);
        this.function = function;
    }

    @Override
    public void subscribeActual(Observer<? super U> t) {
        source.subscribe(new MapObserver<T, U>(t, function));
    }


    static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
        final Function<? super T, ? extends U> mapper;

        MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
            super(actual);
            this.mapper = mapper;
        }

        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }

            if (sourceMode != NONE) {
                actual.onNext(null);
                return;
            }

            U v;

            try {
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            actual.onNext(v);
        }

        @Override
        public int requestFusion(int mode) {
            return transitiveBoundaryFusion(mode);
        }

        @Nullable
        @Override
        public U poll() throws Exception {
            T t = qs.poll();
            return t != null ? ObjectHelper.<U>requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
        }
    }
}複製程式碼

可以看到這裡用到了裝飾者模式，ObservableMap持有來自它上游的事件源source，MapObserver持有來自它下游的事件接收者和我們實現的轉換方法function，在subscribeActual()方法中完成ObservableMap對source的訂閱，觸發MapObserver的onNext()方法，繼而將來自source的原始資料經過函式mapper轉換後再發射給下游的事件接收者，從而實現map這一功能。

現在我們終於能夠來總結一下包含多個操作符時的訂閱流程了，以下面這段程式碼為例

Observable.
        create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("holen");
            }
        })
        .map(new Function<String, Integer>() {
            @Override
            public Integer apply(@NonNull String s) throws Exception {
                return s.length();
            }
        })
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull Integer integer) {

            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });複製程式碼

執行程式碼時，自上而下每一步操作符都會建立一個新的Observable(均為Observable的子類，對應不同的操作符)，當執行create時，建立並返回了ObservableCreate，當執行map時，建立並返回了ObservableMap，並且每一個新的Observable都持有它上游的源Observable(即source)及當前涉及到的操作函式function。當最後一步執行訂閱方法subscribe時會觸發ObservableMap的subscribeActual()方法，並將最下游的Observer包裝成MapObserver，同時該方法又會繼續呼叫它所持有ObservableCreate的訂閱方法（即執行source.subscribe），由此也會觸發ObservableCreate的subscribeActual()方法，此時我們的發射器CreateEmitter才會呼叫它的onNext()方法發射事件，再依次呼叫MapObserver的操作函式mapper和onNext()方法，最終將事件傳遞給了最下游的Observer的onNext()方法。

我簡單的將這段邏輯用下面這幅圖來表示

操作符lift和compose

lift和compose在Rx中是兩個比較特殊的操作符。
lift讓我們可以對Observer進行封裝，在RxJava1.0中大部分變換都基於lift這個神奇的操作符。

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> lift(ObservableOperator<? extends R, ? super T> lifter) {
   ObjectHelper.requireNonNull(lifter, "onLift is null");
   return RxJavaPlugins.onAssembly(new ObservableLift<R, T>(this, lifter));
}複製程式碼

lift操作符接受一個ObservableOperator物件

/**
 * Interface to map/wrap a downstream observer to an upstream observer.
 *
 * @param <Downstream> the value type of the downstream
 * @param <Upstream> the value type of the upstream
 */
public interface ObservableOperator<Downstream, Upstream> {
    /**
     * Applies a function to the child Observer and returns a new parent Observer.
     * @param observer the child Observer instance
     * @return the parent Observer instance
     * @throws Exception on failure
     */
    @NonNull
    Observer<? super Upstream> apply(@NonNull Observer<? super Downstream> observer) throws Exception;
}複製程式碼

看註釋可以知道，這是一個將下游訂閱者包裝成一個上游訂閱者的介面。類似Map操作符中的MapObserver。

而compose操作符讓我們可以對Observable進行封裝

@SuppressWarnings("unchecked")
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> compose(ObservableTransformer<? super T, ? extends R> composer) {
   return wrap(((ObservableTransformer<T, R>) ObjectHelper.requireNonNull(composer, "composer is null")).apply(this));
}複製程式碼

wrap方法如下，僅僅是走了RxJavaPlugins的流程

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> wrap(ObservableSource<T> source) {
   ObjectHelper.requireNonNull(source, "source is null");
   if (source instanceof Observable) {
       return RxJavaPlugins.onAssembly((Observable<T>)source);
   }
   return RxJavaPlugins.onAssembly(new ObservableFromUnsafeSource<T>(source));
}複製程式碼

compose方法接受一個ObservableTransformer物件

/**
 * Interface to compose Observables.
 *
 * @param <Upstream> the upstream value type
 * @param <Downstream> the downstream value type
 */
public interface ObservableTransformer<Upstream, Downstream> {
    /**
     * Applies a function to the upstream Observable and returns an ObservableSource with
     * optionally different element type.
     * @param upstream the upstream Observable instance
     * @return the transformed ObservableSource instance
     */
    @NonNull
    ObservableSource<Downstream> apply(@NonNull Observable<Upstream> upstream);
}複製程式碼

ObservableSource即為我們的基類Observable繼承的唯一介面。看註釋可以知道，ObservableTransformer是一個組合多個Observable的介面，它通過一個apply()方法接收上游的Observable，進行一些操作後，返回新的Observable。
這裡組合多個Observable的意思其實就是組合多個操作符，比如我們經常會需要在使用Rx進行網路非同步請求時進行執行緒變化，這個操作一般都是差不多的，每次都寫會比較煩，這時我們就可以使用compose把常用的執行緒變換的幾個操作符組合起來

private final ObservableTransformer schedulersObservable = new ObservableTransformer() {
   @Override
   public ObservableSource apply(Observable upstream) {
       return upstream.subscribeOn(Schedulers.io())
               .unsubscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread());
   }
};  

protected void testCompose() {
   getNetObservable()
           .compose(schedulersObservable)
           .subscribe(new Consumer<String>() {
               @Override
               public void accept(@NonNull String s) throws Exception {
                   mRxOperatorsText.append(s);
               }
           });
}複製程式碼

關於compose的典型應用，大家有興趣還可以去看一下開源專案RxLifecycle，它就是巧妙地利用compose操作符來解決了使用Rx可能會出現的記憶體洩露問題。

Rx操作符的應用場景

說了這麼多，其實我們最關心的還是Rx操作符的應用場景。其實只要存在非同步的地方，都可以優雅地使用Rx操作符。比如很多流行的Rx周邊開源專案

而針對自己想要實現的功能情景，如何去選擇特定的操作符，官網的文件中也列出了一些指導——Rx操作符決策樹。

當然除了這些，我們在開發專案時，還會有各種具體的業務場景需要選擇合適的操作符，這裡我總結了一些經常遇到的場景以及適合它們的操作符

只要我們理解了Rx操作符的原理，熟練掌握了一些使用頻率較高的操作符，就能夠在以上場景中輕鬆地使用，不再讓自己的程式碼被複雜的業務邏輯搞得混亂。

---

以上就是本文的全部內容，關於Rx還有很多東西值得深入地學習研究，後續有機會再跟大家分享更多Rx的使用心得。

參考

• RxJava2Examples