Jackson：我是最牛掰的 Java JSON 解析器（有點虛）
在當今的編程世界裏，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方法，將字符串反序列化為 Java 對象valueType) readValue(byte[] src, Class方法，將位元組數組反序列化為 Java 對象valueType) readValue(File src, Class方法，將文件反序列化為 Java 對象valueType)
來看一下將字符串反序列化為 Java 對象的代碼示例：
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 {
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;
/**
* 微信搜索「沉默王二」，回復 Java
*
* @author 沉默王二
* @date 2020/11/26
*/
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;
/**
* 微信搜索「沉默王二」，回復 Java
*
* @author 沉默王二
* @date 2020/11/26
*/
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，示例如下：
/**
* 微信搜索「沉默王二」，回復 Java
*
* @author 沉默王二
* @date 2020/11/26
*/
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 了，我們下篇文章見。
PS：如果你恰好需要一份 Java 精進路線的話，我這裡有一份，我差不多花了 3 天的時間整理的，還挺受歡迎的，已經 2000 多贊了，每個階段都很詳細。
如果你恰好需要的話，可以點擊上面的鏈接看一看，希望能給你一點點幫助（加油）。
