首页 > 编程语言 > Java 手动解析不带引号的JSON字符串的操作
2020
10-20

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

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 详细代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
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) 带引号的测试:

?
1
2
3
4
5
6
7
8
9
// 测试字符串:
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) 不带引号的测试:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
// 测试字符串:
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}" +
     "}}]]]";

解析结果为:

补充知识：将key名不带双引号的JSON字符串转换成JSON对象的方法

根据json.org上面的描述，JSON对象是由对象成员组成，而成员是由key-value键值组成。

key值是一个字符串：

字符串由Unicode字符组成，用双引号包围，用反斜杠转义。可以是单个字符。用法跟C或Java里的字符串的用法相似。

但是，在现实应用中，很少有程序员知道JSON里的key需要用双引号包围，因为大多数的浏览器里并不需要使用双引号。所以，为什么多此一举要多写两个双引号呢？

规范的例子：

{
"keyName" : 34
}

不规范的例子：

{
keyName : 34
}

虽然在浏览器里使用不规范的、不使用双引号的写法在浏览器里不会出现问题，但并不代表你可以在其它地方不会遇到问题，比如，你有一个字符串：

//字符串格式

'{ keyName : 34 }'

你想把它转换成JSON对象。把JSON字符串转换成JSON对象，需要使用 JSON.parse()方法，对于上面的这种key名上不带双引号的的JSON字符串，使用JSON.parse()解析时会报错，无法解析。这就成了一个很麻烦的问题。所以说，尽量使用规范的预防还是有好处的，尽管大多数时候你不会遇到问题。

那么，对于key名不带双引号的JSON字符串，如何将它转换成JSON对象呢？

最直接的方法是手工给key名加上双引号。

如果你不像手工添加，可以使用函数全文搜索追加双引号，比如下面的这段代码：

json_string.replace(/(s*?{s*?|s*?,s*?)(['"])?([a-zA-Z0-9]+)(['"])?:/g, '$1"$3":');

eval('var json = new Object(' + json_string + ')');

最后，最简单的一种方法是直接用eval()运行它：

var obj = eval('(' + invalid_json + ')');

但这样执行时，你需要理解执行的代码是什么，因为如果它里面含有一些恶意程序，你这样直接运行很可能引起安全问题。

以上这篇Java 手动解析不带引号的JSON字符串的操作就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持自学编程网。

编程技巧