Antlr实战之JSON解析器slowjson

最近一直在学习编译原理,然后就了解到了antlr4这个强大的工具,antlr的全称是(Another Tool for Language Recognition),是一款很强大的词法和语法分析工具,虽然是用java写成的,但它也能生成c++、go……等语言的代码。它的主要作用就是你可以用巴科斯范式来描述语法规则,然后它帮你生成对应的解析器。
大家都知道实践是最好的学习方式,要快速深刻地理解antlr的操作和相关接口就不得不找一个练手的东西。回想到去年连续报安全漏洞的fastjson,所以我准备霍霍一下json解析器。咱写不出来比fastjson更快、bug更少、更安全的json解析器,难道还写不出来一个bug更多、更慢、更不安全的解析器吗,正面拼不赢咱反其道而行。
为了对标阿里的fastjson,我给它起名 slowjson,源码已在github slowjson 欢迎star。为了推广slowjson,我都想好广告词了。

你想升职加薪吗?
你想拿年终奖吗?
你想成为同事眼中的性能优化小能手吗?
今天用slowjson,年底做性能优化换回fastjson,十倍性能不是梦,升职加薪准能成。

解析JSON字符串

说这么多进入正题,json解析器该怎么写?实际上你并不需要自己动手写词法分析器、语法分析器……,今天的主角antlr都会帮你生成,你只需要用巴科斯范式把json的语法规则描述清楚就行了,这份描述你可以直接在json.org找到,在antlr的github代码库里也有,二者看起来稍有差别,json官网的规则更详细些。这里我直接用antlr提供的规则描述。

grammar JSON;

json
   : value
   ;

obj
   : '{' pair (',' pair)* '}'
   | '{' '}'
   ;

pair
   : STRING ':' value
   ;

array
   : '[' value (',' value)* ']'
   | '[' ']'
   ;

value
   : STRING
   | NUMBER
   | obj
   | array
   | 'true'
   | 'false'
   | 'null'
   ;


STRING
   : '"' (ESC | SAFECODEPOINT)* '"'
   ;


fragment ESC
   : '\\' (["\\/bfnrt] | UNICODE)
   ;
fragment UNICODE
   : 'u' HEX HEX HEX HEX
   ;
fragment HEX
   : [0-9a-fA-F]
   ;
fragment SAFECODEPOINT
   : ~ ["\\\u0000-\u001F]
   ;


NUMBER
   : '-'? INT ('.' [0-9] +)? EXP?
   ;


fragment INT
   : '0' | [1-9] [0-9]*
   ;

// no leading zeros

fragment EXP
   : [Ee] [+\-]? INT
   ;

// \- since - means "range" inside [...]

WS
   : [ \t\n\r] + -> skip
   ;

把这个文件保存成 JSON.g4,然后执行下面命令,当然前提是你得正确安装antlr4。

antlr4 JSON.g4  -no-listener -package xyz.xindoo.slowjson

这个时候antlr就会帮你生成json的词法分析器JSONLexer.java和语法分析器JSONParser.java。

    private static String jsonStr = "{\"key1\":\"value1\",\"sub\":{\"subkey\":\"subvalue1\"}}"; 
    public static JSONParser.ObjContext parse() {
        JSONLexer lexer = new JSONLexer(CharStreams.fromString(jsonStr));
        CommonTokenStream tokens = new CommonTokenStream(lexer);  //生成token 
        JSONParser parser = new JSONParser(tokens);
        JSONParser.ObjContext objCtx = parser.obj(); // 将token转化为抽象语法树(AST) 
        return new objCtx;
    }

实际上你只需要写上面这么多代码,就可以完成对一个jsonStr的解析,不过这里解析后的结果是antlr内部封装的抽象语法树,利用antlr的idea插件,我们可以将解析后的AST可视化出来, "{“key1”:“value1”,“sub”:{“subkey”:“subvalue1”}}"的语法树长下面这样。
在这里插入图片描述

JSON字符到JSONObject

虽然已经完成了json字符串的解析,但如果你想像fastjson那样使用,你还得完成对语法树节点到JSONObject的转化。antlr根据语法规则,已经自动帮你生成了每个节点类型,实际上你只需要遍历整个树,然后把每个节点转化为JSONObject或者k-v对就可以了。

package xyz.xindoo.slowjson;

import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

public class JSONObject {

    private Map<String, Object> map;

    public JSONObject() {
        this.map = new HashMap<>();
    }

    protected JSONObject(JSONParser.ObjContext objCtx) {
        this.map = new HashMap<>();
        for (JSONParser.PairContext pairCtx: objCtx.pair()) {
            String key = pairCtx.STRING().getText();
            map.put(key.substring(1, key.length()-1), pairCtx.value());
        }
    }

    public JSONObject getJSONObject(String key) {
        JSONParser.ValueContext value = (JSONParser.ValueContext)map.get(key);
        if (value == null) {
            return null;
        }
        return new JSONObject(value.obj());
    }

    public String getString(String key) {
        Object value = map.get(key);
        if (value == null) {
            return null;
        }
        if (JSONParser.ValueContext.class.isInstance(value)) {
            JSONParser.ValueContext ctx = (JSONParser.ValueContext)value;
            String newValue = ctx.STRING().getText();
            map.put(key, newValue.substring(1, newValue.length()-1));
        }
        return (String)map.get(key);
    }

    public int getInt(String key) {
        String value = getString(key);
        if (value == null || "".equals(value)) {
            return 0;
        }
        return Integer.parseInt(value);
    }

    public long getLong(String key) {
        String value = getString(key);
        if (value == null || "".equals(value)) {
            return 0L;
        }
        return Long.parseLong(value);
    }

    public double getDouble(String key) {
        String value = getString(key);
        if (value == null || "".equals(value)) {
            return 0.0;
        }
        return Double.parseDouble(value);
    }
    
    public JSONArray getJSONArray(String key) {
        JSONParser.ValueContext value = (JSONParser.ValueContext)map.get(key);
        if (value == null) {
            return null;
        }
        return new JSONArray(value.array());
    }

    public void put(String key, Object object) {
        map.put(key, object);
    }

    public static JSONObject parseObject(String text) {
        JSONLexer lexer = new JSONLexer(CharStreams.fromString(text));
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        JSONParser parser = new JSONParser(tokens);
        JSONParser.ObjContext objCtx = parser.obj();
        return new JSONObject(objCtx);
    }

    public static JSONArray parseArray(String text) {
        if (text == null) {
            return null;
        }
        JSONArray array = JSONArray.parseArray(text);
        return array;
    }
}

代码中我并没有遍历整个AST并将其转化为JSONObject,而是等到需要的时候再转,实现起来比较方便。看到这里有没有发现slowjson的API和fastjson的很像! 没错,我就是抄的fastjson,而且我还没抄全。。。

性能测试

接下来做个很随便的性能测试,我随便找了个json字符串,并拉来了slowjson的几个主要竞争对手 fastjson、jackson、gson,测试结果如下:

Benchmark       Mode  Cnt       Score   Error  Units
Test.fastjson  thrpt    2  235628.511          ops/s
Test.gson      thrpt    2  237975.534          ops/s
Test.jackson   thrpt    2  212453.073          ops/s
Test.slowjson  thrpt    2   29905.109          ops/s

性能只差一个数量级,没我预期的慢……这这么行呢,加上随机自旋……

    private static void randomSpin() {
        Random random = new Random();
        int nCPU = Runtime.getRuntime().availableProcessors();
        int spins = (random.nextInt()%8 + nCPU) * SPIN_UNIT;
        while (spins > 0) {
            spins--;
            float a = random.nextFloat();
        }
    }

然后在所有get的方法里先调用一次随机自旋,消耗掉cpu。再来测试下性能。

Benchmark       Mode  Cnt       Score   Error  Units
Test.fastjson  thrpt    2  349994.543          ops/s
Test.gson      thrpt    2  318087.884          ops/s
Test.jackson   thrpt    2  244393.573          ops/s
Test.slowjson  thrpt    2    2681.164          ops/s

嗯~ 这次差两个量级了,达到了我生产环境的性能标准,可以上线了……

JSONObject到JSON字符串

wait wait 桥都麻袋,目前只实现了json字符串到JSONObject的转换,没有实现从JSONObject到json字符串的转化,功能不完整啊。不过这个也简单,我们按照JSONObject里对象的层次,递归地来做toSting,代码如下。

    @Override
    public String toString() {
        return toJSONString();
    }

    public String toJSONString() {
        StringBuilder sb = new StringBuilder();
        List<String> list = new ArrayList<>(map.size());
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            String key = entry.getKey();
            Object object = entry.getValue();
            String value = null;
            if (String.class.isInstance(object)) {
                value = "\"" + object.toString() + "\"";
            } else if (JSONObject.class.isInstance(object)) {
                value = object.toString();
            } else if (JSONArray.class.isInstance(object)) {
                value = object.toString();
            } else {
                value = ((JSONParser.ValueContext)object).getText();
            }
            list.add("\"" + key + "\":" + value);
        }
        sb.append("{");
        sb.append(String.join(",", list));
        sb.append("}");
        return sb.toString();
    }

JSONArray

上面始终没有提到JSONArray,其实JSONArray也是JSON中重要组成部分,之所以没提是因为JSONArray和JSONObject的实现思路是非常相似的,而且简单多了,我的封装如下。

package xyz.xindoo.slowjson;

import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class JSONArray {
    private final List<JSONObject> list;

    public JSONArray() {
        this.list = new ArrayList<>();
    }
    public JSONArray(List<JSONObject> list) {
        this.list = new ArrayList<>(list.size());
        this.list.addAll(list);
    }

    protected JSONArray(JSONParser.ArrayContext arrayCtx) {
        this.list = arrayCtx.value()
                            .stream()
                            .map(valueContext -> new JSONObject(valueContext.obj()))
                            .collect(Collectors.toList());
    }

    public static JSONArray parseArray(String text) {
        JSONLexer lexer = new JSONLexer(CharStreams.fromString(text));
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        JSONParser parser = new JSONParser(tokens);
        JSONParser.ArrayContext arrayCtx = parser.array();
        return new JSONArray(arrayCtx);
    }

    public JSONObject getJSONObject(int index) {
        return list.get(index);
    }

    public void add(JSONObject jsonObject) {
        list.add(jsonObject);
    }

    @Override
    public String toString() {
        return toJSONString();
    }

    public String toJSONString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        List<String> strList = list.stream().map(JSONObject::toString).collect(Collectors.toList());
        sb.append(String.join(",", strList));
        sb.append("]");
        return sb.toString();
    }
}

Todo

  1. 上传至maven中心仓库,方便大家冲KPI,嘿嘿嘿。
  2. 完善API,虽然抄了fastjson的api,但确实没抄全。
  3. 完善类型,json规范里其实是支持null, boolean, 数字类型的,我这图简单都用了String类型。
  4. 完善Excption,目前如果抛Exception都是抛的antlr的,会对用户有误导作用。
  5. 增加控制随机自旋的API,性能控制交于用户。

实际上列Todo是为了让slowjson看起来像个项目,至于做不做就随缘了,毕竟不完美才是slowjson最大的特点。。。。

最后所有源码已上传至github slowjson ,欢迎star。

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 猿与汪的秘密 设计师: 上身试试
应支付0元
点击重新获取
扫码支付

支付成功即可阅读