理解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的操作。