Java一次性递归解析json报文为Map(不使用第三方jar包)

最新推荐文章于 2023-04-06 18:02:29 发布
最新推荐文章于 2023-04-06 18:02:29 发布
阅读量3.8k 收藏 3
点赞数 4
分类专栏： Java 文章标签： json解析 java解析json jsontomap jaon递归解析 json全量解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Roy_70/article/details/72231110
版权

一、前言

json报文相信大家都接触过，对于前段JavaScript来说，它是最方便处理的数据格式，而对于后端应用来说，解析json报文并没有xml格式来的那么清晰明了，尤其是对于通用的处理来说很难做到，这里在参考了阿里巴巴的json(非fastjson项目)处理后，十分佩服它的思路，尤其是递归迭代的应用，现在将其源码贴出，供自己以及大家学习。

二、json解析测试

这里使用了一个包含所有数据类型的模拟json报文，来测试解析类是否一次性全部解析完成了

public static void main(String args[]){
        String jsonString = "{\"str\":\"string\",\"num\":100,\"boolean\":true,\"obj\":{\"key1\":\"value1\",\"key2\":\"value2\"},\"list\":[{\"list1\":\"list1\"},{\"list2\":\"list2\"}]}";
        JSONReader jr = new JSONReader();
        Map map = (Map)jr.read(jsonString);
        System.out.println("Json解析完成");
        System.out.println("Map----" + map.toString());
        System.out.println("list----" + map.get("list").getClass().getName() + ":" + map.get("list"));
        System.out.println("str----" + map.get("str").getClass().getName() + ":" + map.get("str"));
        System.out.println("num----" + map.get("num").getClass().getName() + ":" + map.get("num"));
        System.out.println("boolean----" + map.get("boolean").getClass().getName() + ":" + map.get("boolean"));
        System.out.println("obj----" + map.get("obj").getClass().getName() + ":" + map.get("obj"));
    }

测试json体中含有了字符串、数字、布尔、对象以及数组类型，调用一次解析得到一个map，里面各种数据结构均相应解析为对应的java类型，下面是测试输出：

Json解析完成
Map----{str=string, boolean=true, obj={key1=value1, key2=value2}, num=100, list=[{list1=list1}, {list2=list2}]}
list----java.util.ArrayList:[{list1=list1}, {list2=list2}]
str----java.lang.String:string
num----java.lang.Long:100
boolean----java.lang.Boolean:true
obj----java.util.HashMap:{key1=value1, key2=value2}

测试说明解析是成功的，所有的数据类型都相应得到了解析，并且所有层的对象和数组也全部解析了，达到了全部迭代解析的效果。

三、JSONReader类

这里先贴出JSONReader类的全部代码：

package roy.json.util;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.CharacterIterator;
import java.text.StringCharacterIterator;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created with IntelliJ IDEA
 * Created by Roy.
 * Date:2017/5/15
 * Time:21:48
 */
public class JSONReader {
    private static final Object OBJECT_END = new Object();
    private static final Object ARRAY_END = new Object();
    private static final Object COLON = new Object();
    private static final Object COMMA = new Object();
    public static final int FIRST = 0;
    public static final int CURRENT = 1;
    public static final int NEXT = 2;

    private static Map<Character, Character> escapes = new HashMap<Character, Character>();
    static {
        escapes.put(Character.valueOf('"'), Character.valueOf('"'));
        escapes.put(Character.valueOf('\\'), Character.valueOf('\\'));
        escapes.put(Character.valueOf('/'), Character.valueOf('/'));
        escapes.put(Character.valueOf('b'), Character.valueOf('\b'));
        escapes.put(Character.valueOf('f'), Character.valueOf('\f'));
        escapes.put(Character.valueOf('n'), Character.valueOf('\n'));
        escapes.put(Character.valueOf('r'), Character.valueOf('\r'));
        escapes.put(Character.valueOf('t'), Character.valueOf('\t'));
    }

    private CharacterIterator it;
    private char c;
    private Object token;
    private StringBuffer buf = new StringBuffer();

    private char next() {
        c = it.next();
        return c;
    }

    private void skipWhiteSpace() {
        while (Character.isWhitespace(c)) {
            next();
        }
    }

    public Object read(CharacterIterator ci, int start) {
        it = ci;
        switch (start) {
            case FIRST:
                c = it.first();
                break;
            case CURRENT:
                c = it.current();
                break;
            case NEXT:
                c = it.next();
                break;
        }
        return read();
    }

    public Object read(CharacterIterator it) {
        return read(it, NEXT);
    }

    public Object read(String string) {
        return read(new StringCharacterIterator(string), FIRST);
    }

    private Object read() {
        skipWhiteSpace();
        char ch = c;
        next();
        switch (ch) {
            case '"': token = string(); break;
            case '[': token = array(); break;
            case ']': token = ARRAY_END; break;
            case ',': token = COMMA; break;
            case '{': token = object(); break;
            case '}': token = OBJECT_END; break;
            case ':': token = COLON; break;
            case 't':
                next(); next(); next(); // assumed r-u-e
                token = Boolean.TRUE;
                break;
            case'f':
                next(); next(); next(); next(); // assumed a-l-s-e
                token = Boolean.FALSE;
                break;
            case 'n':
                next(); next(); next(); // assumed u-l-l
                token = null;
                break;
            default:
                c = it.previous();
                if (Character.isDigit(c) || c == '-') {
                    token = number();
                }
        }
        //logger.debug("token: " + token);
        System.out.println("token: " + token); // enable this line to see the token stream
        return token;
    }

    private Object object() {
        Map<Object, Object> ret = new HashMap<Object, Object>();
        Object key = read();
        while (token != OBJECT_END) {
            read(); // should be a colon
            if (token != OBJECT_END) {
                ret.put(key, read());
                if (read() == COMMA) {
                    key = read();
                }
            }
        }

        return ret;
    }

    private Object array() {
        List<Object> ret = new ArrayList<Object>();
        Object value = read();
        while (token != ARRAY_END) {
            ret.add(value);
            if (read() == COMMA) {
                value = read();
            }
        }
        return ret;
    }

    private Object number() {
        int length = 0;
        boolean isFloatingPoint = false;
        buf.setLength(0);

        if (c == '-') {
            add();
        }
        length += addDigits();
        if (c == '.') {
            add();
            length += addDigits();
            isFloatingPoint = true;
        }
        if (c == 'e' || c == 'E') {
            add();
            if (c == '+' || c == '-') {
                add();
            }
            addDigits();
            isFloatingPoint = true;
        }

        String s = buf.toString();
        return isFloatingPoint
                ? (length < 17) ? (Object)Double.valueOf(s) : new BigDecimal(s)
                : (length < 19) ? (Object)Long.valueOf(s) : new BigInteger(s);
    }

    private int addDigits() {
        int ret;
        for (ret = 0; Character.isDigit(c); ++ret) {
            add();
        }
        return ret;
    }

    private Object string() {
        buf.setLength(0);
        while (c != '"') {
            if (c == '\\') {
                next();
                if (c == 'u') {
                    add(unicode());
                } else {
                    Object value = escapes.get(Character.valueOf(c));
                    if (value != null) {
                        add(((Character) value).charValue());
                    }
                }
            } else {
                add();
            }
        }
        next();

        return buf.toString();
    }

    private void add(char cc) {
        buf.append(cc);
        next();
    }

    private void add() {
        add(c);
    }

    private char unicode() {
        int value = 0;
        for (int i = 0; i < 4; ++i) {
            switch (next()) {
                case '0': case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9':
                    value = (value << 4) + c - '0';
                    break;
                case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                    value = (value << 4) + c - 'k';
                    break;
                case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
                    value = (value << 4) + c - 'K';
                    break;
            }
        }
        return (char) value;
    }
}

其核心思路是使用CharacterIterator字符迭代，逐个字符进行解析，然后再read()方法内对字符使用switch进行判断，最先是”{“，所以进入object()方法，object()方法内再执行read()方法获取key值，若是没有迭代到”}”字符，则一直进行递归，解析内层的内容。同时若判断为arraylist，number，boolean都有相应的操作。object()和array()方法内确保了递归的完整性，整体过程空口评述不是很方便，建议有兴趣了解的同学可以将源码执行一遍，然后设置断点，进入debug模式，一步步查看代码的流转。
下面附上执行过程中，解析每个token的输出，也就是JSONReader源码中System.out那行的输出：

token: str
token: java.lang.Object@279f2327
token: string
token: java.lang.Object@2ff4acd0
token: num
token: java.lang.Object@279f2327
token: 100
token: java.lang.Object@2ff4acd0
token: boolean
token: java.lang.Object@279f2327
token: true
token: java.lang.Object@2ff4acd0
token: obj
token: java.lang.Object@279f2327
token: key1
token: java.lang.Object@279f2327
token: value1
token: java.lang.Object@2ff4acd0
token: key2
token: java.lang.Object@279f2327
token: value2
token: java.lang.Object@54bedef2
token: {key1=value1, key2=value2}
token: java.lang.Object@2ff4acd0
token: list
token: java.lang.Object@279f2327
token: list1
token: java.lang.Object@279f2327
token: list1
token: java.lang.Object@54bedef2
token: {list1=list1}
token: java.lang.Object@2ff4acd0
token: list2
token: java.lang.Object@279f2327
token: list2
token: java.lang.Object@54bedef2
token: {list2=list2}
token: java.lang.Object@5caf905d
token: [{list1=list1}, {list2=list2}]
token: java.lang.Object@54bedef2
token: {str=string, boolean=true, obj={key1=value1, key2=value2}, num=100, list=[{list1=list1}, {list2=list2}]}

这里可以看出每次解析的对象，输出中的那些Object是最开始的自定义对象，用来表示对象、数组结束以及冒号，逗号，其实就代表了”}”、”]”、”:”、”,”。

四、后记

这里体现了java不使用第三方jar包，进行json报文解析的方法，其执行效率没有深入研究，有兴趣的同学可以研究下，并且非常欢迎贴出结果与我讨论。还有，上述方法中没有对非法json结构体进行处理，如果是非法的json格式，就会出现错误的解析结果，而没有异常处理。所以，最好是解析之前，对json结构进行校验，通过后再进行解析，校验打算放在下次再做，谢谢。

张小鸣
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
不用第三方jar的json与object(map、list)互换java类
01-09
一个不用第三方jar的json与object(map、list)互换java类，定界符可以是'或"。提供测试实例。
Java不使用第三方工具包转换对象为JSON格式
qq_45525848的博客
03-07 488
Java不使用第三方工具包转换对象为JSON格式
java 不用工具转json_Java 不使用工具包把json更快的转化为map
weixin_39724287的博客
03-05 367
转化成map，也有可能是list哦，当然如果你写的不是符合json格式的数据当然会有错误。我这么写有点不好理解，关键是几次出栈，当然可以封装一个类专门来表示，限于篇幅就直接用map和list了/**** @param jsonstring* @return*/@SuppressWarnings("unchecked")public static Object json2Map(String jso...
java 递归解析json_java解析任意层数json字符串的方法
weixin_39815310的博客
02-12 219
//解析策略，有可能是解析json字符串，有可能为数据中的图片地址，email等package cc.util.regex;public enum RegexPolicy {Json("Json"),Image("ImageFromHtml");private String value;RegexPolicy (String value) {this.value = value;}@Overrid...
json字符串递归解析
04-02
json字符串递归解析
java解析json格式字符串所需jar包
07-09
2. **commons-lang-2.5.jar**：Apache Commons Lang是Java语言工具包，包含一些高级字符串处理、日期/时间操作等，对于JSON解析可能不直接相关，但可以支持更复杂的字符串操作。 3. **commons-beanutils-1.8.0.jar*...
JAVA解析json文件（使用json.org.jar）
12-18
首先，`json.org.jar`是由JSON.org提供的一个纯Java实现的JSON解析库，它提供了对JSON的创建、解析和序列化等功能。在Android项目中，我们需要将这个jar文件添加到项目的类路径中。在给定的文件列表中，`.classpath`...
利用java+mysql递归实现拼接树形JSON列表的方法示例
10-19
总结来说，通过以上步骤，我们成功地使用Java和MySQL实现了将扁平化的数据转换为树形JSON列表的方法。这个过程的关键在于理解递归的思想，以及如何正确地遍历和连接数据。这种方法不仅适用于商品目录，也可以应用于...
json-ref-resolver:[不建议使用]递归解析JSON指针和远程授权
05-20
JSON参考解析器 按照$ref的JSON模式，OpenAPI的（原名扬鞭）值，和任何其他对象以$ref他们的内部价值。 查看更改日志： 特征 性能：记住热路径，并发解析远程URI，并爬网并解析最小表面积。 缓存：缓存来自远程...
Java递归算法构造JSON树形结构
10-20
Java 递归算法构造 JSON 树形结构是指通过 Java 语言使用递归算法将数据库中的菜单表构建成树形的 JSON 格式发送给第三方。这种方法可以将复杂的树形结构数据转换成易于理解和处理的 JSON 格式。 在 Java 中，使用...
java解析任意层数json字符串的方法
10-26
一个方法解析任意层数的json字符窜：使用正则表达式，递归算法，将jsonArray解析出后添加到List, JsonObject添加至Map
Java解析N多层嵌套JSON对象（递归）
离风的博客
08-30 2508
解析多层嵌套JSON对象
Java解析多层复杂JSON---JSON循环嵌套后递归替换原有key，删除json一条数据。
m0_52767002的博客
07-19 3714
Java解析JSON---JSON循环嵌套找key，找到后替换原有key。
Python处理Json报文
Roy_70的专栏
11-18 5756
前言：Json作为更加出色的数据格式，已经越来越广泛应用于各种领域，金融银行体系也不例外，但是金融底层语言多采用python语言，在工作第一次接触新互联网核心json格式的报文，在了解学习后将内容整理出来，供大家参考，有部分内容引用自网络，如有侵权，请告知。
Json string 递归成 Map 集合操作，或者直接递归操作
weixin_30695195的博客
12-22 81
Json string 递归成 Map 集合操作，或者直接递归操作 转载于:https://www.cnblogs.com/linksky1018/p/4177677.html
JSON篇：解析json报文
但行前路 无问西东
10-24 6335
JSON 通常用于与服务端交换数据。在接收服务器数据时一般是字符串。 解析JSON字符串 首先，调用cJSON_Parse()函数， recvJSON = cJSON_Parse(szBuffer); //parse str to json 其次调用cJSON_GetArraySize()函数 size = cJSON_GetArraySize(recvJSON);//get json siz...
不依赖任何库，使用Java实现对象转json
weixin_35756373的博客
01-04 262
在 Java 中，可以使用 Google 的 Gson 库来将对象转换为 JSON 字符串。 首先，需要在项目中引入 Gson 库。 然后，可以使用如下代码将对象转换为 JSON 字符串： Gson gson =new Gson(); String json = gson.toJson(object); 其中，object 是要转换的对象，json 是转换后的 JSON 字符串。 如果希望在转换...
json报文解析
weixin_30451709的博客
08-17 1456
1.json字符串报文解析for (Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<String, Object> entry = iterator.next(); //如果是字符串直...
Java 实现递归查询Json字符串中的特定key
z103566940的博客
04-06 1525
【代码】Java 实现递归查询Json字符串中的特定key。
java 递归解析json
最新发布
09-11
不过需要注意的是，在使用递归算法解析 JSON 数据时，要确保数据格式的正确性，以避免解析出现错误。 ### 回答3： 在Java中，可以使用递归方法来解析JSON数据。首先，我们需要使用JSON库（如JSON.org、Gson、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值