包含JSONObject和JSONArray的json字符串进行递归取值，附源码（一）

包含JSONObject和JSONArray的json字符串进行递归组装思路（二）

JSON字符串出参递归

1 如果字符串数据时这样的，需要把所有的key和value解析出来，使用List<HashMap<String, Object>>进行存储

2 pom依赖引入

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.yg</groupId>
    <artifactId>recurseJson</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>recurseJson</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>31.0.1-jre</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
3 递归解析json字符串，以及测试main
package com.yg.recursejson.service;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.yg.recursejson.utils.JsonUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
 * @Author suolong
 * @Date 2022/4/1 11:48
 * @Version 1.5
@Service
@Slf4j
public class RecurseService {
    //递归取key和value，jsonObject表示datas中每一个对象
    //taskInputMap存放每一个jsonObject解析出来的key和value
    private void recurseParseJsonObject(JSONObject jsonObject, HashMap<String, Object> taskInputMap) {
        Set<Map.Entry<String, Object>> entries = jsonObject.entrySet();
        for (Map.Entry<String, Object> entry : entries) {
            //如果value类型为Map，那么说明又是一个jsonObject对象，因此需要继续递归
            if (entry.getValue() instanceof Map) {
                jsonObject = JSON.parseObject(JSON.toJSONString(entry.getValue()));
                recurseParseJsonObject(jsonObject, taskInputMap);
            //如果value类型为List，说明是一个JSONArray，那么使用for循环把里面的每一个jsonObject对象再一次做递归
            else if (entry.getValue() instanceof List) {
                List<JSONObject> jsonList = JsonUtils.jsonToList(JSON.toJSONString(entry.getValue()), JSONObject.class);
                for (JSONObject json : jsonList) {
                    recurseParseJsonObject(json, taskInputMap);
            } else {
                //说明value是一个普通的属性，String，Number
                taskInputMap.put(entry.getKey(), entry.getValue());
    private void saveTaskInputParam(List<JSONObject> datas, List<HashMap<String, Object>> outputList) {
        log.info(("Begin saveTaskInputParam"));
        for (int i = 0; i < datas.size(); i++) {
            HashMap<String, Object> taskInputMap = Maps.newHashMap();
            JSONObject jsonObject = datas.get(i);
            if (jsonObject == null || jsonObject.isEmpty()) {
                continue;
            recurseParseJsonObject(jsonObject, taskInputMap);
         //   log.info("taskInputMap: {}", taskInputMap);
            outputList.add(taskInputMap);
    public static void main(String[] args) {
        String jsonStr = "{\"data\":[{\"msg\":\"成功\",\"status\":\"200\",\"data\":{\"records\":[{\"coder\":\"6d5\",\"name\":\"yuan\",\"type\":\"0001\"}],\"page_info\":{\"total\":1,\"page_no\":1,\"page_size\":1}}}],\"code\":\"200\",\"globalId\":\"df666\"}";
        RecurseService recurseService = new RecurseService();
        JSONObject data = JSON.parseObject(jsonStr);
        List<JSONObject> datas = Lists.newArrayList();
        datas.add(data);
        List<HashMap<String, Object>> outputList = Lists.newArrayList();
        recurseService.saveTaskInputParam(datas, outputList);
        System.out.println(outputList);
4 JsonUtils工具类
package com.yg.recursejson.utils;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
@Slf4j
public final class JsonUtils {
     * 定义jackson对象
    private static final ObjectMapper MAPPER = new ObjectMapper();
     * 将对象转换成json字符串。
     * <p>Title: pojoToJson</p>
     * <p>Description: </p>
     * @param data
     * @return
    public static String objectToJson(Object data) {
        try {
            return MAPPER.writeValueAsString(data);
        } catch (JsonProcessingException e) {
            log.error("JSON Exception", e);
        return null;
     * 将json结果集转化为对象
     * @param jsonData json数据
     * @param beanType 对象中的object类型
     * @return
    public static <T> T jsonToPojo(String jsonData, Class<T> beanType) throws JsonProcessingException {
        try {
            return MAPPER.readValue(jsonData, beanType);
        } catch (JsonProcessingException e) {
            log.error("json结果集转化为对象异常:{}", e.getLocalizedMessage());
            throw e;
     * 将json数据转换成pojo对象list
     * <p>Title: jsonToList</p>
     * <p>Description: </p>
     * @param jsonData
     * @param beanType
     * @return
    public static <T> List<T> jsonToList(String jsonData, Class<T> beanType) {
        JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
        try {
            return MAPPER.readValue(jsonData, javaType);
        } catch (Exception e) {
            log.error("JSON Exception", e);
        return null;
    public static HashMap<String, Object> toHashMap(Object object) {
        HashMap<String, Object> data = new HashMap<>();
        // 将json字符串转换成jsonObject
        JSONObject jsonObject = (JSONObject) object;
        Set<Map.Entry<String, Object>> entries = jsonObject.entrySet();
        for (Map.Entry<String, Object> entry : entries) {
            if (entry == null) {
                continue;
            data.put(entry.getKey(), entry.getValue());
        return data;
5 启动类
package com.yg.recursejson;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class RecurseJsonApplication {
    public static void main(String[] args) {
        SpringApplication.run(RecurseJsonApplication.class, args);
6 整个项目目录