4大Json工具详细使用说明

快来打我* 2023-06-11 08:26 45阅读 0赞

## 前言 ##

Json在项目开发中使用的太多了，各种关于Json的依赖也是不断地额退出，`JackJson` `net.sf.json` 以及阿里巴巴的Json，下面的将我实际项目中对于他们的使用做个介绍 。

## 1、解释和依赖 ##

我这里按照我接触的先后顺序进行

### 1.1、net.sf.json ###

最开始接触的就是它，非常神奇，不用找任何博客就能熟练使用，但是后来借出了JsonNode之后，比较之后二者差的不是一点在使用过程中

<dependency>
                <groupId>net.sf.json-lib</groupId>
                <artifactId>json-lib</artifactId>
                <version>2.4</version>
                <classifier>jdk15</classifier>
            </dependency>
            
            <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>
            
            <dependency>
                <groupId>net.sf.ezmorph</groupId>
                <artifactId>ezmorph</artifactId>
                <version>1.0.6</version>
            </dependency>
            
            <dependency>
                <groupId>commons-collections</groupId>
                <artifactId>commons-collections</artifactId>
                <version>3.2.2</version>
            </dependency>
            
            <dependency>
                <groupId>commons-beanutils</groupId>
                <artifactId>commons-beanutils</artifactId>
                <version>1.8.3</version>
            </dependency>

### 1.2、jackson ###

它就没必要解释了，用的最多的就是它

<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>
    
    
    <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>
    
    
    <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());
        }
    }

![ContactAuthor][]

[ContactAuthor]: /images/20230531/cea8508d554244e6a006460055fe3185.png