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

如果满意,请打赏博主任意金额,感兴趣的在微信转账的时候,添加博主微信哦, 请下方留言吧。可与博主自由讨论哦

支付包 微信 微信公众号
支付宝 微信 微信公众号
posted @ 2019-10-29 21:50  HealerJean  阅读(1179)  评论(0编辑  收藏  举报