Android 高级 Jackson Marshalling(serialize)/Unmarshalling(dese

日期:2019-01-31 编辑:AG88

Android 高级 Jackson Marshalling(serialize)/Unmarshalling(deserialize),unmarshalling
本文内容

  • 高级 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 输出,只序列化 Userid,而不是整个 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));
}

或是使用接受 JavaTypereadValue 的重载方法:

@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: [email protected]; 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)

 

下载 Demo 下载 Jackson 2


http://www.bkjia.com/Androidjc/864285.htmlwww.bkjia.comtruehttp://www.bkjia.com/Androidjc/864285.htmlTechArticleAndroid 高级 Jackson Marshalling(serialize)/Unmarshalling(deserialize),unmarshalling 本文内容 高级 Jackson Marshalling 只序列化符合自定义标准的字段 把...

本文源自: AG环亚官网