RxJava使用場景整理

Rxjava是什麼（異步庫、響應式編程）

基於自己的理解簡單的下一個定義： RxJava是一個使用Java語言實現基於觀察者模式拓展而來的高效異步庫。

1.緩存的邏輯處理

取數據時先檢查是否有內存緩存，然後再檢查是否有文件緩存，再從網絡上請求數據，任何一個條件滿足則不執行後面的操作，如我們平時去請求圖片的邏輯。

Observable<String> memory = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        if (memoryCache != null) {
            subscriber.onNext(memoryCache);
        } else {
            subscriber.onCompleted();
        }
    }
});
Observable<String> disk = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        String cachePref = rxPreferences.getString("cache").get();
        if (!TextUtils.isEmpty(cachePref)) {
            subscriber.onNext(cachePref);
        } else {
            subscriber.onCompleted();
        }
    }
});

Observable<String> network = Observable.just("network");

//依次檢查memory、disk、network
Observable.concat(memory, disk, network)
.first()
.subscribeOn(Schedulers.newThread())
.subscribe(s -> {
    memoryCache = "memory";
    System.out.println("--------------subscribe: " + s);
});

2.使用merge合併兩個數據源

例如一組數據來自網絡，一組數據來自文件，需要合併兩組數據一起展示

Observable.merge(getDataFromFile(), getDataFromNet())
              .observeOn(AndroidSchedulers.mainThread())
              .subscribe(new Subscriber<String>() {
                  @Override
                  public void onCompleted() {
                      log.d("done loading all data");
                  }

                  @Override
                  public void onError(Throwable e) {
                      log.d("error");
                  }

                  @Override
                  public void onNext(String data) {
                      log.d("all merged data will pass here one by one!")
              });

3.一個API的請求依賴另一個接口返回的數據（解決嵌套回調的問題）

例如要登錄獲取到token後再去獲取用戶詳情

NetworkService.getToken("username", "password")
    .flatMap(s -> NetworkService.getUserInfo(s))
    .subscribe(s -> {
        System.out.println("message: " + s);
    });

4.每個HTTP請求都帶token給服務器 [如果token過期則獲取新token]

一般請情況下,很多公司的提api接口, 請求的的時候都需要帶有token, 該token在用戶第一次啓動app或者登陸的時候去獲取. 以後的所有請求都需要帶該Token
如果token過期, 服務器將返回401, 這時候就需要去請求獲取token的接口, 如果獲取成功接着在請求原來的接口.
這個時候就兩個回調的嵌套了. 實現起來比較費勁, 而且也不夠優雅. 代碼的可維護性變得很差.
可以使用 onErrorResumeNext 來處理這樣的業務邏輯.

5. HTTP 請求重試

當請求網絡的時候出現錯誤, 我們需要重試, 如果不停的重試也沒有多大意義, 出現錯誤延遲多少秒然後重試.
所以使用RxJava可以設置最多重試次數和延遲的時間

6.使用throttleFirst防止按鈕重複點擊（點擊防抖）

debounce也能達到同樣的效果

RxView.clicks(button)
              .throttleFirst(1, TimeUnit.SECONDS)
              .subscribe(new Observer<Object>() {
                  @Override
                  public void onCompleted() {
                        log.d ("completed");
                  }

                  @Override
                  public void onError(Throwable e) {
                        log.e("error");
                  }

                  @Override
                  public void onNext(Object o) {
                       log.d("button clicked");
                  }
              });

7.搜索防抖

現在幾乎所有的App都有搜索功能 , 一般情況我們監聽EditText控件,當值發生改變去請求搜索接口. 這將導致2個問題:

可能導致很多沒有意義的請求,耗費用戶流量(因爲控件的值沒更改一次立即就會去請求網絡)

可能導致最終的結果不是用戶想要的. 例如,用戶一開始輸入關鍵字’AB’ 這個時候出現兩個請求, 一個請求是A關鍵字, 一個請求是AB關鍵字.
表面上是’A’請求先發出去, ‘AB’請求後發出去. 如果後發出去的’AB’請求先返回, ‘A’請求後返回,那麼’A’請求後的結果將會覆蓋’AB’請求的結果.
從而導致搜索結果不正確.

很多文章說使用 debounce 操作可以解決這個問題.
但是, RxJava也不能完全解決這個問題, 可以使用 debounce 操作符 也只能從一定程度上減少這種情況的出現.
比如: 一開始用戶輸入了AB兩個字符, 在某個時間段內, 用戶沒有輸入新的關鍵字, 將會發出搜索請求, 此時用戶又輸入新的關鍵字C,
那就輸入框就是ABC了, 在某個時間段內, 用戶沒有輸入新的關鍵字, 將會發出搜索新的請求. 如果’ABC’的請求返回比’AB’的快, 那麼AB請求的結果將會覆蓋’ABC’請求的結果,從而導致不正確的結果

RxTextView.textChangeEvents(inputEditText)
      .debounce(400, TimeUnit.MILLISECONDS) 
      .observeOn(AndroidSchedulers.mainThread())
      .subscribe(new Observer<TextViewTextChangeEvent>() {
    @Override
    public void onCompleted() {
        log.d("onComplete");
    }

    @Override
    public void onError(Throwable e) {
        log.d("Error");
    }

    @Override
    public void onNext(TextViewTextChangeEvent onTextChangeEvent) {
        log.d(format("Searching for %s", onTextChangeEvent.text().toString()));
    }
});

8.RxJava代替EventBus廣播效果

注意：RxBus並不是一個庫，而是一種模式，是使用了RxJava的思想來達到EventBus的廣播效果。

9.使用combineLatest合併最近N個結點

例如：註冊的時候所有輸入信息（郵箱、密碼、電話號碼等）合法才點亮註冊按鈕。

Observable<CharSequence> _emailChangeObservable = RxTextView.textChanges(_email).skip(1);
Observable<CharSequence> _passwordChangeObservable = RxTextView.textChanges(_password).skip(1);
Observable<CharSequence>   _numberChangeObservable = RxTextView.textChanges(_number).skip(1);

Observable.combineLatest(_emailChangeObservable,
              _passwordChangeObservable,
              _numberChangeObservable,
              new Func3<CharSequence, CharSequence, CharSequence, Boolean>() {
                  @Override
                  public Boolean call(CharSequence newEmail,
                                      CharSequence newPassword,
                                      CharSequence newNumber) {

                      Log.d("xiayong",newEmail+" "+newPassword+" "+newNumber);
                      boolean emailValid = !isEmpty(newEmail) &&
                                           EMAIL_ADDRESS.matcher(newEmail).matches();
                      if (!emailValid) {
                          _email.setError("Invalid Email!");
                      }

                      boolean passValid = !isEmpty(newPassword) && newPassword.length() > 8;
                      if (!passValid) {
                          _password.setError("Invalid Password!");
                      }

                      boolean numValid = !isEmpty(newNumber);
                      if (numValid) {
                          int num = Integer.parseInt(newNumber.toString());
                          numValid = num > 0 && num <= 100;
                      }
                      if (!numValid) {
                          _number.setError("Invalid Number!");
                      }

                      return emailValid && passValid && numValid;

                  }
              })//
              .subscribe(new Observer<Boolean>() {
                  @Override
                  public void onCompleted() {
                      log.d("completed");
                  }

                  @Override
                  public void onError(Throwable e) {
                     log.d("Error");
                  }

                  @Override
                  public void onNext(Boolean formValid) {
                     _btnValidIndicator.setEnabled(formValid);  
                  }
              });

10.使用timer做定時操作。當有“x秒後執行y操作”類似的需求的時候，想到使用timer

例如：2秒後輸出日誌“hello world”，然後結束。

Observable.timer(2, TimeUnit.SECONDS)
              .subscribe(new Observer<Long>() {
                  @Override
                  public void onCompleted() {
                      log.d ("completed");
                  }

                  @Override
                  public void onError(Throwable e) {
                      log.e("error");
                  }

                  @Override
                  public void onNext(Long number) {
                      log.d ("hello world");
                  }
              });

11.使用interval做週期性操作。當有“每隔xx秒後執行yy操作”類似的需求的時候，想到使用interval

例如：每隔2秒輸出日誌“helloworld”。

     Observable.interval(2, TimeUnit.SECONDS)
              .subscribe(new Observer<Long>() {
                  @Override
                  public void onCompleted() {
                     log.d ("completed");
                  }

                  @Override
                  public void onError(Throwable e) {
                     log.e("error");
                  }

                  @Override
                  public void onNext(Long number) {
                     log.d ("hello world");
                  }
              });

12.使用schedulePeriodically做輪詢請求

Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(final Subscriber<? super String> observer) {

                Schedulers.newThread().createWorker()
                      .schedulePeriodically(new Action0() {
                          @Override
                          public void call() {
                              observer.onNext(doNetworkCallAndGetStringResult());
                          }
                      }, INITIAL_DELAY, POLLING_INTERVAL, TimeUnit.MILLISECONDS);
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                log.d("polling….”));
            }
        })

13.RxJava進行數組、list的遍歷，做一些數據變換

Observable.just("1", "2", "2", "3", "4", "5")
    .map(Integer::parseInt)
    .filter(s -> s > 1)
    .distinct()
    .take(3)
    .reduce((integer, integer2) -> integer.intValue() + integer2.intValue())
    .subscribe(System.out::println);//9

14.結合RxJava做網絡請求框架,鏈式調用，邏輯清晰，自由切換線程，解決嵌套回調.

15.響應式的界面

SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
RxSharedPreferences rxPreferences = RxSharedPreferences.create(preferences);

Preference<Boolean> checked = rxPreferences.getBoolean("checked", true);

CheckBox checkBox = (CheckBox) findViewById(R.id.cb_test);
RxCompoundButton.checkedChanges(checkBox)
        .subscribe(checked.asAction());

---

參考

http://blog.csdn.net/lzyzsd/article/details/50120801

http://blog.csdn.net/theone10211024/article/details/50435325

http://blog.csdn.net/johnny901114/article/details/51042840

https://github.com/fashare2015/rxjava_for_android