具有“默认”对象类型的嵌套对象的动态反序列化

Question

class GeneralObject {
    public String objType;
    public String commonProp;
    public GeneralObject nestedObject;

    // map for additional properties, so that I can re-serialize the full object later
    public Map<String, JsonNode> additionalFields = new HashMap<>();
    @JsonAnyGetter
    public Map<String, JsonNode> getAdditionalFields() {
        return additionalFields;
    }
    @JsonAnySetter
    public void addAdditionalField(String fieldName, JsonNode value) {
        this.additionalFields.put(fieldName, value);
    }
}

class SpecialObject extends GeneralObject {
    public String specialProp;
}

{
  "objType": "someType1",
  "commonProp": "example1..."
}

{
  "objType": "SPECIAL",
  "commonProp": "example2...",
  "specialProp": "more example"
}

{
  "objType": "someOtherType",
  "commonProp": "example3...",
  "nestedObject": {
    "objType": "SPECIAL",
    "commonProp": "example2...",
    "specialProp": "more example"
  }
}

ObjectMapper mapper = new ObjectMapper();
String objString = "{\"objType\": \"SPECIAL\", \"commonProp\": \"...\", \"specialProp\": \"more example\"}";
GeneralObject genObj = mapper.readValue(objString, GeneralObject.class);
if (genObj.objType.equals("SPECIAL")) {
    genObj = mapper.readValue(objString, SpecialObject.class);
}
// Some business-logic: If SPECIAL, then this cast is required to work:
System.out.println(((SpecialObject) genObj).specialProp);

这适用于顶级对象，但不适用于嵌套对象。例如，如果嵌套对象是特殊对象，则仍将其反序列化为公共对象。

我想做的是告诉Jackson：“无论嵌套级别如何，如果ObjType=Special，使用SpecialObject，否则使用GeneralObject”。我研究了多态反序列化，并尝试使用@JSONSubtypes，但无法正确设置该逻辑。如何确保特殊对象被反序列化到适当的类中，即使它们是嵌套的？

Answer 1

我首先尝试从这个要点中获得灵感，我想用自定义的TypeIDResolver来解决这个问题，但是这个问题不能正确地反序列化ObjType（请参阅本答案的第一版）。

然后切换到自定义的反序列化器:

class CustomDeserializer extends StdDeserializer<GeneralObject> {

    private static final String SPECIAL = "\"SPECIAL\"";

    protected CustomDeserializer() {
        super(GeneralObject.class);
    }

    @Override
    public GeneralObject deserialize(JsonParser p, DeserializationContext ctx) throws IOException {
        TreeNode node = p.readValueAsTree();

        // Select appropriate class based on "resourceType"
        TreeNode objTypeNode = node.get("objType");
        if (null == objTypeNode) {
            throw new JsonParseException(p, "field \"objType\" is missing!");
        }
        if (!objTypeNode.isValueNode()) {
            throw new JsonParseException(p, "field \"objType\" must be a String.");
        }
        String objType = objTypeNode.toString();
        Class<? extends GeneralObject> clazz;
        if (objType.equals(SPECIAL)) {
            clazz = SpecialObject.class;
        } else {
            clazz = RecursionStopper.class;
        }
        return p.getCodec().treeToValue(node, clazz);
    }
}

它检查.objtype的内容，并发出应该用于反序列化的适当（子）类。需要在GeneralObject上注册反序列化器，例如使用以下注释：

@JsonDeserialize(using = CustomDeserializer.class)
class GeneralObject {
    ...
}

@JsonDeserialize(using = JsonDeserializer.None.class)
class SpecialObject extends GeneralObject {
    public String specialProp;
}

@JsonDeserialize(using = JsonDeserializer.None.class)
class RecursionStopper extends GeneralObject {
    // this class intentionally empty
}

ObjectMapper mapper = new ObjectMapper();
String objString = "{\n" +
        "  \"objType\": \"someObjType\",\n" +
        "  \"commonProp\": \"example3...\",\n" +
        "  \"nestedObject\": {\n" +
        "    \"objType\": \"SPECIAL\",\n" +
        "    \"commonProp\": \"example2...\",\n" +
        "    \"specialProp\": \"more example\"\n" +
        "  }\n" +
        "}";
GeneralObject genObj = mapper.readValue(objString, GeneralObject.class);
System.out.println(((SpecialObject) genObj.nestedObject).specialProp);