java递归实现动态解析json字符串未知key的方法

最新推荐文章于 2025-05-18 09:33:36 发布

转载最新推荐文章于 2025-05-18 09:33:36 发布 · 2.6k 阅读

javase 专栏收录该内容

31 篇文章

订阅专栏

本文介绍了一种使用Java递归方法动态解析未知结构JSON字符串的技术。通过将JSON转换为Map，可灵活处理不同前端传入的数据，适用于界面数据结构多变的场景。递归方法覆盖了基本JSON对象及数组，确保数据的完整解析。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

java递归实现动态解析json字符串未知key的方法

2018年05月05日 23:12:44 喜欢原味奶茶阅读数：683

以下maven依赖需要一起加载

<dependency>
     <groupId>net.sf.json-lib</groupId>
     <artifactId>json-lib</artifactId>
     <version>2.4</version>
     <classifier>jdk15</classifier>
</dependency>
<dependency>
    <groupId>commons-lang</groupId>
    <artifactId>commons-lang</artifactId>
    <version>2.6</version>
</dependency>
<dependency>
    <groupId>commons-httpclient</groupId>
    <artifactId>commons-httpclient</artifactId>
    <version>3.1</version>
</dependency>
<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>1.8.3</version>
</dependency>
<dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.2</version>
</dependency>
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.1.1</version>
</dependency>
<dependency>
    <groupId>net.sf.ezmorph</groupId>
    <artifactId>ezmorph</artifactId>
    <version>1.0.6</version>
</dependency>
<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib-ext-spring</artifactId>
    <version>1.0.2</version>
</dependency>
---------------------

1、递归一

有的时候我们需要解析未知的json。或者说是动态的json。那么我们并不知道key具体是多少，或者说key不是固定的。这时候就需要解析动态key的方法。

这个方法是我在实现解析前台传入的json时所需要的。因为每个界面的前台传的是json是不固定的。如果真对每一个页面所传的数据都单独进行一次解析，那么太麻烦了。所以需要一个通用的解析方式。将其解析到map中。那么只需要调用该方法，就能获取到前台所传json对于的map。

在网上搜了一会，找不到我想要的方法，即不和我心意，代码又不给全。所以自己测试了一个简单的代码。我是使用递归实现的，代码简单。就不一一讲解了，如果还有不清楚的，请留言。

package jsonTest;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import net.sf.json.JSONObject;

public class JsonTest {
    public static void main(String[] args) {
        //测试字符串
        String test = "{a:1,b:2,c:3,d:{q:4,w:5,e:6,y:{o:7,p:8}}}";
        Map res = new HashMap();
        //递归遍历解析方法
        iteraJson(test,res);
        //解析得到最终map后，遍历该map输出值
        Set keySet = res.keySet();
        Iterator iterator = keySet.iterator();
        while(iterator.hasNext()){
            String key = iterator.next().toString();
            Object val = res.get(key);
            System.out.println(key+":"+val.toString());
        }
    }
    //递归遍历解析方法
    public static boolean iteraJson(String str,Map res){
      //因为json串中不一定有逗号，但是一定有：号，所以这里判断没有则已经value了
        if(str.toString().indexOf(":") == -1){
            return true;
        }
        JSONObject fromObject = JSONObject.fromObject(str);
        Iterator keys = fromObject.keys();
        while(keys.hasNext()){
            String key = keys.next().toString();
            Object value = fromObject.get(key);
            if(iteraJson(value.toString(),res)){
                res.put(key, value);
            }
        }
        return false;
    }
}

效果如下：
这里写图片描述

2、递归二

上面的递归方式只支持没有包含数组格式的json字符串。例如：

        String test = "{a:1,b:[1,2,3],c:3,d:{q:4,w:5,e:6,y:{o:7,p:8}},arry:[{name1:'joker',age:30},{name2:'dd',age:20},{name3:'bb',age:10}]}";

b:[1,2,3] 这个数组是正规数组，不是json数组，不需要解析。
arry:[{name1:’joker’,age:30},{name2:’dd’,age:20},{name3:’bb’,age:10}]。这个是json数组，需要继续解析。
要实现这两个格式的兼容。下面的代码能够实现：

    public static boolean iteraJsonOrArray(String source,Map map){
        if(source.indexOf(":") == -1){
            return true;
        }
        JSONObject fromObject = JSONObject.fromObject(source);
        Iterator keys = fromObject.keys();
        while(keys.hasNext()){
            String key = keys.next().toString();
            Object value = fromObject.get(key);
            String val = value.toString();
            if(val.indexOf("[{") == -1){
                //说明不存在数组json即格式为："[{" 开头的数据。可以允许是[10,11,12]的非json数组
                if(val.indexOf(":") == -1){
                    map.put(key, val);
                }else{
                    iteraJson(val,map);
                }
            }else if(val.indexOf("[{") != -1){
                //说明存在数组json即格式为：[{开头的json数组
                if(val.indexOf("[{") == 0){
                    //说明当前value就是一个json数组
                    //去除[括号
                    String jsons = val.substring(1, val.lastIndexOf("]"));//得到数据格式为：{...},{...},{...}
                    //把上面得到jsons分割成数组
                        //因为数据格式为{name:joker,age:20},{...},{...}，所以不能用逗号分割。否则会变"{name:joker" "age:20}"
                        //使用正则表达式把},{替换成}|{
                    jsons = jsons.replaceAll("\\}\\s?,\\s?\\{", "}|{");
                    String[] split = jsons.split("\\|");
                    for(int i = 0; i < split.length;i++){
                        iteraJsonOrArray(split[i],map);//符合当前递归条件
                    }

                }else{
                    //说明value可能是一个json，这个json中任然包含数组。例如：{inner:[{a:1,b:2,c:3}]}
                    iteraJsonOrArray(val,map);//符合当前递归条件
                }
            }

        }

        return false;
    }

把 iteraJsonOrArray 方法写到递归一中的代码里。因为这个方法里调用了递归一中的iteraJson来解析没包含任何数组类型的json串。

执行代码

        String test = "{a:1,b:[1,2,3],c:3,d:{q:4,w:5,e:6,y:{o:7,p:8}},arry:[{name1:'joker',age:30},{name2:'dd',age:20},{name3:'bb',age:10}]}";
        Map res = new HashMap();
        iteraJsonOrArray(test,res);
        Set keySet = res.keySet();
        Iterator iterator = keySet.iterator();
        while(iterator.hasNext()){
            String key = iterator.next().toString();
            Object val = res.get(key);
            System.out.println(key+":"+val.toString());
        }

效果如下:
这里写图片描述

注意：上图中的name我分为name1,name2,name3。上图只有一个age。因为key重名了，所以放入map中自然会被覆盖掉。如果三个name一样，最后只能得到一个name一个age.

3、递归三

**
递归二的方式可以实现大部分json格式。但是遇到key相同的json就不好保存数据。
比如：{arry:[{name:joker,age:15},{name:jake,age:20},{name:mari,age:25}]};这种格式用递归二的话，放入map中，最后只得到name:mari 和 age:25。

所以我们需要把所有的值都保存起来，那么就不是放入map中，而是list中了。
如下图，在递归二中创建临时tempmap和list。然后把list添加到最终map中。
这里写图片描述