Jackson的使用
Jackson 简介
Jackson 是一个简单基于 Java 应用库，Jackson 可以轻松的将 Java 对象转换成 json 对象和 xml 文档，同样也可以将 json、xml 转换成 Java 对象。Jackson 所依赖的 jar 包较少，简单易用并且性能也要相对高些，并且 Jackson 社区相对比较活跃，更新速度也比较快。
Jackson 特点
容易使用 - jackson API 提供了一个高层次外观，以简化常用的用例。
无需创建映射 - API提供了默认的映射大部分对象序列化。
性能高 - 快速，低内存占用，适合大型对象图表或系统。
干净的 JSON - jackson 创建一个干净和紧凑的 JSON 结果，这是让人很容易阅读。
不依赖 - 库不需要任何其他的库，除了 JDK。
开源代码 - jackson 是开源的，可以免费使用。
Jackson 注解
Jackson 类库包含了很多注解，可以让我们快速建立 Java 类与 JSON 之间的关系。
@JsonProperty
@JsonProperty 注解指定一个属性用于 JSON 映射，默认情况下映射的 JSON 属性与注解的属性名称相同，不过可以使用该注解的 value 值修改 JSON 属性名，该注解还有一个 index 属性指定生成 JSON 属性的顺序，如果有必要的话。
@JsonIgnore
@JsonIgnore 注解用于排除某个属性，这样该属性就不会被 Jackson 序列化和反序列化。
@JsonIgnoreProperties
@JsonIgnoreProperties 注解是类注解。在序列化为 JSON 的时候，@JsonIgnoreProperties({"prop1", "prop2"}) 会忽略 pro1 和 pro2 两个属性。在从 JSON 反序列化为 Java 类的时候，@JsonIgnoreProperties(ignoreUnknown=true) 会忽略所有没有 Getter 和 Setter 的属性。该注解在 Java 类和 JSON 不完全匹配的时候很有用。
@JsonIgnoreType
@JsonIgnoreType 也是类注解，会排除所有指定类型的属性。
@JsonPropertyOrder
@JsonPropertyOrder 和 @JsonProperty 的 index 属性类似，指定属性序列化时的顺序。
@JsonRootName
@JsonRootName 注解用于指定 JSON 根属性的名称。
@JsonInclude
@JsonInclude(JsonInclude.Include.NON_NULL)：对值为 null 的属性不进行序列化
@JsonFormat
添加到需要指定格式的日期属性上,指定日期属性序列化与反序列化时的格式。timezone = “GMT+8” 设置时区，表示 +8 小时，否则会少8小时。ObjectMapper 序列化 POJO 对象为 json 字符串时，Date 日期类型默认会转为 long 长整型，json 字符串反序列化为 POJO 时自动将长整型的日期转为 Date 类型。
@JsonInclude(JsonInclude.Include.NON_NULL)
@Data
public class Book {
private Integer id;
private String title;
private Float price;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date publish;
}
加 @JsonFormat(pattern = “yyyy-MM-dd HH:mm:ss”, timezone = “GMT+8”)后序列号的结果
Jackson 使用实例
jackson-databind 内部依赖了 jackson-annotations 与 jackson-core，所以 Maven 应用时，只要导入 databind 一个，则同时也导入了 annotations 与 core 依赖。
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.11.0</version>
</dependency>
如果是springboot项目只需要引入web模块即可
对象的序列化与反序列化
package com.zysheep.hello.httpclient;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
public class JsonTester {
public static void main(String[] args) {
// 创建 ObjectMapper 对象
ObjectMapper mapper = new ObjectMapper();
String jsonString = "{\"name\":\"Mahesh\", \"age\":21}";
try {
// 反序列化 JSON 到对象
Student student = mapper.readValue(jsonString, Student.class);
System.out.println(student);
// 序列化对象到 JSON
String json = mapper.writeValueAsString(student);
System.out.println(json);
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
class Student {
private String name;
private int age;
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Student [ name: " + name + ", age: " + age + " ]";
}
}
集合的序列化与反序列化
package com.zysheep.hello.httpclient;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class JsonTester {
public static void main(String[] args) {
// 创建 ObjectMapper 对象
ObjectMapper mapper = new ObjectMapper();
String jsonString = "{\"draw\":1,\"recordsTotal\":1,\"recordsFiltered\":1,\"data\":[{\"id\":33,\"title\":\"ad1\",\"subTitle\":\"ad1\",\"titleDesc\":\"ad1\",\"url\":\"https://sale.jd.com/act/XkCzhoisOMSW.html\",\"pic\":\"https://m.360buyimg.com/babel/jfs/t20164/187/1771326168/92964/b42fade7/5b359ab2N93be3a65.jpg\",\"pic2\":\"\",\"content\":\"<p><br></p>\"}],\"error\":null}";
try {
// 反序列化 JSON 到树
JsonNode jsonNode = mapper.readTree(jsonString);
// 从树中读取 data 节点
JsonNode jsonData = jsonNode.findPath("data");
System.out.println(jsonData);
// 反序列化 JSON 到集合
JavaType javaType = mapper.getTypeFactory().constructParametricType(ArrayList.class, TbContent.class);
List<TbContent> tbContents = mapper.readValue(jsonData.toString(), javaType);
for (TbContent tbContent : tbContents) {
System.out.println(tbContent);
}
// 序列化集合到 JSON
String json = mapper.writeValueAsString(tbContents);
System.out.println(json);
} catch (IOException e) {
e.printStackTrace();
}
}
}
class TbContent {
private Long id;
private String title;
private String subTitle;
private String titleDesc;
private String url;
private String pic;
private String pic2;
private String content;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getSubTitle() {
return subTitle;
}
public void setSubTitle(String subTitle) {
this.subTitle = subTitle;
}
public String getTitleDesc() {
return titleDesc;
}
public void setTitleDesc(String titleDesc) {
this.titleDesc = titleDesc;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getPic() {
return pic;
}
public void setPic(String pic) {
this.pic = pic;
}
public String getPic2() {
return pic2;
}
public void setPic2(String pic2) {
this.pic2 = pic2;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public String toString() {
return "TbContent{" +
"id=" + id +
", title='" + title + '\'' +
", subTitle='" + subTitle + '\'' +
", titleDesc='" + titleDesc + '\'' +
", url='" + url + '\'' +
", pic='" + pic + '\'' +
", pic2='" + pic2 + '\'' +
", content='" + content + '\'' +
'}';
}
}
ObjectMapper常用API
ObjectMapper 主要用于对 Java 对象（比如 POJO、List、Set、Map 等等）进行序列化与反序列化。ObjectMapper 除了能在 json 字符串与 Java 对象之间进行转换，还能将 json 字符串与 JsonNode 进行转换。
| Java 对象与 Json 字符串的转换 | |
|---|---|
| String writeValueAsString(Object value) | 1、用于将任何 Java 对象（如 POJO、List、Set、Map等）序列化为 json 字符串，如果对象中某个属性的值为 null，则默认也会序列化为 null；2、如果 value 为 null，返回序列化的结果也返回 null |
| byte[] writeValueAsBytes(Object value) | 将 java 对象序列化为 字节数组 |
| writeValue(File resultFile, Object value) | 将 java 对象序列化并输出指定文件中 |
| writeValue(OutputStream out, Object value) | 将 java 对象序列化并输出到指定字节输出流中 |
| writeValue(Writer w, Object value) | 将 java 对象序列化并输出到指定字符输出流中 |
| T readValue(String content, Class valueType) | 1、从给定的 JSON 字符串反序列化为 Java 对象；2、content 为空或者为 null，都会报错3、valueType 表示反序列化的结果对象，可以是任何 java 对象，比如 POJO、List、Set、Map 等等. |
| T readValue(byte[] src, Class valueType) | 将 json 内容的字节数组反序列化为 java 对象 |
| T readValue(File src, Class valueType) | 将本地 json 内容的文件反序列化为 java 对象 |
| T readValue(InputStream src, Class valueType) | 将 json 内容的字节输入流反序列化为 java 对象 |
| T readValue(Reader src, Class valueType) | 将 json 内容的字符输入流反序列化为 java 对象 |
| T readValue(URL src, Class valueType) | 通过网络 url 地址将 json 内容反序列化为 java 对象 |
| Json 字符串内容反序列化为 Json 节点对象 | |
|---|---|
| JsonNode readTree(String content) | 将 JSON 字符串反序列化为 JsonNode 对象，即 json 节点对象 |
| JsonNode readTree(URL source) | 对网络上的 json 文件进行反序列化为 json 节点对象 |
| JsonNode readTree(InputStream in) | 对 json 文件输入流进行反序列化为 json 节点对象 |
| JsonNode readTree(byte[] content) | 对 json 字节数组反序列化为 json 节点对象 |
| JsonNode readTree(File file) | 将本地 json 文件反序列为为 json 节点对象 |
| Java 对象与 Json 节点对象的转换 | |
|---|---|
| T convertValue(Object fromValue, Class toValueType) | 将 Java 对象（如 POJO、List、Map、Set 等）序列化为 Json 节点对象 |
| T treeToValue(TreeNode n, Class valueType) | json 树节点对象转 Java 对象（如 POJO、List、Set、Map 等等）TreeNode 树节点是整个 json 节点对象模型的根接口。 |
/**
* POJO 对象转 json 字符串
* String writeValueAsString(Object value)
* 1、该方法可用于将任何 Java 值、对象序列化为 json 字符串，如果对象中某个属性的值为 null，则默认也会序列化为 null
* 2、value 为 null，返回 null
*
* @throws JsonProcessingException
*/
@Test
public void writeValueAsString1() throws JsonProcessingException {
User user = new User(1000, "张三", new Date(), null);
ObjectMapper objectMapper = new ObjectMapper();
String json = objectMapper.writeValueAsString(user);
System.out.println(json);
//{"uId":1000,"uName":"张三","birthday":1594881355832,"price":null}
}
/**
* String writeValueAsString(Object value)
* 1、 Java 值、对象序列化为 json 字符串，value 可以是任意的 java 对象，比如 POJO、list、Map、Set 等等
*/
@Test
public void writeValueAsString2() {
try {
List<User> userList = new ArrayList<>(2);
User user1 = new User(1000, "张三", null, 7777.88F);
User user2 = new User(2000, "李四", new Date(), 9800.78F);
userList.add(user1);
userList.add(user2);
ObjectMapper objectMapper = new ObjectMapper();
String json = objectMapper.writeValueAsString(userList);
//[{"uId":1000,"uName":"张三","birthday":null,"price":7777.88},{"uId":2000,"uName":"李四","birthday":1594882217908,"price":9800.78}]
System.out.println(json);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* String writeValueAsString(Object value)
* 1、 Java 值、对象序列化为 json 字符串，value 可以是任意的 java 对象，比如 POJO、list、Map、Set 等等
*/
@Test
public void writeValueAsString3() throws JsonProcessingException {
try {
Map<String, Object> dataMap = new HashMap<>();
dataMap.put("uId", 9527);
dataMap.put("uName", "华安");
dataMap.put("birthday", new Date());
dataMap.put("price", 9998.45F);
dataMap.put("marry", null);
ObjectMapper objectMapper = new ObjectMapper();
//{"birthday":1594884443501,"uId":9527,"uName":"华安","price":9998.45,"marry":null}
String json = objectMapper.writeValueAsString(dataMap);
System.out.println(json);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* writeValue(File resultFile, Object value)
* 1、 Java java 对象，比如 POJO、list、Map、Set 等等 序列化并输出到指定文件中
* 2、文件不存在时，会自动新建
*/
@Test
public void writeValueAsString4() throws JsonProcessingException {
try {
Map<String, Object> dataMap = new HashMap<>();
dataMap.put("uId", 9527);
dataMap.put("uName", "华安2");
dataMap.put("birthday", new Date());
dataMap.put("price", 9998.45F);
dataMap.put("marry", null);
File homeDirectory = FileSystemView.getFileSystemView().getHomeDirectory();
File jsonFile = new File(homeDirectory, "wmx2.json");
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.writeValue(jsonFile, dataMap);
System.out.println("输出 json 文件：" + jsonFile.getAbsolutePath());
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* T readValue(String content, Class<T> valueType)
* 1、从给定的 JSON 内容字符串反序列化为对象
* 2、content 为空或者为 null，都会报错
* 3、valueType 表示反序列号的结果对象，可以是任何 java 对象，比如 POJO、List、Set、Map 等等.
*/
@Test
public void readValue1() {
try {
String json = "{\"uId\":1000,\"uName\":\"张三\",\"birthday\":1594881355832,\"price\":null}";
ObjectMapper objectMapper = new ObjectMapper();
User user = objectMapper.readValue(json, User.class);
//User{uId=1000, uName='张三', birthday=Thu Jul 16 14:35:55 CST 2020, price=null}
System.out.println(user);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* T readValue(String content, Class<T> valueType)
* 1、从给定的 JSON 内容字符串反序列化为对象
* 2、content 为空或者为 null，都会报错
* 3、valueType 表示反序列号的结果对象，可以是任何 java 对象，比如 POJO、List、Set、Map 等等.
*/
@Test
public void readValue2() {
try {
String json = "[{\"uId\":1000,\"uName\":\"张三\",\"birthday\":null,\"price\":7777.88},{\"uId\":2000,\"uName\":\"李四\",\"birthday\":1594882217908,\"price\":9800.78}]";
ObjectMapper objectMapper = new ObjectMapper();
List<User> userList = objectMapper.readValue(json, List.class);
//{uId=2000, uName=李四, birthday=1594882217908, price=9800.78}
System.out.println(userList.get(1));
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* T readValue(String content, Class<T> valueType)
* 1、从给定的 JSON 内容字符串反序列化为对象
* 2、content 为空或者为 null，都会报错
* 3、valueType 表示反序列号的结果对象，可以是任何 java 对象，比如 POJO、List、Set、Map 等等.
*/
@Test
public void readValue3() {
try {
String json = "{\"birthday\":1594884443501,\"uId\":9527,\"uName\":\"华安\",\"price\":9998.45,\"marry\":null}";
ObjectMapper objectMapper = new ObjectMapper();
Map map = objectMapper.readValue(json, Map.class);
//{birthday=1594884443501, uId=9527, uName=华安, price=9998.45, marry=null}
System.out.println(map);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* T readValue(File src, Class<T> valueType)：将本地 json 内容文件反序列为 Java 对象
*/
@Test
public void readTree4() {
try {
String json = "[{\"uId\":1000,\"uName\":\"张三\",\"birthday\":null,\"price\":7777.88},{\"uId\":2000,\"uName\":\"李四\",\"birthday\":1594882217908,\"price\":9800.78}]";
File homeDirectory = FileSystemView.getFileSystemView().getHomeDirectory();
File jsonFile = new File(homeDirectory, "wmx.json");
if (!jsonFile.exists()) {
FileWriter fileWriter = new FileWriter(jsonFile);
fileWriter.write(json);
fileWriter.flush();
fileWriter.close();
System.out.println("输出 json 文件：" + jsonFile.getAbsolutePath());
}
List<User> userList = new ObjectMapper().readValue(jsonFile, List.class);
//{uId=2000, uName=李四, birthday=1594882217908, price=9800.78}
System.out.println(userList.get(1));
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* JsonNode readTree(String content)：将 JSON 内容反序列化为 JsonNode 对象
*
* @throws IOException
*/
@Test
public void readTree1() throws IOException {
//被解析的 json 格式的字符串
String json = "{\"notices\":[{\"title\":\"停水\",\"day\":\"1\"},{\"title\":\"停电\",\"day\":\"3\"},{\"title\":\"停网\",\"day\":\"2\"}]}";
ObjectMapper objectMapper = new ObjectMapper();
JsonNode jsonNode = objectMapper.readTree(json);
System.out.println(jsonNode);
}
/**
* JsonNode readTree(URL source) :对网络上的 json 文件进行反序列化为 json 节点对象
*/
@Test
public void readTree2() {
try {
URL url = new URL("http://t.weather.sojson.com/api/weather/city/101030100");
JsonNode jsonNode = new ObjectMapper().readTree(url);
System.out.println(jsonNode);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* JsonNode readTree(File file)：将本地 json 文件反序列化为 json 节点对象
*/
@Test
public void readTree3() {
try {
String json = "[{\"uId\":1000,\"uName\":\"张三\",\"birthday\":null,\"price\":7777.88},{\"uId\":2000,\"uName\":\"李四\",\"birthday\":1594882217908,\"price\":9800.78}]";
File homeDirectory = FileSystemView.getFileSystemView().getHomeDirectory();
File jsonFile = new File(homeDirectory, "wmx.json");
if (!jsonFile.exists()) {
FileWriter fileWriter = new FileWriter(jsonFile);
fileWriter.write(json);
fileWriter.flush();
fileWriter.close();
System.out.println("输出 json 文件：" + jsonFile.getAbsolutePath());
}
JsonNode jsonNode = new ObjectMapper().readTree(jsonFile);
System.out.println(jsonNode.get(0));//{"uId":1000,"uName":"张三","birthday":null,"price":7777.88}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* T treeToValue(TreeNode n, Class<T> valueType)：json 节点对象转 Java 对象（如 POJO、List、Set、Map 等等）
*/
@Test
public void test() {
try {
ObjectNode objectNode = JsonNodeFactory.instance.objectNode();
objectNode.put("uId", 3200);
objectNode.put("uName", "李世民");
objectNode.put("birthday", new Date().getTime());
User user = new ObjectMapper().treeToValue(objectNode, User.class);
//User{uId=3200, uName='李世民', birthday=Fri Jul 17 20:34:13 CST 2020, price=null}
System.out.println(user);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
}
/**
* T convertValue(Object fromValue, Class<T> toValueType)
* 1、将 Java 对象（如 POJO、List、Map、Set 等）序列化为 Json 节点对象，通常有以下两种方式：
* 2、一种方式是先序列化为 json 字符串，然后 readTree 反序列化为 Json 节点
* 3、还有就是使用此种方式进行转换，将 java 对象直接转换为 json 节点。
*/
@Test
public void convertValue1() {
User user = new User(1000, "张三", new Date(), null);
ObjectMapper objectMapper = new ObjectMapper();
JsonNode jsonNode = objectMapper.convertValue(user, JsonNode.class);
//{"uId":1000,"uName":"张三","birthday":1594967015825,"price":null}
System.out.println(jsonNode);
}
@Test
public void convertValue2() {
Map<String, Object> dataMap = new HashMap<>();
dataMap.put("uId", 9527);
dataMap.put("uName", "华安");
dataMap.put("birthday", new Date());
dataMap.put("price", 9998.45F);
dataMap.put("marry", null);
ObjectMapper objectMapper = new ObjectMapper();
JsonNode objectNode = objectMapper.convertValue(dataMap, JsonNode.class);
//{"birthday":1594950930586,"uId":9527,"uName":"华安","price":9998.45,"marry":null}
System.out.println(objectNode);
}
@Test
public void convertValue3() {
List<User> userList = new ArrayList<>(2);
User user1 = new User(1000, "张三", null, 7777.88F);
User user2 = new User(2000, "李四", new Date(), 9800.78F);
userList.add(user1);
userList.add(user2);
ObjectMapper objectMapper = new ObjectMapper();
JsonNode objectNode = objectMapper.convertValue(userList, JsonNode.class);
//[{"uId":1000,"uName":"张三","birthday":null,"price":7777.88},{"uId":2000,"uName":"李四","birthday":1594967168878,"price":9800.78}]
System.out.println(objectNode);
}
JsonNode常用API
/**
* JsonNodeFactory.instance: 创建单例的 JsonNodeFactory 工厂
* ObjectNode objectNode() : 构造空的 JSON 对象
* ObjectNode put(String fieldName, String v): 将字段的值设置为指定的字符串值，如果字段已经存在，则更新值
* ObjectNode put(String fieldName, int v)：其它数据类型也是同理
* ArrayNode putArray(String fieldName)：构造 ArrayNode 并将其作为此 ObjectNode 的字段添加。
* ObjectNode putNull(String fieldName): 为指定字段添加 null 值
* ArrayNode add(String v) :将指定的字符串值添加到此数组的末尾，其它数据类型也是同理。
*/
@Test
public void objectNode1() {
JsonNodeFactory jsonNodeFactory = JsonNodeFactory.instance;
ObjectNode objectNode = jsonNodeFactory.objectNode();
objectNode.put("name", "张三");
objectNode.put("age", 25);
objectNode.putNull("marry");
ArrayNode arrayNode = objectNode.putArray("urls");
arrayNode.add("http://tomcat.org/tomcat.png#1");
arrayNode.add("http://tomcat.org/tomcat.png#2");
arrayNode.add("http://tomcat.org/tomcat.png#3");
//{"name":"张三","age":25,"marry":null,"urls":["http://tomcat.org/tomcat.png#1","http://tomcat.org/tomcat.png#2","http://tomcat.org/tomcat.png#3"]}
System.out.println(objectNode.toString());
}
@Test
public void objectNode2() {
JsonNodeFactory jsonNodeFactory = JsonNodeFactory.instance;
ObjectNode objectNode_root = jsonNodeFactory.objectNode();
ArrayNode arrayNode = objectNode_root.putArray("notices");
ObjectNode objectNodeChild = jsonNodeFactory.objectNode();
objectNodeChild.put("title", "放假通知");
objectNodeChild.put("content", "寒假放假于本月3浩开始.");
arrayNode.add(objectNodeChild);
//{"notices":[{"title":"放假通知","content":"寒假放假于本月3浩开始."}]}
System.out.println(objectNode_root);
}
/**
* JsonNode replace(String fieldName, JsonNode value):将特定属性的值替换为传递的值，字段存在时更新，不存在时新增
* JsonNode set(String fieldName, JsonNode value)：设置指定属性的值为 json 节点对象，字段存在时更新，不存在时新增，类似 replace 方法
* JsonNode setAll(Map<String,? extends JsonNode> properties)：同时设置多个 json 节点
*/
@Test
public void objectNode3() {
try {
String json = "{\"notices\":[{\"title\":\"放假通知\",\"content\":\"寒假放假于本月3浩开始.\"}]}";
JsonNode jsonNode = new ObjectMapper().readTree(json);
ObjectNode objectNode = (ObjectNode) jsonNode;
ObjectNode node = JsonNodeFactory.instance.objectNode();
node.put("code", 200);
objectNode.set("status", node);
//{"notices":[{"title":"放假通知","content":"寒假放假于本月3浩开始."}],"status":{"code":200}}
System.out.println(objectNode);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* JsonNode setAll(ObjectNode other)：添加给定对象（other）的所有属性，重写这些属性的任何现有值
*/
@Test
public void objectNode4() {
try {
String json = "{\"notices\":[{\"title\":\"放假通知\",\"content\":\"寒假放假于本月3浩开始.\"}]}";
JsonNode jsonNode = new ObjectMapper().readTree(json);
ObjectNode objectNode = (ObjectNode) jsonNode;
ObjectNode node = JsonNodeFactory.instance.objectNode();
node.put("code", 200);
objectNode.setAll(node);
//{"notices":[{"title":"放假通知","content":"寒假放假于本月3浩开始."}],"code":200}
System.out.println(objectNode);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* JsonNode get(String fieldName):
* 1、用于访问对象节点的指定字段的值，如果此节点不是对象、或没有指定字段名的值，或没有这样名称的字段，则返回 null。
* boolean isArray(): 判断此节点是否为 {@link ArrayNode} 数组节点
* int size()：获取数组节点的大小
* int asInt()：
* 1、尝试将此节点的值转换为 int 类型，布尔值 false 转换为 0,true 转换为 1。
* 2、如果不能转换为 int（比如值是对象或数组等结构化类型），则返回默认值 0 ，不会引发异常。
* String asText()：如果节点是值节点（isValueNode返回true），则返回容器值的有效字符串表示形式，否则返回空字符串。
* 其它数据类型也是同理
*/
@Test
public void objectNode5() {
try {
String json = "{\"notices\":[{\"title\":\"停水\",\"day\":\"12\"},{\"title\":\"停电\",\"day\":\"32\"},{\"title\":\"停网\",\"day\":\"22\"}]}";
ObjectMapper objectMapper = new ObjectMapper();
ObjectNode jsonNode = (ObjectNode) objectMapper.readTree(json);
JsonNode notices = jsonNode.get("notices");
if (notices != null && notices.isArray()) {
for (int i = 0; i < notices.size(); i++) {
JsonNode childNode = notices.get(i);
String title = childNode.get("title").asText();
Integer day = childNode.get("day").asInt();
System.out.println((i + 1) + "：" + title + "\t" + day);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* ArrayNode withArray(String propertyName): 将 json 节点转为 json 数组对象
* ObjectNode with(String propertyName)：将 json 节点转为 ObjectNode 对象
*/
@Test
public void objectNode6() {
try {
String json = "{\"notices\":[{\"title\":\"放假通知\",\"content\":\"寒假放假于本月3浩开始.\"}]}";
JsonNode jsonNode = new ObjectMapper().readTree(json);
ObjectNode objectNode = (ObjectNode) jsonNode;
ArrayNode arrayNode = objectNode.withArray("notices");
for (int i = 0; i < arrayNode.size(); i++) {
//{"title":"放假通知","content":"寒假放假于本月3浩开始."}
JsonNode node = arrayNode.get(i);
System.out.println(node);
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* JsonNode remove(String fieldName)：删除指定的 key，返回被删除的节点
* JsonNode without(String fieldName):
* ObjectNode remove(Collection<String> fieldNames)：同时删除多个字段
* ObjectNode without(Collection<String> fieldNames)：同时删除多个字段
* ObjectNode removeAll(): 删除所有字段属性
*/
@Test
public void objectNode7() {
try {
String json = "{\"notices\":[{\"title\":\"放假通知\",\"content\":\"寒假放假于本月3浩开始.\"}]}";
JsonNode jsonNode = new ObjectMapper().readTree(json);
ObjectNode objectNode = (ObjectNode) jsonNode;
JsonNode remove = objectNode.remove("notices");
System.out.println(remove);//[{"title":"放假通知","content":"寒假放假于本月3浩开始."}]
System.out.println(objectNode);//{}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* ObjectNode deepCopy()：json 节点对象深度复制，相当于克隆
* Iterator<String> fieldNames(): 获取 json 对象中的所有 key
*/
@Test
public void objectNode8() {
try {
String json = "{\"title\":\"放假通知\",\"content\":\"寒假放假于本月3浩开始.\"}";
JsonNode jsonNode = new ObjectMapper().readTree(json);
ObjectNode objectNode = (ObjectNode) jsonNode;
ObjectNode deepCopy = objectNode.deepCopy();
deepCopy.put("summary", "同意");
System.out.println(objectNode);//{"title":"放假通知","content":"寒假放假于本月3浩开始."}
System.out.println(deepCopy);//{"title":"放假通知","content":"寒假放假于本月3浩开始.","summary":"同意"}
Iterator<String> fieldNames = deepCopy.fieldNames();
while (fieldNames.hasNext()) {
String next = fieldNames.next();
System.out.println(next + "=" + deepCopy.get(next));
}
} catch (IOException e) {
e.printStackTrace();
}
}
@Test
public void objectNode9() {
Map<String, Object> dataMap = new HashMap<>();
dataMap.put("code", 200);
dataMap.put("msg", "成功");
ObjectNode objectNode = JsonNodeFactory.instance.objectNode();
objectNode.putPOJO("data", dataMap);
System.out.println(objectNode);
JsonNode jsonNode = objectNode.get("data");
}
/**
* double asDouble(): 尝试将此节点的值转换为 double，布尔值转换为0.0（false）和1.0（true），字符串使用默认的Java 语言浮点数解析规则进行解析。
* 如果表示不能转换为 double（包括对象和数组等结构化类型），则返回默认值 0.0,不会引发异常。
* BigDecimal decimalValue() :返回此节点的浮点值 BigDecimal, 当且仅当此节点为数字时（isNumber 返回true）,对于其他类型，返回 BigDecimal.ZERO
*/
@Test
public void test10() {
ObjectNode objectNode = JsonNodeFactory.instance.objectNode();
objectNode.put("id", 1000);
objectNode.put("salay", 15000.456);
double salay = objectNode.get("salay").asDouble();
BigDecimal bigDecimal = objectNode.get("salay").decimalValue();
System.out.println(salay + "," + bigDecimal);//15000.456,15000.456
}
/**
* boolean has(int index)：检查此节点是否为数组节点，并是否含有指定的索引。
* boolean has(String fieldName)：检查此节点是否为 JSON 对象节点并包含指定属性的值。
*/
@Test
public void test11() {
ArrayNode arrayNode = JsonNodeFactory.instance.arrayNode();
arrayNode.add(12).add("中国").addNull().add(345.5667);
System.out.println(arrayNode);//[12,"中国",null,345.5667]
System.out.println(arrayNode.has(1));//true
System.out.println(arrayNode.has(2));//true
System.out.println(arrayNode.has(4));//false
}
/**
* Iterator<JsonNode> elements()：如果该节点是JSON数组或对象节点，则访问此节点的所有值节点
* 对于对象节点，不包括字段名（键），只包括值，对于其他类型的节点，返回空迭代器。
*/
@Test
public void test12() {
try {
String json = "{\"title\":\"放假通知\",\"content\":\"寒假放假于本月3浩开始.\",\"id\":23400}";
JsonNode jsonNode = new ObjectMapper().readTree(json);
Iterator<JsonNode> elements = jsonNode.elements();
while (elements.hasNext()) {
JsonNode next = elements.next();
//"放假通知" "寒假放假于本月3浩开始." 23400
System.out.print(next + " ");
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* ArrayNode addAll(ArrayNode other): 用于添加给定数组的所有子节点
*/
@Test
public void test13() {
try {
String json = "[{\"title\":\"放假通知\",\"content\":\"寒假放假于本月3浩开始.\"}]";
JsonNode jsonNode = new ObjectMapper().readTree(json);
ArrayNode rootArrayNode = JsonNodeFactory.instance.arrayNode();
rootArrayNode.add(1000);
if (jsonNode.isArray()) {
ArrayNode arrayNode = (ArrayNode) jsonNode;
rootArrayNode.addAll(arrayNode);
}
//[1000,{"title":"放假通知","content":"寒假放假于本月3浩开始."}]
System.out.println(rootArrayNode);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* ArrayNode addNull() :该方法将在此数组节点的末尾添加空值。
*/
@Test
public void test14() {
try {
String json = "[{\"title\":\"放假通知\",\"content\":\"寒假放假于本月3浩开始.\"}]";
JsonNode jsonNode = new ObjectMapper().readTree(json);
if (jsonNode.isArray()) {
ArrayNode arrayNode = (ArrayNode) jsonNode;
arrayNode.addNull();
//[{"title":"放假通知","content":"寒假放假于本月3浩开始."},null]
System.out.println(arrayNode);
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* ArrayNode addArray(): 构造新的 ArrayNode 节点，并将其添加到此数组节点的末尾
*/
@Test
public void test15() {
try {
String json = "[{\"title\":\"放假通知\",\"content\":\"寒假放假于本月3浩开始.\"}]";
JsonNode jsonNode = new ObjectMapper().readTree(json);
if (jsonNode.isArray()) {
ArrayNode arrayNode = (ArrayNode) jsonNode;
ArrayNode addArray = arrayNode.addArray();
addArray.add(31.4F);
addArray.add("优秀");
//[{"title":"放假通知","content":"寒假放假于本月3浩开始."},[31.4,"优秀"]]
System.out.println(arrayNode);
//[31.4,"优秀"]
System.out.println(addArray);
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* ObjectNode putObject(String fieldName)：构造新的 ObjectNode 字节的，并将其作为此 ObjectNode 的字段添加。
*/
@Test
public void test16() {
try {
String json = "{\"title\":\"放假通知\",\"content\":\"寒假放假于本月3浩开始.\"}";
JsonNode jsonNode = new ObjectMapper().readTree(json);
if (jsonNode.isObject()) {
ObjectNode objectNode = (ObjectNode) jsonNode;
ObjectNode persons = objectNode.putObject("person");
persons.put("name", "张三");
persons.put("age", 34);
//{"title":"放假通知","content":"寒假放假于本月3浩开始.","person":{"name":"张三","age":34}}
System.out.println(objectNode);
}
} catch (IOException e) {
e.printStackTrace();
}
}
JackJsonUtil
@Slf4j
public class JackJsonUtil {
private static ObjectMapper objectMapper = new ObjectMapper();
// 时间日期格式
private static final String STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";
//以静态代码块初始化
static {
//对象的所有字段全部列入序列化
objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
//取消默认转换timestamps形式
objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
//忽略空Bean转json的错误
objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
//所有的日期格式都统一为以下的格式，即yyyy-MM-dd HH:mm:ss
objectMapper.setDateFormat(new SimpleDateFormat(STANDARD_FORMAT));
//忽略 在json字符串中存在，但在java对象中不存在对应属性的情况。防止错误
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
/**===========================以下是从JSON中获取对象====================================*/
public static <T> T parseObject(String jsonString, Class<T> object) {
T t = null;
try {
t = objectMapper.readValue(jsonString, object);
} catch (JsonProcessingException e) {
log.error("JsonString转为自定义对象失败：{}", e.getMessage());
}
return t;
}
public static <T> T parseObject(File file, Class<T> object) {
T t = null;
try {
t = objectMapper.readValue(file, object);
} catch (IOException e) {
log.error("从文件中读取json字符串转为自定义对象失败：{}", e.getMessage());
}
return t;
}
//将json数组字符串转为指定对象List列表或者Map集合
public static <T> T parseJSONArray(String jsonArray, TypeReference<T> reference) {
T t = null;
try {
t = objectMapper.readValue(jsonArray, reference);
} catch (JsonProcessingException e) {
log.error("JSONArray转为List列表或者Map集合失败：{}", e.getMessage());
}
return t;
}
/**=================================以下是将对象转为JSON=====================================*/
public static String toJSONString(Object object) {
String jsonString = null;
try {
jsonString = objectMapper.writeValueAsString(object);
} catch (JsonProcessingException e) {
log.error("Object转JSONString失败：{}", e.getMessage());
}
return jsonString;
}
public static byte[] toByteArray(Object object) {
byte[] bytes = null;
try {
bytes = objectMapper.writeValueAsBytes(object);
} catch (JsonProcessingException e) {
log.error("Object转ByteArray失败：{}", e.getMessage());
}
return bytes;
}
public static void objectToFile(File file, Object object) {
try {
objectMapper.writeValue(file, object);
} catch (JsonProcessingException e) {
log.error("Object写入文件失败：{}", e.getMessage());
} catch (IOException e) {
e.printStackTrace();
}
}
/**=============================以下是与JsonNode相关的=======================================*/
//JsonNode和JSONObject一样，都是JSON树形模型，只不过在jackson中，存在的是JsonNode
public static JsonNode parseJSONObject(String jsonString) {
JsonNode jsonNode = null;
try {
jsonNode = objectMapper.readTree(jsonString);
} catch (JsonProcessingException e) {
log.error("JSONString转为JsonNode失败：{}", e.getMessage());
}
return jsonNode;
}
public static JsonNode parseJSONObject(Object object) {
JsonNode jsonNode = objectMapper.valueToTree(object);
return jsonNode;
}
public static String toJSONString(JsonNode jsonNode) {
String jsonString = null;
try {
jsonString = objectMapper.writeValueAsString(jsonNode);
} catch (JsonProcessingException e) {
log.error("JsonNode转JSONString失败：{}", e.getMessage());
}
return jsonString;
}
//JsonNode是一个抽象类，不能实例化，创建JSON树形模型，得用JsonNode的子类ObjectNode，用法和JSONObject大同小异
public static ObjectNode newJSONObject() {
return objectMapper.createObjectNode();
}
//创建JSON数组对象，就像JSONArray一样用
public static ArrayNode newJSONArray() {
return objectMapper.createArrayNode();
}
/**===========以下是从JsonNode对象中获取key值的方法，个人觉得有点多余，直接用JsonNode自带的取值方法会好点，出于纠结症，还是补充进来了*/
public static String getString(JsonNode jsonObject, String key) {
String s = jsonObject.get(key).asText();
return s;
}
public static Integer getInteger(JsonNode jsonObject, String key) {
Integer i = jsonObject.get(key).asInt();
return i;
}
public static Boolean getBoolean(JsonNode jsonObject, String key) {
Boolean bool = jsonObject.get(key).asBoolean();
return bool;
}
public static JsonNode getJSONObject(JsonNode jsonObject, String key) {
JsonNode json = jsonObject.get(key);
return json;
}
}
753
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
