用GSON序列化/反序列化包含特殊枚举（非字符串枚举）的POJO

Question

我需要序列化/反序列化一个POJO包含一个特殊枚举（不是字符串的枚举）。我找到了很多字符串枚举的示例，但不是我的情况。

public class ApplicationError {

    private static final long serialVersionUID = 1L;

    private final ErrorCode code;

    private final String description;

    private final URL infoURL;

    ....
}

public enum ErrorCode {
    INVALID_URL_PARAMETER(HttpStatus.BAD_REQUEST, 20, "Invalid URL parameter value"),
    MISSING_BODY(HttpStatus.BAD_REQUEST, 21, "Missing body"),
    INVALID_BODY(HttpStatus.BAD_REQUEST, 22, "Invalid body")
}

public class ErrorCodeDeserializer implements JsonDeserializer<ErrorCode> /*, JsonSerializer<ErrorCode> */{

    @Override
    public ErrorCode deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
            throws JsonParseException {
        ErrorCode[] scopes = ErrorCode.values();
        for (ErrorCode scope : scopes) {
            System.out.println("--------->" + scope + "   " + json.getAsString());
            if (scope.equals(json.getAsString())) {
                return scope;
            }
        }
        return null;
    }

    /*
    @Override
    public JsonElement serialize(ErrorCode arg0, Type arg1, JsonSerializationContext arg2) {
        ???
    }*/
}

...
ApplicationError applicationError = new ApplicationError(ErrorCode.INVALID_URL_PARAMETER,
                    "Application identifier is missing");
....
GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.registerTypeAdapter(ErrorCode.class, new ErrorCodeDeserializer());
Gson gson = gsonBuilder.create();
gson.toJson(applicationError)

而不是：

{“代码”：“20”，“消息”：“无效的URL参数值”，“说明”：“缺少应用程序标识符”}

编辑1

@Override
public JsonElement serialize(ErrorCode src, Type typeOfSrc, JsonSerializationContext context) {
    JsonArray jsonMerchant = new JsonArray();
    jsonMerchant.add("" + src.getCode());
    jsonMerchant.add("" + src.getMessage());
    return jsonMerchant;
}

{"code":["20","Invalid URL parameter value"],"description":"Application identifier is missing"}

@Override
public JsonElement serialize(ErrorCode src, Type typeOfSrc, JsonSerializationContext context) {
    JsonObject result = new JsonObject();
    result.add("code", new JsonPrimitive(src.getCode()));
    result.add("message", new JsonPrimitive(src.getMessage()));
    return result;
}

但我的结果是：

{"code":{"code":20,"message":"Invalid URL parameter value"},"description":"Application identifier is missing"}

现在，我希望将“code”：{“code”：20,“message”：“invalid URL parameter value”}改为“code”：20,“message”：“invalid URL parameter value”

Answer 1

总的来说，这是一个坏主意，原因有几个：

• 如果在流模式下读取平面属性（确保属性的顺序保持不变），您的反序列化器（如果需要的话）需要非常复杂。
• 否则，您需要使用errorcode枚举为每个类编写一个特殊的类型适配器，并且需要为每个类编写一个自定义的JSONSerializer/JSONDeserializer。
• 反序列化errorcode对我来说毫无意义。
• GSON不允许对象相互“拉平”。

在其最简单的实现中，我想说您可能希望使用以下内容：

final class FlatErrorCodeTypeAdapter
        extends TypeAdapter<ErrorCode> {

    private FlatErrorCodeTypeAdapter() {
    }

    @Override
    public void write(final JsonWriter out, final ErrorCode errorCode)
            throws IOException {
        // very bad idea - the serializer may be in a bad state and we assume the host object is being written
        out.value(errorCode.code);
        out.name("message");
        out.value(errorCode.message);
    }

    @Override
    public ErrorCode read(final JsonReader in)
            throws IOException {
        // now fighting with the bad idea being very fragile assuming that:
        // * the code field appears the very first property value
        // * we ignore the trailing properties and pray the host object does not have "message" itself
        // * no matter what "message" is -- it simply does not have sense
        final int code = in.nextInt();
        return ErrorCode.valueByCode(code);
    }

}

然后在您的代码中如下所示：

final class ApplicationError {

    @JsonAdapter(FlatErrorCodeTypeAdapter.class)
    final ErrorCode code;
    final String description;

    ApplicationError(final ErrorCode code, final String description) {
        this.code = code;
        this.description = description;
    }

}

使用示例：

private static final Gson gson = new Gson();

...

final ApplicationError before = new ApplicationError(ErrorCode.INVALID_URL_PARAMETER, "Application identifier is missing");
final String json = gson.toJson(before);
System.out.println(json);
final ApplicationError after = gson.fromJson(json, ApplicationError.class);
System.out.println(before.code == after.code);
System.out.println(before.description.equals(after.description));

{"code":20,"message":"Invalid URL parameter value","description":"Application identifier is missing"}
true
true

我仍然认为这是一个非常脆弱的解决方案，我只建议您重新设计applicationerror并自己“扁平化”errorcode:

final class ApplicationError {

    final int code;
    final String message;
    final String description;

    ApplicationError(final ErrorCode errorCode, final String description) {
        this.code = errorCode.code;
        this.message = errorCode.message;
        this.description = description;
    }

    ...

    final ErrorCode resolveErrorCode() {
        final ErrorCode errorCode = ErrorCode.valueByCode(code);
        if ( !errorCode.message.equals(message) ) {
            throw new AssertionError('wow...');
        }
        return errorCode;
    }

}

对于后者，您甚至不需要以任何方式配置GSON。