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

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

时间是一种解药

22998人浏览 · 2022-04-02 14:18:24

时间是一种解药 · 2022-04-02 14:18:24 发布

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

问题背景
JSON字符串出参递归
代码测试
总结
Lyric：我们笑得很甜

问题背景

最近做一个项目，整个项目里面都是递归取参数，组装参数，粗滤算了一下有20个左右的递归，简直把我一辈子的递归写够了
注意事项：

可以复制文章的代码自己创建工程，也可以下载源码进行参考

JSON字符串出参递归

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

{
	"data": [{
		"msg": "成功",
		"status": "300",
		"data": {
			"records": [{
				"coder": "6d5",
				"name": "yuan",
				"type": "0001"
			}],
			"page_info": {
				"total": 1,
				"page_no": 1,
				"page_size": 1
			}
		}
	}],
	"code": "200",
	"globalId": "df666"
}

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 整个项目目录

代码测试

1 启动main函数，可以看到把json字符串的每个key和value都解析出来了

总结

如果是解析json字符串，应该还是算常用的递归

作为程序员第 93 篇文章，每次写一句歌词记录一下，看看人生有几首歌的时间，wahahaha …

Lyric：我们笑得很甜

华为云开发者联盟

为开发者提供学习成长、分享交流、生态实践、资源工具等服务，帮助开发者快速成长。

更多推荐

cover

openEuler系统通过shell脚本安装openGauss 5.0.0企业版

华为云开发者联盟

cover

一文了解npm install -g和npm install --save-dev的关系

华为云开发者联盟

cover

【FAQ】HarmonyOS SDK 闭源开放能力 —Map Kit（2）

华为云开发者联盟

所有评论(0)

查看更多评论

时间是一种解药

已为社区贡献27条内容