jackson · JAVA

[TOC] # 导包 Jackson包含一个core JAR，和两个依赖core JAR的JAR： * Jackson Core * Jackson Annotations * Jackson Databind 其中Jackson Annotations依赖Jackson Core，Jackson Databind依赖Jackson Annotations。 ~~~  <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.10.0</version> </dependency>  <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-annotations</artifactId> <version>2.10.0</version> </dependency>  <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(); } ~~~