多层级动态结构的JSON数据如何解析_gson解析多层json

两个工具
GSON
Google Gson是一个简单的基于Java的库，用于将Java对象序列化为JSON，反之亦然。 它是由Google开发的一个开源库。
以下几点说明为什么应该使用这个库 -
标准化 - Gson是一个由Google管理的标准化库。
高效 - 这是对Java标准库的可靠，快速和高效的扩展。
优化 - Gson库经过高度优化。
支持泛型 - 它为泛型提供了广泛的支持。
支持复杂的内部类 - 它支持具有深度继承层次结构的复杂对象。
OGNL表达式
OGNL表达式是Object-Graph Navigation Language的缩写，是一种功能强大的表达式语言，通过简单一致的表达式语法，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转换。
开发指南

<dependency>
        <groupId>ognl</groupId>
        <artifactId>ognl</artifactId>
        <version>3.1.1</version>
    </dependency>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.9.0</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
    </dependency>
</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

工具类

public class JsonUtils {
    /**
     * 将指定JSON转为Map对象，Key固定为String，对应JSONkey
     * Value分情况：
     * 1. Value是字符串，自动转为字符串,例如:{"a","b"}
     * 2. Value是其他JSON对象，自动转为Map，例如：{"a":{"b":"2"}}}
     * 3. Value是数组，自动转为List<Map>，例如：{"a":[{"b":"2"},"c":"3"]}
     * @param json 输入的JSON对象
     * @return 动态的Map集合
     */
    public static Map<String,Object> transferToMap(String json) {
        Gson gson = new Gson();
        Map<String, Object> map = gson.fromJson(json,
                new TypeToken<Map<String, Object>>() {
                }.getType());
        return map;
    }

    /**
     * 简化方法
     * @param json 原始的JSON数据
     * @param path OGNL规则表达式
     * @param clazz Value对应的目标类
     * @return clazz对应数据
     */
    public static <T> T getValue(String json, String path, Class<T> clazz) {
        try {
            Map map = transferToMap(json);
            OgnlContext context = new OgnlContext();
            context.setRoot(map);
            T value = (T) Ognl.getValue(path, context, context.getRoot());
            return value;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public static <T> T getValueFromMap(Map map, String path, Class<T> clazz) {
        try {
            OgnlContext context = new OgnlContext();
            context.setRoot(map);
            T value = (T) Ognl.getValue(path, context, context.getRoot());
            return value;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

测试用例

import com.itlaoqi.JsonUtils;
import org.junit.Test;

import java.util.List;
import java.util.Map;

public class JsonCase {
    /**
     * {
     *     "a": {
     *         "b": {
     *             "c": {
     *                 "d": {
     *                     "e": "nothing"
     *                 }
     *             }
     *         }
     *     }
     * }
     */
    /**
     * 超多层级JSON嵌套的快速提取
     */
    @Test
    public void case0(){
        String text = "{\n" +
                "    \"a\": {\n" +
                "        \"b\": {\n" +
                "            \"c\": {\n" +
                "                \"d\": {\n" +
                "                    \"e\": \"nothing\"\n" +
                "                }\n" +
                "            }\n" +
                "        }\n" +
                "    }\n" +
                "}";
        Map<String, Object> jsonMap = JsonUtils.transferToMap(json);

        String e = JsonUtils.getValue(text, "a.b.c.d.e", String.class);
        System.out.println(e);
    }

    /**
     * {
     * "showapi_res_error": "",
     * "showapi_res_id": "628cc9850de3769f06edbb49",
     * "showapi_res_code": 0,
     * "showapi_fee_num": 1,

     * }
     */
    private String json = "{\n" +
            "\"showapi_res_error\": \"\",\n" +
            "\"showapi_res_id\": \"628cc9850de3769f06edbb49\",\n" +
            "\"showapi_res_code\": 0,\n" +
            "\"showapi_fee_num\": 1,\n" +

            "}";

    //将JSON转为标准Map结构
    @Test
    public void case1(){
        Map<String, Object> jsonMap = JsonUtils.transferToMap(json);
        System.out.println(jsonMap);
    }
    /**
     * OGNL直接提取数据，Value为子JSON对象的情况
     */
    @Test
    public void case2(){
        Map<String, Object> jsonMap = JsonUtils.transferToMap(json);
        Map resBody = JsonUtils.getValue(json, "showapi_res_body", Map.class);
        System.out.println(resBody);
    }

    /**
     * OGNL直接提取数据，Value为标准字符串的情况
     */
    @Test
    public void case3(){
        Map<String, Object> jsonMap = JsonUtils.transferToMap(json);
        String value = JsonUtils.getValue(json, "showapi_res_body.area", String.class);
        System.out.println(value);
    }

    /**
     * OGNL直接提取数据，Value为标准字符串的情况，Value为数组的情况
     */
    @Test
    public void case4(){
        Map<String, Object> jsonMap = JsonUtils.transferToMap(json);
        List<Map> hourList = JsonUtils.getValue(json, "showapi_res_body.hourList", List.class);
        System.out.println(hourList);
        // 每一个集合对象都是List
        for(Map hour : hourList){
            System.out.println(hour);
        }
    }

    /**
     * 利用List语法获取第6个时点天气预报
     */
    @Test
    public void case5(){
        Map<String, Object> jsonMap = JsonUtils.transferToMap(json);
        String area = JsonUtils.getValue(json, "showapi_res_body.hourList[5].weather_code", String.class);
        System.out.println(area);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109