Jackson 框架的高階應用

時間 2019-11-10

標籤 jackson 框架高階應用简体版

原文原文鏈接

　　Jackson 是當前用的比較普遍的，用來序列化和反序列化 json 的 Java 的開源框架。Jackson 社區相對比較活躍，更新速度也比較快，從 Github 中的統計來看，Jackson 是最流行的 json 解析器之一。 Spring MVC 的默認 json 解析器即是 Jackson。 Jackson 優勢不少。 Jackson 所依賴的 jar 包較少，簡單易用。與其餘 Java 的 json 的框架 Gson 等相比， Jackson 解析大的 json 文件速度比較快；Jackson 運行時佔用內存比較低，性能比較好；Jackson 有靈活的 API，能夠很容易進行擴展和定製。 html

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

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

jackson-core，核心包，提供基於"流模式"解析的相關 API，它包括 JsonPaser 和 JsonGenerator。 Jackson 內部實現正是經過高性能的流模式 API 的 JsonGenerator 和 JsonParser 來生成和解析 json。
jackson-annotations，註解包，提供標準註解功能；
jackson-databind ，數據綁定包，提供基於"對象綁定" 解析的相關 API （ ObjectMapper ）和"樹模型" 解析的相關 API （JsonNode）；基於"對象綁定" 解析的 API 和"樹模型"解析的 API 依賴基於"流模式"解析的 API。

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

Jackson 的基本用法

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

清單 1.在 pom.xml 的 Jackson 的配置信息

<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。 app

ObjectMapper 的使用

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

清單 2 . ObjectMapper 使用示例

ObjectMapper mapper = new ObjectMapper();
Person person = new Person();
person.setName("Tom");
person.setAge(40);
String jsonString = mapper.writerWithDefaultPrettyPrinter()
.writeValueAsString(person);
Person deserializedPerson = mapper.readValue(jsonString, Person.class);

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

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

信息配置

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

清單 3 . 配置信息使用示例

//在反序列化時忽略在 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)
//在序列化時忽略值爲 null 的屬性
mapper.setSerializationInclusion(Include.NON_NULL);
//忽略值爲默認值的屬性
mapper.setDefaultPropertyInclusion(Include.NON_DEFAULT);

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

Jackson 的註解的使用

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

表 1. Jackson 的經常使用註解

註解	用法
@JsonProperty	用於屬性，把屬性的名稱序列化時轉換爲另一個名稱。示例： @JsonProperty("birth_ d ate") private Date birthDate;
@JsonFormat	用於屬性或者方法，把屬性的格式序列化時轉換成指定的格式。示例： @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm") public Date getBirthDate()
@JsonPropertyOrder	用於類，指定屬性在序列化時 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; }

在瞭解 Jackson 的基本用法後，下面詳細地介紹它的一些高階應用。

Jackson 的高階應用

格式處理（含日期格式）

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

對於日期類型爲 java.util.Calendar,java.util.GregorianCalendar,java.sql.Date,java.util.Date,java.sql.Timestamp，若不指定格式，在 json 文件中將序列化爲 long 類型的數據。顯然這種默認格式，可讀性差，轉換格式是必要的。Jackson 有不少方式轉換日期格式。
註解方式，請參照" Jackson 的註解的使用"的@ JsonFormat 的示例。
ObjectMapper 方式，調用 ObjectMapper 的方法 setDateFormat，將序列化爲指定格式的 string 類型的數據。
對於日期類型爲 java.time.LocalDate，還須要添加代碼 mapper.registerModule(new JavaTimeModule())，同時添加相應的依賴 jar 包

清單 4 . JSR31 0 的配置信息

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

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

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

清單 5. joda 的配置信息

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

泛型反序列化

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

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

清單 6 . List 泛型使用示例

 
    CollectionType javaType = mapper.getTypeFactory()
.constructCollectionType(List.class, Person.class);
List<Person> personList = mapper.readValue(jsonInString, javaType); 
List<Person> personList = mapper.readValue(jsonInString, new
   TypeReference<List<Person>>(){}); 
   

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

清單 7 . Map 泛型使用示例

 
    //第二參數是 map 的 key 的類型，第三參數是 map 的 value 的類型
 MapType javaType =
    mapper.getTypeFactory().constructMapType(HashMap.class,String.class,
    Person.class);
 Map<String, Person> personMap = mapper.readValue(jsonInString,
    javaType);
 Map<String, Person> personMap = mapper.readValue(jsonInString, new
    TypeReference<Map<String, Person>>() {}); 
   

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

屬性可視化

是 java 對象的全部的屬性都被序列化和反序列化，換言之，不是全部屬性均可視化，默認的屬性可視化的規則以下：

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

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

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

清單 8 . 屬性可視化示例

mapper.setVisibility(PropertyAccessor.FIELD, Visibility.ANY);
 public class Person {
public int age;
 protected String name;
}
 PropertyAccessor 支持的類型有 ALL,CREATOR,FIELD,GETTER,IS_GETTER,NONE,SETTER 
 Visibility 支持的類型有 A
    NY,DEFAULT,NON_PRIVATE,NONE,PROTECTED_AND_PUBLIC,PUBLIC_ONLY

屬性過濾

在將 Java 對象序列化爲 json 時，有些屬性須要過濾掉，不顯示在 json 中， Jackson 有多種實現方法。

註解方式，能夠用 @JsonIgnore 過濾單個屬性或用 @JsonIgnoreProperties 過濾多個屬性，示例以下：

清單 9 . 屬性過濾示例一

 
    @JsonIgnore
public int getAge()
@JsonIgnoreProperties(value = { "age","birth_date" }) 
public class Person 
   

addMixIn 方法加註解方式@JsonIgnoreProperties。

addMixIn 方法簽名以下：

public ObjectMapper addMixIn(Class<?> target, Class<?> mixinSource);

addMixIn 方法的做用是用 mixinSource 接口或類的註解會重寫 target 或 target 的子類型的註解。用ixIn 設置

Person peixIn 的 @JsonIgnoreProperties("name")所重寫，最終忽略的屬性爲 name，最終生成的 json 以下：

{"birthDate":"2017/09/13","age":40}

SimpleBeanPropertyFilter 方式。這種方式比前兩種方式更加靈活，也更復雜一些。

首先須要設置@JsonFilter 類或接口，其次設置 addMixIn，將@JsonFilter 做用於 java 對象上，最後調用 SimpleBeanPropertyFilter 的 serializeAllExcept 方法或重寫 S impleBeanPropertyFilter 的 serializeAsField 方法來過濾相關屬性。示例以下：

清單 11 . 屬性過濾示例三

//設置 Filter 類或接口
 @JsonFilter("myFilter")
public interface MyFilter {}
//設置 addMixIn
mapper.addMixIn(Person.class, MyFilter.class);
//調用 SimpleBeanPropertyFilter 的 serializeAllExcept 方法
 SimpleBeanPropertyFilter newFilter =
 SimpleBeanPropertyFilter.serializeAllExcept("age");
//或重寫 SimpleBeanPropertyFilter 的 serializeAsField 方法
 SimpleBeanPropertyFilter newFilter = 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);
 mapper.setFilterProvider(filterProvider).writeValueAsString(person);

自定義序列化和反序列化

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

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

清單 12 . 自定義序列化

public class CustomSerializer extends StdSerializer<Person> { 
@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.writeEndObject();
}
}

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

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

清單 13 . 自定義序列化

public class CustomDeserializer extends StdDeserializer<Person> {
 @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，示例以下：

清單 14 . 注冊 M odule 示例

SimpleModule module = new SimpleModule("myModule");
module.addSerializer(new CustomSerializer(Person.class));
module.addDeserializer(Person.class, new CustomDeserializer()); 
mapper.registerModule(module);
也可經過註解方式加在 java 對象的屬性，方法或類上面來調用它們，
@JsonSerialize(using = CustomSerializer.class)
@JsonDeserialize(using = CustomDeserializer.class)
public class Person

樹模型處理

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

清單 15 . ObjectNode 生成和解析 json 示例

 
    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);
//經過 path 查找節點
JsonNode searchNode = personNode.path("street ")；
//刪除屬性
((ObjectNode) personNode).remove("address");
//讀取 json
JsonNode rootNode = mapper.readTree(personNode.toString());
//JsonNode 轉換成 java 對象
Person person = mapper.treeToValue(personNode, Person.class); 
//java 對象轉換成 JsonNode
JsonNode node = mapper.valueToTree(person); 
   
 
    import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.io.IOException;

/**
 * Created by clc on 2017/8/1.
 */
public class JacksonUtil {
    private static ObjectMapper mapper = new ObjectMapper();
    static {
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    }

    private JacksonUtil() {
    }

    public static ObjectMapper getMapper() {
        return mapper;
    }

    public static <T> T jsonStrToObject(String jsonStr, Class<T> valueType) {
        try {
            return mapper.readValue(jsonStr, valueType);
        } catch (IOException e) {
            return null;
        }
    }

    public static <T> T ObjectNodeToObject(ObjectNode objNode, Class<T> valueType) {
        try {
            return mapper.treeToValue(objNode, valueType);
        } catch (JsonProcessingException e) {
            return null;
        }
    }

    public static <T> String beanToString(T input) {
        try {
            return mapper.writeValueAsString(input);
        } catch (JsonProcessingException e) {
            return null;
        }
    }


} 
   