Retrofit 自定义 GsonConverterFactory

 

在项目中 网络请求中, 后台返回的数据有一个统一样式:

     /**
     * message : "success"
     * result : {}
     * status : 1
     * accessToken : ""
     */

其中 status == 1 时,才是请求正确, 我们再来根据具体接口来解析 result 对象, 获取我们想要的数据

当 status != 1 时,代表请求失败, 后台会在 message 中返回错误信息.

但是在  OkHttp + Retrofit +Rxjava 结构中就很麻烦了, 每次都会出现这样的情况:

OkHttpUtil.getInstance().getContact(id)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.io())
                .subscribe(new Observer<BaseResponse<ContactBean>>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(BaseResponse<ContactBean> contactResponse) {
                        if(contactResponse.getStatus() == 0){
                            //todo 正常,获取result中数据
                        } else {
                           //todo 异常, 显示异常信息
                        }
                    }

                    @Override
                    public void onError(Throwable e) {
                        // todo 异常, 处理异常
                    }

                    @Override
                    public void onComplete() {

                    }
                });

每个请求都需要在 onNext 中在进行一次判断, 最变态的就是, 如果说接口很多, 假如下次这个 status == 2 才代表请求成功呢? 岂不是要改到吐血;

下面就是解决方案了, 我们可以自己定义 GsonConverterFactory 来先转换一遍数据, 将 status == 0 的结果一并丢给 onError 这个回调去处理, 这样我们的 onNext 就可以专心处理正确的结果了.

 

首先我们来看看日常使用的 GsonConverterFactory  的代码:

public final class GsonConverterFactory extends Converter.Factory {
  /**
   * Create an instance using a default {@link Gson} instance for conversion. Encoding to JSON and
   * decoding from JSON (when no charset is specified by a header) will use UTF-8.
   */
  public static GsonConverterFactory create() {
    return create(new Gson());
  }

  /**
   * Create an instance using {@code gson} for conversion. Encoding to JSON and
   * decoding from JSON (when no charset is specified by a header) will use UTF-8.
   */
  @SuppressWarnings("ConstantConditions") // Guarding public API nullability.
  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);
  }


    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 {
          return adapter.read(jsonReader);
        } finally {
          value.close();
        }
      }
    }


    final 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());
      }
    }
}

很简单, 是将服务器返回数据解析成对象, 然后我们参考这个, 先解析一遍返回数据,再分类:

public class CustomGsonConverterFactory extends Converter.Factory {

    private final Gson gson;

    private CustomGsonConverterFactory(Gson gson) {
        if (gson == null) throw new NullPointerException("gson == null");
        this.gson = gson;
    }

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

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

    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
        TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
        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 CustomGsonRequestBodyConverter<>(gson, adapter);
    }

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

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

        CustomGsonRequestBodyConverter(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());
        }
    }

    final class CustomGsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
        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();
            BaseResponse baseResponse = gson.fromJson(response, BaseResponse.class);
            //核心代码:  判断 status 是否是后台定义的正常值
            if (baseResponse.isCodeInvalid()) {
                value.close();
                throw new ApiException(baseResponse.getStatus(), baseResponse.getMessage());
            }

            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 {
                return adapter.read(jsonReader);
            } finally {
                value.close();
            }
        }
    }
}

重要代码就那么几行, 已经写好注释了; 顺便把相关代码也贴出来吧:

public class BaseResponse<T> {

    /**
     * message : success
     * result : {}
     * status : 1
     * accessToken : ""
     */

    private String message;
    private T result;
    private int status;
    private String accessToken;

    //省略 getter / setter ...

    @Override
    public String toString() {
        return "BaseResponse{" +
                "message='" + message + '\'' +
                ", result=" + result +
                ", status=" + status +
                ", accessToken='" + accessToken + '\'' +
                '}';
    }

    public boolean isCodeInvalid() {
        //Constant.RES_OK 后台协议的网络请求正常状态值
        return status != Constant.RES_OK;
    }
}

public class ApiException extends RuntimeException {
    private int mErrorCode;

    public ApiException(int errorCode, String errorMessage) {
        super(errorMessage);
        mErrorCode = errorCode;
    }

    /**
     * 判断是否是token失效
     *
     * @return 失效返回true, 否则返回false;
     */
    public boolean isTokenExpried() {
        return mErrorCode == Constant.TOKEN_INVALID;
    }
}

然后在 创建Retrofit 时使用我们自定义的 CustomGsonConverterFactory 来解析返回数据:

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

以后再请求后台接口时 就不用像之前那么麻烦在 onNext 中判断一遍了. END