首页 > > 程序设计 > Java技术 >

Java - 手动解析不带引号的JSON字符串

2019-08-26 06:10:41来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

Java - 手动解析不带引号的JSON字符串

目录

  • 1 需求说明
  • 2 解析代码
    • 2.1 实现思路
    • 2.2 详细代码
    • 2.3 测试样例

1 需求说明

项目中遇到了一批不带引号的类JSON格式的字符串:

{Name:Heal,Age:20,Tag:[Coding,Reading]}

需要将其解析成JSON对象, 然后插入到Elasticsearch中, 当作Object类型的对象存储起来.

在对比了阿里的FastJson、Google的Gson, 没找到想要的功能 ( 可能是博主不够仔细, 有了解的童学留言告诉我下呀??), 于是就自己写了个工具类, 用来实现此需求.

如果是带有引号的标准JSON字符串, 可直接通过上述2种工具进行解析, 使用方法可参考:
Java - 格式化输出JSON字符串的两种方式

2 解析代码

2.1 实现思路

代码的主要思路在注释中都有说明, 主要思路是:

(1) 借助Stack统计字符串首尾的[]、{}符号 —— []代表List, {}代表Map;

(2) 使用String#subString()方法缩减已解析的字符串;

(3) 使用递归解析内部的List、Map对象;

(4) 为了便于处理, 最小的key-value都解析成String类型.

需要注意的是: 要解析的字符串内部不要存在无意义的{、}、[、]符号, 否则会导致解析发生异常.
—— 暂时没想到好的兼容方法, 有想法的童学请直接留言.**

2.2 详细代码

package com.healchow.util;

import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;

/**
 * Java 解析不带引号的JSON字符串
 *
 * @author Heal Chow
 * @date 2019/08/13 11:36
 */
public class ParseJsonStrUtils {

    public static void main(String[] args) {

        // 带引号的字符串, 会将字符串当作key-value的一部分, 因此这类字符串推荐使用fastJson、Gson等工具转换
        // 注意: String内部不要存在无意义的{、}、[、]符号 - 暂时没想到好的兼容方法
        /*String sourceStr = "{\"_index\":\"book_shop\"," +
                           "\"_id\":\"1\"," +
                           "\"_source\":{" +
                               "\"name\":\"Thinking in Java [4th Edition]\"," +
                               "\"author\":\"[US] Bruce Eckel\"," +
                               "\"price\":109.0,\"date\":\"2007-06-01 00:00:00\"," +
                               "\"tags\":[\"Java\",[\"Programming\"]" +
                           "}}";*/

        // 不带引号的字符串, 首尾多对[]、{}不影响解析
        String sourceStr = "[[[{" +
                            "{" +
                                "Type:1," +
                                "StoragePath:[{Name:/image/2019-08-01/15.jpeg,DeviceID:4401120000130},{ShotTime:2019-08-01 14:44:24}]," +
                                "Width:140" +
                            "}," +
                            "{" +
                                "Type:2,StoragePath:9090/pic/2019_08_01/src.jpeg," +
                                "Inner:{DeviceID:44011200}," +
                                "Test:[{ShotTime:2019-08-01 14:50:14}]," +
                                "Width:5600}" +
                            "}}]]]";

        List<Map<String, Object>> jsonArray;
        Map<String, Object> jsonMap;

        Object obj = null;
        try {
            obj = parseJson(sourceStr);
        } catch (Exception e) {
            System.out.println("出错啦: " + e.getMessage());
            e.printStackTrace();
        }

        if (obj instanceof List) {
            jsonArray = (List<Map<String, Object>>) obj;
            System.out.println("解析生成了List对象: " + jsonArray);
        } else if (obj instanceof Map) {
            jsonMap = (Map<String, Object>) obj;
            System.out.println("解析生成了Map对象: " + jsonMap);
        } else {
            System.out.println("需要解析的字符串既不是JSON Array, 也不符合JSON Object!\n原字符串: " + sourceStr);
        }
    }

    /**
     * 解析 Json 格式的字符串, 封装为 List 或 Map 并返回
     * 注意: (1) key 和 value 不能含有 ",", key 中不能含有 ":" —— 要分别用 "," 和 ":" 进行分隔
     *      (2) 要解析的字符串必须符合JSON对象的格式, 只对最外层的多层嵌套做了简单的处理,
     *          复杂的如"{a:b},{x:y}"将不能完全识别 —— 正确的应该是"[{a:b},{x:y}]"
     * @param sourceStr 首尾被"[]"或"{}"包围的字符串
     * @return 生成的JsonObject
     */
    public static Object parseJson(String sourceStr) throws InvalidParameterException {
        if (sourceStr == null || "".equals(sourceStr)) {
            return sourceStr;
        }

        // 判断字符串首尾有没有多余的、相匹配的 "[]" 和 "{}"
        String parsedStr = simplifyStr(sourceStr, "[", "]");
        parsedStr = simplifyStr(parsedStr, "{", "}");

        // 借助栈来实现 "[]" 和 "{}" 的出入
        Stack<String> leftSymbolStack = new Stack<>();
        Stack<String> rightSymbolStack = new Stack<>();

        if ((parsedStr.startsWith("[") && parsedStr.endsWith("]")) || (parsedStr.startsWith("{") && parsedStr.endsWith("}"))) {
            leftSymbolStack.push(parsedStr.substring(0, 1));
            rightSymbolStack.push(parsedStr.substring(parsedStr.length() - 1));
            parsedStr = parsedStr.substring(1, parsedStr.length() - 1);

            // parsedStr 内部还可能是连续的"{{}}"
            parsedStr = simplifyStr(parsedStr, "{", "}");
        } else {
            throw new InvalidParameterException("要解析的字符串中存在不匹配的'[]'或'{}', 请检查!\n原字符串为: " + sourceStr);
        }

        // 保存解析的结果, jsonArray中可能只有String, 也可能含有Map<String, Object>
        List<Object> jsonArray = new ArrayList<>();
        Map<String, Object> jsonMap = new HashMap<>(16);

        // 内部遍历、解析
        innerParseByLoop(parsedStr, leftSymbolStack, rightSymbolStack, jsonArray, jsonMap);

        // 判断jsonArray是否为空
        if (jsonArray.size() > 0) {
            return jsonArray;
        } else {
            return jsonMap;
        }
    }

    /**
     * 循环解析内部的List、Map对象
     */
    private static void innerParseByLoop(String parsedStr, Stack<String> leftSymbolStack, Stack<String> rightSymbolStack,
                                         List<Object> jsonArray, Map<String, Object> jsonMap) throws InvalidParameterException {
        if (parsedStr == null || parsedStr.equals("")) {
            return;
        }
        // 按照","分隔
        String[] allKeyValues = parsedStr.split(",");
        if (allKeyValues.length > 0) {

            // 遍历, 并按照":"分隔解析
            out:
            for (String keyValue : allKeyValues) {

                // 如果keyValue中含有":", 说明该keyValue是List<Map>中的一个对象, 就需要确定第一个":"的位置 —— 可能存在多个":"
                int index = keyValue.indexOf(":");
                if (index > 0) {

                    // 判断key是否仍然以"{"或"["开始, 如果是, 则压栈
                    String key = keyValue.substring(0, index);
                    while (key.startsWith("[") || key.startsWith("{")) {
                        leftSymbolStack.push(key.substring(0, 1));
                        // 解析过的串要一直跟进
                        parsedStr = parsedStr.substring(1);
                        key = key.substring(1);
                    }

                    // 判读和value是否以"["开头 —— 又是一个 List 对象 —— 递归解析
                    String value = keyValue.substring(index + 1);
                    if (value.startsWith("[")) {
                        int innerIndex = parsedStr.indexOf("]");
                        List<Object> innerList = (List<Object>) parseJson(parsedStr.substring(key.length() + 1, innerIndex + 1));
                        jsonMap.put(key, innerList);
                        // 清除最后的"]", 并判断是否存在","
                        parsedStr = parsedStr.substring(innerIndex + 1);
                        if (parsedStr.indexOf(",") == 0) {
                            parsedStr = parsedStr.substring(1);
                        }

                        // 此内部存在对象, 内部的","已经解析完毕了, 要修正按照","切割的字符串数组, 并继续遍历
                        innerParseByLoop(parsedStr, leftSymbolStack, rightSymbolStack, jsonArray, jsonMap);
                        break;
                    }

                    // 判读和value是否以 "{" 开头 —— 又是一个 Map 对象 —— 递归解析
                    else if (value.startsWith("{")) {
                        int innerIndex = parsedStr.indexOf("}");
                        Map<String, Object> innerMap = (Map<String, Object>) parseJson(parsedStr.substring(key.length() + 1, innerIndex + 1));
                        jsonMap.put(key, innerMap);

                        // 清除最后的"}", 并判断是否存在","
                        parsedStr = parsedStr.substring(innerIndex + 1);
                        if (parsedStr.indexOf(",") == 0) {
                            parsedStr = parsedStr.substring(1);
                        }

                        // 此内部存在对象, 内部的","已经解析完毕了, 要修正按照","切割的字符串数组, 并继续遍历
                        innerParseByLoop(parsedStr, leftSymbolStack, rightSymbolStack, jsonArray, jsonMap);
                        break;
                    }

                    // 最后判断value尾部是否含有 "]" 或 "}"
                    else {
                        while (value.endsWith("]") || value.endsWith("}")) {
                            // 最右侧的字符
                            String right = value.substring(value.length() - 1);
                            // 此时栈顶元素
                            String top = leftSymbolStack.peek();
                            // 如果有相匹配的, 则弹栈, 否则忽略
                            if (("}".equals(right) && "{".equals(top)) || ("]".equals(right) && "[".equals(top))) {
                                leftSymbolStack.pop();
                                value = value.substring(0, value.length() - 1);
                                jsonMap.put(key, value);

                                // 清除最后的"}", 并判断是否存在","
                                parsedStr = parsedStr.substring(key.length() + 1 + value.length() + 1);
                                if (parsedStr.indexOf(",") == 0) {
                                    parsedStr = parsedStr.substring(1);
                                }

                                // 解析完成了一个对象, 则将该元素添加到List中, 并创建新的对象
                                jsonArray.add(jsonMap);
                                jsonMap = new HashMap<>(16);

                                // 继续进行外层的解析
                                continue out;
                            }

                            // 如果都不匹配, 则有可能是源字符串的最后一个符号
                            else {
                                rightSymbolStack.push(right);
                                value = value.substring(0, value.length() - 1);
                            }
                        }
                        jsonMap.put(key, value);
                        int length = key.length() + value.length() + 2;
                        if (parsedStr.length() > length) {
                            parsedStr = parsedStr.substring(length);
                        } else {
                            parsedStr = "";
                        }
                    }
                }
                // 如果keyValue中不含":", 说明该keyValue只是List<String>中的一个串, 而非List<Map>中的一个Map, 则直接将其添加到List中即可
                else {
                    jsonArray.add(keyValue);
                }
            }

            // 遍历结束, 处理最后的符号问题 —— 判断左右栈是否匹配
            while (!leftSymbolStack.empty()) {
                if (leftSymbolStack.peek().equals("{") && parsedStr.equals("}")) {
                    leftSymbolStack.pop();
                }
                if (!rightSymbolStack.empty()) {
                    if (leftSymbolStack.peek().equals("{") && rightSymbolStack.peek().equals("}")) {
                        leftSymbolStack.pop();
                        rightSymbolStack.pop();
                    } else if (leftSymbolStack.peek().equals("[") && rightSymbolStack.peek().equals("]")) {
                        leftSymbolStack.pop();
                        rightSymbolStack.pop();
                    } else {
                        throw new InvalidParameterException("传入的字符串中不能被解析成JSON对象!\n原字符串为: " + parsedStr);
                    }
                }
            }
        }
    }

    /**
     * 判断字符串首尾有没有多余的、相匹配的 "[]" 和 "{}", 对其进行简化
     */
    private static String simplifyStr(String sourceStr, String firstSymbol, String lastSymbol) {

        while (sourceStr.startsWith(firstSymbol) && sourceStr.endsWith(lastSymbol)) {
            String second = sourceStr.substring(1, 2);
            // 如果第二个仍然是"["或"{", 再判断倒数第二个是不是"]"或"}" —— 说明长度至少为3, 不会发生 IndexOutOfBoundsException
            if (second.equals(firstSymbol)) {
                String penultimate = sourceStr.substring(sourceStr.length() - 2, sourceStr.length() - 1);
                if (penultimate.equals(lastSymbol)) {
                    // 缩短要解析的串
                    sourceStr = sourceStr.substring(1, sourceStr.length() - 1);
                } else {
                    break;
                }
            } else {
                break;
            }
        }
        return sourceStr;
    }

}

2.3 测试样例

(1) 带引号的测试:

// 测试字符串:
String sourceStr = "{\"_index\":\"book_shop\"," +
                   "\"_id\":\"1\"," +
                   "\"_source\":{" +
                       "\"name\":\"Thinking in Java [4th Edition]\"," +
                       "\"author\":\"[US] Bruce Eckel\"," +
                       "\"price\":109.0,\"date\":\"2007-06-01 00:00:00\"," +
                       "\"tags\":[\"Java\",[\"Programming\"]" +
                   "}}";

解析结果为:
字符串解析结果-带引号

(2) 不带引号的测试:

// 测试字符串: 
String sourceStr = "[[[{" +
                    "{" +
                        "Type:1," +
                        "StoragePath:[{Name:/image/2019-08-01/15.jpeg,DeviceID:4401120000130},{ShotTime:2019-08-01 14:44:24}]," +
                        "Width:140" +
                    "}," +
                    "{" +
                        "Type:2,StoragePath:9090/pic/2019_08_01/src.jpeg," +
                        "Inner:{DeviceID:44011200}," +
                        "Test:[{ShotTime:2019-08-01 14:50:14}]," +
                        "Width:5600}" +
                    "}}]]]";

解析结果为:

字符串解析结果-不带引号


版权声明

作者: 瘦风(https://healchow.com)

出处: 博客园 瘦风的博客(https://www.cnblogs.com/shoufeng)

感谢阅读, 如果文章有帮助或启发到你, 点个[好文要顶??] 或 [推荐??] 吧??

本文版权归博主所有, 欢迎转载, 但 [必须在文章页面明显位置标明原文链接], 否则博主保留追究相关人员法律责任的权利.


原文链接:https://www.cnblogs.com/shoufeng/p/11382231.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：SpringBoot内置tomcat启动原理

下一篇：JavaWeb零基础入门-02 开发环境安装

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签