开源Json解析器的浅述

之前在做项目中，Json 这种数据转换格式经常用，为什么呢？我认为是
1、它的易用性，跨平台性，它是JS(JavaScript)的子集，是一种对象字面量。
2、它与XML都是树结构的语法树；
同样的XML,JSON表示，Json则相对简洁，XML相对冗余，当然也是互相不可替代的，根据具体需求选择合适才是完美的。

做个原生的Json解析器是掌阅科技的大佬提出的一个问题，在之前没有相对的深入了解这个Json解析器，项目里用到的都是org.Json开源包\Gson包。这周就主要对Json解析器包括与塌相关的知识做个梳理，形成网络结构。想做Json解析器，必须对Json本身有了解，在这里主要点出几个下面需要用的点：
JSON结构：

"string"：Java的String；
number：Java的Long或Double；
true/false：Java的Boolean；
null：Java的null；
[array]：Java的List<Object>或Object[]；
{"key":"value"}：Java的Map<String, Object>。

JSON文法：

Jsonobject = {} | { members }
members = pair | pair , members
pair = string : value
array = [] | [ elements ]
elements = value | value , elements
value = string | number | object | array | true | false | null
string = “” | ” chars ”
chars = char | char chars
char = any-Unicode-character-except-“-or–or- control-character | \” | \ | \/ | \b | \f | \n | \r | \t | \u four-hex-digits
number = int | int frac | int exp | int frac exp
int = digit | digit1-9 digits | - digit | - digit1-9 digits
frac = . digits
exp = e digits
digits = digit | digit digits
e = e | e+ | e- | E | E+ | E-
细节可以参看《Json必知必会》http://download.csdn.net/download/qq_34417408/10122524；

同时也要了解编译原理的一些知识：
编译过程：词法分析，语法分析，语义分析，当然其中还有代码优化，目标代码；
其中，
词法分析作用：找出单词。如int a=b+c; 结果为： int，a，=，b,+,c和;
语法分析作用：找出表达式，程序段，语句等。如int a=b=c;的语法分析结果为int a=b+c这条语句。
语义分析作用：查看类型是否匹配等。

还有中间代码的优化：http://blog.csdn.net/qq_34417408/article/details/78126087（我之前总结的博客）

同时要了解解析器的功能，原理；
Json解析器是把输入字符串重新变成熟悉类型的对象，像一个函数，它的输入是一个表示JSON的字符串，输出是结构化的对应到语言本身的数据结构。

在解析过程中，主要有两部分一个是，词法分析，将源码解析为词法单元token；另一个是语法分析，构造语法树parser；当然都是基于Json 词法和文法。

在第一部分，形成词法分析时，即是构造自动机（DFA）；在写Json之前，我先手写了几个简单的自动机，很久没写过，热了下身，其实只要逻辑分析没问题，是很简单的，就是代码实现。
（a|bb)一个可以有’a’和’b’的字符串，’b’出现时必为偶数个；

public class ABB {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws Exception {
        // TODO code application logic here
        Scanner in =new Scanner(System.in);
        String string=in.nextLine();
        char[] ch=string.toCharArray();
        if(ch.length==0){
            throw new Exception("不合法字符!");
        }
        int i=0;
        while(i<ch.length){
            if(ch[i]=='a'){
                ++i;
            }else if(i<ch.length-1&&ch[i]=='b'){
                ++i;
                if(i<ch.length&&ch[i]=='b'){
                   ++i;
                }else{
                    throw new Exception("不合法字符！");
                }
            }else{
                throw new Exception("不合法字符！");
            }
        }
        System.out.println("合法字符！");
    }
}

由于Json 的结构特殊，在输入第一字符的时候就可以判断是哪个对象，{}/[]/string/true/false/number/null；我们可以加工构造并对应枚举类型即token流，进行词法分析：

STRING（字符串字面量）
NUMBER（数字字面量）
NULL（null）
START_ARRAY（[）
END_ARRAY（]）
START_OBJ（{）
END_OBJ（}）
COMMA（,）
COLON（:）
BOOLEAN（true或者false）
END_DOC（表示JSON数据的结束）

枚举类型：

public enum TokenType {
    START_OBJ, END_OBJ, START_ARRAY, END_ARRAY, NULL, NUMBER, STRING, BOOLEAN, COLON, COMMA, END_DOC
}

同时构造token类：

public class Token {
    private TokenType type;
    private String value;

    public Token(TokenType type, String value) {
        this.type = type;
        this.value = value;
    }

    public TokenType getType() {
        return type;
    }

    public void setType(TokenType type) {
        this.type = type;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public String toString() {
        return getValue();
    }
}

在进行Json解析的词法分析时，首先需要将字符串转为字符数组，我们可以用BufferReader(new StringReader(String str));
关于BufferReader()可以见：https://www.cnblogs.com/meilidelaohuhua/p/6638545.html ;
转化之后进行字符逐一分析，此时用到的是Json的结构的自动机，将其转化为token流。此时第一部分词法分析完成。
在第二部分语法树parser构造中，主要分两部分；
一块是对象Object文法，一块是数组Array文法，其他文法是基本类型；
其中对象可以用Map实现（Key:Value)，数组用List集合

public class JObject implements Json {
    private Map<String, Value> map = new HashMap<>();
    public JObject(Map<String, Value> map) {
        this.map = map;
    }

    public int getInt(String key) {
        return Integer.parseInt((String) map.get(key).value());
    }

    public String getString(String key) {
        return (String) map.get(key).value();
    }

    public boolean getBoolean(String key) {
        return Boolean.parseBoolean((String) map.get(key).value());
    }

    public JArray getJArray(String key) {
        return (JArray) map.get(key).value();
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{ ");
        int size = map.size();
        for (String key : map.keySet()) {
            sb.append(key + " : " + map.get(key));
            if (--size != 0) {
                sb.append(", ");
            }
        }
        sb.append(" }");
        return sb.toString();
    }
}
public class JArray implements  Json, Value {
    private List<Json> list = new ArrayList<>();

    public JArray(List<Json> list) {
        this.list = list;
    }

    public int length() {
        return list.size();
    }

    public void add(Json element) {
        list.add(element);
    }

    public Json get(int i) {
        return list.get(i);
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[ ");
        for (int i =0; i < list.size(); i++) {
            sb.append(list.get(i).toString());
            if (i != list.size() - 1) {
                sb.append(", ");
            }
        }
        sb.append(" ]");
        return sb.toString();
    }

    @Override
    public Object value() {
        return this;
    }
}

其中重要的是Json，和Value抽象类的建立得以使JObject和JArray相互转化，动态的完成对象和数组相互嵌套的转化。
另外，在构造token 类的时候把枚举类型和Value为属性，在后面添加list的时候，省了许多麻烦。
源码：https://github.com/weiyanyanyan/Json

资料查找：https://www.cnblogs.com/meilidelaohuhua/p/6638545.html
https://www.zhihu.com/question/24640264/answer/80500016
http://blog.csdn.net/yuanzhou314/article/details/43032067
https://www.liaoxuefeng.com/article/0014211269349633dda29ee3f29413c91fa65c372585f23000

开源Json解析器的浅述

猜你喜欢