具有杰克逊序列化/反序列化的多级多态树答案

【问题标题】：multi level polymophic trees with jackson serialization/deserialization具有杰克逊序列化/反序列化的多级多态树
【发布时间】：2014-05-21 22:59:04
【问题描述】：

是否有可能用杰克逊序列化和反序列化复杂的继承结构？它的注释是什么？例如，如果我有以下课程

@Inheritance
@JsonTypeInfo(
    use = JsonTypeInfo.Id.NAME,
    include = JsonTypeInfo.As.PROPERTY,
    property = "type")
@JsonSubTypes({
     @Type(value = Dog.class,name = "dog")
     @Type(value = Cat.class,name = "cat")
})

public class Animal implements Serializable{

@id
long id;

String name;

}

这当然是父类。如果 cat 和 dog 没有任何继承类，我知道这是正确的。如果我想要狗的子类，我需要在动物类和狗类中进行哪些更改？

这里是第二类，仅供参考

@JsonTypeName("dog")
public class Dog extends Animal implements Serializable{
    //all my props etc here
{

我将如何创建一个继承自动物和狗的 retrier 类和一个 yorki 类，我可以将它们投射到其中一个并且让 jackson 不会对我发脾气。

【问题讨论】：

标签： java json inheritance serialization jackson

【解决方案1】：

多级多态树应该不是杰克逊的问题。这是一个序列化/反序列化类层次结构的示例，类似于您在the Jackson wiki page. 中的问题中的内容@

public class JacksonPolymorphism3 {

    @JsonTypeInfo(
            use = JsonTypeInfo.Id.NAME,
            include = JsonTypeInfo.As.PROPERTY,
            property = "type")
    public abstract static class Animal {
        public final String animalField;

        @JsonCreator
        public Animal(@JsonProperty("animalField") String animalField) {
            this.animalField = animalField;
        }
    }

    @JsonTypeName("dog")
    public static class Dog extends Animal {
        public final String dogField;

        public Dog(@JsonProperty("animalField") String animalField,
                   @JsonProperty("dogField") String dogField) {
            super(animalField);
            this.dogField = dogField;
        }

        @Override
        public String toString() {
            return "Dog{" +
                    "dogField='" + dogField + '\'' +
                    '}';
        }
    }

    @JsonTypeName("husky")
    public static class Husky extends Dog {
       public final String huskyField;

        public Husky(@JsonProperty("animalField") String animalField,
                     @JsonProperty("dogField") String dogField,
                     @JsonProperty("huskyField") String huskyField) {
            super(animalField, dogField);
            this.huskyField = huskyField;
        }

        @Override
        public String toString() {
            return "Husky{" +
                    "huskyField='" + huskyField + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) throws IOException {
        List<Dog> dogs;
        dogs = Arrays.asList(new Dog("aField", "dogField"), new Husky("hField", "dField2", "hField"));

        ObjectMapper mapper = new ObjectMapper();
        mapper.registerSubtypes(Dog.class, Husky.class);
        TypeReference<List<Dog>> referenceType = new TypeReference<List<Dog>>() {
        };
        String json = mapper.writerWithDefaultPrettyPrinter().withType(referenceType).writeValueAsString(dogs);
        System.out.println(json);
        System.out.println(mapper.readValue(json, referenceType));
    }
}

输出：

[ {
  "type" : "dog",
  "animalField" : "aField",
  "dogField" : "dogField"
}, {
  "type" : "husky",
  "animalField" : "hField",
  "dogField" : "dField2",
  "huskyField" : "hField"
} ]
[Dog{dogField='dogField'}, Husky{huskyField='hField'}]

如果没有帮助，请提供更多代码。

【讨论】：