[TOC] # 導包 Jackson包含一個core JAR，和兩個依賴core JAR的JAR： * Jackson Core * Jackson Annotations * Jackson Databind 其中Jackson Annotations依賴Jackson Core，Jackson Databind依賴Jackson Annotations。 ~~~ <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.10.0</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.10.0</version> </dependency> <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-core</artifactId> <version>2.10.0</version> </dependency> ~~~ # 簡介 Jackson提供了兩種不同的JSON解析器： 1. ObjectMapper：把JSON解析到自定義的Java類中，或者解析到一個Jackson指定的樹形結構中（Tree model）。 2. Jackson JsonParser：一種“拉式”（pull）解析器，每次解析一組JSON數據。 Jackson也包含了兩種不同的JSON生成器 # Jackson配置 在調用 writeValue 或調用 readValue 方法之前，往往需要設置 ObjectMapper 的相關配置信息。這些配置信息應用 java 對象的所有屬性上。示例如下： ~~~ //在反序列化時忽略在 json 中存在但 Java 對象不存在的屬性 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); //在序列化時日期格式默認為 yyyy-MM-dd'T'HH:mm:ss.SSSZ ,比如如果一個類中有private Date date;這種日期屬性，序列化后為：{"date" : 1413800730456}，若不為true，則為{"date" : "2014-10-20T10:26:06.604+0000"} mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false); //在序列化時忽略值為 null 的屬性 mapper.setSerializationInclusion(Include.NON_NULL); //忽略值為默認值的屬性 mapper.setDefaultPropertyInclusion(Include.NON_DEFAULT); // 美化輸出 mapper.enable(SerializationFeature.INDENT_OUTPUT); // 允許序列化空的POJO類 // （否則會拋出異常） mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS); // 把java.util.Date, Calendar輸出為數字（時間戳） mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS); // 在遇到未知屬性的時候不拋出異常 mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); // 強制JSON 空字符串("")轉換為null對象值: mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT); // 在JSON中允許C/C++ 樣式的注釋(非標準，默認禁用) mapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true); // 允許沒有引號的字段名（非標準） mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true); // 允許單引號（非標準） mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true); // 強制轉義非ASCII字符 mapper.configure(JsonGenerator.Feature.ESCAPE_NON_ASCII, true); // 將內容包裹為一個JSON屬性，屬性名由@JsonRootName注解指定 mapper.configure(SerializationFeature.WRAP_ROOT_VALUE, true); //序列化枚舉是以toString()來輸出，默認false，即默認以name()來輸出 mapper.configure(SerializationFeature.WRITE_ENUMS_USING_TO_STRING,true); //序列化Map時對key進行排序操作，默認false mapper.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS,true); //序列化char[]時以json數組輸出，默認false mapper.configure(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS,true); //序列化BigDecimal時之間輸出原始數字還是科學計數，默認false，即是否以toPlainString()科學計數方式來輸出 mapper.configure(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS,true); ~~~ # java轉json ObjectMapper提供了三種方法轉換 ~~~ writeValue() writeValueAsString() writeValueAsBytes() ~~~ ~~~ //創建JackSon的核心對象, ObjectMapper ObjectMapper mapper = new ObjectMapper(); /** * 轉換方法 * writeValue(參數1, obj): * 參數1: * File: 將obj對象轉換為json字符串,并保存到指定的文件中 * Writer: 將obj對象轉換為json字符串,并將json數據填充到字符輸出流中 * OutputStream: 將obj對象轉換為json字符串,并將json數據填充到字節輸出流中 * * writeValueAsString(obj): 將對象轉為json字符串 */ String s = mapper.writeValueAsString(person); System.out.println(s); //{"name":"xjd","id":1,"birthday":1571416610414} //把json寫入到文件 mapper.writeValue(new File("/Users/jdxia/Desktop/website/a.txt"), person); ~~~ # 日期處理 Jackson 默認會將`java.util.Date`對象轉換成`long`值,同時也支持將時間轉換成格式化的字符串 日期轉換 ~~~ @JsonFormat(pattern = "yyyy-MM-dd", timezone="GMT+8") private Date birthday; ~~~ 忽略該類型,json中不包含這個 ~~~ @JsonIgnore private Date birthday; ~~~ `@DateTimeFormat`用于接收 前端傳的時間值自動轉換 可以是Date 可以是string? ?注意 ?格式要一樣 如`yyyy-MM-dd ? yyyy/MM/ddd` ~~~ @DateTimeFormat(pattern="yyyy-MM-dd") ~~~ # list和map list ~~~ //創建JackSon的核心對象, ObjectMapper ObjectMapper mapper = new ObjectMapper(); String s = mapper.writeValueAsString(list); System.out.println(s); //[{"name":"xjd","id":1},{"name":"xjd","id":1}] ~~~ map和javaBean轉換一樣 # json轉java 調用ObjectMapper的相關方法進行轉換 1. readValue(json字符串, class) ~~~ String json = "{\"name\":\"xjd\",\"id\":1,\"birthday\":\"2019-10-18\"}"; ObjectMapper objectMapper = new ObjectMapper(); //把json轉換為person對象 Person person = objectMapper.readValue(json, Person.class); System.out.println(person); //{"name":"xjd","id":1,"birthday":"Fri Oct 18 08:00:00 CST 2019"} ~~~ **從json文件讀取** ~~~ ObjectMapper objectMapper = new ObjectMapper(); File file = new File("data/car.json"); Car car = objectMapper.readValue(file, Car.class); ~~~ **從json字節數組中讀取** ~~~ ObjectMapper objectMapper = new ObjectMapper(); String carJson = "{ \"brand\" : \"Mercedes\", \"doors\" : 5 }"; byte[] bytes = carJson.getBytes("UTF-8"); Car car = objectMapper.readValue(bytes, Car.class); ~~~ # 反序列化不同類型 **轉換為數組** ~~~ String jsonArray = "[{\"brand\":\"ford\"}, {\"brand\":\"Fiat\"}]"; ObjectMapper objectMapper = new ObjectMapper(); Car[] cars = objectMapper.readValue(jsonArray, Car[].class); ~~~ **轉換為集合** ~~~ String jsonArray = "[{\"brand\":\"ford\"}, {\"brand\":\"Fiat\"}]"; ObjectMapper objectMapper = new ObjectMapper(); List<Car> cars = objectMapper.readValue(jsonArray, new TypeReference<List<Car>>(){}); ~~~ **轉換為Map** ~~~ String jsonObject = "{\"brand\":\"ford\", \"doors\":5}"; ObjectMapper objectMapper = new ObjectMapper(); Map<String, Object> jsonMap = objectMapper.readValue(jsonObject, new TypeReference<Map<String,Object>>(){}); ~~~ # 注解 ## 日期`@JsonFormat` ~~~ @JsonFormat 此注解用于屬性上，作用是把Date類型直接轉化為想要的格式，如@JsonFormat(pattern = "yyyyMMdd", timezone="GMT+8") ~~~ ~~~ @JsonFormat(pattern = "yyyy-MM-dd HH-mm-ss") ~~~ ## 重命名`@JsonProperty` ~~~ @JsonProperty 此注解用于屬性上，作用是把該屬性的名稱序列化為另外一個名稱，如把eMail屬性序列化為mail，@JsonProperty("mail"),該注解還有一個`index`屬性指定生成JSON屬性的順序，如果有必要的話 ~~~ ## 忽略某些`@JsonIgnoreProperties` ~~~ @JsonIgnore注解用來忽略某些字段，可以用在Field或者Getter方法上，用在Setter方法時，和Filed效果一樣。這個注解只能用在POJO存在的字段要忽略的情況，不能滿足現在需要的情況。有一種情況，當getter上注解@JsonIgnore而setter上注解@JsonProperty，就會出現“只讀”情況（read from input, but is not written output） @JsonIgnoreProperties(ignoreUnknown = true)，將這個注解寫在類上之后，就會忽略類中不存在的字段，可以滿足當前的需要。這個注解還可以指定要忽略的字段。使用方法如下： @JsonIgnoreProperties({ "internalId", "secretKey" })是類級別的，并且可以同時指定多個屬性 指定的字段不會被序列化和反序列化。 @JsonIgnoreProperties({"uselessProp1", "uselessProp3"}) public class FriendDetail { ~~~ ## 定義一個根key`@JsonRootName` ~~~ @JsonRootName(value = "root") public class User { ~~~ 使用時必須做如下設置 ~~~ mapper.enable(SerializationFeature.WRAP_ROOT_VALUE); ~~~ 序列化會有個根節點 `{"root": {}}` 加上根以后，反序列化時也要做設置 ~~~ mapper.enable(DeserializationFeature.UNWRAP_ROOT_VALUE); ~~~ ## 指定順序`@JsonPropertyOrder` 在將 java pojo 對象序列化成為 json 字符串時，使用 @JsonPropertyOrder 可以指定屬性在 json 字符串中的順序 ~~~ @JsonPropertyOrder(value={"desc","name"}) public class SomeEntity { private String name; private String desc; ~~~ ## 在哪些情況下才轉為json`@JsonInclude` 取值 * `JsonJsonInclude.Include.ALWAYS` 默認，任何情況下都序列化該字段 * `JsonJsonInclude.Include.NON_NULL`這個最常用，即如果加該注解的字段為null,就不序列化這個字段 * `JsonJsonInclude.Include.NON_ABSENT` 包含NON_NULL，即為null的時候不序列化,相當于`NON_NULL`的增強版，比如jdk和谷歌Guava的Optional類型對象，不是null，但它的isPresent方法返回false * `JsonJsonInclude.Include.NON_EMPTY` 包含NON_NULL，NON_ABSENT之后還包含如果字段為空也不序列化 * `JsonJsonInclude.Include.NON_DEFAULT`如果字段是默認值的話就不序列化。 在將 java pojo 對象序列化成為 json 字符串時，使用 @JsonInclude 注解可以控制在哪些情況下才將被注解的屬性轉換成 json，例如只有屬性不為 null 時 ~~~ @JsonInclude(JsonInclude.Include.NON_NULL) public class SomeEntity { private String name; private String desc; public SomeEntity(String name, String desc){ this.name = name; this.desc = desc; } ~~~ ## set指定名字`@JsonSetter` @JsonSetter 標注于 setter 方法上，類似 @JsonProperty ，也可以解決 json 鍵名稱和 java pojo 字段名稱不匹配的問題 ~~~ public class SomeEntity { private String desc; @JsonSetter("description") public void setDesc(String desc) { this.desc = desc; } ~~~ ## 自動發現字段的級別`@JsonAutoDetect` fieldVisibility：字段屬性的可見范圍。 getterVisibility：getter的可見范圍（對象序列化成json字符串時的可見范圍）。 isGetterVisibility：is-getter的可見范圍（如boolean類型的getter）。 setterVisibility：setter的可見范圍（json字符串反序列化成對象時的可見范圍）。 creatorVisibility：構造方法的可見范圍。 可見范圍是一個枚舉，包括： * Visibility.ANY：表示從private到public修飾，都可見。 * Visibility.NON_PRIVATE：表示除private修飾不可見外，其他都可見。 * Visibility.PROTECTED_AND_PUBLIC：protected和public可見。 * Visibility.PUBLIC_ONLY：僅public可見。 * Visibility.NONE：所以皆不可見。 * Visibility.DEFAULT：缺省，所有被public修飾的屬性、getter和所有setter(不管能見度)皆可見 ~~~ @JsonIgnoreProperties(ignoreUnknown=true) @JsonAutoDetect(fieldVisibility=Visibility.PUBLIC_ONLY) public class Person { protected String name = "zyc"; public boolean boy = true; ~~~ ## 反序列化時構造`@JsonCreator` ## 自定義Jackson序列化`@JsonSerialize` @JsonSerialize注解,可以實現date數據轉換成long型數據等功能, 該注解作用在屬性的getter()方法上 用于在序列化時嵌入我們自定義的代碼， 比如序列化一個double時在其后面限制兩位小數點。 因為在java中日期時期的時間戳是ms，我現在需要將ms轉換為s，就需要將ms/1000 ~~~ import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JsonSerializer; import com.fasterxml.jackson.databind.SerializerProvider; import java.util.Date; import java.io.IOException; /** *該類可以將data轉換成long類型 */ public class Data2LongSerizlizer extends JsonSerializer<Date> { @Override public void serialize(Date date, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { //將毫秒值轉換成秒變成long型數據返回 jsonGenerator.writeNumber(date.getTime()/1000); } } ~~~ 這樣就完成了時間戳13位到10位的轉換 ~~~ //創建時間 @JsonSerialize(using = Data2LongSerizlizer.class ) private Date createTime; //更新時間 @JsonSerialize(using = Data2LongSerizlizer.class ) private Date updateTime; ~~~ ## 自定義反序列化@JsonDeserialize ~~~ public class DateJsonDeserializer extends JsonDeserializer<Date> { public static final SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); @Override public Date deserialize(com.fasterxml.jackson.core.JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, com.fasterxml.jackson.core.JsonProcessingException { try { if(jsonParser!=null&&StringUtils.isNotEmpty(jsonParser.getText())){ return format.parse(jsonParser.getText()); }else { return null; } } catch(Exception e) { System.out.println(e.getMessage()); throw new RuntimeException(e); } } } ~~~ ~~~ public class DateJsonSerializer extends JsonSerializer<Date> { public static final SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); @Override public void serialize(Date date, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { jsonGenerator.writeString(format.format(date)); } } ~~~ 已注解方式使用 ~~~ @JsonDeserialize(using= DateJsonDeserializer.class) @JsonSerialize(using= DateJsonSerializer.class) private Date time; ~~~ # 流式生成json`JsonGenerator` Jackson提供了一種對于**性能要求**應用程序操作json更加高效的方式——**流式API**，這種方式**開銷小，性能高**，因此，如果應用程序或者程序邏輯對于性能有一定要求，可以使用這種方式來進行json文件的讀寫操作，而對于一般的讀寫，使用普通的databind api即可。 1. 與Java8的“流式”概念不同，這種Jackson的這種流式是屬于IO流，在寫出與讀入的最后都要進行流的關閉 —— close()。 2. 這種流式API（Streaming APIs），是一種高性能（high-performance）讀寫JSON的方式，同時也是一種增量模式（incremental mode）。 3. Token概念：使用流式API的時候，每一個JSON 字符串都是一個獨立的 token ，每一個token都會被增量處理（可以理解為一個一個地往上增加，類似于壘磚），這就是“增量模式”的含義 ~~~ { "name" : "Morty" } ~~~ ~~~ Token 1 = "{" Token 2 = "name" Token 3 = "Morty" Token 4 = "}" ~~~ 4. 流式API的缺點：雖然流式API在性能上有所特長，但是通過第三點，也可以知道，每一個token都是增量處理的，也就是說，我們必須要小心翼翼地處理每個token，這可能會因為粗心導致丟掉必要的token （如 "}"、"]" 等），而且代碼可能并不簡潔，可讀性也不一定好，因此，不到需要考慮性能的時候，一定不要使用這種方式 ~~~ JsonFactory factory = new JsonFactory(); JsonGenerator gentor = factory.createGenerator(new File("/Users/jdxia/Desktop/website/user.json"), JsonEncoding.UTF8); gentor.writeStartObject(); // { gentor.writeStringField("name", "Tomson"); gentor.writeNumberField("age", 23); gentor.writeFieldName("messages"); gentor.writeStartArray(); // [ gentor.writeString("msg1"); gentor.writeString("msg2"); gentor.writeString("msg3"); gentor.writeEndArray(); // ] gentor.writeEndObject(); // } gentor.close(); //{"name":"Tomson","age":23,"messages":["msg1","msg2","msg3"]} ~~~ # 解析json`JsonParser` 準備數據 ~~~ {"name":"Tomson","age":23,"messages":["msg1","msg2","msg3"]} ~~~ ~~~ JsonFactory factory = new JsonFactory(); JsonParser parser = factory.createParser(new File("/Users/jdxia/Desktop/website/user.json")); while (parser.nextToken() != JsonToken.END_OBJECT) { String fieldName = parser.getCurrentName(); if ("name".equals(fieldName)) { // current token is "name",move to next which is "name"'s value. parser.nextToken(); System.out.println(parser.getText());// display "Tomson" } if ("age".equals(fieldName)) { parser.nextToken(); System.out.println(parser.getIntValue()); } if ("messages".equals(fieldName)) { parser.nextToken(); // messages is array, loop until equals "]" while (parser.nextToken() != JsonToken.END_ARRAY) { System.out.println(parser.getText()); } } } parser.close(); ~~~ 輸出 ~~~ Tomson 23 msg1 msg2 msg3 ~~~ # readTree讀取json,拼接json ~~~ ObjectMapper objectMapper = new ObjectMapper(); //jsonStr 就是需要解析的字符串 JsonNode jsonNode = objectMapper.readTree(jsonStr); int distance = jsonNode.get("result").get("routes").get(0).get("distance").asInt(); ~~~ ~~~ try { ObjectMapper mapper = new ObjectMapper(); // 允許出現特殊字符和轉義符 mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true); // String jsonstr = // "{\"msg\":{\"head\":{\"version\":\"1.0\",\"bizcode\":\"1006\",\"senddate\":\"20140827\",\"sendtime\":\"110325\",\"seqid\":\"1\"},\"body\":{\"datalist\":\"wahaha\",\"rstcode\":\"000000\",\"rstmsg\":\"成功\"}}}"; ObjectNode root = mapper.createObjectNode(); ObjectNode msg = mapper.createObjectNode(); ObjectNode head = mapper.createObjectNode(); ////path與get作用相同,但是當找不到該節點的時候,返回missing node而不是Null. head.put("version", "1.0"); head.put("bizcode", "1006"); head.put("senddate", "20140827"); head.put("sendtime", "110325"); head.put("seqid", "1"); ObjectNode body = mapper.createObjectNode(); body.put("datalist", "wahaha"); body.put("rstcode", "000000"); body.put("rstmsg", "成功"); msg.put("head", head); msg.put("body", body); root.put("msg", msg); System.out.println(mapper.writeValueAsString(root)); //{"msg":{"head":{"version":"1.0","bizcode":"1006","senddate":"20140827","sendtime":"110325","seqid":"1"},"body":{"datalist":"wahaha","rstcode":"000000","rstmsg":"成功"}}} } catch (Exception e) { e.printStackTrace(); } ~~~