【淺度渣文】Jackson之jackson-databind

摘要： 原文連結：http://www.dubby.cn/detail.html?id=9070 前幾篇介紹Jackson的文章（Jackson介紹，Jackson之jackson-core ），雖然很好，但是我相信你並願意在專案中使用，因為使用起來很複雜，...

ofollow,noindex">原文連結：http://www.dubby.cn/detail.html?id=9070

前幾篇介紹Jackson的文章（Jackson介紹，Jackson之jackson-core ），雖然很好，但是我相信你並願意在專案中使用，因為使用起來很複雜，也許這也是很多人願意使用Fastjson的原因吧。為什麼會感覺這麼複雜呢，因為jackson-core提供的是很低階的API，我們可以充分的瞭解細節，但是代價就是操作起來更復雜。

這篇文章介紹使用高階的API，讓你看到Jackson也可以這麼的簡單，容易。

Maven依賴

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.2</version>
</dependency>
複製程式碼

因為jackson-databind依賴core和annotations，所以在這裡需要依賴這三個jar。

POJO和JSON之間的轉化

給出一個足夠簡單的POJO:

public class MyValue {
public String name;
public int age;
}
複製程式碼

注意:如果使用getters/setters的話，可以用private/protected修飾屬性，這裡直接用public修飾了，就不需要getters/setters了。

使用databind ，我們需要一個最基礎的物件com.fasterxml.jackson.databind.ObjectMapper ，這裡我們構造一個:

ObjectMapper mapper = new ObjectMapper(); 
複製程式碼

注意:這個mapper是可以複用的，就好比HttpClient一樣。

簡單的把JSON反序列化成Object的用法如下:

MyValue value = mapper.readValue(new File("data.json"), MyValue.class);
// or:
value = mapper.readValue(new URL("http://www.dubby.cn/api/entry.json"), MyValue.class);
// or:
value = mapper.readValue("{\"name\":\"Bob\", \"age\":13}", MyValue.class);
複製程式碼

簡單的把Object序列化成JSON的用法如下:

mapper.writeValue(new File("result.json"), myResultObject);
// or:
byte[] jsonBytes = mapper.writeValueAsBytes(myResultObject);
// or:
String jsonString = mapper.writeValueAsString(myResultObject);
複製程式碼

其實到這一步，對於很多讀者來說已經足夠了。因為大部分時候我們要的就是這些。但是不妨繼續看下去，還有一些你可能會用到的。

集合、樹

如果你使用的不是簡單的POJO，而是List ,Map :

Map<String, Integer> scoreByName = mapper.readValue(jsonSource, Map.class);
List<String> names = mapper.readValue(jsonSource, List.class);

mapper.writeValue(new File("names.json"), names);
複製程式碼

如果你反序列化的更復雜，你可以指定型別:

Map<String, ResultValue> results = mapper.readValue(jsonSource, new TypeReference<Map<String, ResultValue>>() { } );
複製程式碼

思考:為什麼需要指定型別？(型別擦除)

注意:序列化的時候不需要指定，只有反序列化的時候需要。

雖然看起來處理的很方便，但是某些時候會有一些很麻煩的情況，這時候可以考慮使用樹模型 :

//如果結果可能是Object或者是Array，那可以使用JsonNode;
//如果你知道是Object，你可以直接強轉成ObjectNode;如果你知道是Array，你可以直接強轉成ArrayNode;
ObjectNode root = (ObjectNode) mapper.readTree("stuff.json");
String name = root.get("name").asText();
int age = root.get("age").asInt();

// 還可以修改這個樹，然後再輸出成json字串
root.with("other").put("type", "student");
String json = mapper.writeValueAsString(root);

// with above, we end up with something like as 'json' String:
// {
//"name" : "Bob", "age" : 13,
//"other" : {
//"type" : "student"
//}
// }
複製程式碼

上面的例子中的JSON如下:

{
"name" : "Bob", "age" : 13,
"other" : {
"type" : "student"
}
}
複製程式碼

如果 json 型別太過動態，不適合反序列化成物件的時候，樹模型比資料繫結更合適。

流式解析器、生成器

看完上面的介紹，我想你應該相當滿意ObjectMapper 的能力了，但是如果你希望控制底層的一些細節，或者對效能有更高的要求，你可以通過ObjectMapper 來設定。建議你先看看Jackson之jackson-core :

JsonFactory f = mapper.getFactory();
// 1、輸入JSON字串
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
JsonGenerator g = f.createGenerator(outputStream);
// 輸出JSON: { "message" : "Hello world!" }
g.writeStartObject();
g.writeStringField("message", "Hello world!");
g.writeEndObject();
g.close();
// 2、把JSON字串反序列化
JsonParser p = f.createParser(outputStream.toString());
JsonToken t = p.nextToken(); // Should be JsonToken.START_OBJECT
t = p.nextToken(); // JsonToken.FIELD_NAME
if ((t != JsonToken.FIELD_NAME) || !"message".equals(p.getCurrentName())) {
// handle error
}
t = p.nextToken();
if (t != JsonToken.VALUE_STRING) {
// similarly
}
String msg = p.getText();
System.out.printf("My message to you is: %s!\n", msg);
p.close();
複製程式碼

你也可以直接構造JsonFactory ，然後作為構造引數傳給ObjectMapper 。

配置

有兩個方面的配置，特性 和註解 。

特性配置

給出一個簡單的使用特性配置的例子，先給出序列化配置:

// 設定序列化成漂亮的JSON，而不是壓縮的字串
mapper.enable(SerializationFeature.INDENT_OUTPUT);
// 如果你要序列化的物件沒有欄位(很搞笑吧)，會拋異常，可以設定這個來避免異常，直接序列化成`{}`
mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
// 預設Date會序列化成時間戳，可以設定這個來序列化成`date":"2017-12-09T12:50:13.000+0000`這個樣子
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
複製程式碼

反序列化配置的例子:

// 預設，如果反序列化時，JSON字串裡有欄位，而POJO中沒有定義，會拋異常，可以設定這個來忽略未定義的欄位
mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
// 預設如果是字串("")，反序列化會失敗，可以開啟這個設定，字串("")會被反序列化成(null)
mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
複製程式碼

除此之外，還可以針對序列化和反序列化的底層細節指定一些配置，先給出parsing的配置:

// 預設如果JSON中有C/C++風格的註釋，在反序列化的時候會報錯，可以指定這個配置來忽略C/C++風格的註釋
mapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
//預設JSON字串如果欄位名沒有用雙引號包裹，回報錯，可以設定這個來支援這種非正規的JSON(JS支援這種非正規的JSON)
mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
// 預設如果JSON中是用的單引號包裹欄位和值，反序列化時會報錯，可以設定這個來相容單引號這種非正規的JSON
mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
複製程式碼

再給出generation的配置:

// 把非ASCII轉義成ASCII值，如(楊正)會被轉義成(\u6768\u6B63)
mapper.configure(JsonGenerator.Feature.ESCAPE_NON_ASCII, true);
複製程式碼

註解配置

改變欄位名

註解@JsonProperty :

public class MyBean {
private String _name;

// 預設是`theName`，現在改為`name`
@JsonProperty("name")
public String getTheName() { return _name; }

// 只需要修飾getter或者setter其中的一個就可以了，這裡可以省略不寫
public void setTheName(String n) { _name = n; }
}
複製程式碼

忽略欄位

@JsonIgnore 可以忽略單個欄位，@JsonIgnoreProperties 可以加在類定義上:

// 序列化和反序列化時，直接忽略JSON中的foo和bar欄位
@JsonIgnoreProperties({ "foo", "bar" })
public class MyBean
{
// 序列化和反序列化時，直接忽略JSON中的internal欄位
@JsonIgnore
public String internal;

// 正常欄位
public String external;

@JsonIgnore
public void setCode(int c) { _code = c; }

// 雖然這裡沒有修飾，但是setter被修飾了，所以也會被忽略
public int getCode() { return _code; }
}
複製程式碼

從上面我們可以看出，註解在欄位名、setter和getter上都是一樣的，修飾任何一個都會直接忽略這個欄位，但是我們可以值忽略反序列化，而不忽略序列化，或者反之:

public class ReadButDontWriteProps {
private String _name;
@JsonProperty public void setName(String n) { _name = n; }
@JsonIgnore public String getName() { return _name; }
}
複製程式碼

這裡使用@JsonProperty 保證，雖然序列化是name會被忽略，但是從JSON中反序列化時，可以正常接收這個欄位。

自定義構造方法

和其他資料繫結工具不一樣，Jackson不會強制要求你的POJO必須有個預設構造方法(無參構造方法)。你可以指定一個構造方法來接收反序列化的欄位值:

public class CtorBean
{
public final String name;
public final int age;

@JsonCreator
private CtorBean(@JsonProperty("name") String name,
@JsonProperty("age") int age)
{
this.name = name;
this.age = age;
}
}
複製程式碼

構造方法可以是public,private或者任何其他修飾符修飾

對於一些不可改變的物件，這個會很有用，除了構造方法，@JsonCreator 這個註解還可以定義一個工廠方法:

public class FactoryBean
{
// fields etc omitted for brewity

@JsonCreator
public static FactoryBean create(@JsonProperty("name") String name) {
// construct and return an instance
}
}
複製程式碼

注意:構造方法(@JsonCreator 和@JsonProperty )和setter不互斥，你可以混合使用。

填充、轉換

Jackson還有一個很有意思的功能，雖然沒有廣泛的被人所知道。那就是POJO和POJO之間的轉換。概念性的可以理解成POJO1->JSON->POJO2，但是實際上會省略中間這一步，不會真正的生成JSON，而會用其他更高效的實現:

ResultType result = mapper.convertValue(sourceObject, ResultType.class);
複製程式碼

還有其他用法:

// List<Integer> -> int[]
List<Integer> sourceList = ...;
int[] ints = mapper.convertValue(sourceList, int[].class);
// POJO -> Map
Map<String,Object> propertyMap = mapper.convertValue(pojoValue, Map.class);
// Map -> POJO
PojoType pojo = mapper.convertValue(propertyMap, PojoType.class);
// decode Base64! (default byte[] representation is base64-encoded String)
複製程式碼

甚至還可以解碼base64碼:

//解碼
String base64 = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz";
byte[] binary = mapper.convertValue(base64, byte[].class);
System.out.println(new String(binary));
//編碼
String str = "Man is distinguished, not only by his reason, but by this";
String base = mapper.convertValue(str.getBytes(), String.class);
System.out.println(base);
複製程式碼

所以，Jackson甚至強大到可以代替Apache Commons元件。