Retrofit2自定义拦截器和ConverterFactory

网络请求框架使用的retrofit，客户端与服务端之间需要加密通信并且请求需要gzip压缩。为完成这一需求，需要拦截请求和响应。特此记录下修改请求的过程，希望可以帮助有需要的人。

处理request

retrofit2使用okhttp3.x，请求上的处理只需要给okhttp添加拦截器即可

这里与服务端通信相互之间对称加密，并且需要开启gzip压缩，因此这里定义了三个拦截器完成这一需求

1. 修改请求头

    public class RequestHeaderInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request originalRequest = chain.request();
            Request updateRequest = originalRequest.newBuilder()
                    .header("Content-Type", "text/plain; charset=utf-8")
                    .header("Accept", "*/*")
                    .header("Accept-Encoding", "gzip")
                    .build();
            return chain.proceed(updateRequest);
        }
    }
   

2. 加密请求内容

    public class RequestEncryptInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            RequestBody body = request.body();
            Buffer buffer = new Buffer();
            body.writeTo(buffer);
            Charset charset = Charset.forName("UTF-8");
            MediaType contentType = body.contentType();
            if (contentType != null) {
                charset = contentType.charset(charset);
            }
            String paramsStr = buffer.readString(charset);
            try {
                paramsStr = EncryptUtils.encryptParams(paramsStr);
            } catch (Exception e) {
                LogUtils.e(e);
            }
            RequestBody requestBody = RequestBody.create(MediaType.parse("text/plain; charset=utf-8"), paramsStr);
            request = request.newBuilder()
                    .post(requestBody)
                    .build();
            return chain.proceed(request);
        }
    }
   

3. 启用Gzip压缩

    public class GzipRequsetInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request originalRequest = chain.request();
            if (originalRequest.body() == null || originalRequest.header("Content-Encoding") != null) {
                return chain.proceed(originalRequest);
            }
            Request compressedRequest = originalRequest.newBuilder()
                    .header("Content-Encoding", "gzip")
                    .method(originalRequest.method(), gzip(originalRequest.body()))
                    .build();
            return chain.proceed(compressedRequest);
        }
    
        private RequestBody gzip(final RequestBody body) {
            return new RequestBody() {
                @Override
                public MediaType contentType() {
                    return body.contentType();
                }
    
                @Override
                public long contentLength() throws IOException {
                    return -1;
                }
    
                @Override
                public void writeTo(BufferedSink sink) throws IOException {
                    BufferedSink gzipSink = Okio.buffer(new GzipSink(sink));
                    body.writeTo(gzipSink);
                    gzipSink.close();
                }
            };
        }
    }
   

处理response

对response处理需要未retrofit设置自定义的ConverterFactory，因客户端与服务端使用json通信，因此我们参考官方提供GsonConverterFactory编写

自定义GsonConverterFactory，其实相对于原版只修改了responseBodyConverter方法的内容，requestBodyConverter依旧用的原版内容。

注意,GsonRequestBodyConverter类的修饰符不是public，需要将其代码拷贝出来

public final class CustomGsonConverterFactory extends Converter.Factory {

    private final Gson gson;

    public static CustomGsonConverterFactory create() {
        return create(new Gson());
    }

    @SuppressWarnings("ConstantConditions") // Guarding public API nullability.
    public static CustomGsonConverterFactory create(Gson gson) {
        if (gson == null) throw new NullPointerException("gson == null");
        return new CustomGsonConverterFactory(gson);
    }
   
    private CustomGsonConverterFactory(Gson gson) {
        this.gson = gson;
    }

    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
        TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
        return new CustomGsonResponseConverter<>(gson, adapter);
    }

    @Override
    public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
        TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
        return new GsonRequestBodyConverter<>(gson, adapter);
    }

}

修改GsonResponseConverter，使其解密后再处理内容。

注意：这里预处理json的过程并非通用步骤，因我的json格式是 { "code": 0, "message": "success", "data": { ... } }这样的，如果你的不同请换一种方式。

class CustomGsonResponseConverter<T> implements Converter<ResponseBody, T> {

    private final Gson gson;
    private final TypeAdapter<T> adapter;

    CustomGsonResponseConverter(Gson gson, TypeAdapter<T> adapter) {
        this.gson = gson;
        this.adapter = adapter;
    }

    @Override
    public T convert(ResponseBody value) throws IOException {
        try {
            String originalBody = value.string();
            // 解密
            String body = EncryptUtils.decryptParams(originalBody);
            // 获取json中的code，对json进行预处理
            JSONObject json = new JSONObject(body);
            int code = json.optInt("code");
            // 当code不为0时，设置data为{}，这样转化就不会出错了
            if (code != 0) {
                json.put("data", new JSONObject());
                body = json.toString();
            }

            return adapter.fromJson(body);
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        } finally {
            value.close();
        }
    }

这里也贴一下原版的GsonRequestBodyConverter：

class GsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
  private static final MediaType MEDIA_TYPE = MediaType.parse("application/json; charset=UTF-8");
  private static final Charset UTF_8 = Charset.forName("UTF-8");

  private final Gson gson;
  private final TypeAdapter<T> adapter;

  GsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) {
    this.gson = gson;
    this.adapter = adapter;
  }

  @Override public RequestBody convert(T value) throws IOException {
    Buffer buffer = new Buffer();
    Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
    JsonWriter jsonWriter = gson.newJsonWriter(writer);
    adapter.write(jsonWriter, value);
    jsonWriter.close();
    return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
  }
}

这样build.gradle中就可以删掉引入的GsonConverterFactory了

整合使用

使用方式如下

Retrofit retrofit = new Retrofit.Builder()
                .client(getOkHttpClient())
                .addConverterFactory(CustomGsonConverterFactory.create())
                .baseUrl(BASE_URL)
                .build();

其中，okhttpClient方法：

@NonNull
private OkHttpClient getOkHttpClient() {
    OkHttpClient.Builder okHttpClientBuilder = new OkHttpClient.Builder();
    okHttpClientBuilder.connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
            .writeTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
            .readTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
            .addInterceptor(new RequestHeaderInterceptor())
            .addInterceptor(new RequestEncryptInterceptor())
            .addInterceptor(new GzipRequsetInterceptor());
    return okHttpClientBuilder.build();
}

就酱