杰克逊多态性:嵌套亚型

Question

是否可以以嵌套方式使用多个@JsonSubType注释？

例如，假设以下类：

@Data
@JsonSubTypeInfo(include=As.EXISTING_PROPERTY, property="species", use=Id.NAME, visible=true)
@JsonSubTypes({
@Type(name="Dog", value=Dog.class)
@Type(name="Cat", value=Cat.class)
})
public abstract class Animal {
private String name;
private String species;
}

@Data
@JsonSubTypeInfo(include=As.EXISTING_PROPERTY, property="breed", use=Id.NAME, visible=true)
@JsonSubTypes({
@Type(name="Labrador", value=Labrador.class)
@Type(name="Bulldog", value=Bulldog.class)
})
public abstract class Dog extends Animal {
private String breed;
}

@Data
public class Cat extends Animal {
private boolean lovesCatnip;
}

@Data
public class Labrador extends Dog {
private String color;
}

@Data
public class Bulldog extends Dog {
private String type; // "frenchy", "english", etc..
}

如果我使用对象映射器，我可以成功地将Bulldog映射到 JSON，但是，当尝试读取生成的 JSON 并将其读回时，我收到如下错误：

Can not construct instance of com.example.Dog abstract types either need to be mapped to concrete types, have custom deserializer, or contain additional type information

有没有可能让杰克逊使用这样的分字？我是否需要为每个子类创建自定义反序列化程序？

编辑：

我从原始帖子中稍微修改了上面的类。我添加了一个Cat类，并拥有它，并且Dog从Animal扩展。

下面是可以使用ObjectMapper::writeValueAsString创建的示例 JSON：

{
"name": null,
"species": "Dog",
"breed": "Bulldog",
"type": "B-Dog"
}

Answer 1

如果我使用@JsonTypeInfo和与您的设置类似的设置，则以下内容有效。也许你的问题出在反序列化代码中，所以看看这个：

public class MyTest {
@Test
public void test() throws IOException {
final Bulldog bulldog = new Bulldog();
bulldog.setBreed("Bulldog");
bulldog.setType("B-Dog");
final ObjectMapper om = new ObjectMapper();
final String json = om.writeValueAsString(bulldog);
final Dog deserialized = om.readValue(json, Dog.class);
assertTrue(deserialized instanceof Bulldog);
}
@JsonTypeInfo(include = As.EXISTING_PROPERTY, property = "species", use = Id.NAME, visible = true)
@JsonSubTypes({
@Type(name = "Dog", value = Dog.class),
@Type(name = "Cat", value = Cat.class)
})
public static abstract class Animal {
private String name;
private String species;
}
@JsonTypeInfo(include = As.EXISTING_PROPERTY, property = "breed", use = Id.NAME, visible = true)
@JsonSubTypes({
@Type(name = "Labrador", value = Labrador.class),
@Type(name = "Bulldog", value = Bulldog.class)
})
public static abstract class Dog {
private String breed;
public String getBreed() {
return breed;
}
public void setBreed(final String breed) {
this.breed = breed;
}
}
public static abstract class Cat {
private String name;
}
public static class Labrador extends Dog {
private String color;
public String getColor() {
return color;
}
public void setColor(final String color) {
this.color = color;
}
}
public static class Bulldog extends Dog {
private String type; // "frenchy", "english", etc..
public String getType() {
return type;
}
public void setType(final String type) {
this.type = type;
}
}
}

针对更新的问题进行了编辑：如果可以对继承层次结构使用相同的属性(在下面的代码中为隐藏属性"@class"(，则它可以工作：

@Test
public void test() throws IOException {
final Bulldog bulldog = new Bulldog();
// bulldog.setSpecies("Dog");
// bulldog.setBreed("Bulldog");
bulldog.setType("B-Dog");
final ObjectMapper om = new ObjectMapper();
final String json = om.writeValueAsString(bulldog);
final Animal deserialized = om.readValue(json, Animal.class);
assertTrue(deserialized instanceof Bulldog);
}
@JsonTypeInfo(include = As.PROPERTY, use = Id.CLASS, visible = false)
@JsonSubTypes({
@Type(Dog.class),
@Type(Cat.class)
})
public static abstract class Animal {
}
@JsonTypeInfo(include = As.PROPERTY, use = Id.CLASS, visible = false)
@JsonSubTypes({
@Type(name = "Labrador", value = Labrador.class),
@Type(name = "Bulldog", value = Bulldog.class)
})
public static abstract class Dog
extends Animal {
}

如果要设置动物类型(例如计算物种，品种等(，也可以使用此设置：

@Test
public void test() throws IOException {
final Bulldog bulldog = new Bulldog();
bulldog.setAnimalType("Bulldog");
// bulldog.setSpecies("Dog");
// bulldog.setBreed("Bulldog");
bulldog.setType("B-Dog");
final ObjectMapper om = new ObjectMapper();
final String json = om.writeValueAsString(bulldog);
System.out.println(json);
final Animal deserialized = om.readValue(json, Animal.class);
assertTrue(deserialized instanceof Bulldog);
}
@JsonTypeInfo(include = As.EXISTING_PROPERTY, property = "animalType", use = Id.NAME, visible = true)
@JsonSubTypes({
@Type(Dog.class)
})
public static abstract class Animal {
private String animalType;
public String getAnimalType() {
return animalType;
}
public void setAnimalType(final String animalType) {
this.animalType = animalType;
}
}
@JsonTypeInfo(include = As.EXISTING_PROPERTY, property = "animalType", use = Id.NAME, visible = true)
@JsonSubTypes({
@Type(value = Bulldog.class)
})
public static abstract class Dog
extends Animal {
}
@JsonTypeName("Bulldog")
public static class Bulldog extends Dog {
private String type; // "frenchy", "english", etc..
public String getType() {
return type;
}
public void setType(final String type) {
this.type = type;
}
}

Answer 2

我能够解决这个问题，使以下 JSON 转换为Bulldog对象：

{
"species": "Dog",
"breed": "Bulldog",
"name": "Sparky",
"type": "English"
}

我使用以下代码来执行此操作：

ObjectMapper om = new ObjectMapper();
om.addHandler(new DeserializationProblemHandler() {
@Override
public Object handleMissingInstantiator(DeserializationContext ctxt, Class<?> instClass, JsonParser p, String msg) throws IOException {
JsonNode o = p.readValueAsTree();
JsonNode copy = o.deepCopy();
JsonNode species = o.get("species");
if (species != null) {
Class<? extends Animal> clazz;
switch (species.asText()) {
case "Dog":
clazz = Dog.class;
break;
case "Cat":
clazz = Cat.class;
break;
default:
return NOT_HANDLED;
}
JsonParser parser = new TreeTraversingParser(copy, p.getCodec());
parser.nextToken(); // without this an error is thrown about missing "breed" type
return ctxt.readValue(parser, clazz);
}
return NOT_HANDLED;
}
});

我相信可能有更好的方法来查找类型化类(我注意到handleMissingInstantiator方法的一个输入中有一个包含所有相关类型的cache，它可能可用于查找基于名称的类型，而不是像我所做的那样硬编码值。