RxJava快速入門

時間  2019-11-17
標籤 rxjava 快速 入門 欄目 Java 简体版
原文   原文鏈接

前言

相信各位看官對RxJava早有耳聞，那麼關於什麼是RxJava我就再也不贅述了，不知道的可自行百度。若是你已經大體瞭解過什麼是RxJava，想開始學習，那麼本文不失爲你良好的選擇，爲何這麼說呢，由於我也是剛學幾天，正所謂「知己知彼，百戰不殆」。網上流傳，RxJava的入門門檻高，而通過我這幾天的學習，我反而不那麼認爲，精通我不敢說，但入門確實也不難，不信？我先來個簡單的例子預熱一下。數據庫

先建立個數據發射源,很好理解，就是發射數據用的：異步

Observable<String> sender = Observable.create(new Observable.OnSubscribe<String>() {

           @Override
            public void call(Subscriber<? super String> subscriber) {

                subscriber.onNext("Hi，Weavey！");  //發送數據"Hi，Weavey！"
            }
        });

再建立個數據接收源，同理，接收數據用的：ide

Observer<String> receiver = new Observer<String>() {

            @Override
            public void onCompleted() {

                //數據接收完成時調用
            }

            @Override
            public void onError(Throwable e) {

                //發生錯誤調用
            }

            @Override
            public void onNext(String s) {

               //正常接收數據調用
                System.out.print(s);  //將接收到來自sender的問候"Hi，Weavey！"
            }
        };

好了，將發射源和接收源關聯起來：post

sender.subscribe(receiver);

這樣就造成RxJava一個簡單的用法，sender發射"Hi，Weavey！"，將會被receiver的onNext的接收，經過這個例子，也許你會想到「異步」、「觀察者模式」，沒錯，這些都是RxJava所作的事情，而且讓他們變得更簡單和簡潔，而RxJava全部的一切都將圍繞這兩個點展開，一個是發射數據，一個是接收數據，是否是很通俗易懂？若是你理解了這點或者你已經知道RxJava就是這麼一回事，那麼恭喜你，你已經一隻腳跨進RxJava的大門了，若是不是！！！！那也無所謂，請繼續往下看...學習

論概念的重要性

網上關於RxJava的博文也有不少，我也看過許多，其中不乏有優秀的文章，但絕大部分文章都有一個共同點，就是側重於講RxJava中各類強大的操做符，而忽略了最基本的東西——概念，因此一開始我也看的一臉懵逼，看到後面又忘了前面的，腦子裏全是問號，這個是什麼，那個又是什麼，這兩個長得怎麼那麼像。舉個不太恰當的例子，概念之於初學者，就像食物之於人，當你餓了，你會想吃麪包、牛奶，那你爲何不去吃土呢，由於你知道麪包牛奶是用來幹嗎的，土是用來幹嗎的。同理，前面已經說過，RxJava無非是發送數據與接收數據，那麼什麼是發射源，什麼是接收源，這就是你應該明確的事，也是RxJava的入門條件之一，下面就依我我的理解，對發射源和接收源作個歸類，以及RxJava中頻繁出現的幾個「單詞」解釋一通，說的很差還請海涵，歡迎補充。spa

基本概念

Observable：發射源，英文釋義「可觀察的」，在觀察者模式中稱爲「被觀察者」或「可觀察對象」；code

Observer：接收源，英文釋義「觀察者」，沒錯！就是觀察者模式中的「觀察者」，可接收Observable、Subject發射的數據；orm

Subject：Subject是一個比較特殊的對象，既可充當發射源，也可充當接收源，爲避免初學者被混淆，本章將不對Subject作過多的解釋和使用，重點放在Observable和Observer上，先把最基本方法的使用學會，後面再學其餘的都不是什麼問題；server

Subscriber：「訂閱者」，也是接收源，那它跟Observer有什麼區別呢？Subscriber實現了Observer接口，比Observer多了一個最重要的方法unsubscribe( )，用來取消訂閱，當你再也不想接收數據了，能夠調用unsubscribe( )方法中止接收，Observer 在 subscribe() 過程當中,最終也會被轉換成 Subscriber 對象，通常狀況下，建議使用Subscriber做爲接收源；對象

Subscription ：Observable調用subscribe( )方法返回的對象，一樣有unsubscribe( )方法，能夠用來取消訂閱事件；

Action0：RxJava中的一個接口，它只有一個無參call（）方法，且無返回值，一樣還有Action1，Action2...Action9等，Action1封裝了含有 1 個參的call（）方法，即call（T t），Action2封裝了含有 2 個參數的call方法，即call（T1 t1，T2 t2），以此類推；

Func0：與Action0很是類似，也有call（）方法，可是它是有返回值的，一樣也有Func0、Func1...Func9;

基本用法

  • Observable的建立
    1.使用create( ),最基本的建立方式：

    normalObservable = Observable.create(new Observable.OnSubscribe<String>() {
  @Override
  public void call(Subscriber<? super String> subscriber) {
      subscriber.onNext("create1"); //發射一個"create1"的String
      subscriber.onNext("create2"); //發射一個"create2"的String
      subscriber.onCompleted();//發射完成,這種方法須要手動調用onCompleted，纔會回調Observer的onCompleted方法
  }});

    2.使用just( )，將爲你建立一個Observable並自動爲你調用onNext( )發射數據：

    justObservable = Observable.just("just1","just2");//依次發送"just1"和"just2"

    3.使用from( )，遍歷集合，發送每一個item：

    List<String> list = new ArrayList<>();
list.add("from1");
list.add("from2");
list.add("from3");
fromObservable = Observable.from(list);  //遍歷list 每次發送一個
/** 注意，just()方法也能夠傳list，可是發送的是整個list對象，而from（）發送的是list的一個item** /

    4.使用defer( )，有觀察者訂閱時才建立Observable，而且爲每一個觀察者建立一個新的Observable：

    deferObservable = Observable.defer(new Func0<Observable<String>>() {
  @Override
  //注意此處的call方法沒有Subscriber參數
  public Observable<String> call() {
      return Observable.just("deferObservable");
  }});

    5.使用interval( ),建立一個按固定時間間隔發射整數序列的Observable，可用做定時器：

    intervalObservable = Observable.interval(1, TimeUnit.SECONDS);//每隔一秒發送一次

    6.使用range( ),建立一個發射特定整數序列的Observable，第一個參數爲起始值，第二個爲發送的個數，若是爲0則不發送，負數則拋異常：

    rangeObservable = Observable.range(10, 5);//將發送整數10，11，12，13，14

    7.使用timer( ),建立一個Observable，它在一個給定的延遲後發射一個特殊的值，等同於Android中Handler的postDelay( )方法：

    timeObservable = Observable.timer(3, TimeUnit.SECONDS);  //3秒後發射一個值

    8.使用repeat( ),建立一個重複發射特定數據的Observable:

    repeatObservable = Observable.just("repeatObservable").repeat(3);//重複發射3次

  • Observer的建立

    mObserver = new Observer<String>() {
  @Override
  public void onCompleted() {
      LogUtil.log("onCompleted");
  }
  @Override
  public void onError(Throwable e) {
  }
  @Override
  public void onNext(String s) {
      LogUtil.log(s);
  }};

    ok，有了Observable和Obsever，咱們就能夠隨便玩了，任取一個已建立的Observable和Observer關聯上，即造成一個RxJava的例子，如：

    justObservable.subscribe(mObserver);

    mObserver的onNext方法將會依次收到來自justObservable的數據"just1"、"just2"，另外，若是你不在乎數據是否接收完或者是否出現錯誤，即不須要Observer的onCompleted()和onError()方法，可以使用Action1，subscribe()支持將Action1做爲參數傳入,RxJava將會調用它的call方法來接收數據，代碼以下：

    justObservable.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {

          LogUtil.log(s);
     }});

    以上就是RxJava最簡單的用法。看到這裏，我也不知道我寫的是否簡單明瞭，也許你會想，「哎呀，寫個異步的東西，怎麼這麼麻煩，爲何不用Thread+Handler呢」,那你就錯了，RxJava也以代碼的簡潔深受廣大用戶喜好，簡潔不能理解爲代碼量少，而是隨着邏輯的複雜，需求的更改，代碼可依然能保持極強的閱讀性，舉個簡單的例子（前方高能預警~~~），領導要我從數據庫的用戶表查找出全部用戶數據，我二話不說拿出心儀的RxJava就寫：

    Observable.create(new Observable.OnSubscribe<List<User>>() {
          @Override
          public void call(Subscriber<? super List<User>> subscriber) {
              List<User> userList = null;
              ···
              //從數據庫獲取用戶表數據並賦給userList
              ···
              subscriber.onNext(userList);
          }
      }).subscribe(new Action1<List<User>>() {
          @Override
          public void call(List<User> users) {

              //獲取到用戶信息列表
          }
      });

    可是，領導忽然又不想要全部用戶了，只要名字叫「小明」的用戶，行吧，領導最大，我改（假設名字惟一）：

    Observable.create(new Observable.OnSubscribe<List<User>>() {
          @Override
          public void call(Subscriber<? super List<User>> subscriber) {
              List<User> userList = null;
              ···
              //從數據庫獲取用戶表數據並賦給userList
              ···
              subscriber.onNext(userList);
          }
      }).flatMap(new Func1<List<User>, Observable<User>>() {
          @Override
          public Observable<User> call(List<User> users) {
              return Observable.from(users);
          }
      }).filter(new Func1<User, Boolean>() {
          @Override
          public Boolean call(User user) {
              return user.getName().equals("小明");
          }
      }).subscribe(new Action1<User>() {
          @Override
          public void call(User user) {
              //拿到謎之小明的數據
          }
      });

    搞定，這時候領導又說，我不要小明瞭，我要小明的爸爸的數據，（坑爹啊~~），我繼續改：

    Observable.create(new Observable.OnSubscribe<List<User>>() {
          @Override
          public void call(Subscriber<? super List<User>> subscriber) {
              List<User> userList = null;
              ···
              //從數據庫獲取用戶表數據並賦給userList
              ···
              subscriber.onNext(userList);
          } 
     }).flatMap(new Func1<List<User>, Observable<User>>() {
          @Override
          public Observable<User> call(List<User> users) {
              return Observable.from(users);
          }
      }).filter(new Func1<User, Boolean>() {
          @Override
          public Boolean call(User user) {
              return user.getName().equals("小明");
          }
      }).map(new Func1<User, User>() {
          @Override
          public User call(User user) { 
              //根據小明的數據user從數據庫查找出小明的父親user2
              return user2;
          }
      }).subscribe(new Action1<User>() {
          @Override
          public void call(User user2) {
            //拿到謎之小明的爸爸的數據
          }
      });

    搞定，「還想怎麼改？領導請說···」。
    以上例子，涉及到幾個操做符，初學者可能沒法理解，可是無所謂，這不是重點，個人目的只是爲了向你展現RxJava在需求不斷變動、邏輯越發複雜的狀況下，依舊能夠保持代碼簡潔、可閱讀性強的一面，沒有各類回調，也沒有謎之縮進！

 

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程