Android用Retrofit搭建通用网络请求模块

Retrofit是现在十分流行的网络请求库，底层封装了OkHttp，实现了JSON和POJO的互相转换，网络请求回来直接是对象，简化业务逻辑，用起来十分爽。

本文将会简单介绍下Retrofit的使用方法，主要描述下自己写的一个通用网络请求模块。

配置Retrofit

在build.gradle中添加依赖引入Retrofit，目前最新版本是2.1.0：

compile 'com.squareup.retrofit2:retrofit:2.1.0'

对Json的序列化和反序列化，Retrofit提供了gson、jackson等多种转换器。我用的是gson，需要额外添加依赖：

compile 'com.squareup.retrofit2:converter-gson:2.1.0'

创建Retrofit对象用的是Builder模式，同时可以设置底层的OkHttpClinet参数。

OkHttpClient okHttpClient = new OkHttpClient.Builder()
        .addInterceptor(new LoggingInterceptor())
        .addNetworkInterceptor(new StethoInterceptor())
        .connectTimeout(HTTP_CONNECT_TIMEOUT, TimeUnit.SECONDS)
        .readTimeout(HTTP_READ_TIMEOUT, TimeUnit.SECONDS)
        .writeTimeout(HTTP_WRITE_TIMEOUT, TimeUnit.SECONDS)
        .build();
Retrofit retrofit = new Retrofit.Builder()
        .baseUrl(mHost)
        .addConverterFactory(GsonConverterFactory.create())
        .client(okHttpClient)
        .build();

• LoggingInterceptor请求拦截器，后面会介绍；
• Stetho是Facebook出品的Android可视化工具，利用Chrome Developer Tools提供sqlit、preference、network等操作，推荐去了解；
• GsonConverterFactory是上面讲的Json转换器，如果要对Json做特别的处理，可以在create()传入自定义Gson；

请求api

请求api定义在interface，下面是用于登录的Post请求例子，返回值是类似于OkHttp的call。

@FormUrlEncoded
@POST("/api/login/")
Call<LoginResponse> doLoginIn(@FieldMap() TreeMap<String, String> paramMap);

入参形式可以有多种，提供对请求的不同处理，详细可以查官网。
- @Query、@QueryMap：get请求的query参数
- @File、@FieldMap：form-url-encoded参数
- @Part：文件
- @Url：可传入完整url

发出一个请求

获得Retrofit对象和定义好请求的api之后，就可以发出网络请求，下面是同步和异步的例子。

ApiDefine service = retrofit.create(ApiDefine.class);
//同步
Call<LoginResponse> call = service.doLoginIn(paramMap);
retrofit2.Response<LoginResponse> response = call.execute();
LoginResponse loginResponse = response.body().
//异步
call.enqueue(new Callback<LoginResponse>() {
            @Override
            public void onResponse(Call<LoginResponse> call, retrofit2.Response<LoginResponse> response) {   
            }

            @Override
            public void onFailure(Call<LoginResponse> call, Throwable t) {
            }
        });

paramMap是一个Map，请求用到的参数都放在里面。使用execute()发出同步请求，或者enqueue()发出异步请求。响应结果用response.body()获取定义好的LoginResponse，Retrofit会自动将json字符串转换进LoginResponse。

通用的请求响应结果

一般服务器会返回通用的请求结果和对应的业务数据，可以考虑使用一个通用请求基类HttpResponse，里面定义固定的返回结果。

private int result;
private String message;
private long timestamp;
private T data;

重点是data这个泛型，支持不同接口返回不同的具体业务数据，只要设置不同的响应类就行。相应地，登录api修改如下：

@FormUrlEncoded
@POST("/api/login/")
Call<HttpResponse<LoginResponse>> doLoginIn(@FieldMap() TreeMap<String, String> paramMap);

发送方法修改为支持泛型：

  private <T extends BaseBizResponse> HttpResponse<T> doSend(Call<HttpResponse<T>> call) throws Exception {
        retrofit2.Response<HttpResponse<T>> response;
        try {
            response = call.execute();
        } catch (Exception e) {
            //throw Exception
        }

        if (response.isSuccessful()) {
            return response.body();
        } else {
            //throw Exception
      }
}  

泛型T增加实现BaseBizResponse这个业务用的基类，里面可以定义一些公共变量或者方法。

RxJava提供异步处理

自己开线程处理网络请求是可以，但不如用专门的异步处理工具。RxJava是一个提供异步的、响应式编程的库，入门有点难度，但和Retrofit配合十分合适。

 public <T extends BaseBizResponse> Observable<T> send(final Call<HttpResponse<T>> call, Scheduler subscribeScheduler, Scheduler observeScheduler) {
        return Observable.create(new Observable.OnSubscribe<HttpResponse<T>>() {
            @Override
            public void call(Subscriber<? super HttpResponse<T>> subscriber) {
                HttpResponse<T> httpResponse = doSend(call);
                subscriber.onNext(httpResponse);
            }
        }).map(new Func1<HttpResponse<T>, T>() {
            @Override
            public T call(HttpResponse<T> httpResponse) {
                return dealHttpResponse(call, httpResponse);
            }
        }).subscribeOn(subscribeScheduler)
                .observeOn(observeScheduler);

    }

subscribeOn()指定网络请求运行在什么线程，可以新建一个线程或者使用线程池；observeOn()指定网络请求完成后在什么线程观察执行结果，可以指定回到Android主线程。

send方法返回Observable，这是一个可以被观察的对象。观察结果时，调用subscribe可以指定三种Action，分别对应onNext，onError，onComplete，这里使用了onNext和onError，处理成功和失败两种情况。继承Action1实现SuccessAction和FailAction，就算不懂RxJava，也可以照葫芦画瓢调用网络请求。

 observable.subscribe(new SuccessAction<LoginResponse>() {

            @Override
            public void call(LoginResponse loginResponse) {

            }
        }, new FailAction<Throwable>() {
            @Override
            public void call(Throwable throwable) {

            }
        });

对于服务器返回的结果，往往更专注于业务数据，所以加了一个步骤，将HttpResponse转换为T，只留下业务响应类。并且，将服务器报错的请求直接抛出异常，由FailAction处理。

调用dealHttpResponse()用到了map()方法，这是RxJava一个操作符，用于对对象的转换。

    private <T extends BaseBizResponse> T dealHttpResponse(Call<HttpResponse<T>> call, HttpResponse<T> httpResponse) {
        if (httpResponse.getResult() != RESPOND_RESULT_OK) {
            //throw exception;
        }
        return (T) httpResponse.getData();
    }

本文没有详细介绍RxJava，但非常推荐你去深入学习。一旦你弄懂RxJava，你会发现它真的太好用了。RxJava代码如果改用lambda，会更加简洁精妙。

请求拦截

Retrofit的请求拦截使用OkHttp里面的Interceptor，得到Request和Response后就可以做各种自定义操作。比如想获取每个请求的响应时间，可以这样实现：

public static class LoggingInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            long t1 = System.nanoTime();
            Response response = chain.proceed(request);
            long t2 = System.nanoTime();
            LogUtils.d(String.format("HTTP响应请求 %s %s %.1fms", response.request().url(), response.request().method(), time));
            return response;
        }
    }

文件下载

请求文件的下载，基本方法差不多，api定义改成传入url，返回ResponseBody对象。

@GET
@Streaming
Call<ResponseBody> download(@Url String url);

最终可以从ResponseBody对象获得InputStream，然后按照合适的方法写入磁盘，这里不贴代码了。

retrofit2.Response<ResponseBody> retrofitResponse = call.execute();
InputStream inputStream = retrofitResponse.body().byteStream();

总结

Retrofit+RxJava十分好用，学Android的一定要学习下。我一直在改进这个网络请求模块，有好的建议就告诉我啦。最初原文发布在简书。