深入淺出RxJava1（一：基礎篇）

深入淺出RxJava1系列博客

• 深入淺出RxJava1（一：基礎篇）
• 深入淺出RxJava1（二：操作符）
• 深入淺出RxJava1（三：響應式的好處）
• 深入淺出RxJava1（四：在Android中使用響應式編程）

英文原文：https://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/
文章轉載於：https://blog.csdn.net/lzyzsd/article/details/41833541

RxJava正在Android開發者中變得越來越流行。唯一的問題就是上手不容易，尤其是大部分人之前都使用命令式編程語言。但是一旦你弄明白了，你就會發現RxJava真是太棒了。
這裏僅僅是幫助你瞭解RxJava，整個系列共有四篇文章，希望你看完這四篇文章之後能夠了解RxJava背後的思想，並且喜歡上RxJava。

基礎

RxJava最核心的兩個東西是Observables（被觀察者，事件源）和Subscribers（觀察者）。Observable發出一系列事件，Subscriber處理這些事件，這裏的事件可以是任何你感興趣的東西（觸摸事件、web接口調用返回的數據……）。

一個Observable可以發出零個或者多個事件，直到結束或者出錯。每發出一個事件，就會調用它的Subscriber的onNext()方法，最後調用Subscriber.onComplete()或者Subscriber.onError()結束。

Rxjava的看起來很想設計模式中的觀察者模式，但是有一點明顯不同，那就是如果一個Observerble沒有任何的的Subscriber，那麼這個Observable是不會發出任何事件的。

Hello World!

gradle配置：implementation ‘io.reactivex:rxjava:1.3.8’

創建一個Observable對象很簡單，直接調用Observable.create()

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來處理Observable對象發出的字符串。

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

    }
    @Override
    public void onError(Throwable e) {

    }
};

這裏Subscriber僅僅就是打印Observable發出的字符串。通過subscribe()函數就可以將我們定義的myObservable對象和mySubscriber對象關聯起來，這樣就完成了Subscriber對Observable的訂閱。

myObservable.subscribe(mySubscriber);

一旦mySubscriber訂閱了myObservable，myObservable就是調用mySubscriber對象的onNext和onComplete方法，mySubscriber就會打印出Hello World！

更簡潔的代碼

是不是覺得僅僅爲了打印一個hello world要寫這麼多代碼太囉嗦？我們這裏主要是爲了展示RxJava背後的原理而採用了這種比較囉嗦的寫法，RxJava其實提供了很多便捷的函數來幫助我們減少代碼。

首先來看看如何簡化Observable對象的創建過程。RxJava內置了很多簡化創建Observable對象的函數，比如Observable.just()就是用來創建只發出一個事件就結束的Observable對象，上面創建Observable對象的代碼可以簡化爲一行：

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

接下來看看如何簡化Subscriber，上面的例子中，我們其實並不關心OnComplete和OnError，我們只需要在onNext的時候做一些處理，這時候就可以使用Action1類。

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

subscribe()方法有一個重載版本，接受三個Action1類型的參數，分別對應OnNext，OnComplete， OnError函數。

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

上面的代碼最終可以寫成這樣：

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

使用java8的lambda可以使代碼更簡潔：

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

Android Studio已經支持使用lambda了。

交換

讓我們做一些更有趣的事情吧！
比如我想在hello world中加上我的簽名，你可能會想到去修改Observable對象：

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

如果你能夠改變Observable對象，這當然是可以的，但是如果你不能修改Observable對象呢？比如Observable對象是第三方庫提供的？比如我的Observable對象被多個Subscriber訂閱，但是我只想在對某個訂閱者做修改呢？
那麼在Subscriber中對事件進行修改怎麼樣呢？比如下面的代碼：

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

這種方式仍然不能讓人滿意，因爲我希望我的Subscriber越輕量越好，因爲我有可能會在mainThread中運行Subscriber。另外，根據響應式函數編程的概念，Subscriber更應該做的事情是“響應”，響應Observable發出的事件，而不是去修改。如果我能在某些中間步驟中對“Hello World！”進行變換是不是很酷？

操作符（Operators）

操作符就是爲了解決對Observable對象的變換的問題，操作符用於在Observable和最終的Subscriber之間修改Observable發出的事件。RxJava提供了很多很有用的操作符。
比如map操作符，就是用來把把一個事件轉換爲另一個事件的。

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()操作符就是用於變換Observable對象的，map操作符返回一個Observable對象，這樣就可以實現鏈式調用，在一個Observable對象上多次使用map操作符，最終將最簡潔的數據傳遞給Subscriber對象。

map操作符進階

map操作符更有趣的一點是它不必返回Observable對象返回的類型，你可以使用map操作符返回一個發出新的數據類型的observable對象。
比如上面的例子中，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)));

很有趣吧？我們初始的Observable返回的是字符串，最終的Subscriber收到的卻是Integer，當然使用lambda可以進一步簡化代碼：

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

前面說過，Subscriber做的事情越少越好，我們再增加一個map操作符

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

不服？

是不是覺得我們的例子太簡單，不足以說服你？你需要明白下面的兩點:

1. Observable和Subscriber可以做任何事情
   Observable可以是一個數據庫查詢，Subscriber用來顯示查詢結果；Observable可以是屏幕上的點擊事件，Subscriber用來響應點擊事件；Observable可以是一個網絡請求，Subscriber用來顯示請求結果。

2. Observable和Subscriber是獨立於中間的變換過程的。
   在Observable和Subscriber中間可以增減任何數量的map。整個系統是高度可組合的，操作數據是一個很簡單的過程。