Jackson解析多层嵌套的Json类型的字符串数据

 思路：

1. 判断字符串是单独的JSON数据还是JSON数据的数组。如果的JSON数据的数组，需要进行迭代处理。
2. 对于每个JSON数据的对象，获取实体的迭代器对象，然后对迭代器进行遍历。
3. 对于迭代器的每个实体，对值的类型进行判断，根据不同的类型做出不同的处理。
4. 如果值的类型为基本数据类型，则将值进行存储；如果值的类型也为实体，则进行遍历；如果值的类型为数组，则进行迭代。
5. 将处理好的数据保存在JSON文件中。

代码：

import org.nd4j.shade.jackson.core.JsonProcessingException;
import org.nd4j.shade.jackson.databind.JsonNode;
import org.nd4j.shade.jackson.databind.ObjectMapper;

import java.io.File;
import java.io.IOException;
import java.util.*;

public class TraverseStringToJson{

    // 转换字符串为JSON数据，并保存在JSON文件中
    public void traverse(String data) throws JsonProcessingException {
        System.out.println("-------------将字符串转换为json格式-------------------");
        // 创建一个ObjectMapper对象
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode jsonNodes = objectMapper.readTree(data);
        // 遍历JSON对象的所有属性
        // 判断字符串是单独的JSON数据还是JSON数据的数组
        if(jsonNodes.isArray()){
            List list = new ArrayList();
            // 遍历JSON数据数组的所有数据，放在list列表中
            for (JsonNode jsonNode : jsonNodes){
                // 对于每个JSON对象，获取实体的迭代器
                Iterator<Map.Entry<String, JsonNode>> fieldsIterator = jsonNode.fields();
                Map data_map = new HashMap();
                // 对迭代器进行遍历
                while (fieldsIterator.hasNext()) {
                    Map.Entry<String, JsonNode> entry = fieldsIterator.next();
                    // 对每个实体的值的类型进行判断，根据不同的类型做处理
                    traverse_entry(entry,data_map);
                }
                list.add(data_map);
            }
            try {
                // 将JSON字符串写入文件
                objectMapper.writeValue(new File("data.json"), list);

                System.out.println("Data saved to data.json file successfully.");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else {
            Iterator<Map.Entry<String, JsonNode>> fieldsIterator = jsonNodes.fields();
            Map data_map = new HashMap();
            while (fieldsIterator.hasNext()) {
                Map.Entry<String, JsonNode> entry = fieldsIterator.next();
                traverse_entry(entry,data_map);
            }
            try {
                // 将JSON字符串写入文件
                objectMapper.writeValue(new File("data.json"), data_map);
                System.out.println("Data saved to data.json file successfully.");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 对每个实体的值的类型进行判断，根据不同的类型做处理
    private static void traverse_entry(Map.Entry<String, JsonNode> entry,Map data_map){

        String fieldName = entry.getKey();
        JsonNode fieldValue = entry.getValue();

        // 根据不同类型的节点进行处理
        if (fieldValue.isBoolean()) {
            data_map.put(fieldName,fieldValue.asBoolean());
        }else if (fieldValue.isInt()) {
            data_map.put(fieldName,fieldValue.asInt());
        }else if(fieldValue.isDouble()){
            data_map.put(fieldName,fieldValue.asDouble());
        } else if (fieldValue.isTextual()) {
            data_map.put(fieldName,fieldValue.asText());
        } else if (fieldValue.isObject()) {
            // 对于嵌套的对象，递归进行处理
            Map map = traverseObject(fieldValue);
            data_map.put(fieldName,map);
        } else if (fieldValue.isArray()) {
            // 对于数组，进行遍历处理
            List arrayList = new ArrayList();
            for (JsonNode arrayItem : fieldValue) {
                if(arrayItem.isObject()){
                    Map map = traverseObject(arrayItem);
                    arrayList.add(map);
                }else {
                    if (arrayItem.isBoolean()) {
                        arrayList.add(arrayItem.asBoolean());
                    }else if (arrayItem.isInt()) {
                        arrayList.add(arrayItem.asInt());
                    }if(arrayItem.isDouble()){
                        arrayList.add(arrayItem.asDouble());
                    } else if (arrayItem.isTextual()) {
                        arrayList.add(arrayItem.asText());
                    }
                }
            }
            data_map.put(fieldName,arrayList);
        } else {
            // 如果所有类型都不满足，给出提示信息           
            System.out.println("Unsupported field type.");
            System.out.println(fieldValue.toString());
        }
    }

    // 实现对嵌套对象的迭代处理
    private static Map traverseObject(JsonNode objNode) {
        // 遍历嵌套JSON对象的所有属性
        Iterator<Map.Entry<String, JsonNode>> fieldsIterator = objNode.fields();
        Map data_map = new HashMap();
        while (fieldsIterator.hasNext()) {
            Map.Entry<String, JsonNode> entry = fieldsIterator.next();
            traverse_entry(entry,data_map);
        }
        return data_map;
    }
}