JAVA动态表达式：Antlr4 G4 模板 + 读取字符串表达式结构树

已于 2024-06-12 11:29:39 修改
阅读量317 收藏
点赞数 1
分类专栏： SpringBoot 文章标签： java 前端 javascript
于 2024-06-11 16:11:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq873113580/article/details/139601947
版权

安装antlr4插件

创建一个后缀是g4的文件

grammar Expr;

expression :
             '(' expression ')'          # parens
            | expression 'and' expression # andOp
            | expression 'or' expression  # orOp
            | '@' VARNAME comparison_op NUMBER # comparison
            | '@' VARNAME comparison_op STRING # comparison
            | '@' NUMBER comparison_op NUMBER # comparison
            | '@' STRING comparison_op STRING # comparison
            | '@' VARNAME comparison_op VARNAME # comparison
            | '@' VARNAME contains_op VARNAME # comparison
            | '@' VARNAME contains_op NUMBER # comparison
            | '@' VARNAME contains_op STRING # comparison
            | '@' STRING contains_op STRING # comparison
            |  VARNAME comparison_op NUMBER # comparison
            |  VARNAME comparison_op STRING # comparison
            |  NUMBER comparison_op NUMBER # comparison
            |  STRING comparison_op STRING # comparison
            |  VARNAME comparison_op VARNAME # comparison
            |  VARNAME contains_op VARNAME # comparison
            |  VARNAME contains_op NUMBER # comparison
            |  VARNAME contains_op STRING # comparison
            |  STRING contains_op STRING # comparison
            ;

comparison_op : '<' | '<=' | '>' | '>=' | '==' | '!=';
contains_op: 'contains' | 'notcontains';

STRING : '\'' ( '\\' . | '\\\'' | ~[\\'] )* '\'';
NUMBER : '-'? [0-9]+ ('.' [0-9]+)?;
VARNAME : [a-zA-Z_][a-zA-Z_0-9]*;
WS : [ \t\r\n]+ -> skip; // 忽略空白字符
fragment Letter: [a-zA-Z];
fragment Digit: [0-9];
fragment ChineseCharacter: [\u4e00-\u9fa5];

上面的文件可以直接解析如下格式的表达式：

@prices == 1 and (@val >=1 or @name<=4) and 1==1 and '2'=='3' and '1123' contains '1' and '23455' notcontains '5'

右键生成代码

 引入POM

 <!--动态表达式-->
        <dependency>
            <groupId>org.antlr</groupId>
            <artifactId>antlr4</artifactId>
            <version>4.10.1</version>
        </dependency>

 测试表达式结构

 @Test
    public  void  Test00(){
        // 构建字符流
        CodePointCharStream charStream = CharStreams.fromString("@prices == 1 and (@val >=1 or @name<=4) and 1==1 and '2'=='3' and '1123' contains '1' and '23455' notcontains '5'");

        // 从字符流分析词法， 解析为token
        ExprLexer lexer = new ExprLexer(charStream);

        // 从token进行分析
        ExprParser parser = new ExprParser(new CommonTokenStream( lexer) );

        // 使用监听器，遍历语法树，根据语法定义，prog为语法树的根节点
        ParseTree prog = parser.expression();

        // 创建监听器
        CustomerExprListener listener = new CustomerExprListener();


        // 遍历AST并使用监听器处理
        ParseTreeWalker walker = new ParseTreeWalker();
        walker.walk(listener, prog);

        // 打印生成的语法树
        //System.out.println( prog.toStringTree(parser));

    }

拿到表达式以后，就可以把结果处理成实际业务想要的对象了

package com.java.core.web.antlr4;

import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.tree.ErrorNode;
import org.antlr.v4.runtime.tree.TerminalNode;

public class CustomerExprListener  extends ExprBaseListener{
    @Override
    public void enterEveryRule(ParserRuleContext ctx) {
        //System.out.println("Entering rule: " + ctx.getText());
    }

    @Override
    public void exitEveryRule(ParserRuleContext ctx) {
        //System.out.println("Exiting rule: " + ctx.getText());
    }

    @Override
    public void visitTerminal(TerminalNode node) {
        System.out.println("Visiting terminal: " + node.getText());
    }

    @Override
    public void visitErrorNode(ErrorNode node) {
        //System.out.println("Visiting error: " + node.getText());
    }
}

监听输出的内容


Visiting terminal: @
Visiting terminal: prices
Visiting terminal: ==
Visiting terminal: 1
Visiting terminal: and
Visiting terminal: (
Visiting terminal: @
Visiting terminal: val
Visiting terminal: >=
Visiting terminal: 1
Visiting terminal: or
Visiting terminal: @
Visiting terminal: name
Visiting terminal: <=
Visiting terminal: 4
Visiting terminal: )
Visiting terminal: and
Visiting terminal: 1
Visiting terminal: ==
Visiting terminal: 1
Visiting terminal: and
Visiting terminal: '2'
Visiting terminal: ==
Visiting terminal: '3'
Visiting terminal: and
Visiting terminal: '1123'
Visiting terminal: contains
Visiting terminal: '1'
Visiting terminal: and
Visiting terminal: '23455'
Visiting terminal: notcontains
Visiting terminal: '5'

可以把监控的类提取出来

/**
     * 遍历语法树节点
     * @param tree
     */
    public static RuleTest traverseTree(ParseTree tree, String name, RuleTest ruleTest) {
        //自定义变量
        // public String type; //类型 1-属性 2-值 （由比较操作符决定）
        // public String group; //组 0-不用添加组 1-需要添加组 （由连续小括号的数量决定，如果两个符号连续都是小括号，那么系统会认为是一个组）
        // public String bracket;//括号 判断是否是组 （小括号的数量记录）
        // public String isObject;//是否new object （条件对象 0-不创建 1-创建 由逻辑运算符决定 如 and/or）

        if (tree instanceof TerminalNode) {
            TerminalNode terminalNode = (TerminalNode) tree;
            //得到树节点
            String text = terminalNode.getText();
            //获取条件组
            List<Condition> list = ruleTest.getConditionList();
            //判断节点类型 （比较操作符/逻辑运算符号/小括号/中括号/@符）
            int res = CheckSymbolOptions.getNameOrValue(text);
            if (res == 1){ //比较操作符
                ruleTest.setType("2");
                ruleTest.setEndBracket("0");
                if (ruleTest.getGroup() == null || ruleTest.getGroup().equals("0")){
                    if (list.size()>0){
                        Condition condition = list.get(list.size()-1);
                        String symbolOptions = SymbolOptions.getNameOrValue(text);
                        condition.setCompareOperation(symbolOptions);//比较操作（操作符）
                    }
                }else{
                    Condition cond = list.get(list.size()-1);
                    List<Condition> conditionList = cond.getConditionList();
                    if (conditionList.size()>0){
                        Condition condition = conditionList.get(conditionList.size()-1);
                        String symbolOptions = SymbolOptions.getNameOrValue(text);
                        condition.setCompareOperation(symbolOptions);//比较操作（操作符）
                    }
                }

            }else if (res ==2){ //逻辑运算符
                if (ruleTest.getGroup() == null || ruleTest.getGroup().equals("0")){
                    //添加条件对象
                    Condition condition = addCondition(name,"symbol",text);
                    list.add(condition);
                    ruleTest.setIsObject("1");//需要添加条件对象  0-不添加 1-添加
                }else{
                    Condition cond = list.get(list.size()-1);
                    List<Condition> conditionList = cond.getConditionList();
                    //添加条件对象
                    Condition condition = addCondition(name,"symbol",text);
                    conditionList.add(condition);
                    ruleTest.setIsObject("1");//需要添加条件对象  0-不添加 1-添加
                }
            }else if (res==3){ //括号标识符
                if (text.equals("(")){
                    ruleTest.setType("1");
                    if (ruleTest.getBracket()==null || ruleTest.getBracket().equals("0")){
                        ruleTest.setBracket("1");
                    }else{
                        int va = Integer.valueOf(ruleTest.getBracket())+1;
                        ruleTest.setBracket(String.valueOf(va));
                        if (va==2){
                            if (list== null){
                                list = new ArrayList<>();
                            }
                            ruleTest.setGroup("1");
//                            if (list.size()==0){
//                                Condition condition = addCondition(name,"group",null);
//                                int endva = Integer.valueOf(ruleTest.getSubscript())+1;
//                                ruleTest.setSubscript(String.valueOf(endva));//记录下标
//                                condition.setTierIndex(String.valueOf(endva));
//                                list.add(condition);
//                                ruleTest.setConditionList(list);
//                            }
                            //创建对象
                            Condition condition = addCondition(name,"group",null);
                            condition.setDescribe(null);
                            int endva = Integer.valueOf(ruleTest.getSubscript())+1;
                            ruleTest.setSubscript(String.valueOf(endva));//记录下标
                            condition.setTierIndex(String.valueOf(endva));
                            list.add(condition);
                            ruleTest.setConditionList(list);
                            ruleTest.setIsObject("0");//添加对象后回复初始状态
                        }
                        ruleTest.setBracket("0");
                    }
                    if (ruleTest.getId()==null){
                        //设置rule属性
                        ruleTest.setId(generateId("rule"));//id需要自动生成 rule_xxxxxxxxxx（10位数）
                        ruleTest.setName(name);
                        ruleTest.setSubscript("1");//记录索引
                        ruleTest.setTierIndex("1");//层级索引 需要确定来源
                    }
                }
                if (text.equals(")")){
                    if (ruleTest.getEndBracket()==null || ruleTest.getEndBracket().equals("0")){
                        ruleTest.setEndBracket("1");
                    }else{
                        int endva = Integer.valueOf(ruleTest.getEndBracket())+1;
                        ruleTest.setEndBracket(String.valueOf(endva));
                    }
                    if (ruleTest.getEndBracket().equals("2")){
                        ruleTest.setGroup("0");
                    }
                }
            }else if (res ==4){ //@ 参数标识
                ruleTest.setType("1");
            }else {
                //初始化对象与集合
                if (list== null || list.size()==0){
                    list = new ArrayList<>();
                    Condition condition = addCondition(name,"single",null);
                    list.add(condition);
                    ruleTest.setConditionList(list);
                }
                if (ruleTest.getGroup() == null || ruleTest.getGroup().equals("0")){
                    if (ruleTest.getIsObject()!=null){
                        if (ruleTest.getIsObject().equals("1")){
                            //创建对象
//                            Condition condition = new Condition();
                            Condition condition = addCondition(name,"single",null);
                            list.add(condition);
                            ruleTest.setIsObject("0");//添加对象后回复初始状态
                        }
                    }
                }else{
                    if (ruleTest.getIsObject()!=null){
                        if (ruleTest.getIsObject().equals("1")) {
                            Condition cond = list.get(list.size()-1);
                            List<Condition> conditionList = cond.getConditionList();
                            //创建对象
                            Condition addCondition = addCondition(name,"single",null);
                            conditionList.add(addCondition);
                            ruleTest.setIsObject("0");//添加对象后回复初始状态
                        }
                    }
                }
                if (list.size()>0){
                    if (ruleTest.getGroup()== null || ruleTest.getGroup().equals("0") ){
                        //获取属性详情，判断属性是否存在，如果存在拿到属性名称、类型等信息
                        String type = DataType.getDataType("5000"); //此处需要替换
                        Condition condition = list.get(list.size()-1);
                        if (condition.getLeftOperatorExpression()==null || condition.getRightOperatorExpression()==null ){
                            if (ruleTest.getType().equals("1")){
                                //创建左边运算符表达式
                                LeftOperatorExpression left = addLeftOperatorExpression(type,text);
                                condition.setLeftOperatorExpression(left);
                                ruleTest.setType("0");
                            }
                            if (ruleTest.getType().equals("2")){
                                //创建右边运算符表达式
                                RightOperatorExpression right = addRightOperatorExpression(type,text);
                                condition.setRightOperatorExpression(right);
                                ruleTest.setType("0");
                                ruleTest.setBracket("0");
                            }
                        }
                    }else{
                        if (ruleTest.getGroup().equals("1")){
                            String type = DataType.getDataType("5000"); //此处需要替换
                            Condition cond = list.get(list.size()-1);
//                            Rule rule = cond.getRule();
                            List<Condition> conditionList = cond.getConditionList();
                            //初始化对象与集合
                            if (conditionList== null || conditionList.size()==0){
                                conditionList = new ArrayList<>();
                                Condition condition = addCondition(name,"single",null);
                                if (condition.getLeftOperatorExpression() == null || condition.getRightOperatorExpression() == null) {
                                    if (ruleTest.getType().equals("1")) {
                                        //创建左边运算符表达式
                                        LeftOperatorExpression left = addLeftOperatorExpression(type, text);
                                        condition.setLeftOperatorExpression(left);
                                        ruleTest.setType("0");
                                    }
                                    if (ruleTest.getType().equals("2")) {
                                        //创建右边运算符表达式
                                        RightOperatorExpression right = addRightOperatorExpression(type, text);
                                        condition.setRightOperatorExpression(right);
                                        ruleTest.setType("0");
                                        ruleTest.setBracket("0");
                                    }
                                }
                                conditionList.add(condition);
                                cond.setConditionList(conditionList);
                            }else{
                                Condition condition = conditionList.get(conditionList.size()-1);
                                if (condition.getLeftOperatorExpression() == null || condition.getRightOperatorExpression() == null) {
                                    if (ruleTest.getType().equals("1")) {
                                        //创建左边运算符表达式
                                        LeftOperatorExpression left = addLeftOperatorExpression(type, text);
                                        condition.setLeftOperatorExpression(left);
                                        ruleTest.setType("0");
                                    }
                                    if (ruleTest.getType().equals("2")) {
                                        //创建右边运算符表达式
                                        RightOperatorExpression right = addRightOperatorExpression(type, text);
                                        condition.setRightOperatorExpression(right);
                                        ruleTest.setType("0");
                                        ruleTest.setBracket("0");
                                    }
                                }
                            }

                        }

                    }
                }
            }
        }
        //递归 循环遍历
        for (int i = 0; i < tree.getChildCount(); i++) {
            traverseTree(tree.getChild(i),name,ruleTest);
        }
        return ruleTest;
    }

上面的g4模板，是把@prices这样的变量，分成了@+price，下面的g4模板是获得整体@price变量的

grammar Expr;

expression :
             '(' expression ')'          # parens
            | expression 'and' expression # andOp
            | expression 'or' expression  # orOp
            | AT_VARNAME comparison_op NUMBER # comparison
            | AT_VARNAME comparison_op STRING # comparison
            | AT_VARNAME comparison_op VARNAME # comparison
            | AT_VARNAME contains_op VARNAME # comparison
            | AT_VARNAME contains_op NUMBER # comparison
            | AT_VARNAME contains_op STRING # comparison
            | AT_VARNAME comparison_op AT_VARNAME # comparison
            | VARNAME comparison_op NUMBER # comparison
            | VARNAME comparison_op STRING # comparison
            | NUMBER comparison_op NUMBER # comparison
            | STRING comparison_op STRING # comparison
            | VARNAME comparison_op VARNAME # comparison
            | VARNAME contains_op VARNAME # comparison
            | VARNAME contains_op NUMBER # comparison
            | VARNAME contains_op STRING # comparison
            | STRING contains_op STRING # comparison
            ;

comparison_op : '<' | '<=' | '>' | '>=' | '==' | '!=';
contains_op: 'contains' | 'notcontains';

AT_VARNAME : '@' VARNAME;
STRING : '\'' ( '\\' . | '\\\'' | ~[\\'] )* '\'';
NUMBER : '-'? [0-9]+ ('.' [0-9]+)?;
VARNAME : [a-zA-Z_][a-zA-Z_0-9]*;
WS : [ \t\r\n]+ -> skip; // 忽略空白字符
fragment Letter: [a-zA-Z];
fragment Digit: [0-9];
fragment ChineseCharacter: [\u4e00-\u9fa5];

Teln_小凯
关注
专栏目录
解码 SQL：深入探索 Antlr4 语法解析器背后的奥秘
探索大数据世界 - 深入解析数据存储、分布式计算与人工智能
11-29 1802
解码 SQL：深入探索 Antlr4 语法解析器背后的奥秘
语法解析器ANTLR4的java表达式解析实战
asas1019mm的专栏
08-30 2530
语法解析器ANTLR4的java表达式解析实战
JAVA动态表达式：Antlr4 表达式树解析
℡メ㏑╭ァ小凯
06-13 523
这样通过循环你就能得到这串表达式的每个值：((1==1 and (2==2 or 3==3)) or (2==2 or 3==3)) and '啦啦啦'=='1'下面的RuleEntity rule对象，就是把上面的结构树给拿到了。比如，第一个是( ，第二个是(，第三个是1，第四个是==......目前已经实现了常理及分组常规表达式的解析。
G4Studio行业应用二次快速java开发平台最新版(5.2正式发行版)
10-18
G4Studio行业应用二次快速java开发平台最新版(5.2正式发行版)
java 画树,使用Java在ANTLR4中绘制解析树
weixin_33364134的博客
02-16 285
I am new to ANTLR4, when I was first trying it out in command line I was using the grun with gui parameter. Now I am developing a Java application and I want to display the same dialog while executing...
ANTLR4开发实用操作（一）：文件读入
heaven_h_c的博客
08-13 2256
前言 ANTLR是一款强大的语言解析工具，包含语法分析器、词法分析器等。可以用来实现语言解析器、编译器、配置文件读取器等等。也可以用来实现自己的编程语言。感谢Terence Parr教授多年研究的成果，为语言开发进行了大量的基础工作。关于ANTLR的介绍网上不少，但以简单范例居多，antlr内部复杂的原理、部件、逻辑关系等信息非常少。 由于在工作中需要进行一款解释器开发，虽然看完了两本教程，但结合...
MastarCpler开发日志（二）——用antlr4搞出parse树
布克布克丶
04-05 1574
参考：-官方文件：https://github.com/antlr/grammars-v4/blob/master/cpp/CPP14.g4-《C++ Primer》第五版-别人的总结https://abcdabcd987.com/notes-on-antlr4/过程：Mx*语言结构另外推荐一个挺好的在线画框图的网站：https://processon.com/我认为基本用到的antlr4格式大概...
Antlr4 ---遍历模式
04stone37
01-07 6049
Listener模式   使用ParseTreeWalker遍历树的过程中（深度优先），每次进入和退出规则节点时，触发对应的enterRule/exitRule方法。 使用示例 //step1:创建ParseTreeWalker ParseTreeWalker walker = new ParseTreeWalker(); //step2:创建ParseTreeListener和ParseTre...
java-antlr-sql.rar_antlr_antlr sql_antlr-sql_antlr4 sql解析_java
09-14
ANTLR的工作原理是通过读取一个描述语言语法的文法文件（通常以.g或.g4为扩展名），然后生成一个解析器，该解析器能够理解并处理符合该文法的语言输入。在提供的文件列表中，"sql.g"就是这样一个文法文件，它定义了...
一个简单的语言的语法（二）：ANTLR的重写规则
03-14
最后，它打印出解析树的字符串表示，方便我们检查结果。 ANTLR的强大之处在于其灵活性和可扩展性。通过调整重写规则，我们可以构建复杂的语法分析器，不仅支持基本的运算符，还能处理更复杂的语言结构，如条件语句...
G4Studio开发指南
07-18
G4Studio开发指南.pdf，296页 。
Antlr4 JAVA 语法解析器
01-06
解析java语法 grammar Java; // starting point for parsing a java file compilationUnit : packageDeclaration? importDeclaration* typeDeclaration* EOF ; packageDeclaration : annotation* 'package' qualifiedName ';' ; importDeclaration : 'import' 'static'? qualifiedName ('.' '*')? ';' ; typeDeclaration : classOrInterfaceModifier* classDeclaration | classOrInterfaceModifier* enumDeclaration | classOrInterfaceModifier* interfaceDeclaration | classOrInterfaceModifier* annotationTypeDeclaration | ';' ; .....
antlr实现四则运算源码
01-28
ANTLR（ANother Tool for Language Recognition）是一个强大的解析器生成器，用于读取、处理、执行或翻译结构化文本或二进制文件。它广泛应用于构建语言、工具和框架，包括SQL解析器、XML处理器以及各种编程语言的...
SPARKSQL3.0-Antlr4由浅入深&SparkSQL语法解析
探索大数据世界 - 深入解析数据存储、分布式计算与人工智能
11-16 2752
SPARKSQL3.0-Antlr4由浅入深&SparkSQL语法解析
ANTLR4规则解析生成器(三)：遍历语法分析树
追寻梦想的青春
02-29 1690
定义好词法和语法规则，就可以对提供的输入串进行词法分析和语法分析，得到语法分析树，antlr4提供了Listener和Visitor两种机制遍历语法分析树
【Antlr】Antlr 使用语法分析树监听器编写程序、Antlr 解析 Properties 格式、监听器模式
九师兄
01-10 979
出自：Antlr权威指南 并且进行补充。构建应用逻辑和语法松男合的语言类应用程序的关键在于，令语法分析器建立一棵语法分析树，然后在遍历该树的过程中触发应用逻辑代码。我们可以使用自己熟悉的方法遍历这样的语法分析树，也可以利用ANTLR自动生成的树遍历器。在本节中，我们将会使用ANTLR内貴的ParseTreeWalker构建一个与上一节类似的、基于监听器的属性文件处理程序。让我们从一个“干净”的、识别属性文件的语法开始。该语法树可以构建如下这种结构。
解析器生成器 ANTLR的详细介绍
G探险者的博客
03-22 3516
ANTLR诞生的背景是，当时的语言工具包大多数都是基于YACC和LEX等老旧技术，无法支持新的编程语言和复杂的语法规则，同时，它们的性能和可扩展性也受到一定的限制。根据SQL语句的各个部分和解析结果，我们可以记录和分析SQL执行情况，包括执行的时间、执行的参数、执行的结果等信息。解析输入的SQL语句。另外，在自然语言处理领域中，还有许多其他的类似ANTLR的语言工具，例如Stanford Parser、NLTK、SpaCy等，它们都能够用于自然语言文本的处理和分析，提高自然语言处理的效率和准确性。
antlr java,antlr4 / java：漂亮的打印解析树到标准输出
weixin_31261145的博客
02-19 522
Beginners question: how do I print a readable version of the parse tree to stdout?CharStream input = CharStreams.fromFileName("testdata/test.txt");MyLexer lexer = new MyLexer(input);CommonTokenStream ...
开坑学习一下antlr4工具使用
最新发布
weixin_42142600的博客
09-03 1247
在最近的work中，接触到了一个新的工具：ANTLR4，简单说明一下这个工具其实就是一个语法分析器生成器，功能与bison，yacc等相似，ANTLR是一款功能强大的语法分析器生成器，可用来读取、处理、执行和转换结构化文本或二进制文件。它被广泛应用于学术界和工业界构建各种语言、工具和框架。Antlr在Hadoop整个生态系统应用较为广泛，如Hive 词法文件是Antlr3写的；Presto词法文件也Antlr4实现的；SparkSQL词法文件是用Presto的词法文件改写的；还有。
解耦语法与应用：ANTLR4解析器设计
本章节主要探讨ANTLR 4的语言应用开发，尤其是如何通过解析器将语法与特定应用逻辑解耦。ANTLR 4的核心价值在于它提供了一种分离语法定义（使用ANTLR语法）和应用程序逻辑的方法。通常，解析器仅能判断输入是否遵循...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值