Question

每当我收到错误时，错误正文如下：

[
 {
  "errorCode": 10001,
  "resource": null,
  "resourceId": null,
  "field": null,
  "parameter": null,
  "header": null,
  "allowedValues": null,
  "maxLength": null,
  "minLength": null
 }
]

错误正文是一个数组。我有许多API方法成功的不同主体，但错误数组响应是标准化的。我尝试过很多事情

使用泛型类型成功响应和错误响应数组制作包装类，并为此创建反序列化器，但我无法从类型变量和参数化类中反序列化。
制作了一个ErrorDeserializer，但我不知道如何让Retrofit将它用于错误响应。

我绝对可以在每次回调时为所有api方法序列化原始字符串，但我有很多这样的，我需要通用的解决方案。如果我没有正确解释自己，请询问。

我会添加我尝试的例子（但它们将不完整）：

响应换行类：

    public class ResponseWrap<T> {
        @Nullable
        private final T response;

        @Nullable
        private final List<ErrorResponse> errorResponses;

        public ResponseWrap(@Nullable T response, @Nullable List<ErrorResponse> errorResponses) {
            this.response = response;
            this.errorResponses = errorResponses;
        }
    }

错误响应类：

    public class ErrorResponse {
        private int errorCode;
        private String resource;
        private String resourceId;
        private String field;
        private String parameter;
        private String header;
        private String allowedValues;
        private int maxLength;
        private int minLength;

        // getters and setters
    }

错误解串器：

    public class ErrorDeserializer implements JsonDeserializer<ArrayList<ErrorResponse>> {
        @Override
        public ArrayList<ErrorResponse> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {
            Gson gson = new Gson();
            Type listType = new TypeToken<ArrayList<ErrorResponse>>(){}.getType();
            ArrayList<ErrorResponse> list = new Gson().fromJson(json, listType);
            final JsonArray jsonArray = json.getAsJsonArray();
            for (int i = 0; i < jsonArray.size(); i++) {
                ErrorResponse error = new ErrorResponse();
                JsonObject jsonObject = jsonArray.get(i).getAsJsonObject();

                error.setErrorCode(jsonObject.get("errorCode").getAsInt());
                error.setResource(jsonObject.get("resource").getAsString());
                error.setResourceId(jsonObject.get("resourceId").getAsString());
                error.setField(jsonObject.get("field").getAsString());
                error.setParameter(jsonObject.get("parameter").getAsString());
                error.setHeader(jsonObject.get("header").getAsString());
                error.setAllowedValues(jsonObject.get("allowedValues").getAsString());
                error.setMaxLength(jsonObject.get("maxLength").getAsInt());
                error.setMinLength(jsonObject.get("minLength").getAsInt());

                list.add(error);
             }

             return list;
        }
    }

响应包装反序列化器 - 它不能正常工作，2个错误：

List error = new Gson（）。fromJson（jsonObject.getAsJsonObject（“error”），ArrayList.class）; //无法从参数化类

T success = new Gson（）。fromJson（jsonObject，T.class）; //无法从类型变量中选择

public class ResponseWrapDeserializer<T> implements JsonDeserializer<ResponseWrap<T>> {
    @Override
    public ResponseWrap<T> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        // Get JsonObject
        final JsonObject jsonObject = json.getAsJsonObject();
        if (jsonObject.has("error")) {

            Gson gson = new GsonBuilder()
                    .registerTypeAdapter(typeOfT, new ErrorDeserializer())
                    .setDateFormat("yyyy-MM-dd'T'HH:mm:ss")
                    .create();

            List<ErrorResponse> error = new Gson().fromJson(jsonObject.getAsJsonObject("error"), ArrayList<ErrorResponse>.class);

            return new ResponseWrap<T>(null, error);
        } else {
            T success = new Gson().fromJson(jsonObject, T.class);
            return new ResponseWrap<T>(success, null);
        }
    }
}

这个想法就是像这样使用它们：

@POST("Login")
Call<ResponseWrap<AccessTokenResponse>> Login(@Body LoginRequest request);

但由于上述原因，我不能。

问题是：如何使用Retrofit2以通用方式处理数组中的错误响应？

Answer 1

你不能写T.class - 这在Java中是非法的。为了克服这个限制，您必须以某种方式自己传递Type实例，或者从Gson提供的内容中解析泛型类型参数。在第一种情况下，您需要打十几个JSON反序列化器来绑定各种ResponseWrap<T>参数化;而在第二种情况下，您可以自己简单地解析实际的类型参数。在调用站点，您可以使用TypeToken s - 一种特殊的Gson机制，通过类型参数化定义类型参数。另请注意，您不必实例化内部Gson实例：这可能相对昂贵（特别是按顺序）并且不尊重当前反序列化器绑定的Gson配置 - 使用JsonDeserializationContext因为它可以满足您的所有需求（下游类型适配器除外）。

以下JSON反序列化程序使用第二种方法，因为我发现它更方便。

final class ResponseWrapJsonDeserializer<T>
        implements JsonDeserializer<ResponseWrap<T>> {

    // This deserializer holds no state, so we can hide its instantiation details away  
    private static final JsonDeserializer<ResponseWrap<Object>> responseWrapJsonDeserializer = new ResponseWrapJsonDeserializer<>();

    // Type instances from TypeToken seems to be fully immutable and can be treated as value types, thus we can make them static final to re-use (it's safe)
    private static final Type errorResponseListType = new TypeToken<List<ErrorResponse>>() {
    }.getType();

    private ResponseWrapJsonDeserializer() {
    }

    // Just cheating the call site: we always return the same instance if the call site requests for a specially typed deserializer (it's always the same instance however, this is just how Java generics work)
    static <T> JsonDeserializer<ResponseWrap<T>> getResponseWrapJsonDeserializer() {
        @SuppressWarnings({ "rawtypes", "unchecked" })
        final JsonDeserializer<ResponseWrap<T>> cast = (JsonDeserializer) responseWrapJsonDeserializer;
        return cast;
    }

    @Override
    public ResponseWrap<T> deserialize(final JsonElement jsonElement, final Type type, final JsonDeserializationContext context)
            throws JsonParseException {
        // Checking if jsonElement looks like an error (I'm not sure if it's possible to check HTTP statuses delegating them to request/response converters in Retrofit)
        if ( isError(jsonElement) ) {
            final List<ErrorResponse> errorResponses = context.deserialize(jsonElement, errorResponseListType);
            return new ResponseWrap<>(null, errorResponses);
        }
        // If it does not look an error, then:
        // * resolve what's the actual T in the given ResponseWrap<T>
        // * deserialize the JSON tree as an instance of T -- it's like we're stripping the wrapper and then instantiate the wrap due to our rules
        final T response = context.deserialize(jsonElement, resolveTypeParameter0(type));
        return new ResponseWrap<>(response, null);
    }

    private static Type resolveTypeParameter0(final Type type) {
        // The given type does not have parameterization?
        if ( !(type instanceof ParameterizedType) ) {
            // Then it's raw, simply <Object> or <?>
            return Object.class;
        }
        // If it's parameterized, let's take it's first parameter as ResponseWrap is known to a have a single type parameter only
        return ((ParameterizedType) type).getActualTypeArguments()[0];
    }

    // Some AI party here, he-he
    private static boolean isError(final JsonElement jsonElement) {
        if ( !jsonElement.isJsonArray() ) {
            return false;
        }
        final JsonArray jsonArray = jsonElement.getAsJsonArray();
        for ( final JsonElement innerJsonElement : jsonArray ) {
            if ( !innerJsonElement.isJsonObject() ) {
                return false;
            }
            final JsonObject innerJsonObject = innerJsonElement.getAsJsonObject();
            final boolean looksLikeErrorObject = innerJsonObject.has("errorCode");
            if ( !looksLikeErrorObject ) {
                return false;
            }
        }
        return true;
    }

}

接下来，注册Gson实例的反序列化器：

private static final Gson gson = new GsonBuilder()
        .registerTypeAdapter(ResponseWrap.class, getResponseWrapJsonDeserializer())
        .create();

用

进行测试

success.json

{
    "foo": [1, 2, 3]
}

failure.json

[
    {"errorCode": 10001},
    {"errorCode": 10002}
]

// It's a constant
// Also, ResponseWrap<Map<String,List<Integer>>>.class is illegal in Java
private static final Type type = new TypeToken<ResponseWrap<Map<String, List<Integer>>>>() {
}.getType();

public static void main(String... args)
        throws IOException {
    final String successJson = getPackageResourceString(Q43525433.class, "success.json");
    final String failureJson = getPackageResourceString(Q43525433.class, "failure.json");
    final ResponseWrap<Map<String, List<Integer>>> success = gson.fromJson(successJson, type);
    final ResponseWrap<Map<String, List<Integer>>> failure = gson.fromJson(failureJson, type);
    System.out.println("SUCCESS: " + success.response);
    for ( final ErrorResponse response : failure.errorResponses ) {
        System.out.println("FAILURE: " + response.errorCode);
    }
}

输出：

成功：{foo = [1,2,3]}
  失败：10001
  失败：10002

是的，不要忘记使用gson将GsonConverterFactory.create(gson)添加到Retrofit。

此外，您可能对Json response parser for Array or Object感兴趣，但从另一个角度描述了几乎相同的问题。

使用Retrofit2转换器转换错误响应数组

1 个答案:

success.json

failure.json