Jackson之JavaJSON解析器

在当今的编程世界里，JSON 已经成为将信息从客户端传输到服务器端的选择协议，可以好不夸张的说，XML 就是那个被拍死在沙滩上的前浪。

很不幸的是，JDK 没有 JSON 库，不知道为什么不搞一下。Log4j 的时候，为了竞争，还推出了 java.util.logging，虽然最后也没多少人用。

Java 之所以牛逼，很大的功劳在于它的生态非常完备，JDK 没有 JSON 库，第三方类库有啊，还挺不错，比如说本篇的猪脚——Jackson，GitHub 上标星 6.1k，Spring Boot 的默认 JSON 解析器。

怎么证明这一点呢?

当我们通过 starter 新建一个 Spring Boot 的 Web 项目后，就可以在 Maven 的依赖项中看到 Jackson 的身影。

Jackson 有很多优点：

  • 解析大文件的速度比较快;
  • 运行时占用的内存比较少，性能更佳;
  • API 很灵活，容易进行扩展和定制。

Jackson 的核心模块由三部分组成：

  • jackson-core，核心包，提供基于“流模式”解析的相关 API，包括 JsonPaser 和 JsonGenerator。
  • jackson-annotations，注解包，提供标准的注解功能;
  • jackson-databind ，数据绑定包，提供基于“对象绑定”解析的相关 API ( ObjectMapper ) 和基于“树模型”解析的相关 API (JsonNode)。

01、引入 Jackson 依赖

要想使用 Jackson，需要在 pom.xml 文件中添加 Jackson 的依赖。

 
 
 
 
    
  
  
  
  
    2. 
  
  
  
  
  2.     com.fasterxml.jackson.core
    3. 
  
  
  
  
  3.     jackson-databind
    4. 
  
  
  
  
  4.     2.10.1
    5. 
  
  
  
  
  5.

jackson-databind 依赖于 jackson-core 和 jackson-annotations，所以添加完 jackson-databind 之后，Maven 会自动将 jackson-core 和 jackson-annotations 引入到项目当中。

Maven 之所以讨人喜欢的一点就在这，能偷偷摸摸地帮我们把该做的做了。

02、使用 ObjectMapper

Jackson 最常用的 API 就是基于”对象绑定” 的 ObjectMapper，它通过 writeValue 的系列方法将 Java 对象序列化为 JSON，并且可以存储成不同的格式。

  • writeValueAsString(Object value) 方法，将对象存储成字符串
  • writeValueAsBytes(Object value) 方法，将对象存储成字节数组
  • writeValue(File resultFile, Object value) 方法，将对象存储成文件

来看一下存储成字符串的代码示例：

 
 
 
 
    
  
  
  
  
  1. import com.fasterxml.jackson.core.JsonProcessingException;
    2. 
  
  
  
  
  2. import com.fasterxml.jackson.databind.ObjectMapper;
    3. 
  
  
  
  
  3. 
  
  
  
  
  4. /**
    5. 
  
  
  
  
  5.  * 微信搜索「沉默王二」，回复 Java
    6. 
  
  
  
  
  6.  *
    7. 
  
  
  
  
  7.  * @author 沉默王二
    8. 
  
  
  
  
  8.  * @date 2020/11/26
    9. 
  
  
  
  
  9.  */
    10. 
  
  
  
  
  10. public class Demo {
    11. 
  
  
  
  
  11.     public static void main(String[] args) throws JsonProcessingException {
    12. 
  
  
  
  
  12.         Writer wanger = new Writer("沉默王二", 18);
    13. 
  
  
  
  
  13.         ObjectMapper mapper = new ObjectMapper();
    14. 
  
  
  
  
  14.         String jsonString = mapper.writerWithDefaultPrettyPrinter()
    15. 
  
  
  
  
  15.                 .writeValueAsString(wanger);
    16. 
  
  
  
  
  16.         System.out.println(jsonString);
    17. 
  
  
  
  
  17.     }
    18. 
  
  
  
  
  18. }
    19. 
  
  
  
  
  19. 
  
  
  
  
  20. class Writer {
    21. 
  
  
  
  
  21.     private String name;
    22. 
  
  
  
  
  22.     private int age;
    23. 
  
  
  
  
  23. 
  
  
  
  
  24.     public Writer(String name, int age) {
    25. 
  
  
  
  
  25.         this.name = name;
    26. 
  
  
  
  
  26.         this.age = age;
    27. 
  
  
  
  
  27.     }
    28. 
  
  
  
  
  28. 
  
  
  
  
  29.     public String getName() {
    30. 
  
  
  
  
  30.         return name;
    31. 
  
  
  
  
  31.     }
    32. 
  
  
  
  
  32. 
  
  
  
  
  33.     public void setName(String name) {
    34. 
  
  
  
  
  34.         this.name = name;
    35. 
  
  
  
  
  35.     }
    36. 
  
  
  
  
  36. 
  
  
  
  
  37.     public int getAge() {
    38. 
  
  
  
  
  38.         return age;
    39. 
  
  
  
  
  39.     }
    40. 
  
  
  
  
  40. 
  
  
  
  
  41.     public void setAge(int age) {
    42. 
  
  
  
  
  42.         this.age = age;
    43. 
  
  
  
  
  43.     }
    44. 
  
  
  
  
  44. }
    45.

程序输出结果如下所示：

 
 
 
 
    
  
  
  
  
  1. {
    2. 
  
  
  
  
  2.   "name" : "沉默王二",
    3. 
  
  
  
  
  3.   "age" : 18
    4. 
  
  
  
  
  4. }
    5.

不是所有的字段都支持序列化和反序列化，需要符合以下规则：

  • 如果字段的修饰符是 public，则该字段可序列化和反序列化(不是标准写法)。
  • 如果字段的修饰符不是 public，但是它的 getter 方法和 setter 方法是 public，则该字段可序列化和反序列化。getter 方法用于序列化，setter 方法用于反序列化。
  • 如果字段只有 public 的 setter 方法，而无 public 的 getter 方 法，则该字段只能用于反序列化。

如果想更改默认的序列化和反序列化规则，需要调用 ObjectMapper 的setVisibility() 方法。否则将会抛出 InvalidDefinitionException 异常。

ObjectMapper 通过 readValue 的系列方法从不同的数据源将 JSON 反序列化为 Java 对象。

  • readValue(String content, Class valueType) 方法，将字符串反序列化为 Java 对象
  • readValue(byte[] src, Class valueType) 方法，将字节数组反序列化为 Java 对象
  • readValue(File src, Class valueType) 方法，将文件反序列化为 Java 对象

来看一下将字符串反序列化为 Java 对象的代码示例：

 
 
 
 
    
  
  
  
  
  1. import com.fasterxml.jackson.core.JsonProcessingException;
    2. 
  
  
  
  
  2. import com.fasterxml.jackson.databind.ObjectMapper;
    3. 
  
  
  
  
  3. 
  
  
  
  
  4. public class Demo {
    5. 
  
  
  
  
  5.     public static void main(String[] args) throws JsonProcessingException {
    6. 
  
  
  
  
  6.         ObjectMapper mapper = new ObjectMapper();
    7. 
  
  
  
  
  7.         String jsonString = "{\n" +
    8. 
  
  
  
  
  8.                 "  \"name\" : \"沉默王二\",\n" +
    9. 
  
  
  
  
  9.                 "  \"age\" : 18\n" +
    10. 
  
  
  
  
  10.                 "}";
    11. 
  
  
  
  
  11.         Writer deserializedWriter = mapper.readValue(jsonString, Writer.class);
    12. 
  
  
  
  
  12.         System.out.println(deserializedWriter);
    13. 
  
  
  
  
  13.     }
    14. 
  
  
  
  
  14. }
    15. 
  
  
  
  
  15. 
  
  
  
  
  16. class Writer{
    17. 
  
  
  
  
  17.     private String name;
    18. 
  
  
  
  
  18.     private int age;
    19. 
  
  
  
  
  19. 
  
  
  
  
  20.     // getter/setter
    21. 
  
  
  
  
  21. 
  
  
  
  
  22.     @Override
    23. 
  
  
  
  
  23.     public String toString() {
    24. 
  
  
  
  
  24.         return "Writer{" +
    25. 
  
  
  
  
  25.                 "name='" + name + '\'' +
    26. 
  
  
  
  
  26.                 ", age=" + age +
    27. 
  
  
  
  
  27.                 '}';
    28. 
  
  
  
  
  28.     }
    29. 
  
  
  
  
  29. }
    30.

程序输出结果如下所示：

 
 
 
 
    
  
  
  
  
  1. Writer{name='沉默王二', age=18}
    2.

PS：如果反序列化的对象有带参的构造方法，它必须有一个空的默认构造方法，否则将会抛出 InvalidDefinitionException 一行。

 
 
 
 
    
  
  
  
  
  1. Exception in thread "main" com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of `com.itwanger.jackson.Writer` (no Creators, like default construct, exist): cannot deserialize from Object value (no delegate- or property-based Creator)
    2. 
  
  
  
  
  2.  at [Source: (String)"{
    3. 
  
  
  
  
  3.   "name" : "沉默王二",
    4. 
  
  
  
  
  4.   "age" : 18
    5. 
  
  
  
  
  5. }"; line: 2, column: 3]
    6. 
  
  
  
  
  6.  at com.fasterxml.jackson.databind.exc.InvalidDefinitionException.from(InvalidDefinitionException.java:67)
    7. 
  
  
  
  
  7.  at com.fasterxml.jackson.databind.DeserializationContext.reportBadDefinition(DeserializationContext.java:1589)
    8. 
  
  
  
  
  8.  at com.fasterxml.jackson.databind.DeserializationContext.handleMissingInstantiator(DeserializationContext.java:1055)
    9. 
  
  
  
  
  9.  at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.deserializeFromObjectUsingNonDefault(BeanDeserializerBase.java:1297)
    10. 
  
  
  
  
  10.  at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserializeFromObject(BeanDeserializer.java:326)
    11. 
  
  
  
  
  11.  at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserialize(BeanDeserializer.java:159)
    12. 
  
  
  
  
  12.  at com.fasterxml.jackson.databind.ObjectMapper._readMapAndClose(ObjectMapper.java:4202)
    13. 
  
  
  
  
  13.  at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:3205)
    14. 
  
  
  
  
  14.  at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:3173)
    15. 
  
  
  
  
  15.  at com.itwanger.jackson.Demo.main(Demo.java:19)
    16.

Jackson 最常用的 API 就是基于”对象绑定” 的 ObjectMapper，

ObjectMapper 也可以将 JSON 解析为基于“树模型”的 JsonNode 对象，来看下面的示例。

 
 
 
 
    
  
  
  
  
  1. import com.fasterxml.jackson.core.JsonProcessingException;
    2. 
  
  
  
  
  2. import com.fasterxml.jackson.databind.JsonNode;
    3. 
  
  
  
  
  3. import com.fasterxml.jackson.databind.ObjectMapper;
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. public class JsonNodeDemo {
    6. 
  
  
  
  
  6.     public static void main(String[] args) throws JsonProcessingException {
    7. 
  
  
  
  
  7.         ObjectMapper mapper = new ObjectMapper();
    8. 
  
  
  
  
  8.         String json = "{ \"name\" : \"沉默王二\", \"age\" : 18 }";
    9. 
  
  
  
  
  9.         JsonNode jsonNode = mapper.readTree(json);
    10. 
  
  
  
  
  10.         String name = jsonNode.get("name").asText();
    11. 
  
  
  
  
  11.         System.out.println(name); // 沉默王二
    12. 
  
  
  
  
  12.     }
    13. 
  
  
  
  
  13. }
    14.

借助 TypeReference 可以将 JSON 字符串数组转成泛型 List，来看下面的示例：

 
 
 
 
    
  
  
  
  
  1. import com.fasterxml.jackson.core.JsonProcessingException;
    2. 
  
  
  
  
  2. import com.fasterxml.jackson.core.type.TypeReference;
    3. 
  
  
  
  
  3. import com.fasterxml.jackson.databind.ObjectMapper;
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. import java.util.List;
    6. 
  
  
  
  
  6. 
  
  
  
  
  7. public class TypeReferenceDemo {
    8. 
  
  
  
  
  8.     public static void main(String[] args) throws JsonProcessingException {
    9. 
  
  
  
  
  9.         ObjectMapper mapper = new ObjectMapper();
    10. 
  
  
  
  
  10.         String json = "[{ \"name\" : \"沉默王三\", \"age\" : 18 }, { \"name\" : \"沉默王二\", \"age\" : 19 }]";
    11. 
  
  
  
  
  11.         List listAuthor = mapper.readValue(json, new TypeReference>(){});
    12. 
  
  
  
  
  12.         System.out.println(listAuthor);
    13. 
  
  
  
  
  13.     }
    14. 
  
  
  
  
  14. }
    15. 
  
  
  
  
  15. class Author{
    16. 
  
  
  
  
  16.     private String name;
    17. 
  
  
  
  
  17.     private int age;
    18. 
  
  
  
  
  18. 
  
  
  
  
  19.     // getter/setter
    20. 
  
  
  
  
  20. 
  
  
  
  
  21.     // toString
    22. 
  
  
  
  
  22. }
    23.

03、更高级的配置

Jackson 之所以牛掰的一个很重要的因素是可以实现高度灵活的自定义配置。

在实际的应用场景中，JSON 中常常会有一些 Java 对象中没有的字段，这时候，如果直接解析的话，会抛出 UnrecognizedPropertyException 异常。

下面是一串 JSON 字符串：

 
 
 
 
    
  
  
  
  
  1. String jsonString = "{\n" +
    2. 
  
  
  
  
  2.                 "  \"name\" : \"沉默王二\",\n" +
    3. 
  
  
  
  
  3.                 "  \"age\" : 18\n" +
    4. 
  
  
  
  
  4.                 "  \"sex\" : \"男\",\n" +
    5. 
  
  
  
  
  5.                 "}";
    6.

但 Java 对象 Writer 中没有定义 sex 字段：

 
 
 
 
    
  
  
  
  
  1. class Writer{
    2. 
  
  
  
  
  2.     private String name;
    3. 
  
  
  
  
  3.     private int age;
    4. 
  
  
  
  
  4. 
  
  
  
  
  5.     // getter/setter
    6. 
  
  
  
  
  6. }
    7.

我们来尝试解析一下：

 
 
 
 
    
  
  
  
  
  1. ObjectMapper mapper = new ObjectMapper();
    2. 
  
  
  
  
  2. Writer deserializedWriter = mapper.readValue(jsonString, Writer.class);
    3.

不出意外，抛出异常了，sex 无法识别。

 
 
 
 
    
  
  
  
  
  1. Exception in thread "main" com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException: Unrecognized field "sex" (class com.itwanger.jackson.Writer), not marked as ignorable (2 known properties: "name", "age"])
    2. 
  
  
  
  
  2.  at [Source: (String)"{
    3. 
  
  
  
  
  3.   "name" : "沉默王二",
    4. 
  
  
  
  
  4.   "age" : 18,
    5. 
  
  
  
  
  5.   "sex" : "男"
    6. 
  
  
  
  
  6. }"; line: 4, column: 12] (through reference chain: com.itwanger.jackson.Writer["sex"])
    7.

怎么办呢?可以通过 configure() 方法忽略掉这些“无法识别”的字段。

 
 
 
 
    
  
  
  
  
  1. mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    2.

除此之外，还有其他一些有用的配置信息，来了解一下：

 
 
 
 
    
  
  
  
  
  1. // 在序列化时忽略值为 null 的属性
    2. 
  
  
  
  
  2. mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    3. 
  
  
  
  
  3. // 忽略值为默认值的属性
    4. 
  
  
  
  
  4. mapper.setDefaultPropertyInclusion(JsonInclude.Include.NON_DEFAULT);
    5.

04、处理日期格式

对于日期类型的字段，比如说 java.util.Date，如果不指定格式，序列化后将显示为 long 类型的数据，这种默认格式的可读性很差。

 
 
 
 
    
  
  
  
  
  1. {
    2. 
  
  
  
  
  2.   "age" : 18,
    3. 
  
  
  
  
  3.   "birthday" : 1606358621209
    4. 
  
  
  
  
  4. }
    5.

怎么办呢?

第一种方案，在 getter 上使用 @JsonFormat 注解。

 
 
 
 
    
  
  
  
  
  1. private Date birthday;
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. // GMT+8 是指格林尼治的标准时间，在加上八个小时表示你现在所在时区的时间
    4. 
  
  
  
  
  4. @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    5. 
  
  
  
  
  5. public Date getBirthday() {
    6. 
  
  
  
  
  6.     return birthday;
    7. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. 
  
  
  
  
  9. public void setBirthday(Date birthday) {
    10. 
  
  
  
  
  10.     this.birthday = birthday;
    11. 
  
  
  
  
  11. }
    12.

再来看一下结果：

 
 
 
 
    
  
  
  
  
  1. {
    2. 
  
  
  
  
  2.   "age" : 18,
    3. 
  
  
  
  
  3.   "birthday" : "2020-11-26 03:02:30"
    4. 
  
  
  
  
  4. }
    5.

具体代码如下所示：

 
 
 
 
    
  
  
  
  
  1. ObjectMapper mapper = new ObjectMapper();
    2. 
  
  
  
  
  2. Writer wanger = new Writer("沉默王二", 18);
    3. 
  
  
  
  
  3. wanger.setBirthday(new Date());
    4. 
  
  
  
  
  4. String jsonString = mapper.writerWithDefaultPrettyPrinter()
    5. 
  
  
  
  
  5.                 .writeValueAsString(wanger);
    6. 
  
  
  
  
  6. System.out.println(jsonString);
    7.

第二种方案，调用 ObjectMapper 的 setDateFormat() 方法。

 
 
 
 
    
  
  
  
  
  1. ObjectMapper mapper = new ObjectMapper();
    2. 
  
  
  
  
  2. mapper.setDateFormat(StdDateFormat.getDateTimeInstance());
    3. 
  
  
  
  
  3. Writer wanger = new Writer("沉默王二", 18);
    4. 
  
  
  
  
  4. wanger.setBirthday(new Date());
    5. 
  
  
  
  
  5. String jsonString = mapper.writerWithDefaultPrettyPrinter()
    6. 
  
  
  
  
  6.                 .writeValueAsString(wanger);
    7. 
  
  
  
  
  7. System.out.println(jsonString);
    8.

输出结果如下所示：

 
 
 
 
    
  
  
  
  
  1. {
    2. 
  
  
  
  
  2.   "name" : "沉默王二",
    3. 
  
  
  
  
  3.   "age" : 18,
    4. 
  
  
  
  
  4.   "birthday" : "2020年11月26日 上午11:09:51"
    5. 
  
  
  
  
  5. }
    6.

05、字段过滤

在将 Java 对象序列化为 JSON 时，可能有些字段需要过滤，不显示在 JSON 中，Jackson 有一种比较简单的实现方式。

@JsonIgnore 用于过滤单个字段。

 
 
 
 
    
  
  
  
  
  1. @JsonIgnore
    2. 
  
  
  
  
  2. public String getName() {
    3. 
  
  
  
  
  3.     return name;
    4. 
  
  
  
  
  4. }
    5.

@JsonIgnoreProperties 用于过滤多个字段。

 
 
 
 
    
  
  
  
  
  1. @JsonIgnoreProperties(value = { "age","birthday" })
    2. 
  
  
  
  
  2. class Writer{
    3. 
  
  
  
  
  3.     private String name;
    4. 
  
  
  
  
  4.     private int age;
    5. 
  
  
  
  
  5.     private Date birthday;
    6. 
  
  
  
  
  6. }
    7.

06、自定义序列化和反序列化

当 Jackson 默认序列化和反序列化不能满足实际的开发需要时，可以自定义新的序列化和反序列化类。

自定义的序列化类需要继承 StdSerializer，同时重写 serialize() 方法，利用 JsonGenerator 生成 JSON，示例如下：

 
 
 
 
    
  
  
  
  
  1. public class CustomSerializer extends StdSerializer {
    2. 
  
  
  
  
  2.     protected CustomSerializer(Class t) {
    3. 
  
  
  
  
  3.         super(t);
    4. 
  
  
  
  
  4.     }
    5. 
  
  
  
  
  5. 
  
  
  
  
  6.     public CustomSerializer() {
    7. 
  
  
  
  
  7.         this(null);
    8. 
  
  
  
  
  8.     }
    9. 
  
  
  
  
  9. 
  
  
  
  
  10.     @Override
    11. 
  
  
  
  
  11.     public void serialize(Man value, JsonGenerator gen, SerializerProvider provider) throws IOException {
    12. 
  
  
  
  
  12.         gen.writeStartObject();
    13. 
  
  
  
  
  13.         gen.writeStringField("name", value.getName());
    14. 
  
  
  
  
  14.         gen.writeEndObject();
    15. 
  
  
  
  
  15.     }
    16. 
  
  
  
  
  16. }
    17. 
  
  
  
  
  17. 
  
  
  
  
  18. class Man{
    19. 
  
  
  
  
  19.     private int age;
    20. 
  
  
  
  
  20.     private String name;
    21. 
  
  
  
  
  21. 
  
  
  
  
  22.     public Man(int age, String name) {
    23. 
  
  
  
  
  23.         this.age = age;
    24. 
  
  
  
  
  24.         this.name = name;
    25. 
  
  
  
  
  25.     }
    26. 
  
  
  
  
  26. 
  
  
  
  
  27.     public int getAge() {
    28. 
  
  
  
  
  28.         return age;
    29. 
  
  
  
  
  29.     }
    30. 
  
  
  
  
  30. 
  
  
  
  
  31.     public void setAge(int age) {
    32. 
  
  
  
  
  32.         this.age = age;
    33. 
  
  
  
  
  33.     }
    34. 
  
  
  
  
  34. 
  
  
  
  
  35.     public String getName() {
    36. 
  
  
  
  
  36.         return name;
    37. 
  
  
  
  
  37.     }
    38. 
  
  
  
  
  38. 
  
  
  
  
  39.     public void setName(String name) {
    40. 
  
  
  
  
  40.         this.name = name;
    41. 
  
  
  
  
  41.     }
    42. 
  
  
  
  
  42. }
    43.

定义好自定义序列化类后，要想在程序中调用它们，需要将其注册到 ObjectMapper 的 Module 中，示例如下所示：

 
 
 
 
    
  
  
  
  
  1. ObjectMapper mapper = new ObjectMapper();
    2. 
  
  
  
  
  2. SimpleModule module =
    3. 
  
  
  
  
  3.         new SimpleModule("CustomSerializer", new Version(1, 0, 0, null, null, null));
    4. 
  
  
  
  
  4. module.addSerializer(Man.class, new CustomSerializer());
    5. 
  
  
  
  
  5. mapper.registerModule(module);
    6. 
  
  
  
  
  6. Man man = new Man( 18,"沉默王二");
    7. 
  
  
  
  
  7. String json = mapper.writeValueAsString(man);
    8. 
  
  
  
  
  8. System.out.println(json);
    9.

程序输出结果如下所示：

 
 
 
 
    
  
  
  
  
  1. {"name":"沉默王二"}
    2.

自定义序列化类 CustomSerializer 中没有添加 age 字段，所以只输出了 name 字段。

再来看一下自定义的反序列化类，继承 StdDeserializer，同时重写 deserialize() 方法，利用 JsonGenerator 读取 JSON，示例如下：

 
 
 
 
    
  
  
  
  
  1. public class CustomDeserializer extends StdDeserializer {
    2. 
  
  
  
  
  2.     protected CustomDeserializer(Class vc) {
    3. 
  
  
  
  
  3.         super(vc);
    4. 
  
  
  
  
  4.     }
    5. 
  
  
  
  
  5. 
  
  
  
  
  6.     public CustomDeserializer() {
    7. 
  
  
  
  
  7.         this(null);
    8. 
  
  
  
  
  8.     }
    9. 
  
  
  
  
  9. 
  
  
  
  
  10.     @Override
    11. 
  
  
  
  
  11.     public Woman deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    12. 
  
  
  
  
  12.         JsonNode node = p.getCodec().readTree(p);
    13. 
  
  
  
  
  13.         Woman woman = new Woman();
    14. 
  
  
  
  
  14.         int age = (Integer) ((IntNode) node.get("age")).numberValue();
    15. 
  
  
  
  
  15.         String name = node.get("name").asText();
    16. 
  
  
  
  
  16.         woman.setAge(age);
    17. 
  
  
  
  
  17.         woman.setName(name);
    18. 
  
  
  
  
  18.         return woman;
    19. 
  
  
  
  
  19.     }
    20. 
  
  
  
  
  20. }
    21. 
  
  
  
  
  21. class Woman{
    22. 
  
  
  
  
  22.     private int age;
    23. 
  
  
  
  
  23.     private String name;
    24. 
  
  
  
  
  24. 
  
  
  
  
  25.     public Woman() {
    26. 
  
  
  
  
  26.     }
    27. 
  
  
  
  
  27. 
  
  
  
  
  28.     // getter/setter
    29. 
  
  
  
  
  29. 
  
  
  
  
  30.     @Override
    31. 
  
  
  
  
  31.     public String toString() {
    32. 
  
  
  
  
  32.         return "Woman{" +
    33. 
  
  
  
  
  33.                 "age=" + age +
    34. 
  
  
  
  
  34.                 ", name='" + name + '\'' +
    35. 
  
  
  
  
  35.                 '}';
    36. 
  
  
  
  
  36.     }
    37. 
  
  
  
  
  37. }
    38.

通过 JsonNode 把 JSON 读取到一个树形结构中，然后通过 JsonNode 的 get 方法将对应字段读取出来，然后生成新的 Java 对象，并返回。

定义好自定义反序列化类后，要想在程序中调用它们，同样需要将其注册到 ObjectMapper 的 Module 中，示例如下所示：

 
 
 
 
    
  
  
  
  
  1. ObjectMapper mapper = new ObjectMapper();
    2. 
  
  
  
  
  2. SimpleModule module =
    3. 
  
  
  
  
  3.         new SimpleModule("CustomDeserializer", new Version(1, 0, 0, null, null, null));
    4. 
  
  
  
  
  4. module.addDeserializer(Woman.class, new CustomDeserializer());
    5. 
  
  
  
  
  5. mapper.registerModule(module);
    6. 
  
  
  
  
  6. String json = "{ \"name\" : \"三妹\", \"age\" : 18 }";
    7. 
  
  
  
  
  7. Woman woman = mapper.readValue(json, Woman.class);
    8. 
  
  
  
  
  8. System.out.println(woman);
    9.

程序输出结果如下所示：

 
 
 
 
    
  
  
  
  
  1. Woman{age=18, name='三妹'}
    2.

07、结语

哎呀，好像不错哦，Jackson 绝对配得上“最牛掰”这三个字。如果只想简单的序列化和反序列化，使用 ObjectMapper 的 write 和 read 方法即可。

如果还想更进一步的话，就需要对 ObjectMapper 进行一些自定义配置，或者加一些注解，以及直接自定义序列化和反序列化类，更贴近一些 Java 对象。

需要注意的是，对日期格式的字段要多加小心，尽量不要使用默认配置，可读性很差。

好了，通过这篇文章的系统化介绍，相信读者朋友们已经完全摸透 Jackson 了，我们下篇文章见。

本文转载自微信公众号「沉默王二」，可以通过以下二维码关注。转载本文请联系沉默王二公众号。

网站栏目：Jackson之JavaJSON解析器
网页URL：http://www.shufengxianlan.com/qtweb/news41/416141.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

全网营销推广知识

同城分类信息

三台网站建设　　 　成都定制网站建设　　 　四川白乌鱼　　 　化妆品企业网站建设方案　　 　四川胜锦安防　　 　成都微信小程序开发　　 　东电技服　　 　南充护栏钻孔机　　 　成都微商城　　 　网站设计　　 　服务器机柜租用　　 　网站建设改版　　 　电商网站建设　　 　LOGO设计　　 　wap网站制作　　 　成都多线服务器托管　　 　重庆网站建设　　 　成都添翼二手车　　 　大橙子建站　　 　专业网站设计