自己实现JSON解析器 JsonParser

自己实现json parser，只有一个类，不依赖任何第三方工具。

背景

为什么要实现json解析器呢？在我实现一个rpc框架的过程中，注册中心部分使用consul，而consul的api是通过restful http api来提供的，数据交互格式为json，此时就需要用到json解析工具。

让我们回顾一下java界较为通用的json处理库，常用的json处理库有jackson，gson，fastjson，其他还有许多json工具包，不过都不流行或已退出历史舞台。

java ee也有一个相关的jsr，jsr 353 json processing api，定义了通用的json 处理 api，一个参考实现是oracle 的glassfish jsonp。

jackson是最完善的json处理工具，实现的功能最多，并且支持jaxb注解，而且也有支持适配 jsr353 json processing api的模块。。也是我个人最喜欢的json处理工具包。其实fastjson的很多实现的常量定义都能看到jaxkson的影子。

本来决定使用jackson的，一般来讲现在spring是企业应用的标配，而spring mvc应用通常都会依赖jackson的包。因此依赖一下jackson的包也可以接受。但后来又考虑了几次，觉得依赖第三方的包毕竟不美，额外带来依赖总是会增加复杂性，对于基础组件，除了日志门面框架这样与实现无关的包，还是尽量少依赖其他库为妙。

因此决定自己写一个json解析工具，考虑了一下觉得也不是十分复杂，用递归的方式解析json串即可。具体实现思路接下来分析。

实现思路

json的结构分析

json的结构包含几种元素：

• object（name value pair object），此处指狭义的对象，名值对形式。广义上任何元素都是对象。
• array，由[]符号包裹，元素用英文逗号分隔。
• 字面类型，字面类型最为简单，不能再嵌套
  • number
  • boolean，true or false
  • null

下面放几张json.org的图，以直观的形式展示json格式。

json object

json object

json object

object 内部的value和array内部的元素都可以是任意组成类型，可以存在任意层次的嵌套。因此用递归方式解析比较简单。

实现思路

a) 基本概念

• trim ，trim是把一个字符序列的头尾的不可见字符去掉，由于json允许在元素之间存在任意个tab、换行、空格。因此可能有许多地方需要用到trim。

b) processObjcet: object解析

1. 以"{"开始，正确找到对应的结束的"}"，由于花括号可能存在多重嵌套，找到正确的结束符号是有技巧的。记下整个{}区块的位置。
2. 脱去头尾的{}，中间的部分是properties列表，以name:value,...的形式存储。解析properties列表。
3. 标记nameStartMark，初始为0，遇到冒号":"，从nameStartMark到冒号前都为nameToken（需要trim），从冒号后开始寻找nextValue。同样需要注意(1.)提及的花括号和中括号匹配，遇到逗号或结束表示value区块结束。（由findNextValue函数完成）
4. 移动游标到找到的value区块后，并更新nameStartMark标记。
5. 循环执行(3.)和(4.)，直到不再有冒号。
6. 注意：找到的value区块移交给另一个函数processValue处理，此处存在递归。

c) processArray: array解析

与object类似，但是比object简单

1. 以"["开始，正确找到对应的结束的"]"，由于方括号可能存在多重嵌套，找到正确的结束符号是有技巧的。记下整个[]区块的位置。
2. 脱去头尾的[]，中间的部分是elements列表，以element1,element2...的形式存储。
3. 直接循环执行findNextValue即可，直到结束
4. 注意：同上，找到的value区块移交给另一个函数processValue处理，此处存在递归。

d) processValue: value解析

此处是一个递归操作，value本身可能是一个字面量，或者是object，或者是array。

1. 如果value区块以"{"开头，则是object，移交给processObjcet 做object解析，递归操作。
2. 如果value区块以"["开头，则是array，移交给processArray 做array解析，递归操作。
3. 字面量，如string，boolean，number，null直接解析。string可能有转义字符，这个目前没有考虑处理。

e) completeSymbolPair: 寻找匹配的{}和[]

由于{}和[]都可能存在多重嵌套，因此需要正确的找到一个开始的花括号对应的结束符号，方括号同理。

这个可以用这个原理：符号一定是成对出现的。

步骤如下：

1. 对于已知的第一个左符号，定义symbolsScore=1，index=1，
2. 遍历后续的字符，遇到左符号则symbolsScore++，遇到右符号则symbolsScore--。
3. 直到symbolsScore==0，则找到正确的结束符。
4. 左边开始符号到右边结束符号之间的内容就是需要的内容。

代码实现

方法原型

public class JsonParser {

    private final String json;

    /**
     * 入口方法
     * @return 解析完成的对象
     */
    public Object parse() {
        CharsRange trimmedJson = newRange(0, json.length()).trim();
        return processValue(trimmedJson);
    }

    private Object processPlainObject(CharsRange range) {}

    private List processProperties(CharsRange range) {}

    private List processArray(CharsRange range) {}

    /**
     * @param chars
     * @return value segment trimmed.
     */
    private CharsRange findNextValue(CharsRange chars, AtomicInteger readCursor) {}

    private CharsRange completeSymbolPair(CharsRange trimChars, AtomicInteger readCursor, String symbolPair) {}

    private Object processValue(CharsRange valueSegment) {}

    static class Property { final String name, value;}

    class CharsRange { final int start, end;}

}

具体代码

此处当然要放具体的代码，只有一个类。

package io.destinyshine.storks.utils.json;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

import lombok.extern.slf4j.Slf4j;

/**
 * @author liujianyu
 * @date 2017/10/17
 */
@Slf4j
public class JsonParser {

    private final String json;

    public JsonParser(String json) {
        this.json = json;
    }

    /**
     * 入口方法
     * @return 解析完成的对象
     */
    public Object parse() {
        CharsRange trimmedJson = newRange(0, json.length()).trim();
        return processValue(trimmedJson);
    }

    private Object processPlainObject(CharsRange range) {
        List properties = processProperties(newRange(range.start + 1, range.end - 1));
        Map object = new HashMap<>();
        properties.forEach(prop -> object.put(prop.name, prop.value));
        return object;
    }

    private List processProperties(CharsRange range) {
        List properties = new ArrayList<>();
        int nameStartMark = range.start;
        for (int i = range.start; i < range.end; i++) {
            char ch = json.charAt(i);
            if (ch == ':') {
                CharsRange nameToken = newRange(nameStartMark, i).trim();
                AtomicInteger readCursor = new AtomicInteger();
                CharsRange valueSegment = findNextValue(newRange(++i, range.end), readCursor);
                i = readCursor.intValue() + 1;
                nameStartMark = i;
                logger.info("nameToken:{},\nvalueSegment:{}", nameToken, valueSegment);
                //TODO::valid nameToken is start and end with '"'
                final String name = newRange(nameToken.start + 1, nameToken.end - 1).toString();
                final Object value = processValue(valueSegment);
                properties.add(Property.of(name, value));
            }
        }
        return properties;
    }

    private List processArray(CharsRange range) {
        return processElements(newRange(range.start + 1, range.end - 1));
    }

    private List processElements(CharsRange range) {
        List