煮 Retrofit 论 RxJava（二）

为什么要用Rxjava？没看出Rxjava到底解决了我们什么问题。一门技术或框架只有解决了实际问题，我们才能体会它的美妙，所以我们直面开发中的真实场景。

先来回顾下上篇我们使用Retrofit请求时的方法：

 @GET("top250")
 Call<MovieEntity> getTopMovie(@Query("start") int start, @Query("count") int count);

 getTopMovie(0, 10).enqueue(new Callback<MovieEntity>() {
      @Override
      public void onResponse(Call<MovieEntity> call, Response<MovieEntity> response) {
         resultTV.setText(response.body().toString());
      }

      @Override
      public void onFailure(Call<MovieEntity> call, Throwable t) {
         resultTV.setText(t.getMessage());
      }
 });

现在我们使情景复杂起来，比如获取到MovieEntity后，需要先跟数据库中的数据对比后，再进行显示，可以这样写：

 getTopMovie(0, 10).enqueue(new Callback<MovieEntity>() {
      @Override
      public void onResponse(Call<MovieEntity> call, Response<MovieEntity> response) {
         /** 尝试比较数据并更新 **/
         processData(response.body);
         resultTV.setText(response.body().toString());
      }

      @Override
      public void onFailure(Call<MovieEntity> call, Throwable t) {
         resultTV.setText(t.getMessage());
      }
 });

但是把数据库的操作直接放在主线程里，会造成界面卡顿，为了提升性能，我们把它放到子线程里：

 getTopMovie(0, 10).enqueue(new Callback<MovieEntity>() {
      @Override
      public void onResponse(Call<MovieEntity> call, Response<MovieEntity> response) {
         new Thread() {
            @Override
            public void run() {
                /** 尝试比较数据并更新 **/
                processData(response.body);
                /** 切回主线程 **/
                runOnUiThread(new Runnable() { 
                    @Override
                    public void run() {
                        resultTV.setText(response.body().toString());
                    }
                });
            }).start();       
      }

      @Override
      public void onFailure(Call<MovieEntity> call, Throwable t) {
         resultTV.setText(t.getMessage());
      }
 });

也许你早就对这种杂乱的流程代码看不顺眼了吧，忍了好久终于到今天~，那不妨试试到手的Rxjava：

getTopMovie(start, count)
     .subscribeOn(Schedulers.io())
     /** doOnNext()允许我们在执行onNext()方法之前做一些额外的事情；
       * 这里它是运行在Schedulers.io，所以我们可以访问数据库；
       * 它和onNext()方法是同步操作，即执行完doOnNext()方法后才去执行onNext()方法。
      **/
     .doOnNext(new Action1<HttpResult<List<Subject>>>() {
          @Override
          public void call(HttpResult<List<Subject>> subjects) {
               /** 尝试比较数据并修复数据 **/
               processData(subjects);
          }
     })
     .observeOn(AndroidSchedulers.mainThread())
     .subscribe(new Subscriber<HttpResult<List<Subject>>>() {
          @Override
          public void onNext(HttpResult<List<Subject>> subjects) {
          }
          @Override
          public void onCompleted() {
          }
          @Override
          public void onError(Throwable e) {
          }
     });

这样一来，我们的代码逻辑是不是清晰多了。如果我们的需求是请求完数据，存放到数据库，并显示在UI上，那么上面doOnNext()（关于doOnNext()的测试）和onNext()方法的同步就显然不适用了，不过我们可以这样来修改：

.doOnNext(new Action1<HttpResult<List<Subject>>>() {
     @Override
     public void call(HttpResult<List<Subject>> subjects) {
         /** 这里我们使用Schedulers.io()创建非阻塞的版本，
         这样saveData()和onNext()就实现了异步操作 **/
         Schedulers.io().createWorker().schedule(new Action0() {
            @Override
            public void call() {
                 /** 这里我们把数据存到数据库里 **/
                 saveData(subjects);
            }
         });
     }
})

再来看一个同步等待的场景：假设获取电影top250的接口不能直接访问，需要填入一个在线获取的 token，此时该怎么办？

@GET("/token")
public void getToken(Callback<String> callback);

@GET("top250")
Call<MovieEntity> getTopMovie(@Query("token") String token, @Query("start") int start, @Query("count") int count);

/** 先获取token **/
getToken(new Callback<String>() {
    @Override
    public void onResponse(String token) {
        /** 成功后再获取电影列表数据 **/
        getTopMovie(token, 0, 10, new Callback<MovieEntity>() {
            @Override
            public void onResponse(MovieEntity response) {
                resultTV.setText(response.toString());
            }
            @Override
            public void onFailure(RetrofitError error) {
            }
        };
    }

    @Override
    public void onFailure(RetrofitError error) {
    }
});

又是嵌套式的代码结构，还是不爽不爽。

/** 首先调用getToken() **/
 getToken()  
     /** flatMap()允许我们干预事件流程并返回一个Observable，即转换为其他事件 **/
    .flatMap(new Func1<String, Observable<HttpResult<List<Subject>>>>() {
        @Override
        public Observable<HttpResult<List<Subject>>> onNext(String token) {
            /** 然后调用getTopMovie() **/
            return getTopMovie(token, 0, 10);
        })
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Subscriber<HttpResult<List<Subject>>>() {
          @Override
          public void onNext(HttpResult<List<Subject>> subjects) {
          }
          @Override
          public void onCompleted() {
          }
          @Override
          public void onError(Throwable e) {
          }
     });

以上使用flatMap即用到了Rxjava的 变换 概念，所谓变换，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。通常可以使用map，flatMap，lift等方法来处理变换。

刚开始可能会觉得Rxjava的封装比较抽象，使用起来比较生涩，但通过以上情景的讨论，我们能够看出Rxjava在代码结构上本质的简洁，通过练习多多上手，最终用在项目上才是学习、使用它的最好方式。

转载请标明出处：http://www.jianshu.com/p/3cd9bf183926