Retrofit统一处理响应结果以及注意事项

项目上使用Retrofit作为网络请求框架，最近有个需要对响应结果进行处理的需求，由于让各个模块自己处理响应结果不利于维护，所以需要统一处理，在处理的过程中遇到些问题，在此记录下来。

1.构建Retrofit

// 构建Retrofit代码如下：
OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder();
clientBuilder.addNetworkInterceptor(new NetworkInterceptor());
clientBuilder.connectTimeout(6, TimeUnit.SECONDS);
clientBuilder.writeTimeout(6, TimeUnit.SECONDS);
clientBuilder.readTimeout(6, TimeUnit.SECONDS);

Retrofit retrofit = new Retrofit.Builder()
    .client(clientBuilder.build())
    .addConverterFactory(GsonConverterFactory.create())
    .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
    .baseUrl("https:/xxxxxx")
    .build();

从构建Retrofit代码中可以看到GsonConverterFactory这个类就是把响应结果转变成我们想要的结果的类，所以如果需要统一处理响应结果的话，应该可以在这里面添加处理。

2.解析Converter

// GsonConverterFactory
public final class GsonConverterFactory extends Converter.Factory {
  public static GsonConverterFactory create() {
    return create(new Gson());
  }

  @SuppressWarnings("ConstantConditions")
  public static GsonConverterFactory create(Gson gson) {
    if (gson == null) throw new NullPointerException("gson == null");
    return new GsonConverterFactory(gson);
  }

  private final Gson gson;

  private GsonConverterFactory(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 GsonResponseBodyConverter<>(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);
  }
}

GsonConverterFactory类有两个重要的方法responseBodyConverter()和requestBodyConverter()，从这两个方法名称就可以看出，前者是用来处理响应的，后者是用来处理请求的。由于我们只需要处理响应结果，所以查看下GsonResponseBodyConverter代码。

// GsonResponseBodyConverter
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
  private final Gson gson;
  private final TypeAdapter<T> adapter;

  GsonResponseBodyConverter(Gson gson, TypeAdapter<T> 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();
    }
  }
}

GsonResonseBodyConverter类除了构造方法，就只有一个convert()方法，从convert()方法的实现可以看出这里就是处理响应的地方，所以如果我们需要统一处理响应结果，在这个方法里添加即可。

3.重写Converter

想要重写Converter，只能通过复制代码然后新建类的方式来重写。

// 重写GsonConverterFactory
public final class CustomGsonConverterFactory extends Converter.Factory {
    public static CustomGsonConverterFactory create() {
        return create(new Gson());
    }

    @SuppressWarnings("ConstantConditions")
    public static CustomGsonConverterFactory create(Gson gson) {
        if (gson == null) throw new NullPointerException("gson == null");
        return new CustomGsonConverterFactory(gson);
    }

    private final Gson 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));
        // 返回重写的GsonResponseConverter
        return new CustomGsonResponseBodyConverter<>(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);
    }
}

在CustomGsonConverterFactory的responseBodyConverter()方法中，我们返回了重写的GsonResponseConverter。

// 重写GsonResponseConverter
final class CustomGsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
    private static final String TAG = "ResponseBodyConverter";
    private final Gson gson;
    private final TypeAdapter<T> adapter;

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

    @Override
    public T convert(ResponseBody value) throws IOException {
        String response = value.string();   // value只能读取一次，一次之后就会关闭，所以需要保存
        try {
            JSONObject jsonObject = new JSONObject(response);
            String code = jsonObject.getString("code");
            String description = jsonObject.getString("description");
            LogUtil.d(TAG, "convert: code = " + code + ", description = " + description);

            handleResponseCode(code);
        } catch (JSONException e) {
            e.printStackTrace();
        }

        MediaType contentType = value.contentType();
        Charset charset = contentType != null ? contentType.charset(UTF_8) : UTF_8;
        InputStream inputStream = new ByteArrayInputStream(response.getBytes());
        Reader reader = new InputStreamReader(inputStream, charset);
        JsonReader jsonReader = gson.newJsonReader(reader);
        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();
        }
    }

    private void handleResponseCode(String code) {
        // todo 添加处理逻辑
    }
}

CustomGsonResponseBodyConverter中的convert()方法实现与GsonResponseBodyConverter中的convert()方法实现有很大不同，因为我们要通过传进来的参数value的string()方法来获取完整的响应结果，但是通过value.string()获取响应结果后，会把该数据源给关闭，这时候如果还是按照之前的方式value.charStream()获取数据，是会出现报错closed的，所以需要先保存结果，然后再通过IO流的方式把结果传给JsonReader，这一点是特别需要注意的地方。

4.注意事项及总结

统一处理响应结果需要注意的地方就在GsonResponseBodyConverter的convert()方法里面和ResponseBody类的使用。

// ResponseBody部分实现代码
...
	 /**
   * Returns the response as a string decoded with the charset of the Content-Type header. If that
   * header is either absent or lacks a charset, this will attempt to decode the response body as
   * UTF-8.
   */
  public final String string() throws IOException {
    return new String(bytes(), charset().name());
  }
  
  public final byte[] bytes() throws IOException {
    long contentLength = contentLength();
    if (contentLength > Integer.MAX_VALUE) {
      throw new IOException("Cannot buffer entire body for content length: " + contentLength);
    }

    BufferedSource source = source();
    byte[] bytes;
    try {
      bytes = source.readByteArray();
    } finally {
      Util.closeQuietly(source);	// 注意这里调用了close
    }
    if (contentLength != -1 && contentLength != bytes.length) {
      throw new IOException("Content-Length and stream length disagree");
    }
    return bytes;
  }

  /**
   * Returns the response as a character stream decoded with the charset of the Content-Type header.
   * If that header is either absent or lacks a charset, this will attempt to decode the response
   * body as UTF-8.
   */
  public final Reader charStream() {
    Reader r = reader;
    return r != null ? r : (reader = new InputStreamReader(byteStream(), charset()));
  }

  public final InputStream byteStream() {
    return source().inputStream();
  }
...

// Util部分实现代码
...
    /**
   * Closes {@code closeable}, ignoring any checked exceptions. Does nothing if {@code closeable} is
   * null.
   */
  public static void closeQuietly(Closeable closeable) {
    if (closeable != null) {
      try {
        closeable.close();
      } catch (RuntimeException rethrown) {
        throw rethrown;
      } catch (Exception ignored) {
      }
    }
  }
...

从ResponseBody代码中可以看出，string()方法和charStream()方法最终都需要调用到source()方法，但是如果先调用string()方法，在bytes()方法里面就会把source给关闭，导致后面调用charStream()方法时候会报closed。

这个地方是统一处理响应结果最容易忽略、也是新手容易踩的坑。

总的来说，统一处理响应结果的流程就是重写GsonConverterFactory类和GsonResponseBodyConverter类，需要重写的两个方法是GsonConverterFactory类中的responseBodyConverter()方法和GsonResponseBodyConverter类中的convert()方法。需要注意的就是ResponseBody中的数据读取。

以上是使用Retrofit统一处理响应结果的过程和遇到的一些问题，有错误的地方欢迎指正，希望能够帮助到大家，感谢你的阅读！