【淺度渣文】Jackson之jackson-databind

原文連接：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();
// 一、輸入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();
// 二、把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組件。