GsonConverterFactory源码分析

• 前言

  前面我们分析了Retrofit的源码，知道了GsonConverterFactory是如何和Retrofit结合起来的。

• GsonRequestBodyConverter

  先看请求入参如何转换，即通过handlers[p].apply(requestBuilder, args[p])来解析参数，以ParameterHandler.Body为例：

  static final class Body extends ParameterHandler {
    private final Method method;
    private final int p;
    private final Converter converter;
  
    Body(Method method, int p, Converter converter) {
      this.method = method;
      this.p = p;
      this.converter = converter;
    }
  
    @Override
    void apply(RequestBuilder builder, @Nullable T value) {
      if (value == null) {
        throw Utils.parameterError(method, p, "Body parameter value must not be null.");
      }
      RequestBody body;
      try {
        body = converter.convert(value);
      } catch (IOException e) {
        throw Utils.parameterError(method, e, p, "Unable to convert " + value + " to RequestBody");
      }
      builder.setBody(body);
    }
  }
  

  调用converter.convert(value)生成body，看一下converter（GsonRequestBodyConverter）的convert：

  final class GsonRequestBodyConverter implements Converter {
    private static final MediaType MEDIA_TYPE = MediaType.get("application/json; charset=UTF-8");
    private static final Charset UTF_8 = Charset.forName("UTF-8");
  
    private final Gson gson;
    private final TypeAdapter adapter;
  
    GsonRequestBodyConverter(Gson gson, TypeAdapter 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());
    }
  }
  

  • GsonResponseBodyConverter

  再来看返参转换，即通过OkHttpCall中execute调用的parseResponse(call.execute())：

  Response parseResponse(okhttp3.Response rawResponse) throws IOException {
    ResponseBody rawBody = rawResponse.body();
  
    // Remove the body's source (the only stateful object) so we can pass the response along.
    rawResponse =
        rawResponse
            .newBuilder()
            .body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
            .build();
  
    int code = rawResponse.code();
    if (code < 200 || code >= 300) {
      try {
        // Buffer the entire body to avoid future I/O.
        ResponseBody bufferedBody = Utils.buffer(rawBody);
        return Response.error(bufferedBody, rawResponse);
      } finally {
        rawBody.close();
      }
    }
  
    if (code == 204 || code == 205) {
      rawBody.close();
      return Response.success(null, rawResponse);
    }
  
    ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
    try {
      T body = responseConverter.convert(catchingBody);
      return Response.success(body, rawResponse);
    } catch (RuntimeException e) {
      // If the underlying source threw an exception, propagate that rather than indicating it was
      // a runtime exception.
      catchingBody.throwIfCaught();
      throw e;
    }
  }
  

  调用responseConverter.convert(catchingBody)生成body，看一下responseConverter（GsonResponseBodyConverter）的convert：

  final class GsonResponseBodyConverter implements Converter {
    private final Gson gson;
    private final TypeAdapter adapter;
  
    GsonResponseBodyConverter(Gson gson, TypeAdapter adapter) {
      this.gson = gson;
      this.adapter = adapter;
    }
  
    @Override
    public T convert(ResponseBody value) throws IOException {
      JsonReader jsonReader = gson.newJsonReader(value.charStream());
      try {
        T result = adapter.read(jsonReader);
        if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
          throw new JsonIOException("JSON document was not fully consumed.");
        }
        return result;
      } finally {
        value.close();
      }
    }
  }
  

• 源码分析

  可以看到不管是write还是read，都需要adapter去做，adapter是什么呢？回到构建它们的地方：

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

  都是通过gson.getAdapter来获取adapter的，这里的type就是方法中每个参数的类型，TypeToken封装了一下：

  public static TypeToken get(Type type) {
    return new TypeToken