Java 无字段名的Jackson序列化

这是我工作的一个小小延伸。因此，根据dambros的回答，json现在看起来像：

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

但我真正想要的是：

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

---

是否有任何方法可以将

Foo

字段写入数组，并且不将变量名显示为字段（即删除

“title:

）。

这不是有效的JSON，但是：

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

这是一个JSON对象，有一个名为

Foo

的字段，它是一个对象数组

你应该看报纸

---

或者，如果您有一个

列表

，您可以直接序列化该列表，将JSON数组作为根，而不是JSON对象作为根：

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

---

这不是有效的JSON，但是：

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

这是一个JSON对象，有一个名为

Foo

的字段，它是一个对象数组

你应该看报纸

---

或者，如果您有一个

列表

，您可以直接序列化该列表，将JSON数组作为根，而不是JSON对象作为根：

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

---

似乎您试图实现的是以一种可以发送对象类型和字段的方式来表示java对象。在这种假设下，我会尝试摆脱手动序列化。只需创建一个具有所需格式的DTO，即可使用现有的域对象填充该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;
    }

}

---

似乎您试图实现的是以一种可以发送对象类型和字段的方式来表示java对象。在这种假设下，我会尝试摆脱手动序列化。只需创建一个具有所需格式的DTO，即可使用现有的域对象填充该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;
    }

}

---

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

[
    {
        "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"
            }
        ]
    }
]

@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": "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"
            }
        ]
    }
]

@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);
}

结果是：

阅读下面的博客

这篇文章有点老了，但我还是想回答你们的问题

步骤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();
}

如需进一步参考，请参考以下内容

感谢阅读下面的博客

这篇文章有点老了，但我还是想回答你们的问题

步骤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();
}

如需进一步参考，请参考以下内容

---

谢谢

所以如果不打印变量名，就无法序列化

Foo

中的字段？如果不打印变量名，就无法序列化

Foo

中的字段？