理解RxJava:(一)基礎知識

理解RxJava:(一)基礎知識

本文翻譯自Grokking RxJava, Part 1: The Basics,著做權歸原做者danlew全部。譯文由JohnTsai翻譯。轉載請註明出處，並保留此段聲明。

RxJava這些天成爲了Android開發者關注的新熱點。惟一的問題是它在你剛接觸時難以理解。當你習慣了命令式編程，函數響應式編程就變得難以理解。可是一旦你理解了它，它就變得很棒了。

我在這試着給大家帶來不同的RxJava。這一系列四篇文章的目標是帶大家入門。我不會也不能講解全部的東西。我只是想讓大家對RxJava以及它的工做原理感興趣。

基礎知識

響應式代碼的基本構成部分是Observables和Subscribers(譯者注：技術名詞很難找到合適的中文翻譯，因此維持原文不被翻譯)。Observable發出items，Subscriber消費這些items。

items如何被消費有一套規則。Observable發出任意數量的items（包括0個items），要麼以成功完成終止，要麼以發生錯誤終止。對於Observable的每一個Subscriber,Observable調用Subscriber.onNext()方法任意次，而後調用Subscriber.onComplete()方法或Subscriber.onError()方法。

這看起來和咱們用的觀察者模式相似，但在一個關鍵地方不一樣——Observables在有人明確地訂閱它以後纔會開始發出items。換句話說，沒有人去訂閱，就不會發出訂閱事件（譯者注：引伸自If a tree falls in a forest）。

Hello World

讓咱們經過一個具體例子來看RxJava是如何運做的。首先，先建立一個基本的Observable:

Observable<String> myObservable = Observable.create(
    new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? super String> sub) {
            sub.onNext("Hello, world!");
            sub.onCompleted();
        }
    }
);

Observable發出Hello World而後完成。如今建立一個Subscriber來消費掉數據。

Subscriber<String> mySubscriber = new Subscriber<String>() {
    @Override
    public void onNext(String s) { System.out.println(s); }

    @Override
    public void onCompleted() { }

    @Override
    public void onError(Throwable e) { }
};

全部這些所作的是將Observable發出的每一個String打印出來。

如今有了myObservable和mySubscriber,咱們能夠用subscribe()方法將它們鏈接起來。

myObservable.subscribe(mySubscriber);
// 輸出 "Hello, world!"

當訂閱發生時，myobservable調用subsriber的onNext()和onComplete()方法。做爲結果，mySubscriber輸出"Hello,World"而後結束。

更簡潔的代碼

爲了輸出"Hello,World!",上面寫了許多樣板代碼。這是由於我爲了讓大家可以明確發生了什麼，選擇了一種囉嗦的方式。RxJava提供了許多快捷寫法讓咱們能寫出更簡潔的代碼。

首先，簡化Observable。RxJava有針對通用任務的多種內置Observable構建方法。在這種狀況下，Observable.just()發出一個item而後完成結束，就像咱們上面的代碼:

Observable<String> myObservable =
    Observable.just("Hello, world!");

而後，對於囉嗦的Subscriber。咱們不關心onCompleted()和onError()方法，取而代之，咱們能夠用一個更簡潔的類來定義在onNext()中作什麼:

Action1<String> onNextAction = new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
    }
};

Subscriber每部分的Action都能自定義。Observable.subscribe()能處理一個，兩個以及三個Action參數，以取代onNext(),onError()和onComplete()方法。複用咱們以前的Subscriber,以下:

myObservable.subscribe(onNextAction, onErrorAction, onCompleteAction);

然而，咱們僅僅須要第一個參數，由於咱們能夠省略onError()和onComplete()方法:

myObservable.subscribe(onNextAction);
// 輸出 "Hello, world!"

如今，讓咱們經過方法的鏈式調用來取代這些變量:

Observable.just("Hello, world!")
    .subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
              System.out.println(s);
        }
    });

最後，用Java 8的lambdas表達式來去掉醜陋的Action1代碼。

Observable.just("Hello, world!")
    .subscribe(s -> System.out.println(s));

若是你在Android中使用（迄今爲止不能使用Java8）(譯者注：原文做者寫這篇文章的時候(2014年)Java8在Android中開發不能使用，在譯者翻譯這篇文章的時候（2016年），已經能使用部分特性了)，我推薦使用retrolambda,它將大幅下降代碼的囉嗦程度。

變換

讓咱們把事情變得更有趣。

假設我想要在輸出的"Hello,world!"語句中加上個人簽名。一種可能（的實現方式）是改變Observable:

Observable.just("Hello, world! -Dan")
    .subscribe(s -> System.out.println(s));

若是你可以控制你的Observable,這有效。可是不能保證之後都是這種狀況。若是你使用的是別人的庫呢？
另外一種可能的問題是:若是我在多個地方使用個人Observable，但僅僅是某些狀況下想要加上簽名呢?

那修改咱們的Subscriber怎樣:

Observable.just("Hello, world!")
    .subscribe(s -> System.out.println(s + " -Dan"));

這個回答一樣不能讓人滿意，有不一樣的緣由：我想要個人Subscriber儘量輕量，由於我可能會在主線程上運行它們。在更概念的層次上理解，Subscribers被認定是作出反應(reacts)的事物，而不是作出轉變(mutates)的事物。

若是我可以經過一些中間步驟將"Hello,world!"轉換，是否是很酷？

Operators介紹

接下來是如何解決item轉換問題:使用operators。Operators被用於在源Observable和最終的Subscriber之間操做被髮出的items。RxJava推出了很是多的operators，可是剛開始咱們僅僅須要關注少數幾個。

對於這種狀況，map()操做能被用於將一個被髮出的item轉化爲另外一個：

Observable.just("Hello, world!")
    .map(new Func1<String, String>() {
        @Override
        public String call(String s) {
            return s + " -Dan";
        }
    })
    .subscribe(s -> System.out.println(s));

一樣的，咱們能使用lambda來簡化這個：

Observable.just("Hello, world!")
    .map(s -> s + " -Dan")
    .subscribe(s -> System.out.println(s));

很是酷，咱們的map()操做是一個轉換一個item的Observable。咱們能夠鏈式調用任意個map()
，將數據改進，成爲最終的Subscriber可消費的形式。

深刻map()

map()有一個有趣的方面：它不須要發出和源Observable相同類型的items！

假設個人Subscriber對輸出原文本不感興趣，想要輸出原文本的hash碼:

Observable.just("Hello, world!")
    .map(new Func1<String, Integer>() {
        @Override
        public Integer call(String s) {
            return s.hashCode();
        }
    })
    .subscribe(i -> System.out.println(Integer.toString(i)));

很是有趣——咱們以String開始可是咱們的Subscriber接收的是一個Integer。

一樣地，咱們能使用lambda來簡化代碼：

Observable.just("Hello, world!")
    .map(s -> s.hashCode())
    .subscribe(i -> System.out.println(Integer.toString(i)));

就像我以前說的，咱們想要Subscriber儘量少作事。經過另外一個map()來將hash碼轉化爲String：

Observable.just("Hello, world!")
    .map(s -> s.hashCode())
    .map(i -> Integer.toString(i))
    .subscribe(s -> System.out.println(s));

你有沒有發現——Observable和Subscriber回到了它們以前的樣子了！咱們僅僅在它們之間增長了一些轉換步驟。甚至可以添加個人簽名：

Observable.just("Hello, world!")
   .map(s -> s + " -Dan")
   .map(s -> s.hashCode())
   .map(i -> Integer.toString(i))
   .subscribe(s -> System.out.println(s));

So What？

此刻你可能會想"對於一些簡單的代碼，用了不少花式步伐同樣技巧"。對，那是簡單的例子。可是有兩點你須要掌握：

關鍵點1:Observable和Subscriber能作任何事情

Observale能夠是數據庫查詢，Subscriber獲得結果並將它們顯示在屏幕上。Observable能夠是屏幕上的點擊，Subscriber對它作出反應。Observable能夠是從網絡讀取的字節流，Subscriber把它寫入磁盤。

RxJava是個可以處理任何問題的通用框架。

關鍵點2:Observable和Subscriber獨立於在它們之間的轉換步驟

我能夠調用任意次的map操做，在最初的源Observable和它最終的Subscriber之間。RxJava高度組件化：易於操做數據。只要操做於正確的輸入輸出數據，我能夠製造一條無止盡的方法鏈。

綜合以上兩點，咱們能夠看到RxJava的巨大潛力。雖然此時咱們僅僅有一個map()操做,這嚴重地限制了咱們的能力。在第二部分，咱們將深刻研究更多RxJava的操做。