[TOC]
# 导包
Jackson包含一个core JAR,和两个依赖core JAR的JAR:
* Jackson Core
* Jackson Annotations
* Jackson Databind
其中Jackson Annotations依赖Jackson Core,Jackson Databind依赖Jackson Annotations。
~~~
com.fasterxml.jackson.core
jackson-databind
2.10.0
com.fasterxml.jackson.core
jackson-annotations
2.10.0
com.fasterxml.jackson.core
jackson-core
2.10.0
~~~
# 简介
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 cars = objectMapper.readValue(jsonArray, new TypeReference>(){});
~~~
**转换为Map**
~~~
String jsonObject = "{\"brand\":\"ford\", \"doors\":5}";
ObjectMapper objectMapper = new ObjectMapper();
Map jsonMap = objectMapper.readValue(jsonObject, new TypeReference>(){});
~~~
# 注解
## 日期`@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 {
@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
{
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 {
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();
}
~~~