大家都懂的 JSON 解析器原理(一)简介 & 低配版入门

Java 同时被 2 个专栏收录
92 篇文章 3 订阅

没学过编译原理,做一个 JSON 解析器难吗?——难!是不是就不能“迎难而上”呢?——不是!越是难的越是一个挑战!——笔者这里尝试通过通俗易懂的行文为大家介绍一下 JSON 解析器,——那一串串长长的 JSON 文本到底是如何被解析成为 Java 里面“可以理解的”对象的。前面的铺垫可能比较长,但请尽量不要跳过,因为那都是基础,尤其对于我们非科班来说,应要恶补。当然,为照顾大家的理解程度(包括我自己,我也会以后回看自己的代码,以此反复理解、反复消化),我会把代码写多点注释,把代码可读性提高那么一点点,因为网上很多写解析器的大神都是从 C 语言高手过来的,明显带有过程式的风格。因此我会重构这些代码,使得代码更 OO 一些,这样看起来也会紧凑一些,可读性高一些。

目标

输入 JSON 字符串,对象或数组相互嵌套着,如:

{
      "firstName": "John",
      "lastName": "Smith",
      "age": 25,
      "address": {
          "streetAddress": "21 2nd Street",
          "city": "New York",
          "state": "NY",
          "postalCode": 10021
      },
      "phoneNumbers": [
          {
              "type": "home",
              "number": "212 555-1234"
          },
          {
              "type": "fax",
              "number": "646 555-4567" 
          }
      ] 
  }

可以 {} 包含 [],也可以 [] 包含 {},总之相互嵌套,最后到 Java 返回 Map 或 List 就可以了——当然 Java 里的 Map or List 也是可以相互嵌套着的。

要求知识

好吧,正式开始!

低配版,一个函数搞定

这是来自 “安西都护府首席程序员”的方法。

可以说这是一个超简单 JSON 解析器,它是一个函数。一个函数就能搞定吗?——如果只考虑 JSON 简单情况(此种情况固然是不能放在生产环境的)是可以的,而且代码行数少,正好适合我们初学理解。下面是该函数的完整代码。

/**
 * 
 * @param jsonstring
 * @return
 */
@SuppressWarnings("unchecked")
public static Object json2Map(String jsonstring) {
	char[] cs = jsonstring.toCharArray();
	Stack<Map> maps = new Stack<>(); //用来表示多层的json对象
	Stack<List> lists = new Stack<>(); //用来表示多层的list对象
	Stack<Boolean> islist = new Stack<>();//判断是不是list
	Stack<String> keys = new Stack<>(); //用来表示多层的key

	String keytmp = null;
	Object valuetmp = null;
	StringBuilder builder = new StringBuilder();

	for (int i = 0; i < cs.length; i++) {

		switch (cs[i]) {
			case '{': //如果是{map进栈
				maps.push(new HashMap());
				islist.push(false);
				break;
			case ':'://如果是:表示这是一个属性建,key进栈
				keys.push(builder.toString());
				builder = new StringBuilder();
				break;
			case '[':
				lists.push(new ArrayList());
				islist.push(true);
				break;
			case ',':
				if (builder.length() > 0)
					valuetmp = builder.toString();
				builder = new StringBuilder();

				boolean listis = islist.peek();
				if (!listis) {
					keytmp = keys.pop();
					maps.peek().put(keytmp, valuetmp);
				} else
					lists.peek().add(valuetmp);

				break;
			case ']':
				islist.pop();

				if (builder.length() > 0)
					valuetmp = builder.toString();
				lists.peek().add(valuetmp);
				valuetmp = lists.pop();
				builder = new StringBuilder();
				break;
			case '}':
				islist.pop();
				//这里做的和,做的差不多,只是需要把valuetmp=maps.pop();把map弹出栈
				keytmp = keys.pop();

				if (builder.length() > 0)
					valuetmp = builder.toString();

				builder = new StringBuilder();
				maps.peek().put(keytmp, valuetmp);
				valuetmp = maps.pop();
				break;
			default:
				builder.append(cs[i]);
				break;
		}

	}
	return valuetmp;
}

该函数输入一个 String 类型的参数,返回一个 Object 类型结果。Object 类型只有两种真实类型,要么是 Map,要么是 List,分别对应最外层的 JSON 类型。

怎么理解这个函数呢?首先方法输入的是字符串,我们把字符串“打散”,也就是 char[] cs=jsonstring.toCharArray(); 这句把字符串转换为字符数组。变成数组的目的是要遍历也就是把数组中的每一个字符都读出来。读了一个字符,并进行解析。解析完毕了,我们叫“消耗”。把这个字符消耗了,接着就读取下一个字符重复上述过程。如此 JSON 里面每一个字符都会被读取、解析、消耗。

将字符串变为字符数组,实际上很多 JSON 解析库都会那么做,是为第一步之工序。得到 char[] 然后遍历它,其中的遍历过程就是具体的一个解析 JSON 的过程。

至于遍历 for 里面具体怎么个解析法?此固然是要重点探讨的话题。

解析过程

栈结构的运用

不少非科班的童鞋一听到栈(Stack)就头大了。其实栈没想象中复杂,关键在于怎么把它运用起来,体会了它的真正用途,而不是云里雾里的概念。你可以把栈想象成食堂中的一堆餐盘,通常我们都是在餐盘顶部添加新餐盘(常识),然后取出餐盘就是从餐盘堆顶部拿出。这个便是栈的“后进先出”特性了。理解这个例子的意思固然浅显,但怎么和实际计算机问题结合起来呢——那又是一个问题。如果大家还是不理解,可以读一下我前面的博文《用 JSON 表现树的结构兼谈队列、堆栈的练习》,特别是最后一个 format json 的例子,虽然没有直接运用到 Stack 结构但其中已隐隐约约有种“一进一退”的思想,着实与 Stack 有“异曲同工”之相似。
这里写图片描述

函数中一口气声明了 4个 Stack:

Stack<Map<String, Object>> maps = new Stack<>(); // 用来保存所有父级对象
Stack<List<Object>> lists = new Stack<>(); // 用来保存所有父级数组
Stack<Boolean> isList = new Stack<>();// 判断是不是list
Stack<String> keys = new Stack<>(); // 用来表示多层的key

我们知道 JSON 乃树状结构。树桩结构的特点是父亲节点拥有子节点,子节点的上一级是父节点,形成了这种关系。变量 maps 用于记住遍历字符的时候,字符所在在父级对象有哪些。父级节点 maps 是一个集合的概念,因为可能不止一个父级节点,而且可能有 n 个,那个 n 就代表树的层数。且 maps 里面的顺序不能打乱(不过可以放心,在 Stack 里面并不允许“打乱”顺序)。

同理,遇到数组的方式也可以这样去理解,保存在 lists 变量中。

当然,必须先有父级节点,才会有子节点,否则子节点就没有容身的“场所”。故而第一个欲消耗的字符永远要么是 {,永远要么是 [,才会 new 第一个 map 对象或者 list 对象。第一个 { 或 [ 可以称为“根节点”或“顶级节点”。

回到函数中,分别是如下进行字符的消耗的:

switch (cs[i]) {
case '{': // 如果是 { map 进栈
	maps.push(new HashMap<String, Object>());
	isList.push(false);
	continue;
……
……
case '[':
	isList.push(true);
	lists.push(new ArrayList<Object>());
continue;

我们忽略 switch 中不相关的部分,用省略号表示。可见,一遇到 { 字符,就表示要新建 map 对象,而且要将 map 进栈到 maps 中;一遇到 [ 字符,就表示要新建 list 对象,而且要将 list 进栈到 lists 中。进栈的意思就是在栈顶部添加新的元素。

光有进栈不够,应该还有“退栈”的那么一个操作。不过这里权且埋下伏笔,回过头来我们再看退栈。
结对匹配

上述过程就是匹配 JSON 字符串中的两种括号:尖括号和方括号,如 [ { }, [ ], [ ] ] 或 { [ ], [ ] } 等为正确格式,[ { ] } 或 { [ } } 为不合法格式。我们把 JSON 字符串抽象成这个格式去理解,有助于我们理解怎么匹配成对出现的结构。

例如考虑下面的括号序列。

[ { [ ] [ ] } ]
1 2 3 4 5 6 7 8

当消耗了第 1 个括号 [ 之后,期待与它匹配的第 8 个括号 ] 出现,然而等来的却是第 2 括号 {,此时第 1 个括号只能靠边站,不过没关系,因为我们消耗过程中已经把它保存起来,进行过“入栈”了;好,接着第 2 个括号要匹配的是 },但是很遗憾,第 3 个括号并不是期待的 },而是 [。不过同样没关系,因为第 2 个括号已经保存起来,先记着;现在轮到第 3 个括号,就要看看第 4 个括号怎么样?第 4 个括号正好是 ],完成匹配!期待得到了满足!但是不要忘记刚才第 3 个括号已经入过栈,所以现在满足之后,当前就不是原来的位置——需要执行什么操作?就是要“退栈”的操作。

执行完退栈之后,当前位置是第 5 个括号,而当前所期待的括号理应是第 2 个括号的期待,这个期待最为迫切。不过很遗憾,第 2 个括号还必须“忍一忍”,因为第 5 个括号是 [,说明又有新的期待进来,迫切性更高,第 2 个括号必须“让位于”第 5 个括号。——这里我们假设是故意弄错,第 6 个括号进入的是一个右尖括号 },明显这样不能构成结对,是非法字符,于是应中止遍历,立刻报错。回到正确的例子上,我们看到第 6 个括号是合法的括号,完成匹配,接下来期待第 2 个括号的匹配,或者是 [ or { 新开一级的匹配——这都是可以、合法的。

由此可见,这过程与栈的结构相吻合。“一进一退”是必须完成的结对,否则是不合法的过程。

只有掌握了这个匹配过程,我们才能进入下一步的 JSON 解析。今天先说到这儿,里面的内容有不少地方是需要好好消化的。如果没有帮到读者理解,或者有进一步的问题,都可以跟在下沟通。欢迎交流!

  • 3
    点赞
  • 1
    评论
  • 8
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

相关推荐
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值