JSON根据类型反序列化

如何解决JSON根据类型反序列化

仅注释方法

除了自定义解串器方法之外，您还可以为仅注释的解决方案提供以下内容（类似于Spunc的答案中描述的方法，但type用作外部属性）：

public abstract class AbstractData {

    private Owner owner;

    private Metadata Metadata;

    // Getters and setters
}



public static final class FooData extends AbstractData {

    private Foo object;

    // Getters and setters
}



public static final class BarData extends AbstractData {

    private Bar object;

    // Getters and setters
}



public class Wrapper {

    private String type;

    @JsonTypeInfo(use = Id.NAME, property = "type", include = As.EXTERNAL_PROPERTY)
    @JsonSubTypes(value = { 
            @JsonSubTypes.Type(value = FooData.class, name = "Foo"),
            @JsonSubTypes.Type(value = BarData.class, name = "Bar") 
    })
    private AbstractData data;

    // Getters and setters
}

在这种方法中，@JsonTypeInfo设置为type用作外部属性来确定映射该data属性的正确类。

JSON文档可以反序列化如下：

ObjectMapper mapper = new ObjectMapper();
Wrapper wrapper = mapper.readValue(json, Wrapper.class);

所有这些都可以通过注释来完成。

使用“ Metadata”和“ owner”等通用字段及其获取器/设置器创建一个抽象超类。此类需要使用@JsonTypeInfo进行注释。它应该看起来像：

@JsonTypeInfo(use = Id.CLASS, include = As.PROPERTY, property = "type")

使用该参数，property = “type”您可以指定将类别标识符序列化为JSON文档中的字段类型。

可以使用来指定类标识符的值use。Id.CLASS使用标准的java类名称。您也可以使用Id.MINIMAL_CLASS缩写java类名。要使用自己的标识符，请使用Id.NAME。在这种情况下，您需要声明子类型：

@JsonTypeInfo(use = Id.NAME, include = As.PROPERTY, property = "type")
@JsonSubTypes({
    @JsonSubTypes.Type(value = Foo.class, name = "Foo"),
    @JsonSubTypes.Type(value = Bar.class, name = "Bar")
})

通过扩展抽象超类来实现Foo和Bar类。

Jackson的ObjectMapper将使用JSON文档的其他字段“类型”进行序列化和反序列化。例如 当您将JSON字符串反序列化为超类引用时，它将属于适当的子类：

ObjectMapper om = new ObjectMapper();
AbstractBase x = om.readValue(json, AbstractBase.class);
// x will be instanceof Foo or Bar

完整的代码示例（我使用公共字段作为无需编写getter / setter的快捷方式）：

package test;

import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonTypeInfo.Id;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.annotation.JsonTypeInfo.As;

import java.io.IOException;

import com.fasterxml.jackson.annotation.JsonSubTypes;

@JsonTypeInfo(use = Id.NAME, include = As.PROPERTY, property = "type")
@JsonSubTypes({
    @JsonSubTypes.Type(value = Foo.class, name = "Foo"),
    @JsonSubTypes.Type(value = Bar.class, name = "Bar")
})
public abstract class AbstractBase {

    public MetaData MetaData;
    public Owner owner;
    @Override
    public String toString() {
        return "MetaData=" + MetaData + "; owner=" + owner;
    }

    public static void main(String[] args) throws IOException {

        // Common fields
        Owner owner = new Owner();
        owner.name = "Richard";
        MetaData MetaData = new MetaData();
        MetaData.data = "Some data";

        // Foo
        Foo foo = new Foo();
        foo.owner = owner;
        foo.MetaData = MetaData;
        CustomObject customObject = new CustomObject();
        customObject.id = 20l;
        customObject.fizz = "Example";
        Data data = new Data();
        data.object = customObject;
        foo.data = data;
        System.out.println("Foo: " + foo);

        // Bar
        Bar bar = new Bar();
        bar.owner = owner;
        bar.MetaData = MetaData;
        bar.data = "A String in Bar";

        ObjectMapper om = new ObjectMapper();

        // Test Foo:
        String foojson = om.writeValueAsstring(foo);
        System.out.println(foojson);
        AbstractBase fooDeserialised = om.readValue(foojson, AbstractBase.class);
        System.out.println(fooDeserialised);

        // Test Bar:
        String barjson = om.writeValueAsstring(bar);
        System.out.println(barjson);
        AbstractBase barDeserialised = om.readValue(barjson, AbstractBase.class);
        System.out.println(barDeserialised);

    }

}

class Foo extends AbstractBase {
    public Data data;
    @Override
    public String toString() {
        return "Foo[" + super.toString() + "; data=" + data + ']';
    }
}

class Bar extends AbstractBase {
    public String data;
    public String toString() {
        return "Bar[" + super.toString() + "; data=" + data + ']';
    }
}


class Data {
    public CustomObject object;
    @Override
    public String toString() {
        return "Data[object=" + object + ']';
    }
}

class CustomObject {
    public long id;
    public String fizz;
    @Override
    public String toString() {
        return "CustomObject[id=" + id + "; fizz=" + fizz + ']';
    }
}

class MetaData {
    public String data;
    @Override
    public String toString() {
        return "MetaData[data=" + data + ']';
    }
}

class Owner {
    public String name;
    @Override
    public String toString() {
        return "Owner[name=" + name + ']';
    }
}

解决方法

可以说我有以下格式的JSON：

{
    "type" : "Foo"
    "data" : {
        "object" : {
            "id" : "1"
            "fizz" : "bizz"
            ...
        },"metadata" : {
            ...
        },"owner" : {
            "name" : "John"
            ...
        }
    }
}

我试图避免自定义反序列化器，并尝试将上述JSON（称为Wrapper.java）反序列化为Java POJO。“类型”字段指示“对象”反序列化，即。type
= foo表示使用Foo.java反序列化“ object”字段。（如果type =
Bar，则使用Bar.java反序列化对象字段）。元数据/所有者将始终使用相同的反序列化方式，每个方法都使用一个简单的带有Jackson注释的Java类。有没有一种方法可以使用注释来完成此任务？如果没有，如何使用自定义解串器完成？