Question

这是我的previous question的轻微延伸。所以基于dambros的答案，json现在看起来像：

"Foo": {
    "title": {
        "type": "title",
        "value": "...",
        "variable": "..."
    },
    "message": {
        "type": "message",
        "value": "...",
        "variable": "..."
    }
}

但我真正想要的是：

"Foo": [
{
    {
        "type": "title",
        "value": "...",
        "variable": "..."
    },
    {
        "type": "message",
        "value": "...",
        "variable": "..."
    }
}
]

有没有办法将Foo字段写为数组，也不会将变量名称显示为字段（即删除"title" :）。

Answer 1

这不是有效的JSON，但这是：

{
    "Foo": [
        {
            "type": "title",
            "value": "...",
            "variable": "..."
        },
        {
            "type": "message",
            "value": "...",
            "variable": "..."
        }
    ]
}

这是一个JSON对象，其中包含一个名为Foo的字段，它是一个对象数组。

您应该阅读JSON spec。

或者，如果你有List<Foo>，你可以直接序列化列表，给你一个JSON数组作为根，而不是作为根的JSON对象：

[
    {
        "type": "title",
        "value": "...",
        "variable": "..."
    },
    {
        "type": "message",
        "value": "...",
        "variable": "..."
    }
]

Answer 2

您尝试完成的工作似乎是以可以发送对象类型和字段的方式表示您的java对象。在这种假设下，我试图摆脱手动序列化。只需使用您需要的格式创建一个DTO，您就可以使用您拥有的域对象进行填充。这将是一个例子：

public class FooSerialization {

    public static class Foo {
        private String title;
        private String message;
    }

    public static class Foo2 {
        private String value;
        private String variable;
    }

    public static class ClassDTO {

        private String type;
        private List<FieldDTO> fields;

    }

    public static class FieldDTO {
        private String type;
        private String value;
        private String fieldName;
    }

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

        Foo2 foo2 = new Foo2();
        foo2.setValue("valueMessage");
        foo2.setVariable("variableMessage");
        Foo foo = new Foo();
        foo.setMessage("messageMessage");
        foo.setTitle("titleMessage");

        ObjectMapper mapper = new ObjectMapper();

        List<ClassDTO> dtos = new ArrayList<ClassDTO>();
        dtos.add(convert(foo));
        dtos.add(convert(foo));
        System.out.println(mapper.writeValueAsString(dtos));
    }

    private static ClassDTO convert(Object obj) {
        ClassDTO dto = new ClassDTO();
        dto.setType(obj.getClass().getSimpleName());
        List<FieldDTO> fieldDTOs = new ArrayList<FieldDTO>();
        dto.setFields(fieldDTOs);

        for (Field field : obj.getClass().getDeclaredFields()) {
            field.setAccessible(true);
            FieldDTO fieldDto = new FieldDTO();
            try {
                fieldDto.setFieldName(field.getName());
                fieldDto.setValue(field.get(obj).toString());
                fieldDto.setType(field.getType().getSimpleName());
                fieldDTOs.add(fieldDto);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return dto;
    }

}

为简单起见，省略了Getters和Setter。这基本上从Foo或Foo2转换为某些ClassDTO，其中包含具有字段详细信息的类型和FieldDTO列表。输出如下：

[
    {
        "type": "Foo",
        "fields": [
            {
                "fieldName": "title",
                "type": "String",
                "value": "titleMessage"
            },
            {
                "fieldName": "message",
                "type": "String",
                "value": "messageMessage"
            }
        ]
    },
    {
        "type": "Foo2",
        "fields": [
            {
                "fieldName": "value",
                "type": "String",
                "value": "valueMessage"
            },
            {
                "fieldName": "variable",
                "type": "String",
                "value": "variableMessage"
            }
        ]
    }
]

Answer 3

在我看来，如果你可以使用这样的东西，你可以解决很多问题：

@JsonFormat(shape=JsonFormat.Shape.ARRAY)
public static class Foo {
    @JsonProperty public Foo1 title;
    @JsonProperty public Foo2 message;
}

@JsonTypeInfo(use= JsonTypeInfo.Id.NAME, include=JsonTypeInfo.As.PROPERTY, property="type")
@JsonSubTypes({@JsonSubTypes.Type(value = Foo1.class, name = "title"),
               @JsonSubTypes.Type(value = Foo2.class, name = "message")})
public static class FooParent{
    @JsonProperty private String value;
    @JsonProperty private String variable;
}

public static class Foo1 extends FooParent{}
public static class Foo2 extends FooParent{}

public static void main(String[] args) throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    Foo foo = new Foo();
    foo.title = new Foo1();
    foo.message = new Foo2();

    String serialized = mapper.writeValueAsString(foo);
    System.out.println(serialized);
}

结果是：

[
    {"type":"title","value":null,"variable":null},      
    {"type":"message","value":null,"variable":null}
]

Answer 4

阅读以下博客json in java

这篇文章有点旧但我还是想回答你问题

第1步：创建数据的pojo类。

步骤2：现在使用json创建一个对象。

Foo foo = null;
ObjectMapper mapper = new ObjectMapper();
try{
foo =  mapper.readValue(newFile("/home/sumit/foo.json"),Foo.class);
} catch (JsonGenerationException e){
e.printStackTrace();
}

如需进一步参考，请参阅以下link

由于

杰克逊序列化没有字段名称

4 个答案: