4大Json工具详细使用说明
前言
Github：https://github.com/HealerJean
Json在项目开发中使用的太多了，各种关于Json的依赖也是不断地额退出，
JackJsonnet.sf.json以及阿里巴巴的Json，下面的将我实际项目中对于他们的使用做个介绍 。
1、解释和依赖
我这里按照我接触的先后顺序进行
1.1、net.sf.json
最开始接触的就是它，非常神奇，不用找任何博客就能熟练使用，但是后来借出了JsonNode之后，比较之后二者差的不是一点在使用过程中
<!--net.sf.json-->
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.4</version>
<classifier>jdk15</classifier>
</dependency>
<!--net/sf/json/JSONObject-->
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib-ext-spring</artifactId>
<version>1.0.2</version>
</dependency>
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.4</version>
<classifier>jdk15</classifier>
</dependency>
<!--net/sf/ezmorph/Morpher-->
<dependency>
<groupId>net.sf.ezmorph</groupId>
<artifactId>ezmorph</artifactId>
<version>1.0.6</version>
</dependency>
<!--org/apache/commons/collections/map/ListOrderedMap-->
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.2</version>
</dependency>
<!--org/apache/commons/beanutils/DynaBean -->
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>1.8.3</version>
</dependency>
1.2、jackson
它就没必要解释了，用的最多的就是它
<!-- Jackson jsonUtils-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<exclusions>
<exclusion>
<artifactId>jackson-annotations</artifactId>
<groupId>com.fasterxml.jackson.core</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.module</groupId>
<artifactId>jackson-module-parameter-names</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jdk8</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jsr310</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
</dependency>
1.3、fastjson
这个我使用的不多，在序列化的时候使用过，一般没使用过
<com-alibaba-fastjson.version>1.2.58</com-alibaba-fastjson.version>
<!-- fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${com-alibaba-fastjson.version}</version>
</dependency>
1.4、gson
这个在小米知道fastjson有一些问题的时候，使用gson进行替换
<gson.verson>2.8.5</gson.verson>
<!--gson-->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>${gson.verson}</version>
</dependency>
准备
package com.healerjean.proj.a_test.json;
import com.google.common.collect.Lists;
import com.healerjean.proj.a_test.json.JsonDemoDTO.User;
import com.healerjean.proj.util.json.JsonUtils;
import lombok.Data;
import lombok.experimental.Accessors;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.UUID;
/**
* @author HealerJean
* @ClassName JsonDemoDTO
* @date 2019/10/29 16:22.
* @Description
*/
@Data
@Accessors(chain = true)
public class JsonDemoDTO {
private String reqSn;
private int code;
private String msg;
private Date transDate;
private Integer integer;
private BigDecimal bigDecimal;
private User user;
private List<String> strList;
private List<Company> companys;
@Data
@Accessors(chain = true)
public static class Company {
private Long companyId;
private String companyName;
}
@Data
@Accessors(chain = true)
public static class User {
private Long userId;
private String userName;
}
public static JsonDemoDTO jsonDemo() {
JsonDemoDTO jsonDemoDTO = new JsonDemoDTO();
jsonDemoDTO.setReqSn(UUID.randomUUID().toString().replace("-", ""));
jsonDemoDTO.setMsg("Success");
jsonDemoDTO.setCode(200);
jsonDemoDTO.setTransDate(new Date());
jsonDemoDTO.setBigDecimal(new BigDecimal(100));
jsonDemoDTO.setInteger(100);
jsonDemoDTO.setStrList(Arrays.asList(new String[]{"奔驰", "宝马"}));
jsonDemoDTO.setUser(new User().setUserId(1L).setUserName("HealerJean"));
List<Company> companies = Arrays.asList(new Company[]{
new Company().setCompanyId(1L).setCompanyName("汽车公司"),
new Company().setCompanyId(2L).setCompanyName("房产公司")});
jsonDemoDTO.setCompanys(companies);
return jsonDemoDTO;
}
public static String jsonString() {
String json = JsonUtils.toJsonString(jsonDemo());
return json;
}
public static void main(String[] args) {
System.out.println(jsonString());
}
}
1、net.sf.json
1.1、JSONObject的获取数据以及基本使用
1.1.1、从JSONObject中获取简单数据
1.1.2、JSONArray中获取 JSONObject对象
1.1.3、判断JSONObject是否是数组，是否存在节点
1.1.4、简单遍历 JSONObject
1.1.5、遍历JSONArray（（数组或者Json等都可以用它））
/**
* JsonObject的基本使用
* 1、从JSONObject中获取简单数据
* 2、JSONArray中获取 JSONObject对象
* 3、判断JSONObject是否是数组，是否存在节点
* 4、简单遍历 JSONObject
* 5、遍历JSONArray（（数组或者Json等都可以用它））
*/
@Test
public void test1() {
String json = JsonDemoDTO.jsonString();
log.info("jsonString：【 {} 】", json);
JSONObject jsonObject = JSONObject.fromObject(json);
//1、从JSONObject中获取简单数据
log.info("------------------------------------------------");
log.info("1、从JSONObject中获取简单数据");
String msg = jsonObject.getString(CommonConstants.msg);
Integer code = jsonObject.getInt(CommonConstants.code);
JSONObject userJsonObject = jsonObject.getJSONObject(CommonConstants.user);
JSONArray companyJSONArray = jsonObject.getJSONArray(CommonConstants.companys);
JSONArray strJsonArrayy = jsonObject.getJSONArray(CommonConstants.strList);
log.info("msg：【 {} 】", msg);
log.info("code：【 {} 】", code);
log.info("userJsonObject：【 {} 】", userJsonObject);
log.info("companyJsonArray：【 {} 】", companyJSONArray);
log.info("strJsonArrayy：【 {} 】", strJsonArrayy);
// 2、JSONArray中获取 JSONObject对象
log.info("------------------------------------------------");
log.info("2、JSONArray中获取 JSONObject对象");
JSONObject company0 = companyJSONArray.getJSONObject(0);
log.info("company0：【 {} 】", company0);
// 虽然有下面这个方法，但是也要看情况是否能用，下面的会报错,因为不是一个JsonObject数据
// 报错信息net.sf.json.JSONException: JSONArray[0] is not a JSONObject.
// JSONObject str0 = jsonObject.getJSONArray(CommonConstants.strList).getJSONObject(0);
// log.info("str0：【 {} 】", str0);
// 3、判断JSONObject是否是数组，是否存在节点
log.info("------------------------------------------------");
log.info("3、判断JSONObject是否是数组，是否存在节点");
Boolean flagArray = companyJSONArray.isArray();
Boolean flagHas = jsonObject.has(CommonConstants.msg);
Boolean flagContainsKey = jsonObject.containsKey(CommonConstants.msg);
log.info("flagArray：【 {} 】", flagArray);
log.info("flag：【 {} 】", flagHas);
log.info("flagContainsKey：【 {} 】", flagContainsKey);
//4、简单遍历 JSONObject
log.info("------------------------------------------------");
log.info("4、简单遍历 JSONObject");
for (Object key : jsonObject.keySet()) {
Object value = jsonObject.get(key);
log.info("key：【 {} 】,value：【 {} 】", key, value);
}
//5.1.、遍历JSONArray（（数组或者Json等都可以用它））
log.info("------------------------------------------------");
log.info("5.1.、遍历JSONArray（（数组或者Json等都可以用它））");
Iterator iteratorCompany = companyJSONArray.iterator();
while (iteratorCompany.hasNext()) {
Object object = iteratorCompany.next();
log.info("object：【 {} 】", object);
}
}
// jsonString：【 {"reqSn":"f20b7c4901734a638b9c6ed5e5249f8d","code":200,"msg":"Success","transDate":1574339468774,"integer":100,"bigDecimal":100,"user":{"userId":1,"userName":"HealerJean"},"strList":["奔驰","宝马"],"companys":[{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}]} 】[39]
// ------------------------------------------------[43]
// 1、从JSONObject中获取简单数据[44]
// msg：【 Success 】[50]
// code：【 200 】[51]
// userJsonObject：【 {"userId":1,"userName":"HealerJean"} 】[52]
// companyJsonArray：【 [{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}] 】[53]
// strJsonArrayy：【 ["奔驰","宝马"] 】[54]
// ------------------------------------------------[57]
// 2、JSONArray中获取 JSONObject对象[58]
// company0：【 {"companyId":1,"companyName":"汽车公司"} 】[60]
// ------------------------------------------------[68]
// 3、判断JSONObject是否是数组，是否存在节点[69]
// flagArray：【 true 】[73]
// flag：【 true 】[74]
// flagContainsKey：【 true 】[75]
// ------------------------------------------------[78]
// 4、简单遍历 JSONObject[79]
// key：【 reqSn 】,value：【 f20b7c4901734a638b9c6ed5e5249f8d 】[82]
// key：【 code 】,value：【 200 】[82]
// key：【 msg 】,value：【 Success 】[82]
// key：【 transDate 】,value：【 1574339468774 】[82]
// key：【 integer 】,value：【 100 】[82]
// key：【 bigDecimal 】,value：【 100 】[82]
// key：【 user 】,value：【 {"userId":1,"userName":"HealerJean"} 】[82]
// key：【 strList 】,value：【 ["奔驰","宝马"] 】[82]
// key：【 companys 】,value：【 [{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}] 】[82]
// ------------------------------------------------[86]
// 5.1.、遍历JSONArray（（数组或者Json等都可以用它））[87]
// object：【 {"companyId":1,"companyName":"汽车公司"} 】[91]
// object：【 {"companyId":2,"companyName":"房产公司"} 】[91]
1.2、添加和删除字段
1.2.1、基本数据、日期，对象，集合数据添加
1.2.2、JSONObject放入一个JSONObject
1.2.3、两个JSONObject 合并为一个
1.2.4、删除某个节点
/**
* 2、添加和删除字段
* 1、正常数据添加
* 2、JSONObject放入一个JSONObject
* 3、两个JSONObject 合并为一个
*/
@Test
public void add() {
// 1、正常数据添加
JSONObject jsonObject = new JSONObject();
jsonObject.put("reqSn", UUID.randomUUID().toString().replace("-", ""));
jsonObject.put("msg", "Success");
jsonObject.put("code", 200);
jsonObject.put("transDate", new Date());
jsonObject.put("strList", Arrays.asList(new String[]{"奔驰", "宝马"}));
jsonObject.put("user", new JsonDemoDTO.User().setUserId(1L).setUserName("HealerJean"));
jsonObject.put("companys", Arrays.asList(new JsonDemoDTO.Company[]{
new JsonDemoDTO.Company().setCompanyId(1L).setCompanyName("汽车公司"),
new JsonDemoDTO.Company().setCompanyId(2L).setCompanyName("房产公司")}));
log.info("jsonObject_1 ：【 {} 】", jsonObject);
// 2、JSONObject放入一个JSONObject
JSONObject fieldJsonObject = new JSONObject();
fieldJsonObject.put("key", "Str");
jsonObject.put("fieldJsonObject", fieldJsonObject);
log.info("2、JSONObject放入一个JSONObject ：【 {} 】", jsonObject);
// 3、两个JSONObject 合并为一个
JSONObject userJsonObject = new JSONObject();
// 4、删除某个节点
jsonObject.remove("user");
userJsonObject.put("user", new JsonDemoDTO.User().setUserId(1L).setUserName("HealerJean"));
jsonObject.putAll(userJsonObject);
log.info("3、两个JSONObject 合并为一个 ：【 {} 】", jsonObject);
}
1.3、复杂JSONObject遍历
/**
* 3、 复杂JSONObject遍历
*/
@Test
public void test3() {
String json = JsonDemoDTO.jsonString();
log.info("jsonString：【 {} 】", json);
JSONObject jsonObject = JSONObject.fromObject(json);
//1、获取Json的key集合
for (Object key : jsonObject.keySet()) {
//2、获取某个Key的值
Object value = jsonObject.get(key);
//2、判断是对象-JSONObject吗？
if (value instanceof JSONObject) {
log.info("key 【 {} 】， JSONObject对象 ：【 {} 】", key, value);
}
//3、判断是数组-JSONArray 吗？
else if (value instanceof JSONArray) {
//4、数组迭代
Iterator it = ((JSONArray) value).iterator();
while (it.hasNext()) {
Object object = it.next();
if (object instanceof JSONObject) {
log.info("数组中的JSONObject ：【 {} 】", value);
} else {
log.info("普通数组 ：【 {} 】", value);
}
}
//7、 普通元素
} else {
log.info("key 【 {} 】， 普通元素 ：【 {} 】", key, value);
}
}
}
jsonString：【 {"reqSn":"337017699e4c46daaeaa22e48f304017","code":200,"msg":"Success","transDate":1572354757185,"integer":100,"bigDecimal":100,"user":{"userId":1,"userName":"HealerJean"},"strList":["奔驰","宝马"],"companys":[{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}]} 】 com.healerjean.proj.a_test.json.netSfJson.D01NetSfJson.test3[172]
key 【 reqSn 】， 普通元素 ：【 337017699e4c46daaeaa22e48f304017 】 com.healerjean.proj.a_test.json.netSfJson.D01NetSfJson.test3[198]
key 【 code 】， 普通元素 ：【 200 】 com.healerjean.proj.a_test.json.netSfJson.D01NetSfJson.test3[198]
key 【 msg 】， 普通元素 ：【 Success 】 com.healerjean.proj.a_test.json.netSfJson.D01NetSfJson.test3[198]
key 【 transDate 】， 普通元素 ：【 1572354757185 】 com.healerjean.proj.a_test.json.netSfJson.D01NetSfJson.test3[198]
key 【 integer 】， 普通元素 ：【 100 】 com.healerjean.proj.a_test.json.netSfJson.D01NetSfJson.test3[198]
key 【 bigDecimal 】， 普通元素 ：【 100 】 com.healerjean.proj.a_test.json.netSfJson.D01NetSfJson.test3[198]
key 【 user 】， JSONObject对象 ：【 {"userId":1,"userName":"HealerJean"} 】 com.healerjean.proj.a_test.json.netSfJson.D01NetSfJson.test3[182]
普通数组 ：【 ["奔驰","宝马"] 】 com.healerjean.proj.a_test.json.netSfJson.D01NetSfJson.test3[193]
普通数组 ：【 ["奔驰","宝马"] 】 com.healerjean.proj.a_test.json.netSfJson.D01NetSfJson.test3[193]
数组中的JSONObject ：【 [{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}] 】 com.healerjean.proj.a_test.json.netSfJson.D01NetSfJson.test3[191]
数组中的JSONObject ：【 [{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}] 】 com.healerjean.proj.a_test.json.netSfJson.D01NetSfJson.test3[191]
1.4、序列化
1.4.1、对象转Json
1.4.1.1、日期序列化会变成如下
{"date":29,"day":2,"hours":17,"minutes":41,"month":9,"seconds":27,"time":1572342087782,"timezoneOffset":-480,"year":119} ，
@Test
public void testStringDateOrLong() throws IOException {
JsonDemoDTO jsonDemoDTO = new JsonDemoDTO();
jsonDemoDTO.setTransDate(new Date());
JSONObject jsonObject = JSONObject.fromObject(jsonDemoDTO);
log.info("对象转JSONObject 【 {} 】", jsonObject);
// {"code":0,"companys":[],"msg":"","reqSn":"","strList":[],"transDate":{"date":29,"day":2,"hours":17,"minutes":41,"month":9,"seconds":27,"time":1572342087782,"timezoneOffset":-480,"year":119},"user":null}
}
2、Jackson
2.1、1、JsonNode的获取数据以及基本使用
注意点 JsonNode 使用log打印出的结果不是我们想要的，所以我们要使用 jsonNode.toString()
2.1.1、获取数据值（默认取到的是JsonNode）
JsonNode类型 rootNode.path("fieldName")、 rootNode.get("fieldName") 一般建议使用get
String类型 node.textValue() node.asText() node.toString()
Integer类型 node.intValue() asInt()
BigDecimal类型 node.decimalValue() ,所以一般建议使用 基本类型Value()
2.1.2、判断是不是数组（对象数组、对象、普通字段），判断是不是对象,判断是否拥有某个节点
2.1.3、简单遍历JsonNode , 获取key的迭代集 rootNode.fieldNames()
2.1.4、遍历 JsonNode（数组或者Json等都可以用它）
/**
* 1、JsonNode的获取数据以及基本使用
* 注意点 JsonNode 使用log打印出的结果不是我们想要的，所以我们要使用 jsonNode.toString()
* 1.1、获取数据值（默认取到的是JsonNode）
* JsonNode类型 rootNode.path("fieldName")、 rootNode.get("fieldName") 一般建议使用get
* String类型 node.textValue() node.asText() node.toString()
* Integer类型 node.intValue() asInt()
* BigDecimal类型 node.decimalValue() ,所以一般建议使用 基本类型Value()
* 1.2、判断是不是数组（对象数组或者普通数组，普通数据值），判断是不是对象,判断是否拥有某个节点
* 1.3、简单遍历JsonNode , 获取key的迭代集 rootNode.fieldNames()
* 1.4、遍历 JsonNode（数组或者Json等都可以用它）
* 1.5、遍历某个JsonNode的key和value(value可能是字符串也可能是子jsonNode，但如果value是jsonNode数组的话，是无法读取的)
*/
@Test
public void test1() {
String json = JsonDemoDTO.jsonString();
log.info("jsonString：【 {} 】", json);
JsonNode rootNode = JsonUtils.toJsonNode(json);
//1、获取数据值（默认取到的是JsonNode）
// JsonNode类型 rootNode.path("fieldName")、 rootNode.get("fieldName") 一般建议使用get
// String类型 node.textValue() node.asText() node.toString()
// Integer类型 node.intValue() asInt()
// BigDecimal类型 node.decimalValue() ,所以一般建议使用 基本类型Value()
log.info("------------------------------------------------");
log.info("1、获取数据值（默认取到的是JsonNode）");
String msg = rootNode.get(CommonConstants.msg).textValue();
String msgText = rootNode.get(CommonConstants.msg).asText();
int code = rootNode.get(CommonConstants.code).asInt();
Integer integer = rootNode.get(CommonConstants.integer).intValue();
BigDecimal bigDecimal = rootNode.get(CommonConstants.bigDecimal).decimalValue();
JsonNode userJsonNode = rootNode.get(CommonConstants.user);
JsonNode companyJsonNodeArray = rootNode.get(CommonConstants.companys);
JsonNode strJsonNodeArray = rootNode.get(CommonConstants.strList);
log.info("msg：【 {} 】", msg);
log.info("msgText：【 {} 】", msgText);
log.info("code：【 {} 】", code);
log.info("integer：【 {} 】", integer);
log.info("bigDecimal：【 {} 】", bigDecimal);
log.info("userJsonNode：【 {} 】", userJsonNode.toString());
log.info("companyJsonNodeArray：【 {} 】", companyJsonNodeArray.toString());
log.info("strJsonNodeArray：【 {} 】", strJsonNodeArray.toString());
// 2、判断是不是数组（对象数组或者普通数组），判断是不是对象,判断是否拥有某个节点
log.info("------------------------------------------------");
log.info("2、判断是不是数组（对象数组或者普通数组），判断是不是对象,判断是否拥有某个节点");
Boolean flagObject = userJsonNode.isObject();
Boolean flagArray = strJsonNodeArray.isArray();
Boolean flagValue = userJsonNode.isValueNode();
Boolean exist = rootNode.has(CommonConstants.msg);
log.info("flagObject：【 {} 】", flagObject);
log.info("flagArray：【 {} 】", flagArray);
log.info("flagValue：【 {} 】", flagValue);
log.info("exist：【 {} 】", exist);
//3、简单遍历JsonNode , 获取key的迭代集 rootNode.fieldNames()
log.info("------------------------------------------------");
log.info("3、简单遍历JsonNode , 获取key的迭代集 rootNode.fieldNames()");
Iterator<String> keys = rootNode.fieldNames();
while (keys.hasNext()) {
// 2、获取节点的key值
String key = keys.next();
JsonNode jsonNode = rootNode.get(key);
log.info("key：【 {} 】,value：【 {} 】", key, jsonNode.toString());
}
// 4、遍历 JsonNode（数组或者Json等都可以用它）
log.info("------------------------------------------------");
log.info("4、遍历 JsonNode（数组或者Json等都可以用它）");
for (JsonNode jsonNode : companyJsonNodeArray) {
log.info("jsonNode1：【 {} 】", jsonNode.toString());
}
// 5、遍历某个JsonNode的key和value(value可能是字符串也可能是子jsonNode，但如果value是jsonNode数组的话，是无法读取的)
Iterator<Map.Entry<String, JsonNode>> jsonNodes = companyJsonNodeArray.fields();
while (jsonNodes.hasNext()) {
Map.Entry<String, JsonNode> jsonNode = jsonNodes.next();
log.info("jsonNode2：【 {} 】", jsonNode.toString());
}
// jsonString：【 {"reqSn":"9f2aa3a63dcb493b97accc5fd4eee169","code":200,"msg":"Success","transDate":1572347467277,"integer":100,"bigDecimal":100,"user":{"userId":1,"userName":"HealerJean"},"strList":["奔驰","宝马"],"companys":[{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}]} 】 [35]
// ------------------------------------------------ [44]
// 1、获取数据值（默认取到的是JsonNode） [45]
// msg：【 Success 】 [55]
// msgText：【 Success 】 [56]
// code：【 200 】 [57]
// integer：【 100 】 [58]
// bigDecimal：【 100 】 [59]
// userJsonNode：【 {"userId":1,"userName":"HealerJean"} 】 [60]
// companyJsonNodeArray：【 [{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}] 】 [61]
// strJsonNodeArray：【 ["奔驰","宝马"] 】 [62]
// ------------------------------------------------ [65]
// 3、判断是不是数组（对象数组或者普通数组），判断是不是对象,判断是否拥有某个节点 [66]
// flagObject：【 true 】 [75]
// flagArray：【 true 】 [74]
// flagValue：【 false 】
// exist：【 true 】 [79]
// ------------------------------------------------ [83]
// 3、简单遍历JsonNode , 获取key的迭代集 rootNode.fieldNames() [84]
// key：【 reqSn 】,value：【 "9f2aa3a63dcb493b97accc5fd4eee169" 】 [90]
// key：【 code 】,value：【 200 】 [90]
// key：【 msg 】,value：【 "Success" 】 [90]
// key：【 transDate 】,value：【 1572347467277 】 [90]
// key：【 integer 】,value：【 100 】 [90]
// key：【 bigDecimal 】,value：【 100 】 [90]
// key：【 user 】,value：【 {"userId":1,"userName":"HealerJean"} 】 [90]
// key：【 strList 】,value：【 ["奔驰","宝马"] 】 [90]
// key：【 companys 】,value：【 [{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}] 】 [90]
// ------------------------------------------------ [95]
// 4、遍历 JsonNode（数组或者Json等都可以用它） [96]
// jsonNode：【 {"companyId":1,"companyName":"汽车公司"} 】 [98]
// jsonNode：【 {"companyId":2,"companyName":"房产公司"} 】 [98]
}
2.2、添加和删除字段
2.2.1、基本数据添加、（日期，对象，集合数据不能直接添加，可以考虑将这些变成objectNode，在进行整合）
2.2.2、ObjectNode放入一个ObjectNode
2.2.3、两个ObjectNode 合并为一个
2.2.4、删除某个节点
/**
* 添加和删除
* 1、基本数据添加、（日期，对象，集合数据不能直接添加，可以考虑将这些变成objectNode，在进行整合）
* 2、ObjectNode放入一个ObjectNode
* 3、两个ObjectNode 合并为一个
* 4、删除某个节点
*/
@Test
public void test2() {
String json = "{\"userId\":1,\"userName\":\"HealerJean\"}";
String json1 = "{\"companyId\":1,\"companyName\":\"汽车公司\"}";
log.info("json：【 {} 】", json);
log.info("json1：【 {} 】", json1);
ObjectNode objectNode = JsonUtils.toObjectNode(json);
ObjectNode objectNode1 = JsonUtils.toObjectNode(json1);
// 1、基本数据添加、（日期，对象，集合数据不能直接添加，可以考虑将这些变成objectNode，在进行整合）
objectNode.put("reqSn", UUID.randomUUID().toString().replace("-", ""));
objectNode.put("msg", "Success");
objectNode.put("code", 200);
// objectNode.put("transDate", new Date());
// objectNode.put("strList", Arrays.asList(new String[]{"奔驰", "宝马"}));
// objectNode.put("user", new JsonDemoDTO.User().setUserId(1L).setUserName("HealerJean"));
// 2、ObjectNode放入一个ObjectNode
objectNode.putPOJO("node", objectNode1);
// 3、两个ObjectNode 合并为一个
objectNode.putAll(objectNode1);
//4、删除某个节点
objectNode.remove("userId");
JsonNode jsonNode = objectNode;
log.info("jsonNode 【 {} 】", jsonNode.toString());
}
2.3、复杂JsonNode遍历
/**
* 3、 复杂JsonNode遍历
*/
@Test
public void test3() {
String json = JsonDemoDTO.jsonString();
log.info("jsonString：【 {} 】", json);
JsonNode rootNode = JsonUtils.toJsonNode(json);
//1、获取Json节点的key集合
Iterator<String> keys = rootNode.fieldNames();
while (keys.hasNext()) {
// 2、获取节点的key值
String key = keys.next();
//3、获取key获取某个节点
JsonNode value = rootNode.get(key);
//4、判断节点是一个对象
if (value.isObject()) {
log.info("key 【 {} 】， Json对象 ：【 {} 】", key, value.toString());
}
//5、判断节点是数组
else if (value.isArray()) {
// 普通数组没有fieldName ，所以得到的name内部不存在，不会进入while循环，也不会报错
// Iterator<String> nodeKeys = jsonNode.fieldNames();
// while (nodeKeys.hasNext()) {
// log.info("nodeKeys.next()" + nodeKeys.next());
//}
for (JsonNode node : value) {
if (node.isObject()) {
log.info("数组中的Json对象 :" + node.toString());
} else {
log.info("普通数组 ：【 {} 】", node.toString());
}
}
} else {
log.info("key 【 {} 】， 普通元素 ：【 {} 】", key, value.toString());
}
}
// jsonString：【 {"reqSn":"2305bbd5be23448082918daf2aaccfd0","code":200,"msg":"Success","transDate":1572348749670,"integer":100,"bigDecimal":100,"user":{"userId":1,"userName":"HealerJean"},"strList":["奔驰","宝马"],"companys":[{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}]} 】 [178]
// key 【 reqSn 】， 普通元素 ：【 "2305bbd5be23448082918daf2aaccfd0" 】 [208]
// key 【 code 】， 普通元素 ：【 200 】 [208]
// key 【 msg 】， 普通元素 ：【 "Success" 】 [208]
// key 【 transDate 】， 普通元素 ：【 1572348749670 】 [208]
// key 【 integer 】， 普通元素 ：【 100 】 [208]
// key 【 bigDecimal 】， 普通元素 ：【 100 】 [208]
// key 【 user 】， Json对象 ：【 {"userId":1,"userName":"HealerJean"} 】 [191]
// 普通数组 ：【 "奔驰" 】 [204]
// 普通数组 ：【 "宝马" 】 [204]
// 数组中的Json对象 :{"companyId":1,"companyName":"汽车公司"} [202]
// 数组中的Json对象 :{"companyId":2,"companyName":"房产公司"} [202]
}
2.4、配置对象中null的元素转Json后不存在
**
* 4、配置对象中null的元素转Json后不存在
*/
@Test
public void test4() throws JsonProcessingException {
// 1、注解@JsonInclude(JsonInclude.Include.NON_NULL)
// 2。objectmapper配置
JsonDemoDTO jsonDemoDTO = new JsonDemoDTO();
jsonDemoDTO.setTransDate(new Date());
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
String json = objectMapper.writeValueAsString(jsonDemoDTO);
log.info("对象转Json 【 {} 】", json);
// {"code":0,"transDate":1572343184051}
}
2.5、序列化
2.5.1、对象转Json
2.5.1.1、日期序列化会变成Long
/**
* 5、序列化问题：
* 对象转JSONObject 序列化的日期 变成 Long 1572343018614
*/
@Test
public void test5() throws JsonProcessingException {
JsonDemoDTO jsonDemoDTO = new JsonDemoDTO();
jsonDemoDTO.setTransDate(new Date());
ObjectMapper objectMapper = new ObjectMapper();
String json = objectMapper.writeValueAsString(jsonDemoDTO);
log.info("对象转JSON 【 {} 】", json);
//{"reqSn":null,"code":0,"msg":null,"transDate":1572343018614,"user":null,"strList":null,"companys":null}
JsonNode jsonNode = objectMapper.valueToTree(jsonDemoDTO);
log.info("对象转JsonNode：【{}】", jsonNode);
}
3、Gson
3.1、JsonObject的获取数据以及基本使用
3.1.1、获取数据值（默认取到的是JsonElement）
3.1.2、JsonArray中获取 JsonObject对象
3.1.3、判断是不是数组（对象数组或者普通数组），，判断是不是对象,判断是否拥有某个节点
3.1.4、简单遍历jsonObject
3.1.5、遍历JsonArray
3.1.5.1、遍历正常JsonArray
3.1.5.2、遍历String集合的JsonArray
/**
* 1、JsonObject的获取数据以及基本使用
* 1.1、获取数据值（默认取到的是JsonElement）
* 1.2、JsonArray中获取 JsonObject对象
* 1.3、判断是不是数组（对象数组或者普通数组），，判断是不是对象,判断是否拥有某个节点
* 1.4、简单遍历jsonObject
* 1.5.1.、遍历正常JsonArray
* 1.5.2、遍历String集合的JsonArray
*/
@Test
public void test1() {
String json = JsonDemoDTO.jsonString();
log.info("jsonString：【 {} 】", json);
JsonParser parser = new JsonParser();
JsonObject jsonObject = parser.parse(json).getAsJsonObject();
// 1、获取数据值（默认取到的是JsonElement）
log.info("------------------------------------------------");
log.info("1、获取数据值（默认取到的是JsonElement）");
String msg = jsonObject.get(CommonConstants.msg).getAsString();
int code = jsonObject.get(CommonConstants.code).getAsInt();
BigDecimal bigDecimal = jsonObject.get(CommonConstants.bigDecimal).getAsBigDecimal();
JsonObject userJsonObject = jsonObject.get(CommonConstants.user).getAsJsonObject();
JsonArray companyJsonArray = jsonObject.get(CommonConstants.companys).getAsJsonArray();
JsonArray strJsonArray = jsonObject.get(CommonConstants.strList).getAsJsonArray();
log.info("msg：【 {} 】", msg);
log.info("code：【 {} 】", code);
log.info("bigDecimal：【 {} 】", bigDecimal);
log.info("userJsonObject：【 {} 】", userJsonObject);
log.info("companyJsonArray：【 {} 】", companyJsonArray);
log.info("strJsonArray：【 {} 】", strJsonArray);
// 2、JsonArray中获取 JsonObject对象
log.info("------------------------------------------------");
log.info(" 2、JsonArray中获取 JsonObject对象");
JsonObject company0 = companyJsonArray.get(0).getAsJsonObject();
log.info("company0：【 {} 】", company0);
// 3、判断是不是数组（对象数组或者普通数组），，判断是不是对象,判断是否拥有某个节点
log.info("------------------------------------------------");
log.info("3、判断是不是数组（对象数组或者普通数组），判断是不是对象,判断是否拥有某个节点");
Boolean flagObject = userJsonObject.isJsonObject();
Boolean flagArray = companyJsonArray.isJsonArray();
Boolean exist = userJsonObject.has(CommonConstants.msg);
log.info("flagObject：【 {} 】", flagObject);
log.info("flagArray：【 {} 】", flagArray);
log.info("exist：【 {} 】", exist);
// 4、简单遍历jsonObject
log.info("------------------------------------------------");
log.info("4、简单遍历jsonObject");
Set<String> keys = jsonObject.keySet();
for (String key : keys) {
Object value = jsonObject.get(key);
log.info("key：【 {} 】,value：【 {} 】", key, value);
}
//5.1.、遍历正常JsonArrayy
log.info("------------------------------------------------");
log.info("5.1.、遍历正常JsonArrayy");
Iterator iteratorCompany = companyJsonArray.iterator();
while (iteratorCompany.hasNext()) {
Object object = iteratorCompany.next();
log.info("object：【 {} 】", object);
}
//5.2、遍历String集合的JsonArrayy
log.info("------------------------------------------------");
log.info("5.2、遍历String集合的JsonArrayy");
Iterator iteratorCar = strJsonArray.iterator();
while (iteratorCar.hasNext()) {
Object object = iteratorCar.next();
log.info("object：【 {} 】", object);
}
// jsonString：【 {"reqSn":"e5b9e4c6a5e0460b930ed4d38e3c75d4","code":200,"msg":"Success","transDate":1572351096471,"integer":100,"bigDecimal":100,"user":{"userId":1,"userName":"HealerJean"},"strList":["奔驰","宝马"],"companys":[{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}]} 】[101]
// ------------------------------------------------[107]
// 1、获取数据值（默认取到的是JsonElement）[108]
// msg：【 Success 】[115]
// code：【 200 】[116]
// bigDecimal：【 100 】[117]
// userJsonObject：【 {"userId":1,"userName":"HealerJean"} 】[118]
// companyJsonArray：【 [{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}] 】[119]
// strJsonArray：【 ["奔驰","宝马"] 】[120]
// ------------------------------------------------[123]
// 2、JsonArray中获取 JsonObject对象[124]
// company0：【 {"companyId":1,"companyName":"汽车公司"} 】[126]
// ------------------------------------------------[130]
// 3、判断是不是数组（对象数组或者普通数组），判断是不是对象,判断是否拥有某个节点[131]
// flagObject：【 true 】[135]
// flagArray：【 true 】[136]
// exist：【 false 】[137]
// ------------------------------------------------[141]
// 4、简单遍历jsonObject[142]
// key：【 reqSn 】,value：【 "e5b9e4c6a5e0460b930ed4d38e3c75d4" 】[146]
// key：【 code 】,value：【 200 】[146]
// key：【 msg 】,value：【 "Success" 】[146]
// key：【 transDate 】,value：【 1572351096471 】[146]
// key：【 integer 】,value：【 100 】[146]
// key：【 bigDecimal 】,value：【 100 】[146]
// key：【 user 】,value：【 {"userId":1,"userName":"HealerJean"} 】[146]
// key：【 strList 】,value：【 ["奔驰","宝马"] 】[146]
// key：【 companys 】,value：【 [{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}] 】[146]
// ------------------------------------------------[150]
// 5.1.、遍历正常JsonArrayy[151]
// object：【 {"companyId":1,"companyName":"汽车公司"} 】[155]
// object：【 {"companyId":2,"companyName":"房产公司"} 】[155]
// ------------------------------------------------[159]
// 5.2、遍历String集合的JsonArrayy[160]
// object：【 "奔驰" 】[164]
// object：【 "宝马" 】[164]
//
// //1、添加基本数据
// jsonObject.addProperty("age",27);
// //2、添加Json对象
// JsonElement param = parser.parse(paramJson);
// jsonObject.add("param" ,param);
// System.out.println(jsonObject.toString());
// //{"cars":["奔驰","宝马"],"friends":[{"friendName":"小明","friendSex":"男"},{"friendName":"小花","friendSex":"女"}],"age":27,"param":{"name":"张宇晋","date":"Sep 12, 2019 2:11:52 PM"}}
}
3.2、添加和删除字段
3.2.1、基本数据添加、（日期，对象，集合数据不能直接添加，可以考虑将这些变成JSONObject，在进行整合）
3.2.2、JSONObject放入一个JSONObject
3.2.3、两个JSONObject 合并为一个 (借助工具类)
3.2.4、删除某个节点
/**
* 2、添加和删除字段
* 1、基本数据添加、（日期，对象，集合数据不能直接添加，可以考虑将这些变成JSONObject，在进行整合）
* 2、JSONObject放入一个JSONObject
* 3、两个JSONObject 合并为一个 (借助工具类)
* 4、删除某个节点
*/
@Test
public void test2() {
// 1、正常数据添加 只能放入基本类型数据
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty("reqSn", UUID.randomUUID().toString().replace("-", ""));
jsonObject.addProperty("msg", "Success");
jsonObject.addProperty("code", 200);
//不可以放入日期属性，集合属性,对象属性
// jsonObject.addProperty("transDate", new Date());
// jsonObject.addProperty("strList", Arrays.asList(new String[]{"奔驰", "宝马"}));
// jsonObject.addProperty("user", new JsonDemoDTO.User().setUserId(1L).setUserName("HealerJean"));
log.info("jsonObject_1 ：【 {} 】", jsonObject);
// 2、JSONObject放入一个JSONObject
JsonObject fieldJsonObject = new JsonObject();
fieldJsonObject.addProperty("key", "Str");
fieldJsonObject.add("key", fieldJsonObject);
log.info("2、JSONObject放入一个JSONObject ：【 {} 】", jsonObject);
// 3、两个JSONObject 合并为一个
JsonObject userJsonObject = new JsonObject();
// 4、删除某个节点
jsonObject.remove("msg");
userJsonObject.addProperty("userKey", "JsonObject");
GsonUtil.putAll(jsonObject, userJsonObject);
log.info("3、两个JsonObject 合并为一个 ：【 {} 】", jsonObject);
}
3.3、序列化
3.3.1、对象转Json
3.3.1.1、日期序列化之后会变成 “Oct 29, 2019 7:39:03 PM”
@Test
public void test3_1() {
Gson gson = new Gson();
JsonDemoDTO jsonDemoDTO = JsonDemoDTO.jsonDemo();
String json = gson.toJson(jsonDemoDTO);
log.info("对象转Json【 {} 】", json);
// 对象转Json【 {"reqSn":"a615312e8a854387881e34570d93a37f","code":200,"msg":"Success","transDate":"Oct 29, 2019 7:39:03 PM","integer":100,"bigDecimal":100,"user":{"userId":1,"userName":"HealerJean"},"strList":["奔驰","宝马"],"companys":[{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}]} 】
}
3.3.2、Json转对象
/**
* 3.2、Json转对象
*/
@Test
public void test3_2() {
Gson gson = new Gson();
JsonDemoDTO jsonDemoDTO = new JsonDemoDTO().setMsg("Success");
String json = gson.toJson(jsonDemoDTO);
jsonDemoDTO = gson.fromJson(json, JsonDemoDTO.class);
log.info("Json转对象【 {} 】", jsonDemoDTO);
// Json转对象【 {"code":0,"msg":"Success"} 】
}
3.3.3、Json/对象转JsonObject
注意：必须经历String类型，才能到JsonObject
@Test
public void test3_3() {
String json = "{\"code\":0,\"msg\":\"Success\"}";
JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();
log.info("Json转JsonObject 【 {} 】", jsonObject.toString());
JsonDemoDTO jsonDemoDTO = new JsonDemoDTO().setMsg("Success");
Gson gson = new Gson();
json = gson.toJson(jsonDemoDTO);
jsonObject = new JsonParser().parse(json).getAsJsonObject();
log.info("对象转JsonObject 【 {} 】", jsonObject.toString());
}
3.3.4、json转集合、集合转Json（使用工具类，转化为JsonArray，然后进行拼接）
/**
* json转集合
* 注意，1、转化为JsonArray，然后进行拼接
*/
@Test
public void test3_4() {
JsonDemoDTO jsonDemo1 = new JsonDemoDTO().setMsg("Success");
JsonDemoDTO jsonDemo2 = new JsonDemoDTO().setMsg("Error");
List<JsonDemoDTO> list = new ArrayList<>();
list.add(jsonDemo1);
list.add(jsonDemo2);
String json = GsonUtil.toJsonString(list);
list = GsonUtil.toList(json, JsonDemoDTO.class);
log.info("json转集合 【 {} 】", list);
}
public static <T> List<T> toList(String json, Class<T> cls) {
List<T> list = new ArrayList<T>();
JsonArray array = parser.parse(json).getAsJsonArray();
for (final JsonElement elem : array) {
list.add(gson.fromJson(elem, cls));
}
return list;
}
4、FastJson
4.1、JSONObject的获取数据以及基本使用
4.1.1、获取数据值
4.1.2、JSONArray中获取 JsonObject对象
4.1.3、判断JSONObject是否存在节点
4.1.4、简单遍历 JSONObject
4.1.5、遍历JSONArray
4.1.5.1.、遍历正常JSONArray
4.1.5.2、遍历String集合的JSONArray
/**
* 1、JSONObject的获取数据以及基本使用
* 1、获取数据值
* 2、JSONArray中获取 JsonObject对象
* 3、判断JSONObject是否存在节点
* 4、简单遍历 JSONObject
* 5、遍历JSONArray
* 5.1.、遍历正常JSONArray
* 5.2、遍历String集合的JSONArray
*
*/
@Test
public void test1() {
String json = JsonDemoDTO.jsonString();
log.info("jsonString：【 {} 】", json);
JSONObject jsonObject = JSONObject.parseObject(json);
// 1、获取数据值
log.info("------------------------------------------------");
log.info("1、从JSONObject中获取简单数据");
String msg = jsonObject.getString(CommonConstants.msg);
int code = jsonObject.getIntValue(CommonConstants.code);
BigDecimal bigDecimal = jsonObject.getBigDecimal(CommonConstants.bigDecimal);
JSONObject userJSONObject = jsonObject.getJSONObject(CommonConstants.user);
JSONArray companyJSONArray = jsonObject.getJSONArray(CommonConstants.companys);
JSONArray strJSONArray = jsonObject.getJSONArray(CommonConstants.strList);
log.info("msg：【 {} 】", msg);
log.info("code：【 {} 】", code);
log.info("bigDecimal：【 {} 】", bigDecimal);
log.info("userJSONObject：【 {} 】", userJSONObject);
log.info("companyJSONArray：【 {} 】", companyJSONArray);
log.info("strJSONArray：【 {} 】", strJSONArray);
// 2、JSONArray中获取 JsonObject对象
log.info("------------------------------------------------");
log.info(" 2、JsonArray中获取 JsonObject对象");
JSONObject company0 = companyJSONArray.getJSONObject(0);
log.info("company0：【 {} 】", company0);
// 3、判断JSONObject是否存在节点
log.info("------------------------------------------------");
log.info("3、判断JSONObject是否存在节点");
Boolean flagContainsKey = jsonObject.containsKey(CommonConstants.msg);
log.info("flagContainsKey：【 {} 】", flagContainsKey);
//4、简单遍历 JSONObject
log.info("------------------------------------------------");
log.info("4、简单遍历 JSONObject");
for (Object key : jsonObject.keySet()) {
Object value = jsonObject.get(key);
log.info("key：【 {} 】,value：【 {} 】", key, value);
}
//5.1.、遍历正常JSONArray
log.info("------------------------------------------------");
log.info("5.1.、遍历正常JSONArray");
Iterator iteratorCompany = companyJSONArray.iterator();
while (iteratorCompany.hasNext()) {
Object object = iteratorCompany.next();
log.info("object：【 {} 】", object);
}
//5.2、遍历String集合的JSONArray
log.info("------------------------------------------------");
log.info("5.2、遍历String集合的JSONArray");
Iterator iteratorCar = strJSONArray.iterator();
while (iteratorCar.hasNext()) {
Object object = iteratorCar.next();
log.info("object：【 {} 】", object);
}
}
// jsonString：【 {"reqSn":"5b0ac33c6f5b4931b9311c9b98243d9c","code":200,"msg":"Success","transDate":1572356266239,"integer":100,"bigDecimal":100,"user":{"userId":1,"userName":"HealerJean"},"strList":["奔驰","宝马"],"companys":[{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}]} 】 [36]
// ------------------------------------------------ [40]
// 1、从JSONObject中获取简单数据 [41]
// msg：【 Success 】 [48]
// code：【 200 】 [49]
// bigDecimal：【 100 】 [50]
// userJSONObject：【 {"userName":"HealerJean","userId":1} 】 [51]
// companyJSONArray：【 [{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}] 】 [52]
// strJSONArray：【 ["奔驰","宝马"] 】 [53]
// ------------------------------------------------ [57]
// 2、JsonArray中获取 JsonObject对象 [58]
// company0：【 {"companyId":1,"companyName":"汽车公司"} 】 [60]
// ------------------------------------------------ [64]
// 3、判断JSONObject是否存在节点 [65]
// flagContainsKey：【 true 】 [67]
// ------------------------------------------------ [70]
// 4、简单遍历 JSONObject [71]
// key：【 msg 】,value：【 Success 】 [74]
// key：【 code 】,value：【 200 】 [74]
// key：【 strList 】,value：【 ["奔驰","宝马"] 】 [74]
// key：【 companys 】,value：【 [{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}] 】 [74]
// key：【 transDate 】,value：【 1572356266239 】 [74]
// key：【 integer 】,value：【 100 】 [74]
// key：【 bigDecimal 】,value：【 100 】 [74]
// key：【 user 】,value：【 {"userName":"HealerJean","userId":1} 】 [74]
// key：【 reqSn 】,value：【 5b0ac33c6f5b4931b9311c9b98243d9c 】 [74]
// ------------------------------------------------ [78]
// 5.1.、遍历正常JSONArray [79]
// object：【 {"companyId":1,"companyName":"汽车公司"} 】 [83]
// object：【 {"companyId":2,"companyName":"房产公司"} 】 [83]
// ------------------------------------------------ [87]
// 5.2、遍历String集合的JSONArray [88]
// object：【 奔驰 】 [92]
// object：【 宝马 】 [92]
4.2、添加和删除字段
4.2.1、基本数据、日期，对象，集合数据添加
4.2.2、JSONObject放入一个JSONObje
4.2.3、两个JSONObject 合并为一个
4.2.4、删除某个节点
/**
* 2、添加和删除字段
* 1、基本数据、日期，对象，集合数据添加
* 2、JSONObject放入一个JSONObject
* 3、两个JSONObject 合并为一个
* 4、删除某个节点
*/
@Test
public void test2() {
// 1、基本数据、日期，对象，集合数据添加
JSONObject jsonObject = new JSONObject();
jsonObject.put("reqSn", UUID.randomUUID().toString().replace("-", ""));
jsonObject.put("msg", "Success");
jsonObject.put("code", 200);
jsonObject.put("transDate", new Date());
jsonObject.put("strList", Arrays.asList(new String[]{"奔驰", "宝马"}));
jsonObject.put("user", new JsonDemoDTO.User().setUserId(1L).setUserName("HealerJean"));
jsonObject.put("companys", Arrays.asList(new JsonDemoDTO.Company[]{
new JsonDemoDTO.Company().setCompanyId(1L).setCompanyName("汽车公司"),
new JsonDemoDTO.Company().setCompanyId(2L).setCompanyName("房产公司")}));
log.info("jsonObject_1 ：【 {} 】", jsonObject);
// 2、JSONObject放入一个JSONObject
JSONObject fieldJsonObject = new JSONObject();
fieldJsonObject.put("key", "Str");
jsonObject.put("fieldJsonObject", fieldJsonObject);
log.info("2、JSONObject放入一个JSONObject ：【 {} 】", jsonObject);
// 3、两个JSONObject 合并为一个
JSONObject userJsonObject = new JSONObject();
// 4、删除某个节点
jsonObject.remove("user");
userJsonObject.put("user", new JsonDemoDTO.User().setUserId(1L).setUserName("HealerJean"));
jsonObject.putAll(userJsonObject);
log.info("3、两个JSONObject 合并为一个 ：【 {} 】", jsonObject);
}
4.3、序列化
4.3.1、对象转转Json
4.3.1.1、日期序列化会变成Long
/**
* 对象转转Json
* 日期序列化会变成Long
*/
@Test
public void test3_1() {
JsonDemoDTO jsonDemoDTO = JsonDemoDTO.jsonDemo();
String json = JSONObject.toJSONString(jsonDemoDTO);
log.info("对象转Json【 {} 】", json);
//对象转Json【 {"bigDecimal":100,"code":200,"companys":[{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}],"integer":100,"msg":"Success","reqSn":"85db4a55277d4d0da05692b94239717c","strList":["奔驰","宝马"],"transDate":1572353435560,"user":{"userId":1,"userName":"HealerJean"}} 】
}
4.3.2、Json转对象
/**
* json转对象
*/
@Test
public void test3_2() {
String json = JsonDemoDTO.jsonString();
JsonDemoDTO jsonDemoDTO = JSONObject.parseObject(json, JsonDemoDTO.class);
log.info("Json转对象【 {} 】", jsonDemoDTO);
//Json转对象【 {"bigDecimal":100,"code":200,"companys":[{"companyId":1,"companyName":"汽车公司"},{"companyId":2,"companyName":"房产公司"}],"integer":100,"msg":"Success","reqSn":"72fa274d3b4f4c3ab9453f0c74859754","strList":["奔驰","宝马"],"transDate":1572353529387,"user":{"userId":1,"userName":"HealerJean"}} 】
}
4.3.3、Json/对象转JSONObject
注意：必须经历String类型，才能到JSONObject
/**
* json/对象转JSONObject
* 注意：必须经历String类型，才能到JSONObject
*/
@Test
public void test3_3() {
String json = JsonDemoDTO.jsonString();
JSONObject jsonObject = JSONObject.parseObject(json);
log.info("Json转JSONObject【 {} 】", jsonObject.toJSONString());
JsonDemoDTO jsonDemoDTO = JsonDemoDTO.jsonDemo();
jsonObject = JSONObject.parseObject(JSONObject.toJSONString(jsonDemoDTO));
log.info("对象转JsonObject 【 {} 】", jsonObject.toJSONString());
}
4.3.4、Json转集合、集合转Json
/**
* 4、 json转集合
*/
@Test
public void toList() {
JsonDemoDTO jsonDemo1 = new JsonDemoDTO().setMsg("Success");
JsonDemoDTO jsonDemo2 = new JsonDemoDTO().setMsg("Error");
List<JsonDemoDTO> list = new ArrayList<>();
list.add(jsonDemo1);
list.add(jsonDemo2);
String json = JSONObject.toJSONString(list);
list = JSONObject.parseArray(json, JsonDemoDTO.class);
log.info("json转集合 【 {} 】", list);
}
工具类
1、JsonUtils
package com.healerjean.proj.util.json;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.healerjean.proj.util.sensitivity.SensitiveInfoUtils;
import com.healerjean.proj.util.sensitivity.SensitiveSerializerModifier;
import com.healerjean.proj.util.sensitivity.SensitiveTypeEnum;
import com.healerjean.proj.util.sensitivity.SensitivityConstants;
import java.io.IOException;
import java.lang.reflect.Type;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Utils - JSON
*/
public final class JsonUtils {
/**
* ObjectMapper
*/
private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
private static final ObjectMapper OBJECT_MAPPER_SENSITIVITY = new ObjectMapper();
static {
OBJECT_MAPPER.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
//NULL 不打印
OBJECT_MAPPER.setSerializationInclusion(JsonInclude.Include.NON_NULL);
// 排除json字符串中实体类没有的字段
OBJECT_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
//LocalDateTime LocalDate LocalTime 转化成 String
JavaTimeModule javaTimeModule = new JavaTimeModule();
javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
OBJECT_MAPPER.registerModule(javaTimeModule);
OBJECT_MAPPER.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//脱敏日志创建
OBJECT_MAPPER_SENSITIVITY.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
OBJECT_MAPPER_SENSITIVITY.setSerializationInclusion(JsonInclude.Include.NON_NULL);
OBJECT_MAPPER_SENSITIVITY.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
OBJECT_MAPPER_SENSITIVITY.registerModule(javaTimeModule);
OBJECT_MAPPER_SENSITIVITY.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//脱敏
OBJECT_MAPPER_SENSITIVITY.setSerializerFactory(OBJECT_MAPPER_SENSITIVITY.getSerializerFactory().withSerializerModifier(new SensitiveSerializerModifier()));
}
public static ObjectMapper getObjectMapper() {
return OBJECT_MAPPER;
}
/**
* 1、将对象转换为JSON字符串
*/
public static String toJsonString(Object value) {
try {
return OBJECT_MAPPER.writeValueAsString(value);
} catch (JsonProcessingException e) {
throw new RuntimeException(e.getMessage(), e);
}
}
/**
* 2.1、将JSON字符串转换为对象
*/
public static <T> T toObject(String json, Class<T> c) {
try {
return OBJECT_MAPPER.readValue(json, c);
} catch (IOException e) {
throw new RuntimeException(e.getMessage(), e);
}
}
/**
* 2.2、Json格式字符串转对象 ArrayList
*/
public static <T> List<T> toArrayList(String json, Class<T> c) {
JavaType javaType = OBJECT_MAPPER.getTypeFactory()
.constructParametricType(ArrayList.class, c);
List<T> t = null;
try {
t = OBJECT_MAPPER.readValue(json, javaType);
} catch (IOException e) {
throw new RuntimeException("参数格式有误");
}
return t;
}
/**
* 2.3、Json格式字符串转集合
* collect 仅限于 ArrayList HashSet 等集合对象
*/
public static <T> T toArrayList(String json, Class c, Class collect) {
JavaType javaType = OBJECT_MAPPER.getTypeFactory().constructParametricType(collect, c);
try {
return OBJECT_MAPPER.readValue(json, javaType);
} catch (IOException e) {
throw new RuntimeException("参数格式有误");
}
}
/**
* 2.5、将JSON字符串转换为对象
*/
public static <T> T toObject(String json, JavaType javaType) {
try {
return OBJECT_MAPPER.readValue(json, javaType);
} catch (IOException e) {
throw new RuntimeException(e.getMessage(), e);
}
}
/**
* 2.4、将JSON字符串转换为集合、map 不可以是对象
* List<JavaBean> list = JsonUtils.toObject(jsonArrayStr, new TypeReference<List<JavaBean>>() { });
* Map<String, Object> map = JsonUtils.toObject(JsonUtils.toJson(javaBean),new TypeReference<Map<String, Object>>( ){} );
*/
public static <T> T toObject(String json, TypeReference<?> typeReference) {
try {
return OBJECT_MAPPER.readValue(json, typeReference);
} catch (IOException e) {
throw new RuntimeException(e.getMessage(), e);
}
}
/**
* 将JSON字符串转换为树
*/
public static JsonNode toJsonNode(String json) {
try {
return OBJECT_MAPPER.readTree(json);
} catch (JsonProcessingException e) {
throw new RuntimeException(e.getMessage(), e);
} catch (IOException e) {
throw new RuntimeException(e.getMessage(), e);
}
}
/**
* 将JSON字符串转换为toObjectNode
*/
public static ObjectNode toObjectNode(String json) {
try {
return (ObjectNode) OBJECT_MAPPER.readTree(json);
} catch (JsonProcessingException e) {
throw new RuntimeException(e.getMessage(), e);
} catch (IOException e) {
throw new RuntimeException(e.getMessage(), e);
}
}
/**
* 放入一个对象
*/
public static String putObject(String jsonString, String key, String replaceString) {
ObjectNode jsonNode = null;
ObjectNode keyJsonNode = null;
try {
jsonNode = (ObjectNode) OBJECT_MAPPER.readTree(jsonString);
keyJsonNode = (ObjectNode) OBJECT_MAPPER.readTree(replaceString);
} catch (IOException e) {
throw new RuntimeException(e.getMessage(), e);
}
jsonNode.putPOJO(key, keyJsonNode);
return JsonUtils.toJsonString(jsonNode);
}
/**
* 通过 OBJECT_MAPPER.readValue(json, javaType) 转化为对象
* 参数举例： A.class
*/
public static JavaType toJavaType(Type type) {
return OBJECT_MAPPER.getTypeFactory().constructType(type);
}
/**
* 通过 BJECT_MAPPER.readValue(json, javaType) 转化为 集合、map等
* 参数举例：new TypeReference<List<JavaBean>>() { }
*/
public static JavaType toJavaType(TypeReference<?> typeReference) {
return OBJECT_MAPPER.getTypeFactory().constructType(typeReference);
}
/**
* 格式化到控制台打印
*/
public static String formatJson(String resString) {
StringBuffer jsonForMatStr = new StringBuffer();
int level = 0;
////将字符串中的字符逐个按行输出
for (int index = 0; index < resString.length(); index++) {
//获取s中的每个字符
char c = resString.charAt(index);
//level大于0并且jsonForMatStr中的最后一个字符为\n,jsonForMatStr加入\t
if (level > 0 && '\n' == jsonForMatStr.charAt(jsonForMatStr.length() - 1)) {
jsonForMatStr.append(getLevelStr(level));
}
//遇到"{"和"["要增加空格和换行，遇到"}"和"]"要减少空格，以对应，遇到","要换行
switch (c) {
case '{':
case '[':
jsonForMatStr.append(c + "\n");
level++;
break;
case ',':
jsonForMatStr.append(c + "\n");
break;
case '}':
case ']':
jsonForMatStr.append("\n");
level--;
jsonForMatStr.append(getLevelStr(level));
jsonForMatStr.append(c);
break;
default:
jsonForMatStr.append(c);
break;
}
}
return jsonForMatStr.toString();
}
/**
*
*/
private static String getLevelStr(int level) {
StringBuffer levelStr = new StringBuffer();
for (int levelI = 0; levelI < level; levelI++) {
levelStr.append("\t");
}
return levelStr.toString();
}
/**
* 对象转Json格式字符串----脱敏处理(包含map)
*/
public static String toJsonStringWithSensitivity(Object propName) {
if (propName != null && propName instanceof Map) {
Map map = (Map) propName;
if (map != null && !map.isEmpty()) {
Set<Map.Entry> set = map.entrySet();
for (Map.Entry item : set) {
Object key = item.getKey();
Object value = item.getValue();
if (key instanceof String) {
String keyString = key.toString();
String s = dealSensitivity(keyString, value.toString());
map.put(keyString, s);
}
}
}
}
try {
return OBJECT_MAPPER_SENSITIVITY.writeValueAsString(propName);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return null;
}
private static String dealSensitivity(String mapkey, String mapValue) {
//正则匹配
for (Map.Entry<String, SensitiveTypeEnum> entry : SensitivityConstants.sensitivityRules.entrySet()) {
String rule = entry.getKey();
int length = rule.length();
int propLen = mapkey.length();
if (mapkey.length() < length) {
continue;
}
int temp = rule.indexOf("*");
String key = null;
String substring = null;
if (temp >= 0) {
if (temp < (length >> 2)) {
key = rule.substring(temp + 1, length);
substring = mapkey.substring(propLen - key.length(), propLen);
} else {
key = rule.substring(0, temp);
substring = mapkey.substring(0, temp);
}
if (substring.equals(key)) {
return SensitiveInfoUtils.sensitveValue(entry.getValue(), mapValue);
}
} else if (rule.equals(mapkey)) {
return SensitiveInfoUtils.sensitveValue(entry.getValue(), mapValue);
}
}
return mapValue;
}
}
2、GsonUtils
package com.healerjean.proj.util.gson;
import com.google.gson.*;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
/**
* @author HealerJean
* @ClassName GsonUtils
* @date 2019/9/12 11:41.
* @Description
*/
public class GsonUtil {
private static Gson gson = null;
private static JsonParser parser = null;
static {
GsonBuilder gb = new GsonBuilder();
gb.registerTypeAdapter(java.util.Date.class, new DateSerializer()).setDateFormat(DateFormat.LONG);
gb.registerTypeAdapter(java.util.Date.class, new DateDeserializer()).setDateFormat(DateFormat.LONG);
gson = gb.create();
parser = new JsonParser();
}
/**
* 转成json
*/
public static String toJsonString(Object object) {
return gson.toJson(object);
}
/**
* 转成bean
*/
public static <T> T toObject(String gsonString, Class<T> cls) {
return gson.fromJson(gsonString, cls);
}
/**
* 转换成JsonObject
*/
public static JsonObject toJsonObject(String gsonString) {
return parser.parse(gsonString).getAsJsonObject();
}
/**
* 转换成数组
*/
public static JsonArray toJsonArray(String gsonString) {
return parser.parse(gsonString).getAsJsonArray();
}
/**
* 对象转 JsonObject
*/
public static JsonObject toJsonObject(Object object) {
return toJsonElement(object).getAsJsonObject();
}
public static JsonElement toJsonElement(Object object) {
return parser.parse(toJsonString(object));
}
/**
* 转成list
*/
public static <T> List<T> toList(String json, Class<T> cls) {
List<T> list = new ArrayList<T>();
JsonArray array = parser.parse(json).getAsJsonArray();
for (final JsonElement elem : array) {
list.add(gson.fromJson(elem, cls));
}
return list;
}
/**
* 合并多个JsonObejct对象
*/
public static JsonObject putAll(JsonObject targetJsonObect, JsonObject tempJsonObejct) {
Set<String> keys = tempJsonObejct.keySet();
for (String key : keys) {
targetJsonObect.add(key, tempJsonObejct.get(key));
}
return targetJsonObect;
}
}
2.1、日期序列化Long工具
##### 2.1.1、DateSerializer
package com.healerjean.proj.util.gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonPrimitive;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
import java.lang.reflect.Type;
import java.util.Date;
/**
* @author HealerJean
* @ClassName DateSerializer
* @date 2019/9/12 16:31.
* @Description
*/
public class DateSerializer implements JsonSerializer<Date> {
@Override
public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) {
return new JsonPrimitive(src.getTime());
}
}
2.1.2、DateDeserializer
package com.healerjean.proj.util.gson;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;
import java.lang.reflect.Type;
import java.util.Date;
/**
* @author HealerJean
* @ClassName DateDeserializer
* @date 2019/9/12 16:31.
* @Description
*/
public class DateDeserializer implements JsonDeserializer<Date> {
@Override
public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
return new Date(json.getAsJsonPrimitive().getAsLong());
}
}
3、FastJsonUtils
package com.healerjean.proj.util.fastjson;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import java.util.List;
/**
* @author HealerJean
* @ClassName FastJsonUtils
* @date 2019/11/7 19:33.
* @Description
* JSON是一个抽象类，JSON中有一个静态方法parseObject(String text)，将text解析为一个JSONObject对象并返回;
* * JSONObject是一个继承自JSON的类，当调用JSONObject.parseObject(result)时，会直接调用父类的parseObject(String text)。
* * 所以两者没什么区别，一个是用父类去调用父类自己的静态的parseObject(String text)，一个是用子类去调用父类的静态parseObject(String text)，两者调的是同一个方法
*
*/
public class FastJsonUtils {
public static <T> T toObject(String str, Class<T> clazz) {
// return JSON.parseObject(str, clazz);一样的
return JSONObject.parseObject(str, clazz);
}
public static String toJsonString(Object obj) {
return JSON.toJSONString(obj);
}
/**
* json格式解析为List集合，不解决格式时间问题
*/
public static <T> List<T> jsonTolist(String str, Class<T> clazz) {
return JSON.parseArray(str, clazz);
}
}
