史上最全的Jackson框架使用教程

簡單介紹

別再使用 fastJson 了！漏洞每天報，Bug 修不完。快來擁抱 Jackson 吧！

Jackson 是用來序列化和反序列化 json 的 Java 的開源框架。Spring MVC 的默認 json 解析器即是 Jackson。與其餘 Java 的 json 的框架 Gson 等相比， Jackson 解析大的 json 文件速度比較快；Jackson 運行時佔用內存比較低，性能比較好；Jackson 有靈活的 API，能夠很容易進行擴展和定製。

Jackson 的 1.x 版本的包名是 org.codehaus.jackson ，當升級到 2.x 版本時，包名變爲 com.fasterxml.jackson，本文討論的內容是基於最新的 Jackson 的 2.9.1 版本。

Jackson 的核心模塊由三部分組成。

• jackson-core，核心包，提供基於"流模式"解析的相關 API，它包括 JsonPaser 和 JsonGenerator。Jackson 內部實現正是經過高性能的流模式 API 的 JsonGenerator 和 JsonParser 來生成和解析 json。

• jackson-annotations，註解包，提供標準註解功能；

• jackson-databind ，數據綁定包， 提供基於"對象綁定" 解析的相關 API （ ObjectMapper ） 和"樹模型" 解析的相關 API （JsonNode）；基於"對象綁定" 解析的 API 和"樹模型"解析的 API 依賴基於"流模式"解析的 API。

在瞭解 Jackson 的概要狀況以後，下面介紹 Jackson 的基本用法。

導入依賴

若想在 Java 代碼中使用 Jackson 的核心模塊的 jar 包 ，須要在 pom.xml 中添加以下信息。

<dependency> 
<groupId>com.fasterxml.jackson.core</groupId> 
<artifactId>jackson-databind</artifactId> 
<version>2.9.1</version> 
</dependency>

jackson-databind 依賴 jackson-core 和 jackson-annotations，當添加 jackson-databind 以後， jackson-core 和 jackson-annotations 也隨之添加到 Java 項目工程中。在添加相關依賴包以後，就可使用 Jackson。

快速入門

Jackson 最經常使用的 API 就是基於"對象綁定" 的 ObjectMapper。下面是一個 ObjectMapper 的使用的簡單示例。

準備一個名稱爲 Person 的 Java 對象：

public class Person {
    // 正常case
    private String name;
    // 空對象case
    private Integer age;
    // 日期轉換case
    private Date date;
    // 默認值case
    private int height;
}

使用示例：

@Test
public void test1() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    // 造數據
    Person person = new Person();
    person.setName("Tom");
    person.setAge(40);
    person.setDate(new Date());
    System.out.println("序列化");
    String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(person);
    System.out.println(jsonString);
    System.out.println("反序列化");
    Person deserializedPerson = mapper.readValue(jsonString, Person.class);
    System.out.println(deserializedPerson);
}

打印輸出：

序列化
{
"name" : "Tom",
"age" : 40,
"date" : 1594634846647,
"man" : null,
"height" : 0
}
反序列化
JackSonTest.Person(name=Tom, age=40, date=Mon Jul 13 18:07:26 CST 2020, man=null, height=0)

ObjectMapper 經過 writeValue 系列方法將 java 對象序列化爲 json，並將 json 存儲成不一樣的格式，String（writeValueAsString），Byte Array（writeValueAsString），Writer， File，OutStream 和 DataOutput。

ObjectMapper 經過 readValue 系列方法從不一樣的數據源像 String ， Byte Array， Reader，File，URL， InputStream 將 json 反序列化爲 java 對象。

統一配置

在調用 writeValue 或調用 readValue 方法以前，每每須要設置 ObjectMapper 的相關配置信息。這些配置信息應用 java 對象的全部屬性上。示例以下：

//在反序列化時忽略在 json 中存在但 Java 對象不存在的屬性
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
//在序列化時日期格式默認爲 yyyy-MM-dd'T'HH:mm:ss.SSSZ
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
//在序列化時自定義時間日期格式
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
//在序列化時忽略值爲 null 的屬性
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
//在序列化時忽略值爲默認值的屬性
mapper.setDefaultPropertyInclusion(JsonInclude.Include.NON_DEFAULT);

更多配置信息能夠查看 Jackson 的 DeserializationFeature，SerializationFeature 和 Include。

從新運行單元測試1，打印輸出：

序列化
{
  "name" : "Tom",
  "age" : 40,
  "date" : "2020-07-26 18:46:51"
}
反序列化
JackSonTest.Person(name=Tom, age=40, date=Sun Jul 26 18:46:51 CST 2020, height=0)

使用註解

Jackson 根據它的默認方式序列化和反序列化 java 對象，若根據實際須要，靈活的調整它的默認方式，可使用 Jackson 的註解。經常使用的註解及用法以下。

註解	用法
@JsonProperty	用於屬性，把屬性的名稱序列化時轉換爲另一個名稱。示例：@JsonProperty("birth_date") private Date birthDate
@JsonIgnore	可用於字段、getter/setter、構造函數參數上，做用相同，都會對相應的字段產生影響。使相應字段不參與序列化和反序列化。
@JsonIgnoreProperties	該註解是類註解。該註解在Java類和JSON不徹底匹配的時候使用。
@JsonFormat	用於屬性或者方法，把屬性的格式序列化時轉換成指定的格式。示例：@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm") public Date getBirthDate()
@JsonPropertyOrder	用於類， 和 @JsonProperty 的index屬性相似，指定屬性在序列化時 json 中的順序 ， 示例：@JsonPropertyOrder({ "birth_Date", "name" }) public class Person
@JsonCreator	用於構造方法，和 @JsonProperty 配合使用，適用有參數的構造方法。示例：@JsonCreator public Person(@JsonProperty("name")String name) {…}
@JsonAnySetter	用於屬性或者方法，設置未反序列化的屬性名和值做爲鍵值存儲到 map 中 @JsonAnySetter public void set(String key, Object value) { map.put(key, value); }
@JsonAnyGetter	用於方法 ，獲取全部未序列化的屬性 public Map<String, Object> any() { return map; }
@JsonNaming	類註解。序列化的時候該註解可將駝峯命名的字段名轉換爲下劃線分隔的小寫字母命名方式。反序列化的時候能夠將下劃線分隔的小寫字母轉換爲駝峯命名的字段名。示例：@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)
@JsonRootName	類註解。需開啓mapper.enable(SerializationFeature.WRAP_ROOT_VALUE)，用於序列化時輸出帶有根屬性名稱的 JSON 串，形式如 {"root_name":{"id":1,"name":"zhangsan"}}。但不支持該 JSON 串反序列化。

使用示例：

// 用於類,指定屬性在序列化時 json 中的順序
@JsonPropertyOrder({"date", "user_name"})
// 批量忽略屬性，不進行序列化
@JsonIgnoreProperties(value = {"other"})
// 用於序列化與反序列化時的駝峯命名與小寫字母命名轉換
@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)
public static class User {
    @JsonIgnore
    private Map<String, Object> other = new HashMap<>();

    // 正常case
    @JsonProperty("user_name")
    private String userName;
    // 空對象case
    private Integer age;
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    // 日期轉換case
    private Date date;
    // 默認值case
    private int height;

    public User() {
    }

    // 反序列化執行構造方法
    @JsonCreator
    public User(@JsonProperty("user_name") String userName) {
        System.out.println("@JsonCreator 註解使得反序列化自動執行該構造方法 " + userName);
        // 反序列化須要手動賦值
        this.userName = userName;
    }

    @JsonAnySetter
    public void set(String key, Object value) {
        other.put(key, value);
    }

    @JsonAnyGetter
    public Map<String, Object> any() {
        return other;
    }
    // 本文默認省略getter、setter方法
}

單元測試：

@Test
public void test3() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    // 造數據
    Map<String, Object> map = new HashMap<>();
    map.put("user_name", "Tom");
    map.put("date", "2020-07-26 19:28:44");
    map.put("age", 100);
    map.put("demoKey", "demoValue");
    String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(map);
    System.out.println(jsonString);
    System.out.println("反序列化");
    User user = mapper.readValue(jsonString, User.class);
    System.out.println(user);
    System.out.println("序列化");
    jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);
    System.out.println(jsonString);
}

打印輸出：

{
  "date" : "2020-07-26 19:28:44",
  "demoKey" : "demoValue",
  "user_name" : "Tom",
  "age" : 100
}
反序列化
@JsonCreator 註解使得反序列化自動執行該構造方法Tom
JackSonTest.User(other={demoKey=demoValue}, userName=Tom, age=100, date=Sun Jul 26 19:28:44 CST 2020, height=0)
序列化
{
  "date" : "2020-07-26 19:28:44",
  "user_name" : "Tom",
  "age" : 100,
  "height" : 0,
  "demoKey" : "demoValue"
}

日期處理

不一樣類型的日期類型，JackSon 的處理方式也不一樣。

普通日期

對於日期類型爲 java.util.Calendar, java.util.GregorianCalendar, java.sql.Date, java.util.Date, java.sql.Timestamp，若不指定格式，在 json 文件中將序列化爲 long 類型的數據。顯然這種默認格式，可讀性差，轉換格式是必要的。

JackSon 有不少方式轉換日期格式。

• 註解方式，使用 @JsonFormat 註解指定日期格式。

• ObjectMapper 方式，調用 ObjectMapper 的方法 setDateFormat，將序列化爲指定格式的 string 類型的數據。

Local日期

對於日期類型爲 java.time.LocalDate, java.time.LocalDateTime，還須要添加代碼 mapper.registerModule(new JavaTimeModule())，同時添加相應的依賴 jar 包。

導入依賴：

<dependency> 
  <groupId>com.fasterxml.jackson.datatype</groupId> 
  <artifactId>jackson-datatype-jsr310</artifactId> 
  <version>2.9.1</version> 
</dependency>

對於 Jackson 2.5 如下版本，須要添加代碼 mapper.registerModule(new JSR310Module ())。

使用示例：

@Data
public static class Student {
    // 正常case
    private String name;
    // 日期轉換case
    private LocalDateTime date;
}

@Test
public void test4() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    // 必須添加對LocalDate的支持
    mapper.registerModule(JavaTimeModule());
    // 造數據
    Student student = new Student();
    student.setName("Tom");
    student.setDate(LocalDateTime.now());
    System.out.println("序列化");
    String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(student);
    System.out.println(jsonString);
    System.out.println("反序列化");
    Student deserializedPerson = mapper.readValue(jsonString, Student.class);
    System.out.println(deserializedPerson);
}

private Module JavaTimeModule() {
    JavaTimeModule module = new JavaTimeModule();
    String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    String DATE_FORMAT = "yyyy-MM-dd";
    String TIME_FORMAT = "HH:mm:ss";
    module.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT)));
    module.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DATE_FORMAT)));
    module.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern((TIME_FORMAT))));
    module.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DATE_TIME_FORMAT)));
    module.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DATE_FORMAT)));
    module.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(TIME_FORMAT)));
    return module;
}

打印輸出：

序列化
{
  "name" : "Tom",
  "date" : "2020-07-26 23:10:42"
}
反序列化
JackSonTest.Student(name=Tom, date=2020-07-26T23:10:42)

Joda日期

對於日期類型爲 org.joda.time.DateTime，還須要添加代碼 mapper.registerModule(new JodaModule())，同時添加相應的依賴 jar 包

<dependency> 
  <groupId>com.fasterxml.jackson.datatype</groupId>
  <artifactId>jackson-datatype-joda</artifactId> 
  <version>2.9.1</version> 
</dependency>

對象集合

Jackson 對泛型反序列化也提供很好的支持。

List

對於 List 類型 ，能夠調用 constructCollectionType 方法來序列化，也能夠構造 TypeReference 來序列化。

使用示例：

@Test
public void test5() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    CollectionType javaType = mapper.getTypeFactory().constructCollectionType(List.class, Person.class);
    // 造數據
    List<Person> list = new ArrayList<>();
    for (int i = 0; i < 3; i++) {
        Person person = new Person();
        person.setName("Tom");
        person.setAge(new Random().nextInt(100));
        person.setDate(new Date());
        list.add(person);
    }
    System.out.println("序列化");
    String jsonInString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(list);
    System.out.println(jsonInString);
    System.out.println("反序列化：使用 javaType");
    List<Person> personList = mapper.readValue(jsonInString, javaType);
    System.out.println(personList);
    System.out.println("反序列化：使用 TypeReference");
    List<Person> personList2 = mapper.readValue(jsonInString, new TypeReference<List<Person>>() {
    });
    System.out.println(personList2);
}

打印輸出：

序列化
[ {
  "name" : "Tom",
  "age" : 33,
  "date" : 1595778639371,
  "height" : 0
}, {
  "name" : "Tom",
  "age" : 3,
  "date" : 1595778639371,
  "height" : 0
}, {
  "name" : "Tom",
  "age" : 36,
  "date" : 1595778639371,
  "height" : 0
} ]
反序列化：使用 javaType
[JackSonTest.Person(name=Tom, age=33, date=Sun Jul 26 23:50:39 CST 2020, height=0), JackSonTest.Person(name=Tom, age=3, date=Sun Jul 26 23:50:39 CST 2020, height=0), JackSonTest.Person(name=Tom, age=36, date=Sun Jul 26 23:50:39 CST 2020, height=0)]
反序列化：使用 TypeReference
[JackSonTest.Person(name=Tom, age=33, date=Sun Jul 26 23:50:39 CST 2020, height=0), JackSonTest.Person(name=Tom, age=3, date=Sun Jul 26 23:50:39 CST 2020, height=0), JackSonTest.Person(name=Tom, age=36, date=Sun Jul 26 23:50:39 CST 2020, height=0)]

Map

對於 map 類型， 與 List 的實現方式類似。

使用示例：

@Test
public void test6() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    //第二參數是 map 的 key 的類型，第三參數是 map 的 value 的類型
    MapType javaType = mapper.getTypeFactory().constructMapType(HashMap.class, String.class, Person.class);
    // 造數據
    Map<String, Person> map = new HashMap<>();
    for (int i = 0; i < 3; i++) {
        Person person = new Person();
        person.setName("Tom");
        person.setAge(new Random().nextInt(100));
        person.setDate(new Date());
        map.put("key" + i, person);
    }
    System.out.println("序列化");
    String jsonInString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(map);
    System.out.println(jsonInString);
    System.out.println("反序列化: 使用 javaType");
    Map<String, Person> personMap = mapper.readValue(jsonInString, javaType);
    System.out.println(personMap);
    System.out.println("反序列化: 使用 TypeReference");
    Map<String, Person> personMap2 = mapper.readValue(jsonInString, new TypeReference<Map<String, Person>>() {
    });
    System.out.println(personMap2);
}

打印輸出：

序列化
{
  "key1" : {
    "name" : "Tom",
    "age" : 95,
    "date" : 1595778740606,
    "height" : 0
  },
  "key2" : {
    "name" : "Tom",
    "age" : 27,
    "date" : 1595778740606,
    "height" : 0
  },
  "key0" : {
    "name" : "Tom",
    "age" : 98,
    "date" : 1595778740606,
    "height" : 0
  }
}
反序列化: 使用 javaType
{key1=JackSonTest.Person(name=Tom, age=95, date=Sun Jul 26 23:52:20 CST 2020, height=0), key2=JackSonTest.Person(name=Tom, age=27, date=Sun Jul 26 23:52:20 CST 2020, height=0), key0=JackSonTest.Person(name=Tom, age=98, date=Sun Jul 26 23:52:20 CST 2020, height=0)}
反序列化: 使用 TypeReference
{key1=JackSonTest.Person(name=Tom, age=95, date=Sun Jul 26 23:52:20 CST 2020, height=0), key2=JackSonTest.Person(name=Tom, age=27, date=Sun Jul 26 23:52:20 CST 2020, height=0), key0=JackSonTest.Person(name=Tom, age=98, date=Sun Jul 26 23:52:20 CST 2020, height=0)}

Array 和 Collection 的處理與 List，Map 類似，這裏再也不詳述。

屬性可視化

JackSon 默認不是全部的屬性均可以被序列化和反序列化。默認的屬性可視化的規則以下：

• 若該屬性修飾符是 public，該屬性可序列化和反序列化。
• 若屬性的修飾符不是 public，可是它的 getter 方法和 setter 方法是 public，該屬性可序列化和反序列化。由於 getter 方法用於序列化， 而 setter 方法用於反序列化。
• 若屬性只有 public 的 setter 方法，而無 public 的 getter 方 法，該屬性只能用於反序列化。

若想更改默認的屬性可視化的規則，須要調用 ObjectMapper 的方法 setVisibility。

下面的示例使修飾符爲 protected 的屬性 name 也能夠序列化和反序列化。

public static class People {
    public int age;
    protected String name;
}

@Test
public void test7() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    // PropertyAccessor 支持的類型有 ALL,CREATOR,FIELD,GETTER,IS_GETTER,NONE,SETTER
    // Visibility 支持的類型有 ANY,DEFAULT,NON_PRIVATE,NONE,PROTECTED_AND_PUBLIC,PUBLIC_ONLY
    mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
    // 造數據
    People people = new People();
    people.name = "Tom";
    people.age = 40;
    System.out.println("序列化");
    String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(people);
    System.out.println(jsonString);
    System.out.println("反序列化");
    People deserializedPerson = mapper.readValue(jsonString, People.class);
    System.out.println(deserializedPerson);
}

打印輸出：

序列化
{
  "age" : 40,
  "name" : "Tom"
}
反序列化
JackSonTest.People(age=40, name=Tom)

屬性過濾

在將 Java 對象序列化爲 json 時 ，有些屬性須要過濾掉，不顯示在 json 中 ，除了使用 @JsonIgnore 過濾單個屬性或用 @JsonIgnoreProperties 過濾多個屬性以外， Jackson 還有經過代碼控制的方式。

使用示例：

@JsonFilter("myFilter")
public interface MyFilter {
}

@Test
public void test8() throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    //設置 addMixIn
    mapper.addMixIn(Person.class, MyFilter.class);
    //調用 SimpleBeanPropertyFilter 的 serializeAllExcept 方法
    SimpleBeanPropertyFilter newFilter = SimpleBeanPropertyFilter.serializeAllExcept("age");
    //或重寫 SimpleBeanPropertyFilter 的 serializeAsField 方法
    SimpleBeanPropertyFilter newFilter2 = new SimpleBeanPropertyFilter() {
        @Override
        public void serializeAsField(Object pojo, JsonGenerator jgen,
                                     SerializerProvider provider, PropertyWriter writer)
                throws Exception {
            if (!writer.getName().equals("age")) {
                writer.serializeAsField(pojo, jgen, provider);
            }
        }
    };
    //設置 FilterProvider
    FilterProvider filterProvider = new SimpleFilterProvider().addFilter("myFilter", newFilter);
    // 造數據
    Person person = new Person();
    person.setName("Tom");
    person.setAge(40); // 該屬性將被忽略
    person.setDate(new Date());
    // 序列化
    String jsonString = mapper.setFilterProvider(filterProvider).writeValueAsString(person);
    System.out.println(jsonString);
}

打印輸出：

{"name":"Tom","date":1595780842754}

自定義序列化類

當 Jackson 默認序列化和反序列化的類不能知足實際須要，能夠自定義新的序列化和反序列化的類。

自定義序列化類：自定義的序列化類須要直接或間接繼承 StdSerializer 或 JsonSerializer，同時須要利用 JsonGenerator 生成 json，重寫方法 serialize，示例以下：

public static class CustomSerializer extends StdSerializer<Person> {
    protected CustomSerializer() {
        super(Person.class);
    }

    @Override
    public void serialize(Person person, JsonGenerator jgen, SerializerProvider provider) throws IOException {
        jgen.writeStartObject();
        jgen.writeNumberField("age", person.getAge());
        jgen.writeStringField("name", person.getName());
        jgen.writeStringField("msg", "已被自定義序列化");
        jgen.writeEndObject();
    }
}

JsonGenerator 有多種 write 方法以支持生成複雜的類型的 json，好比 writeArray，writeTree 等 。若想單首創建 JsonGenerator，能夠經過 JsonFactory() 的 createGenerator。

自定義反序列化類：自定義的反序列化類須要直接或間接繼承 StdDeserializer 或 StdDeserializer，同時須要利用 JsonParser 讀取 json，重寫方法 deserialize，示例以下：

public static class CustomDeserializer extends StdDeserializer<Person> {
    protected CustomDeserializer() {
        super(Person.class);
    }

    @Override
    public Person deserialize(JsonParser jp, DeserializationContext ctxt)
            throws IOException, JsonProcessingException {
        JsonNode node = jp.getCodec().readTree(jp);
        Person person = new Person();
        int age = (Integer) ((IntNode) node.get("age")).numberValue();
        String name = node.get("name").asText();
        person.setAge(age);
        person.setName(name);
        return person;
    }
}

JsonParser 提供不少方法來讀取 json 信息， 如 isClosed(), nextToken(), getValueAsString()等。若想單首創建 JsonParser，能夠經過 JsonFactory() 的 createParser。

定義好自定義序列化類和自定義反序列化類，若想在程序中調用它們，還須要註冊到 ObjectMapper 的 Module，示例以下：

@Test
public void test9() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    // 生成 module
    SimpleModule module = new SimpleModule("myModule");
    module.addSerializer(new CustomSerializer());
    module.addDeserializer(Person.class, new CustomDeserializer());
    // 註冊 module
    mapper.registerModule(module);
    // 造數據
    Person person = new Person();
    person.setName("Tom");
    person.setAge(40);
    person.setDate(new Date());
    System.out.println("序列化");
    String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(person);
    System.out.println(jsonString);
    System.out.println("反序列化");
    Person deserializedPerson = mapper.readValue(jsonString, Person.class);
    System.out.println(deserializedPerson);
}

或者也可經過註解方式加在 java 對象的屬性，方法或類上面來調用它們：

• @JsonSerialize(using = CustomSerializer.class)
• @JsonDeserialize(using = CustomDeserializer.class)

樹模型處理

Jackson 也提供了樹模型(tree model)來生成和解析 json。若想修改或訪問 json 部分屬性，樹模型是不錯的選擇。樹模型由 JsonNode 節點組成。程序中經常使用 ObjectNode，ObjectNode 繼承於 JsonNode，示例以下：

@Test
public void test10() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    //構建 ObjectNode
    ObjectNode personNode = mapper.createObjectNode();
    //添加/更改屬性
    personNode.put("name", "Tom");
    personNode.put("age", 40);
    ObjectNode addressNode = mapper.createObjectNode();
    addressNode.put("zip", "000000");
    addressNode.put("street", "Road NanJing");
    //設置子節點
    personNode.set("address", addressNode);
    System.out.println("構建 ObjectNode:\n" + personNode.toString());
    //經過 path 查找節點
    JsonNode searchNode = personNode.path("name");
    System.out.println("查找子節點 name:\n" + searchNode.asText());
    //刪除屬性
    ((ObjectNode) personNode).remove("address");
    System.out.println("刪除後的 ObjectNode:\n" + personNode.toString());
    //讀取 json
    JsonNode rootNode = mapper.readTree(personNode.toString());
    System.out.println("Json 轉 JsonNode:\n" + rootNode);
    //JsonNode 轉換成 java 對象
    Person person = mapper.treeToValue(personNode, Person.class);
    System.out.println("JsonNode 轉對象:\n" + person);
    //java 對象轉換成 JsonNode
    JsonNode node = mapper.valueToTree(person);
    System.out.println("對象轉 JsonNode:\n" + node);
}

打印輸出：

構建 ObjectNode:
{"name":"Tom","age":40,"address":{"zip":"000000","street":"Road NanJing"}}
查找子節點 name:
Tom
刪除後的 ObjectNode:
{"name":"Tom","age":40}
Json 轉 JsonNode:
{"name":"Tom","age":40}
JsonNode 轉對象:
JackSonTest.Person(name=Tom, age=40, date=null, height=0)
對象轉 JsonNode:
{"name":"Tom","age":40,"date":null,"height":0}

---

做者：薛勤，互聯網從業者，編程愛好者。

本文首發自公衆號：代碼藝術（ID: onblog）未經許可, 禁止轉載

本文分享自微信公衆號 - 代碼藝術（onblog）。
若有侵權，請聯繫 support@oschina.cn 刪除。
本文參與「OSC源創計劃」，歡迎正在閱讀的你也加入，一塊兒分享。