Retrofit进阶

前言

什么是Retrofit？
这类文章太多了，这里就不多做介绍，贴个官方链接：
http://square.github.io/retrofit/

以前抱着新鲜感使用Retrofit, 并没有感觉出太大的用处，最近接触到了RESTful API 才感受到了Retrofit的方便与强大。

读本文之前，建议对RxJava, Retrofit, RESTful稍做了解:
RESTful API 设计指南
RxJava 与 Retrofit 结合的最佳实践

关于RESTful API我再补充一句，gank.io的api在国内比较主流但不属于RESTful, GitHub的Api 才是。

下面直入主题。

提交表单

Post请求可以通过@Body提交整个表单，也可以通过@Field提交单个字段。

    @POST("/login")
    Observable<Response<UserEntity>> login(@Body LoginRequest loginRequest);

    /* == ↑非等同，取决于服务器接收 */
    @FormUrlEncoded
    @POST("/login")
    Observable<Response<UserEntity>> loginOtherWay(
            @Field("phone") String phone,
            @Field("password") String password,
            @Field("macAddress") String macAddress,
            @Field("ip") String ip
    );

使用拦截器统一处理Http请求头部与尾缀

@Headers自然可以添加头部，但是如何统一添加呢？
答：在拦截器里添加。

下面这段代码优点长，请注意httpClient.addInterceptor()内的代码:

    private Retrofit getRetrofit(final String baseUrl, final boolean isWithToken) {
        final OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
        httpClient.addInterceptor(new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Request original = chain.request();

                Request.Builder builder = original.newBuilder()
                        .method(original.method(), original.body())
                        //添加请求头部
                        .header("Content-Type", "application/json")
                        .header("Accept", "application/json")
                        .header("key", "value")
                        .header("key2", "value2");
                if (isWithToken)
                    builder.header("token", App.get().getPreferencesHelper().getToken());

                Request finalRequest = builder.build();
                HttpUrl url = finalRequest.url().newBuilder()
                        // 在原链接上添加后缀，相当于在url上添加了 &platform=android&v=1.0
                        .addQueryParameter("platform", "android")
                        .addQueryParameter("v", "1.0")
                        .build();

                Logger.i(url.toString());
                return chain.proceed(builder.build());
            }
        });

        OkHttpClient okHttpClient = httpClient.build();

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(baseUrl)
                .client(okHttpClient)
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .build();
        return retrofit;
    }

有没有发现，这个拦截器很强大～它可以在网络请求前对请求进行修改，而且它还能处理网络返回的结果。相当于一扇大门，外面是服务器，里面是客户端，二者间的通信都得经过它～～

与RxJava结合，在Observer中处理错误

当然，错误也可以在拦截器中统一处理，这里讲一下和RxJava的配合使用。

下面是Api网络请求的返回处理：

        // 未作任何封装
        new UserApi().getInfo("XunMengWinter").subscribe(
                new Observer<UserEntity>() {
                    @Override
                    public void onCompleted() {
                        // 成功后
                    }

                    @Override
                    public void onError(Throwable e) {
                        // 所有的错误全在这里
                    }

                    @Override
                    public void onNext(UserEntity userEntity) {
                        // 成功后
                    }
                }
        );
        
        // 对Observer封装后，统一处理错误
        new UserApi().getInfo("XunMengWinter").subscribe(
                new HttpObserver<UserEntity>() {
                    @Override
                    public void onComplete() {

                    }

                    @Override
                    public void onSuccess(UserEntity model) {

                    }
                });

采用RESTful的Api与RxJava是完美配合的，所有的错误全都在onError()里面，尽管在onNext()里使用数据就好了。下面看下如何对RxJava的Observer稍作封装以统一处理错误(GitHub链接在此)：

/**
 * 网络请求返回需要的模型
 * Created by ice on 3/3/16.
 */
public abstract class HttpObserver<T> implements Observer<T>, INetResult<T> {

    /**
     * 请求失败, 对错误信息进行处理,
     * 默认显示一个Toast提醒用户.
     */
    @Override
    public void onFail(int errorCode, String msg) {
        App.get().showToast(msg);
    }


    @Override
    public void onCompleted() {
        onComplete();
    }

    @Override
    public void onError(Throwable e) {
        onComplete();
        Logger.e(e.toString());
        if (e instanceof SocketTimeoutException) {
            App.get().showToast("连接超时");
        } else if (e instanceof HttpException) {
            HttpException httpException = (HttpException) e;
            Logger.e(httpException.code() + "");
            Logger.e(httpException.message() + "");
            if (httpException.response() != null && httpException.response().errorBody() != null) {
                try {
                    Logger.e(httpException.response().message());
                    String bodyStr = httpException.response().errorBody().string();
                    Logger.e(bodyStr);
                    ErrorBodyEntity errorBodyEntity = JSON.parseObject(bodyStr, ErrorBodyEntity.class);
                    onFail(httpException.code(), errorBodyEntity.getMessage());
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }

    @Override
    public void onNext(T model) {
        Logger.i(JSONObject.toJSONString(model));
        onSuccess(model);
    }

}

注意在onError()方法里一定要将Throwable e强转为HttpException httpException才能看到网络请求错误的全部内容。
经封装，无论网络请求是否成功都会调用onComplete()，这样的话你可以在里面处理进度条等；成功的话会调用onSuccess(model)；错误的话会执行默认处理，你也可以重写onFail()来进行特殊的错误处理～～

后记

其实想把Retrofit玩6，主要还是用好拦截器啦～^^
代码地址：https://github.com/XunMengWinter/PowerfulRetrofit