煮 Retrofit 论 RxJava（一）
首先，本篇是基于这个的总结、思考和拓展，那篇作者由浅入深，徐徐道来，读起来感觉很棒。
** 1、使用Retrofit来进行网络请求 **
a、网络接口使用豆瓣电影的top250，我们根据它返回的json格式封装为一个MovieEntity。
https://api.douban.com/v2/movie/top250?start=0&count=10
b、然后创建接口MovieService：
public interface MovieService {
/** 以Get方法访问接口，参数start和count分别是对接口地址的传参 **/
@GET("top250")
Call<MovieEntity> getTopMovie(@Query("start") int start, @Query("count") int count);
}
c、接着，在界面中使用Retrofit进行网络请求：
private void getMovie() {
String baseUrl = "https://api.douban.com/v2/movie/";
/** 创建Retrofit对象，数据转换使用Gson **/
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(baseUrl)
.addConverterFactory(GsonConverterFactory.create())
.build();
/** 通过MoviceService得到Call，然后加入请求队列并，并在Callback接口方法中处理返回结果 **/
MovieService movieService = retrofit.create(MovieService.class);
Call<MovieEntity> call = movieService.getTopMovie(0, 10);
call.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());
}
});
}
是的，以上方法便可以完成请求，但是看起来不美，我们可以通过封装请求方法，在Activity或Fragment中只保留更新UI相关的逻辑。OK，单纯的封装比较简单，我们一并加入Rxjava来看看。
** 2、添加Rxjava并对请求过程进行封装 **
a、我们之前定义的Service返回值就由Call变为Observable了。
public interface MovieService {
/** 返回的Observable正是被观察者，我们用来通知观察者对象（这里我们通知UI更新） **/
@GET("top250")
Observable<MovieEntity> getTopMovie(@Query("start") int start, @Query("count") int count);
}
b、把请求的过程封装到HttpMethods类里面，
public class HttpMethods {
public static final String BASE_URL = "https://api.douban.com/v2/movie/";
private static final int DEFAULT_TIMEOUT = 5;
private Retrofit retrofit;
private MovieService movieService;
//构造方法私有
private HttpMethods() {
//手动创建一个OkHttpClient并设置超时时间
OkHttpClient.Builder httpClientBuilder = new OkHttpClient.Builder();
httpClientBuilder.connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS);
retrofit = new Retrofit.Builder()
.client(httpClientBuilder.build())
.addConverterFactory(GsonConverterFactory.create())
//此处添加RxJavaCallAdapterFactory，把请求结果直接映射为
//MovieService接口方法返回的具体类型MovieEntity
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.baseUrl(BASE_URL)
.build();
movieService = retrofit.create(MovieService.class);
}
//在访问HttpMethods时创建单例
private static class SingletonHolder{
private static final HttpMethods INSTANCE = new HttpMethods();
}
//获取单例
public static HttpMethods getInstance(){
return SingletonHolder.INSTANCE;
}
/**
* 用于获取豆瓣电影Top250的数据
* @param subscriber 由调用者传过来的观察者对象
* @param start 起始位置
* @param count 获取长度
*/
public void getTopMovie(Subscriber<MovieEntity> subscriber, int start, int count){
movieService.getTopMovie(start, count)
//指定subscribe()发生在io调度器（读写文件、读写数据库、网络信息交互等）
.subscribeOn(Schedulers.io())
.unsubscribeOn(Schedulers.io())
//指定subscriber的回调发生在主线程
.observeOn(AndroidSchedulers.mainThread())
//实现订阅关系
.subscribe(subscriber);
}
}
c、那么getMovie()方法直接调用封装过的getTopMovie()即可。从中，我们看到使用Rxjava带来两点变化：一个是将请求封装进Observable；另外是通过实现Subscriber中的三个接口方法来通知请求状态（即UI更新）。
private void getMovie() {
subscriber = new Subscriber<MovieEntity>() {
@Override
public void onCompleted() {
Toast.makeText(MainActivity.this, "Get Top Movie Completed", Toast.LENGTH_SHORT).show();
}
@Override
public void onError(Throwable e) {
resultTV.setText(e.getMessage());
}
@Override
public void onNext(MovieEntity movieEntity) {
/** 这里得到的请求结果直接是我们想要的java对象 **/
resultTV.setText(movieEntity.toString());
}
};
HttpMethods.getInstance().getTopMovie(subscriber, 0, 10);
}
从上面我们知道Retrofit会把返回的json对象映射为我们需要的java对象，我们的应用中肯定会用到很多网络接口，我们现在是请求的电影列表，我们还会请求电影详情，演员详情等等，那我们就需要定义MovieDetail、Actor等等Entity。问题是我们的服务通常会给我们返回一个固定样式的数据，形如：
{
"resultCode": 1,
"resultMsg": "成功",
"data": {}
}
而且我们通常会先去判断resultCode，以便可以统一处理错误信息。至于data中的结构，则是变化的，它可以是电影列表Movies，也可以是演员信息Actor，那么此时我们就会想起使用泛型来进行封装：
public class HttpResult<T> {
private int resultCode;
private String resultMsg;
private T data;
}
如果data是Actor对象的话，那么定义Service方法返回值就可以写成：
observable<HttpResult<Actor>>
如果data是电影列表，那么我们可以这样写：
observable<HttpResult<List<Movie>>>
考虑到一般列表的数据都会有分页信息，我们仍然可以继续封装：
/** 支持分页的json结构 **/
{
"start": 0,
"count": 20,
"total": 250
"list": []
}
/** 封装后带分页的泛型对象 **/
public class HttpResList<T> {
private int start;
private int count;
private int total;
private T list;
}
那么电影列表，就需要这么写了：
observable<HttpResult<HttpResList<List<Movie>>>>
啊啊啊，是不是有一种碟中谍、局中局的感觉…当然，为了减少层级，我们可以把分页的相关信息提到resultCode这个层级来，这个需要我们跟服务端协定好一个规则。
那么封装为泛型后的代码跟上面的相差不大，只是把Observable相关的参数或返回类型由MovieEntity改为HttpResult<List<Movie>>（注意，我们所使用的测试接口跟我们以上讨论的结构有出入），所有就不再贴出代码。
所以，协定好一个规范、好用的数据结构，是多么的酸爽。
其实，我一直有个疑惑，为什么要用Rxjava呢？没看到代码简洁、好用啊，是啊，Why？请移步 煮 Retrofit 论 RxJava（二）。
