本文内容
- 高级 Jackson Marshalling
- 只序列化符合自定义标准的字段
- 把 Enums 序列化成 JSON 对象
- JsonMappingException（没有找到类的序列化器）
- Jackson – 自定义序列化器
- 高级 Jackson Unmarshalling
- Unmarshall 成 Collection/Array
- Jackson – 自定义反序列化器
- 演示
- 参考资料
本文使用 Jackson 2，包括 jackson-annotations-2.4.0.jar、jackson-core-2.4.1.jar 和 jackson-databind-2.4.1.jar 这三个库。
貌似太理论的东西，看得人也比较少，都喜欢看实际功能的东西，不过啊，只关注功能、理论太弱的人，基本没前途~
下载 Demo
下载 Jackson 2
高级 Jackson Marshalling
介绍高级的序列化配置和优化处理条件、各种数据类型以及自定义 Jackson 异常。
只序列化符合自定义标准的字段
如何使用 Jackson 只序列化一个符合指定的、自定义标准的字段。
例如，我只想序列化一个正整数，否则，就忽略整个整数。
- 使用 Jackson Filter 控制序列化过程
首先，我们在实体上用 @JsonFilter 注解定义过滤器：
@JsonFilter("myFilter")
public class MyDto {
private int intValue;
public MyDto() {
super();
}
public int getIntValue() {
return intValue;
}
public void setIntValue(int intValue) {
this.intValue = intValue;
}
}
然后，定义我们自己的 PropertyFilter：
PropertyFilter theFilter = new SimpleBeanPropertyFilter() {
@Override
public void serializeAsField
(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer)
throws Exception {
if (include(writer)) {
if (!writer.getName().equals("intValue")) {
writer.serializeAsField(pojo, jgen, provider);
return;
}
int intValue = ((MyDtoWithFilter) pojo).getIntValue();
if (intValue >= 0) {
writer.serializeAsField(pojo, jgen, provider);
}
} else if (!jgen.canOmitFields()) { // since 2.3
writer.serializeAsOmittedField(pojo, jgen, provider);
}
}
@Override
protected boolean include(BeanPropertyWriter writer) {
return true;
}
@Override
protected boolean include(PropertyWriter writer) {
return true;
}
};
这个 filter 包含一个 intValue 字段是否被序列化的逻辑，这取决于 intValue 的值。
现在，在 ObjectMapper 里调用 filter，序列化这个实体：
FilterProvider filters = new SimpleFilterProvider().addFilter("myFilter", theFilter);
MyDto dtoObject = new MyDto();
dtoObject.setIntValue(-1);
ObjectMapper mapper = new ObjectMapper();
String dtoAsString = mapper.writer(filters).writeValueAsString(dtoObject);
最后，测试 intValue 字段是否在 JSON 输出中：
assertThat(dtoAsString, not(containsString("intValue")));
filter 功能很强大，当用 Jackson 序列化复杂对象时，可以非常灵活地自定义 JSON。
把 Enums 序列化成 JSON 对象
如何用 Jackson 2 把 Java Enum 序列化。
- 控制枚举表示
定义下面枚举：
public enum Type {
TYPE1(1, "Type A"), TYPE2(2, "Type 2");
private Integer id;
private String name;
private Type(final Integer id, final String name) {
this.id = id;
this.name = name;
}
// standard getters and setters
}
- 默认的枚举表示
默认情况，Jackson 会把 Java 枚举表示成一个字符串，例如：
new ObjectMapper().writeValueAsString(Type.TYPE1);
结果：
"TYPE1"
当把这个枚举序列化成 JSON 对象时，我们想得到如下所示：
{"name":"Type A","id":1}
- 枚举作为 Json 对象
用 Jackson 2.1.2 – 下面的配置可以得到上面的表示 – 这是通过在枚举级别上使用 @JsonFormat 注解：
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum Type { ... }
当序列化上面枚举，就会得到正确的结果：
{"name":"Type A","id":1}
- 枚举和 @JsonValue
另外一种控制方式是使用 @JsonValue 注解：
public enum TypeEnumWithValue {
TYPE1(1, "Type A"), TYPE2(2, "Type 2");
private Integer id;
private String name;
private TypeEnumWithValue(final Integer id, final String name) {
this.id = id;
this.name = name;
}
...
@JsonValue
public String getName() {
return name;
}
}
我们在这里说的是，getName 是此枚举的实际表示；所以：
String enumAsString = mapper.writeValueAsString(TypeEnumWithValue.TYPE1);
assertThat(enumAsString, is(""Type A""));
- 自定义枚举序列化器
在 Jackson 2.1.2 以前，或是对枚举需要更多的自定义 – 我们可以使用一个自定义的 Jackson 序列化器 – 首先，我们需要定义它：
public class TypeSerializer extends JsonSerializer<TypeEnum> {
public void serialize
(TypeEnumWithCustomSerializer value, JsonGenerator generator, SerializerProvider provider)
throws IOException, JsonProcessingException {
generator.writeStartObject();
generator.writeFieldName("id");
generator.writeNumber(value.getId());
generator.writeFieldName("name");
generator.writeString(value.getName());
generator.writeEndObject();
}
}
我们现在将绑定序列化器，在类上应用它：
@JsonSerialize(using = TypeSerializer.class)
public enum TypeEnum { ... }
JsonMappingException（没有找到类的序列化器）
分析序列化没有 getter 的实体，以及 Jackson JsonMappingException 异常的解决方案。
- 问题
默认情况，Jackson 2 运行在 public 或具有 public getter 方法的字段上 – 序列化 private 或 private 包内所有字段的一个实体将会失败：
ublic class MyDtoNoAccessors {
String stringValue;
int intValue;
boolean booleanValue;
public MyDtoNoAccessors() {
super();
}
// no getters
}
@Test(expected = JsonMappingException.class)
public void givenObjectHasNoAccessors_whenSerializing_thenException()
throws JsonParseException, IOException {
String dtoAsString = new ObjectMapper().writeValueAsString(new MyDtoNoAccessors());
assertThat(dtoAsString, notNullValue());
}
异常信息如下所示：
com.fasterxml.jackson.databind.JsonMappingException:
No serializer found for class dtos.MyDtoNoAccessors
and no properties discovered to create BeanSerializer
(to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) )
- 解决方案
显而易见的解决方案是为字段添加 getter ，当然，如果实体处于我们控制之下时。如果不是这种情况，修改实体的源代码就是不可能的，那么 Jackson 为我们提供了几个可选方案。
- 1，全局自动检测任何可见的字段
第一个解决方案是，全局配置 ObjectMapper 来检测所有字段，而不管它们是否可见：
objectMapper.setVisibility(PropertyAccessor.FIELD, Visibility.ANY);
这将允许 private 和 private 包的字段被检测到，即便没有 getter，序列化就会正确地执行：
@Test
public void givenObjectHasNoAccessors_whenSerializingWithAllFieldsDetected_thenNoException()
throws JsonParseException, IOException {
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.FIELD, Visibility.ANY);
String dtoAsString = objectMapper.writeValueAsString(new MyDtoNoAccessors());
assertThat(dtoAsString, containsString("intValue"));
assertThat(dtoAsString, containsString("stringValue"));
assertThat(dtoAsString, containsString("booleanValue"));
}
- 2，在类的级别上检测所有字段
Jackson 2 的另一个选择是，通过 @JsonAutoDetect 注解，在类的级别上控制字段的可见性，而不是进行全局配置：
@JsonAutoDetect(fieldVisibility = Visibility.ANY)
public class MyDtoNoAccessors { ... }
对这个注解，序列化不能正确执行：
@Test
public void givenObjectHasNoAccessorsButHasVisibleFields_whenSerializing_thenNoException()
throws JsonParseException, IOException {
ObjectMapper objectMapper = new ObjectMapper();
String dtoAsString = objectMapper.writeValueAsString(new MyDtoNoAccessors());
assertThat(dtoAsString, containsString("intValue"));
assertThat(dtoAsString, containsString("stringValue"));
assertThat(dtoAsString, containsString("booleanValue"));
}
Jackson – 自定义序列化器
如何用 Jackson 2 通过自定义序列化器序列化一个 Java 实体。
- 标准的序列化
定义两个简单实体，如何用 Jackson 序列化它们，不使用任何的自定义逻辑：
public class User {
public int id;
public String name;
}
public class Item {
public int id;
public String itemName;
public User owner;
}
现在，序列化 Item 实体（里边还包含 User 实体）：
Item myItem = new Item(1, "theItem", new User(2, "theUser"));
String serialized = new ObjectMapper().writeValueAsString(myItem);
结果如下：
{
"id": 1,
"itemName": "theItem",
"owner": {
"id": 2,
"name": "theUser"
}
}
- ObjectMapper 上的自定义序列化器
现在，让我们简化上面的 JSON 输出，只序列化 User 的 id，而不是整个 User 对象；我们希望得到如下简单的JSON：
{
"id": 25,
"itemName": "FEDUfRgS",
"owner": 15
}
我们必须为 Item 对象定义一个自定义序列化器：
public class ItemSerializer extends JsonSerializer<Item> {
@Override
public void serialize(Item value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonProcessingException {
jgen.writeStartObject();
jgen.writeNumberField("id", value.id);
jgen.writeStringField("itemName", value.itemName);
jgen.writeNumberField("owner", value.owner.id);
jgen.writeEndObject();
}
}
现在，我们需要为 Item 类在 ObjectMapper 注册这个自定义序列化器，然后，执行序列化：
Item myItem = new Item(1, "theItem", new User(2, "theUser"));
ObjectMapper mapper = new ObjectMapper();
SimpleModule module = new SimpleModule();
module.addSerializer(Item.class, new ItemSerializer());
mapper.registerModule(module);
String serialized = mapper.writeValueAsString(myItem);
- 在类上自定义序列化器
我们也可以在类上直接注册序列化器，而不用在 ObjectMapper：
@JsonSerialize(using = ItemSerializer.class)
public class Item {
...
}
现在，当我们执行标准的序列化时：
Item myItem = new Item(1, "theItem", new User(2, "theUser"));
String serialized = new ObjectMapper().writeValueAsString(myItem);
我们会得到自定义的 JSON 输出，它是由 @JsonSerialize 指定的序列化器创建的：
{
"id": 25,
"itemName": "FEDUfRgS",
"owner": 15
}
高级 Jackson Unmarshalling
Unmarshall 成 Collection/Array
如何用 Jackson 2 把一个 JSON 数组（Array ）反序列化成一个 Java 数组或集合（Collection ）。
- Unmarshall 成数组（Array）
Jackson 可以很容易地反序列化成一个 Java 数组：
@Test
public void givenJsonArray_whenDeserializingAsArray_thenCorrect()
throws JsonParseException, JsonMappingException, IOException {
ObjectMapper mapper = new ObjectMapper();
List<MyDto> listOfDtos = Lists.newArrayList(
new MyDto("a", 1, true), new MyDto("bc", 3, false));
String jsonArray = mapper.writeValueAsString(listOfDtos);
// [{"stringValue":"a","intValue":1,"booleanValue":true},
// {"stringValue":"bc","intValue":3,"booleanValue":false}]
MyDto[] asArray = mapper.readValue(jsonArray, MyDto[].class);
assertThat(asArray[0], instanceOf(MyDto.class));
}
- Unmarshall 成集合（Collection）
把同一个 JSON 数组读到一个 Java 集合，就有点困难了 – 默认情况，Jackson 无法得到完整的泛型类型信息，而是将创建一个 LinkedHashMap 实例的集合：
@Test
public void givenJsonArray_whenDeserializingAsListWithNoTypeInfo_thenNotCorrect()
throws JsonParseException, JsonMappingException, IOException {
ObjectMapper mapper = new ObjectMapper();
List<MyDto> listOfDtos = Lists.newArrayList(
new MyDto("a", 1, true), new MyDto("bc", 3, false));
String jsonArray = mapper.writeValueAsString(listOfDtos);
List<MyDto> asList = mapper.readValue(jsonArray, List.class);
assertThat((Object) asList.get(0), instanceOf(LinkedHashMap.class));
}
有两种方式可以帮助 Jackson 理解正确的类型信息 – 我们或是使用 TypeReference：
@Test
public void givenJsonArray_whenDeserializingAsListWithTypeReferenceHelp_thenCorrect()
throws JsonParseException, JsonMappingException, IOException {
ObjectMapper mapper = new ObjectMapper();
List<MyDto> listOfDtos = Lists.newArrayList(
new MyDto("a", 1, true), new MyDto("bc", 3, false));
String jsonArray = mapper.writeValueAsString(listOfDtos);
List<MyDto> asList = mapper.readValue(jsonArray, new TypeReference<List<MyDto>>() { });
assertThat(asList.get(0), instanceOf(MyDto.class));
}
或是使用接受 JavaType 的 readValue 的重载方法：
@Test
public final void givenJsonArray_whenDeserializingAsListWithJavaTypeHelp_thenCorrect()
throws JsonParseException, JsonMappingException, IOException {
ObjectMapper mapper = new ObjectMapper();
List<MyDto> listOfDtos = Lists.newArrayList(
new MyDto("a", 1, true), new MyDto("bc", 3, false));
String jsonArray = mapper.writeValueAsString(listOfDtos);
final CollectionType javaType =
mapper.getTypeFactory().constructCollectionType(List.class, MyDto.class);
List<MyDto> asList = mapper.readValue(jsonArray, javaType);
assertThat(asList.get(0), instanceOf(MyDto.class));
}
最后，需要注意的是，MyDto 类需要一个没有任何参数的默认构造函数，否则，Jackson 将不能实例化：
com.fasterxml.jackson.databind.JsonMappingException:
No suitable constructor found for type [simple type, class org.baeldung.jackson.ignore.MyDto]:
can not instantiate from JSON object (need to add/enable type information?)
Jackson – 自定义反序列化器
如何用 Jackson 2 通过一个自定义反序列化器来反序列化 JSON。
标准的反序列化
定义两个实体，如何用 Jackson 2 反序列化成一个 JSON 表示，不用任何的自定义：
public class User {
public int id;
public String name;
}
public class Item {
public int id;
public String itemName;
public User owner;
}
现在，我们定义反序列化后想要得到的 JSON 表示：
{
"id": 1,
"itemName": "theItem",
"owner": {
"id": 2,
"name": "theUser"
}
}
最后，把这个 JSON unmarshall 成 Java 实体：
Item itemWithOwner = new ObjectMapper().readValue(json, Item.class);
在 ObjectMapper 上自定义反序列化器
在前面的示例中，JSON 表示与 Java 实体完全匹配。下面，我们简化 JSON：
{
"id": 1,
"itemName": "theItem",
"createdBy": 2
}
当把这个 JSON unmarshalling 成相同的实体时，默认情况，将会失败：
com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException:
Unrecognized field "createdBy" (class org.baeldung.jackson.dtos.Item),
not marked as ignorable (3 known properties: "id", "owner", "itemName"])
at [Source: java.io.StringReader@53c7a917; line: 1, column: 43]
(through reference chain: org.baeldung.jackson.dtos.Item["createdBy"])
现在，我们用自定义的反序列化器来反序列化：
public class ItemDeserializer extends JsonDeserializer<Item> {
@Override
public Item deserialize(JsonParser jp, DeserializationContext ctxt)
throws IOException, JsonProcessingException {
JsonNode node = jp.getCodec().readTree(jp);
int id = (Integer) ((IntNode) node.get("id")).numberValue();
String itemName = node.get("itemName").asText();
int userId = (Integer) ((IntNode) node.get("createdBy")).numberValue();
return new Item(id, itemName, new User(userId, null));
}
}
反序列化使用 JSON 的标准 Jackson 表示 – JsonNode。一旦输入的 JSON 被表示成一个 JsonNode，就可以从它提取相关的信息，并构造自己的 Item 实体。
我们需要注册这个自定义的反序列化器，再正常地反序列化 JSON：
ObjectMapper mapper = new ObjectMapper();
SimpleModule module = new SimpleModule();
module.addDeserializer(Item.class, new ItemDeserializer());
mapper.registerModule(module);
Item readValue = mapper.readValue(json, Item.class);
在类的级别上自定义反序列化器
另一个方法是，也可以直接在类上注册反序列化器：
@JsonDeserialize(using = ItemDeserializer.class)
public class Item {
...
}
用这个定义在类级别上的反序列化器，就不需要在 ObjectMapper 注册它，那么一个默认的 mapper 就可以反序列化：
Item itemWithOwner = new ObjectMapper().readValue(json, Item.class);
演示
图 1 项目结构
- libs 里，除了 jackson 2 的三个包外，还有 google guava 的一个包，是 Java 项目广泛依赖的核心库，如集合 [collections] 、缓存 [caching] 、原生类型支持 [primitives support] 、并发库 [concurrency libraries] 、通用注解 [common annotations] 、字符串处理 [string processing] 、I/O 等等。
参考资料
- Jackson JSON Tutorial
- Android Jackson 概述
- Android 基本 Jackson Marshalling（serialize）/Unmarshalling（deserialize）