Retrofit统一添加post请求的默认参数

前言

最近在学习使用Retrofit，并尝试将之引入到现有的项目中来。你们都知道，在Http请求中咱们使用Content-Type来指定不一样格式的请求信息：

APP_FORM_URLENCODED("application/x-www-form-urlencoded"),
    APP_JSON("application/json"),
    APP_OCTET_STREAM("application/octet-stream"),
    MULTIPART_FORM_DATA("multipart/form-data"),
    TEXT_HTML("text/html"),
    TEXT_PLAIN("text/plain"),
复制代码

实际项目中一般最后的请求参数都包含默认的一些参数（Token，Api版本、App版本等）和普通的请求参数。网上有不少关于第一种Content-Type添加默认参数的方法（post-表单）。而在我现有项目上，除文件上传外绝大多数请求都走了post-json的方式。这里暂不讨论二者的优缺点，而是谈下Content-Type为application/json时，如何去优雅地添加默认参数。

传统方式：

咱们先来回忆下post-json的两种方式

public interface Apis {
    
    @POST("user/login")
    Observable<Entity<User>> login(@Body RequestBody body);//构造一个RequestBody对象
    
    @POST("user/login")
    Observable<Entity<User>> login(@Body LoginInfo loginInfo);//构造一个实体对象
    
    }
    
复制代码

第二种方法，你须要为每个不一样的请求的对象建立一个不一样的Model，太麻烦了，这里选择第一种直接构造RequestBody对象：

Retrofit mRetrofit = new Retrofit.Builder()
                .baseUrl(HttpConfig.BASE_URL)
                .addConverterFactory(GsonConverterFactory.create())//添加gson转换器
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())//添加rxjava转换器
                .client(new OkHttpClient.Builder().build())
                .build();
Apis  mAPIFunction = mRetrofit.create(Apis.class);
Map<String, Object> params = new LinkedHashMap<>();
    params.put("name", "吴彦祖");
    params.put("request", "123456");
RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), JsonHelper.toJSONString(params));
mAPIFunction.login(RequestBody.create(requestBody))
复制代码

执行后经过抓包查看，请求体以下：

而我但愿的结果是这样的：

固然咱们能够每次构造 RequestBody,在传入的参数中加入默认参数：

public static RequestBody getRequestBody(HashMap<String, Object> hashMap) {
        Map<String, Object> params = new LinkedHashMap<>();
        params.put("auth", getBaseParams());
        params.put("request", hashMap);
        return RequestBody.create(MediaType.parse("application/json; charset=utf-8"), JsonHelper.toJSONString(params));
    }
复制代码

这样彻底没问题，但不够优雅，因此接下来咱们来讨论我所想到的一种方式

拦截器方式：

哈哈，相信熟悉OkHttp的同窗已经想到这种方式了，是的不少网上关于第一种Content-Type添加默认参数也是这么作的(原文连接)：

@Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        if (request.method().equals("POST")) {
       if (request.body() instanceof FormBody) {
            FormBody.Builder bodyBuilder = new FormBody.Builder();
            FormBody formBody = (FormBody) request.body();
            //把原来的参数添加到新的构造器，（由于没找到直接添加，因此就new新的）
            for (int i = 0; i < formBody.size(); i++) {
                bodyBuilder.addEncoded(formBody.encodedName(i), formBody.encodedValue(i));
            }
            formBody = bodyBuilder
                    .addEncoded("clienttype", "1")
                    .addEncoded("imei", "imei")
                    .addEncoded("version", "VersionName")
                    .addEncoded("timestamp", String.valueOf(System.currentTimeMillis()))
                    .build();

            request = request.newBuilder().post(formBody).build();
        }
         return chain.proceed(request);
       }
复制代码

在上面，咱们拿到了request对象，而后拿到了requestBody对象，而后 判断是否是FormBody类型，若是是的话，将里面的键值对取出，并添加默认参数的键值对并构造出一个新的formBody对象，最后将原来用request对象构造出新的一个request对象，将新的formBody对象穿进去，拦截器返回。formBody对象是Content-Type为application/x-www-form-urlencoded时,Retrofit为咱们生成的对象,它是RequestBody的子类；而Content-Type为application/json时，生成的就是RequestBody(准确的说是匿名子类)。因此咱们只要继承重写RequestBody，记录请求内容，再将它在拦截器里取出加入并处理就好了。

public class PostJsonBody extends RequestBody {

    private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
    private static final Charset charset = Util.UTF_8;

    private String content;

    public PostJsonBody(@NonNull String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }

    @Nullable
    @Override
    public MediaType contentType() {
        return JSON;
    }

    @Override
    public void writeTo(@NonNull BufferedSink sink) throws IOException {
        byte[] bytes = content.getBytes(charset);
        if (bytes == null) throw new NullPointerException("content == null");
        Util.checkOffsetAndCount(bytes.length, 0, bytes.length);
        sink.write(bytes, 0, bytes.length);
    }

    public static RequestBody create(@NonNull String content) {
        return new PostJsonBody(content);
    }
}
复制代码

拦截器里面取出原始json数据，并添加新的默认参数：

@Override
    public Response intercept(@NonNull Chain chain) throws IOException {
        Request originalRequest = chain.request();
        Request.Builder builder = originalRequest.newBuilder();
        if (originalRequest.method().equals("POST")) {
            RequestBody requestBody = originalRequest.body();
            if (requestBody instanceof PostJsonBody) {
                String content = ((PostJsonBody) requestBody).getContent();
                HashMap<String, Object> hashMap = JsonHelper.fromJson(content, HashMap.class);
                builder.post(RequestBodyFactory.getRequestBody(hashMap));
            }
        }
        return chain.proceed(builder.build());
    }
复制代码

这样在外面咱们只要改动一行代码就能够实现全局添加默认参数：

RequestBody requestBody =
 RequestBody.create(MediaType.parse("application/json;charset=utf-8"),JsonHelper.toJSONString(params));
复制代码

替换为：

RequestBody requestBody = PostJsonBody.create( JsonHelper.toJSONString(params));
复制代码

不成熟的想法：

先来回顾下post-表单的用法，咱们将前面的登录改用post-表单定义以下：

@FormUrlEncoded      //@FormUrlEncoded将会自动将请求参数的`content
    @POST("user/login")
    Observable<Entity<User>> login(@Field("account") String name, @Field("password") String password);
复制代码

相比post-json的api定义是否是一目了然多了?并且不须要在调用接口的时候本身构造HashMap和requestBody,请求方法里面定义的参数和咱们从输入框中拿到的原始数据已经一一对应，直接调用就行了：

mAPIFunction.login("吴彦祖","123456");
复制代码

但缺点上面也说了，post-表单的请求体里面只能有键值对参数，不能描述更复杂的对象，若是统一在拦截器里面加入了默认参数也只能和普通参数混在一块儿：

因此能不能结合二者优势呢？若是普通请求参数是键值对参数的话，这是能够的，原理就是在Api接口定义的时候定义为post-表单，而后在OkHttp拦截器里面加入默认参数，并将post-表单请求改成post-json请求（get请求也是一样的方法）：

public class AddQueryParameterInterceptor implements Interceptor {

    @Override
    public Response intercept(@NonNull Chain chain) throws IOException {
        Request originalRequest = chain.request();
        Request.Builder builder = originalRequest.newBuilder();
        if (originalRequest.method().equals("POST")) {
            RequestBody requestBody = originalRequest.body();
            if (requestBody instanceof PostJsonBody) {
                String content = ((PostJsonBody) requestBody).getContent();
                HashMap<String, Object> hashMap = JsonHelper.fromJson(content, HashMap.class);
                builder.post(RequestBodyFactory.getRequestBody(hashMap));
            } else if (requestBody instanceof FormBody) {
                FormBody formBody = (FormBody) requestBody;
                LinkedHashMap<String, Object> hashMap = new LinkedHashMap<>();
                for (int i = 0; i < formBody.size(); i++) {
                    hashMap.put(formBody.encodedName(i), formBody.encodedValue(i));
                }
                builder.post(RequestBodyFactory.getRequestBody(hashMap));
            }
        }
        return chain.proceed(builder.build());
    }

}
复制代码

若是你原有项目里面有不少get请求或者post-表单请求的接口，想把他们统一改为post-json方式的话，这是一种不用动上层的简单方法。