4大Json工具詳細使用說明

前言

Json在項目開發中使用的太多了，各種關於Json的依賴也是不斷地額退出，JackJson net.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

1.1.5.1.、遍歷正常JSONArray

1.1.5.2、遍歷String集合的JSONArray

    /**
     * JsonObject的基本使用
     * 1、從JSONObject中獲取簡單數據
     * 2、JSONArray中獲取 JSONObject對象
     * 3、判斷JSONObject是否是數組，是否存在節點
     * 4、簡單遍歷 JSONObject
     * 5.1.、遍歷正常JSONArray
     * 5.2、遍歷String集合的JSONArray
     */
    @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
        log.info("------------------------------------------------");
        log.info("5.1.、遍歷正常JSONArray");
        Iterator iteratorCompany = companyJSONArray.iterator();
        while (iteratorCompany.hasNext()) {
            Object object = iteratorCompany.next();
            log.info("object：【 {} 】", object);
        }
        
}







// jsonString：【 {"reqSn":"58ed7f656bf1415c884bdd1a0a653dc7","code":200,"msg":"Success","transDate":1572354378560,"integer":100,"bigDecimal":100,"user":{"userId":1,"userName":"HealerJean"},"strList":["奔馳","寶馬"],"companys":[{"companyId":1,"companyName":"汽車公司"},{"companyId":2,"companyName":"房產公司"}]} 】 [38]
//         ------------------------------------------------ [42]
// 1、從JSONObject中獲取簡單數據 [43]
// msg：【 Success 】 [49]
// code：【 200 】 [50]
// userJsonObject：【 {"userId":1,"userName":"HealerJean"} 】 [51]
// companyJsonArray：【 [{"companyId":1,"companyName":"汽車公司"},{"companyId":2,"companyName":"房產公司"}] 】 [52]
// strJsonArrayy：【 ["奔馳","寶馬"] 】 [53]
//         ------------------------------------------------ [56]
// 2、JSONArray中獲取 JSONObject對象 [57]
// company0：【 {"companyId":1,"companyName":"汽車公司"} 】 [59]
//         ------------------------------------------------ [67]
// 3、判斷JSONObject是否是數組，是否存在節點 [68]
// flagArray：【 true 】 [72]
// flag：【 true 】 [73]
// flagContainsKey：【 true 】 [74]
//         ------------------------------------------------ [77]
// 4、簡單遍歷 JSONObject [78]
// key：【 reqSn 】,value：【 58ed7f656bf1415c884bdd1a0a653dc7 】 [81]
// key：【 code 】,value：【 200 】 [81]
// key：【 msg 】,value：【 Success 】 [81]
// key：【 transDate 】,value：【 1572354378560 】 [81]
// key：【 integer 】,value：【 100 】 [81]
// key：【 bigDecimal 】,value：【 100 】 [81]
// key：【 user 】,value：【 {"userId":1,"userName":"HealerJean"} 】 [81]
// key：【 strList 】,value：【 ["奔馳","寶馬"] 】 [81]
// key：【 companys 】,value：【 [{"companyId":1,"companyName":"汽車公司"},{"companyId":2,"companyName":"房產公司"}] 】 [81]
//         ------------------------------------------------ [85]
// 5.1.、遍歷正常JSONArray [86]
// object：【 {"companyId":1,"companyName":"汽車公司"} 】 [90]
// object：【 {"companyId":2,"companyName":"房產公司"} 】 [90]
//         ------------------------------------------------ [95]
// 5.2、遍歷String集合的JSONArray [96]
// object：【 奔馳 】 [100]
// object：【 寶馬 】 [100]

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等都可以用它）

 @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 exist = rootNode.has(CommonConstants.msg);

        log.info("flagObject：【 {} 】", flagObject);
        log.info("flagArray：【 {} 】", flagArray);
        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("jsonNode：【 {} 】", 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]
        // 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}
    }

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.JsonGenerationException;
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.databind.type.TypeFactory;
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.io.Writer;
import java.lang.reflect.Type;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
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  objectMapperSensitivity = 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);




        //脫敏日誌創建
        objectMapperSensitivity.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS,false);
        objectMapperSensitivity.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        objectMapperSensitivity.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
        objectMapperSensitivity.registerModule(javaTimeModule);
        objectMapperSensitivity.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //脫敏
        objectMapperSensitivity.setSerializerFactory(objectMapperSensitivity.getSerializerFactory().withSerializerModifier(new SensitiveSerializerModifier()));

    }

    public static ObjectMapper getObjectMapper() {
        return OBJECT_MAPPER;
    }


    /**
     * 將對象轉換爲JSON字符串
     *
     * @param value 對象
     * @return JSON字符串
     */
    public static String toJsonString(Object value) {
        try {
            return OBJECT_MAPPER.writeValueAsString(value);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    /**
     * 將JSON字符串轉換爲對象
     *
     * @param json      JSON字符串
     * @param c 類型
     * @return 對象
     */
    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);
        }
    }

    /**
     * 將JSON字符串轉換爲對象
     * @param json          JSON字符串
     * @param typeReference 類型 可以通過這個轉化爲List集合 ，舉例：
     *                      List<JavaBean> list =  JsonUtils.toObject(jsonArrayStr, new TypeReference<List<JavaBean>>() { });
     *                      Map<String, Object> map =  JsonUtils.toObject(JsonUtils.toJson(javaBean),new TypeReference<Map<String, Object>>( ){} );
     * @return 對象
     */
    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字符串轉換爲對象
     *
     * @param json     JSON字符串
     * @param javaType 類型
     * @return 對象
     */
    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);
        }
    }




    /**
     * 將JSON字符串轉換爲樹
     *
     * @param json JSON字符串
     * @return 樹
     */
    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);
        }
    }

    /**
     * 將對象轉換爲JSON流
     *
     * @param writer Writer
     * @param value  對象
     */
    public static void writeValue(Writer writer, Object value) {
        try {
            OBJECT_MAPPER.writeValue(writer, value);
        } catch (JsonGenerationException e) {
            throw new RuntimeException(e.getMessage(), e);
        } catch (JsonMappingException e) {
            throw new RuntimeException(e.getMessage(), e);
        } catch (IOException e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }


    /**
     * 構造類型
     * @param type 類型,類，接口，枚舉字段類型 （java.class）
     * @return 類型
     */
    public static JavaType constructType(Type type) {
        return TypeFactory.defaultInstance().constructType(type);
    }


    /**
     * 構造類型
     * @param typeReference 類型 new TypeReference<List<JavaBean>>() { }
     * @return 類型
     */
    public static JavaType constructType(TypeReference<?> typeReference) {
        return TypeFactory.defaultInstance().constructType(typeReference);
    }


    /**
     * @param resString
     * @return String
     * @Description Json 格式化到控制檯打印
     */
    public static String responseFormat(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();
    }

    /**
     * @param level
     * @return
     * @throws
     */
    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)
     * @return
     */
    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 objectMapperSensitivity.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());
    }
}