在當今的編程世界里，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 的依賴。

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

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) 方法，將對象存儲成文件

來看一下存儲成字符串的代碼示例：

import com.fasterxml.jackson.core.JsonProcessingException; 
import com.fasterxml.jackson.databind.ObjectMapper; 
 
/** 
 * 微信搜索「沉默王二」，回復 Java 
 * 
 * @author 沉默王二 
 * @date 2020/11/26 
 */ 
public class Demo { 
    public static void main(String[] args) throws JsonProcessingException { 
        Writer wanger = new Writer("沉默王二", 18); 
        ObjectMapper mapper = new ObjectMapper(); 
        String jsonString = mapper.writerWithDefaultPrettyPrinter() 
                .writeValueAsString(wanger); 
        System.out.println(jsonString); 
    } 
} 
 
class Writer { 
    private String name; 
    private int age; 
 
    public Writer(String name, int age) { 
        this.name = name; 
        this.age = age; 
    } 
 
    public String getName() { 
        return name; 
    } 
 
    public void setName(String name) { 
        this.name = name; 
    } 
 
    public int getAge() { 
        return age; 
    } 
 
    public void setAge(int age) { 
        this.age = age; 
    } 
} 

程序輸出結果如下所示：

{ 
  "name" : "沉默王二", 
  "age" : 18 
} 

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

• 如果字段的修飾符是 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 對象的代碼示例：

import com.fasterxml.jackson.core.JsonProcessingException; 
import com.fasterxml.jackson.databind.ObjectMapper; 
 
public class Demo { 
    public static void main(String[] args) throws JsonProcessingException { 
        ObjectMapper mapper = new ObjectMapper(); 
        String jsonString = "{\n" + 
                "  \"name\" : \"沉默王二\",\n" + 
                "  \"age\" : 18\n" + 
                "}"; 
        Writer deserializedWriter = mapper.readValue(jsonString, Writer.class); 
        System.out.println(deserializedWriter); 
    } 
} 
 
class Writer{ 
    private String name; 
    private int age; 
 
    // getter/setter 
 
    @Override 
    public String toString() { 
        return "Writer{" + 
                "name='" + name + '\'' + 
                ", age=" + age + 
                '}'; 
    } 
} 

程序輸出結果如下所示：

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

PS：如果反序列化的對象有帶參的構造方法，它必須有一個空的默認構造方法，否則將會拋出 InvalidDefinitionException 一行。

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) 
 at [Source: (String)"{ 
  "name" : "沉默王二", 
  "age" : 18 
}"; line: 2, column: 3] 
 at com.fasterxml.jackson.databind.exc.InvalidDefinitionException.from(InvalidDefinitionException.java:67) 
 at com.fasterxml.jackson.databind.DeserializationContext.reportBadDefinition(DeserializationContext.java:1589) 
 at com.fasterxml.jackson.databind.DeserializationContext.handleMissingInstantiator(DeserializationContext.java:1055) 
 at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.deserializeFromObjectUsingNonDefault(BeanDeserializerBase.java:1297) 
 at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserializeFromObject(BeanDeserializer.java:326) 
 at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserialize(BeanDeserializer.java:159) 
 at com.fasterxml.jackson.databind.ObjectMapper._readMapAndClose(ObjectMapper.java:4202) 
 at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:3205) 
 at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:3173) 
 at com.itwanger.jackson.Demo.main(Demo.java:19) 

Jackson 最常用的 API 就是基于”對象綁定” 的 ObjectMapper，

ObjectMapper 也可以將 JSON 解析為基于“樹模型”的 JsonNode 對象，來看下面的示例。

import com.fasterxml.jackson.core.JsonProcessingException; 
import com.fasterxml.jackson.databind.JsonNode; 
import com.fasterxml.jackson.databind.ObjectMapper; 
 
public class JsonNodeDemo { 
    public static void main(String[] args) throws JsonProcessingException { 
        ObjectMapper mapper = new ObjectMapper(); 
        String json = "{ \"name\" : \"沉默王二\", \"age\" : 18 }"; 
        JsonNode jsonNode = mapper.readTree(json); 
        String name = jsonNode.get("name").asText(); 
        System.out.println(name); // 沉默王二 
    } 
} 

借助 TypeReference 可以將 JSON 字符串數組轉成泛型 List，來看下面的示例：

import com.fasterxml.jackson.core.JsonProcessingException; 
import com.fasterxml.jackson.core.type.TypeReference; 
import com.fasterxml.jackson.databind.ObjectMapper; 
 
import java.util.List; 
 
public class TypeReferenceDemo { 
    public static void main(String[] args) throws JsonProcessingException { 
        ObjectMapper mapper = new ObjectMapper(); 
        String json = "[{ \"name\" : \"沉默王三\", \"age\" : 18 }, { \"name\" : \"沉默王二\", \"age\" : 19 }]"; 
        List<Author> listAuthor = mapper.readValue(json, new TypeReference<List<Author>>(){}); 
        System.out.println(listAuthor); 
    } 
} 
class Author{ 
    private String name; 
    private int age; 
 
    // getter/setter 
 
    // toString 
} 

03、更高級的配置

Jackson 之所以牛掰的一個很重要的因素是可以實現高度靈活的自定義配置。

在實際的應用場景中，JSON 中常常會有一些 Java 對象中沒有的字段，這時候，如果直接解析的話，會拋出 UnrecognizedPropertyException 異常。

下面是一串 JSON 字符串：

String jsonString = "{\n" + 
                "  \"name\" : \"沉默王二\",\n" + 
                "  \"age\" : 18\n" + 
                "  \"sex\" : \"男\",\n" + 
                "}"; 

但 Java 對象 Writer 中沒有定義 sex 字段：

class Writer{ 
    private String name; 
    private int age; 
 
    // getter/setter 
} 

我們來嘗試解析一下：

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

不出意外，拋出異常了，sex 無法識別。

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"]) 
 at [Source: (String)"{ 
  "name" : "沉默王二", 
  "age" : 18, 
  "sex" : "男" 
}"; line: 4, column: 12] (through reference chain: com.itwanger.jackson.Writer["sex"]) 

怎么辦呢?可以通過 configure() 方法忽略掉這些“無法識別”的字段。

mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); 

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

// 在序列化時忽略值為 null 的屬性 
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); 
// 忽略值為默認值的屬性 
mapper.setDefaultPropertyInclusion(JsonInclude.Include.NON_DEFAULT); 

04、處理日期格式

對于日期類型的字段，比如說 java.util.Date，如果不指定格式，序列化后將顯示為 long 類型的數據，這種默認格式的可讀性很差。

{ 
  "age" : 18, 
  "birthday" : 1606358621209 
} 

怎么辦呢?

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

private Date birthday; 
 
// GMT+8 是指格林尼治的標準時間，在加上八個小時表示你現在所在時區的時間 
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss") 
public Date getBirthday() { 
    return birthday; 
} 
 
public void setBirthday(Date birthday) { 
    this.birthday = birthday; 
} 

再來看一下結果：

{ 
  "age" : 18, 
  "birthday" : "2020-11-26 03:02:30" 
} 

具體代碼如下所示：

ObjectMapper mapper = new ObjectMapper(); 
Writer wanger = new Writer("沉默王二", 18); 
wanger.setBirthday(new Date()); 
String jsonString = mapper.writerWithDefaultPrettyPrinter() 
                .writeValueAsString(wanger); 
System.out.println(jsonString); 

第二種方案，調用 ObjectMapper 的 setDateFormat() 方法。

ObjectMapper mapper = new ObjectMapper(); 
mapper.setDateFormat(StdDateFormat.getDateTimeInstance()); 
Writer wanger = new Writer("沉默王二", 18); 
wanger.setBirthday(new Date()); 
String jsonString = mapper.writerWithDefaultPrettyPrinter() 
                .writeValueAsString(wanger); 
System.out.println(jsonString); 

輸出結果如下所示：

{ 
  "name" : "沉默王二", 
  "age" : 18, 
  "birthday" : "2020年11月26日 上午11:09:51" 
} 

05、字段過濾

在將 Java 對象序列化為 JSON 時，可能有些字段需要過濾，不顯示在 JSON 中，Jackson 有一種比較簡單的實現方式。

@JsonIgnore 用于過濾單個字段。

@JsonIgnore 
public String getName() { 
    return name; 
} 

@JsonIgnoreProperties 用于過濾多個字段。

@JsonIgnoreProperties(value = { "age","birthday" }) 
class Writer{ 
    private String name; 
    private int age; 
    private Date birthday; 
} 

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

當 Jackson 默認序列化和反序列化不能滿足實際的開發需要時，可以自定義新的序列化和反序列化類。

自定義的序列化類需要繼承 StdSerializer，同時重寫 serialize() 方法，利用 JsonGenerator 生成 JSON，示例如下：

public class CustomSerializer extends StdSerializer<Man> { 
    protected CustomSerializer(Class<Man> t) { 
        super(t); 
    } 
 
    public CustomSerializer() { 
        this(null); 
    } 
 
    @Override 
    public void serialize(Man value, JsonGenerator gen, SerializerProvider provider) throws IOException { 
        gen.writeStartObject(); 
        gen.writeStringField("name", value.getName()); 
        gen.writeEndObject(); 
    } 
} 
 
class Man{ 
    private int age; 
    private String name; 
 
    public Man(int age, String name) { 
        this.age = age; 
        this.name = name; 
    } 
 
    public int getAge() { 
        return age; 
    } 
 
    public void setAge(int age) { 
        this.age = age; 
    } 
 
    public String getName() { 
        return name; 
    } 
 
    public void setName(String name) { 
        this.name = name; 
    } 
} 

定義好自定義序列化類后，要想在程序中調用它們，需要將其注冊到 ObjectMapper 的 Module 中，示例如下所示：

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

程序輸出結果如下所示：

{"name":"沉默王二"} 

自定義序列化類 CustomSerializer 中沒有添加 age 字段，所以只輸出了 name 字段。

再來看一下自定義的反序列化類，繼承 StdDeserializer，同時重寫 deserialize() 方法，利用 JsonGenerator 讀取 JSON，示例如下：

public class CustomDeserializer extends StdDeserializer<Woman> { 
    protected CustomDeserializer(Class<?> vc) { 
        super(vc); 
    } 
 
    public CustomDeserializer() { 
        this(null); 
    } 
 
    @Override 
    public Woman deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException { 
        JsonNode node = p.getCodec().readTree(p); 
        Woman woman = new Woman(); 
        int age = (Integer) ((IntNode) node.get("age")).numberValue(); 
        String name = node.get("name").asText(); 
        woman.setAge(age); 
        woman.setName(name); 
        return woman; 
    } 
} 
class Woman{ 
    private int age; 
    private String name; 
 
    public Woman() { 
    } 
 
    // getter/setter 
 
    @Override 
    public String toString() { 
        return "Woman{" + 
                "age=" + age + 
                ", name='" + name + '\'' + 
                '}'; 
    } 
} 

通過 JsonNode 把 JSON 讀取到一個樹形結構中，然后通過 JsonNode 的 get 方法將對應字段讀取出來，然后生成新的 Java 對象，并返回。

定義好自定義反序列化類后，要想在程序中調用它們，同樣需要將其注冊到 ObjectMapper 的 Module 中，示例如下所示：

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

程序輸出結果如下所示：

Woman{age=18, name='三妹'} 

07、結語

哎呀，好像不錯哦，Jackson 絕對配得上“最牛掰”這三個字。如果只想簡單的序列化和反序列化，使用 ObjectMapper 的 write 和 read 方法即可。

如果還想更進一步的話，就需要對 ObjectMapper 進行一些自定義配置，或者加一些注解，以及直接自定義序列化和反序列化類，更貼近一些 Java 對象。

需要注意的是，對日期格式的字段要多加小心，盡量不要使用默認配置，可讀性很差。

好了，通過這篇文章的系統化介紹，相信讀者朋友們已經完全摸透 Jackson 了，我們下篇文章見。

本文轉載自微信公眾號「沉默王二」，可以通過以下二維碼關注。轉載本文請聯系沉默王二公眾號。