语法解析器ANTLR4的java表达式解析实战

最新推荐文章于 2025-04-09 21:44:34 发布
最新推荐文章于 2025-04-09 21:44:34 发布
阅读量3.2k 收藏 14
点赞数 7
文章标签： java 功能测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asas1019mm/article/details/132591312
版权

背景

自动化测试框架中需要支持计算解析断言表达式

需求

发送完一个http请求后，需要对响应的内容做精确校验，实现方式：填写断言表达式，框架实现对类似如下表达式的计算解析。

( [$.statusCode] == 200 OR [$.comments] == '成功' ) AND ${v_cardNo} != '12345' AND ${v_money} > 100.98 AND ${v_money} > 0.98
  1. [json路径]，中括号中间的表示http请求响应的参数路径
  2. ${变量名}，美元符和大括号中间的表示用例执行上下文中储存的变量
  3. 字符串用单引号引用
  4. 支持等于、不等于、大于、大于等于、小于、小于等于、与、或等操作

实现

1. 新建maven工程，并创建一个g4文件

src/main/resources 目录下，命名：Expression.g4

内容如下

// 定义了 grammar 的名字，名字需要与文件名对应
grammar Expression;
@header {
// 定义package
package com.bobo.learn.antlr.core;
}
// Lexer rules
WS:             [ \t\r\n]+ -> skip;
STRING:         '\'' (~['\r\n])* '\'';
NUMBER:         ([0-9][0-9]*)+(.[0-9]+)?;
EXTRACT_PATH:   '[' ~[[\]]+ ']';
VARIABLE_NAME:  '${' ~[${}]+ '}';
LPAREN:         '(';
RPAREN:         ')';
EQUAL:          '==';
NOT_EQUAL:      '!=';
LESS_THAN:      '<';
LESS_EUQAL:     '<=';
LARGER_THAN:    '>';
LARGER_EQUAL:   '>=';
AND:            'AND';
OR:             'OR';

// Parser rules
// #后面的名字，是在后续处理对应规则的时候会用到的
expression
           : LPAREN expression RPAREN                               #expressionWithBr
           | EXTRACT_PATH op=(EQUAL | NOT_EQUAL) STRING             #expressionWithString
           | EXTRACT_PATH op=(EQUAL | NOT_EQUAL) VARIABLE_NAME      #expressionWithString
           | EXTRACT_PATH op=(EQUAL | NOT_EQUAL) EXTRACT_PATH       #expressionWithString
           | EXTRACT_PATH op=(EQUAL | NOT_EQUAL | LESS_THAN | LESS_EUQAL | LARGER_THAN | LARGER_EQUAL) NUMBER   #expressionWithNumber
           | VARIABLE_NAME op=(EQUAL | NOT_EQUAL) STRING            #expressionWithString
           | VARIABLE_NAME op=(EQUAL | NOT_EQUAL) EXTRACT_PATH      #expressionWithString
           | VARIABLE_NAME op=(EQUAL | NOT_EQUAL) VARIABLE_NAME     #expressionWithString
           | VARIABLE_NAME op=(EQUAL | NOT_EQUAL | LESS_THAN | LESS_EUQAL | LARGER_THAN | LARGER_EQUAL) NUMBER  #expressionWithNumber
           | expression AND expression   #andOperation
           | expression OR expression   #orOperation
           ;

2. 安装antlr4插件

此插件可以调试，antlr4语法规则

3. 调试语法规则

  • 在语法上右键-》点击test rule expression

  • 输入表达式，可以到右下方会出现生成的解析树，如果有错误，会有提示

4. 生成java源码文件

  • 右键g4文件，点击Configure ANTLR

  • 选择生成的源码文件的目标目录

在这里直接与g4文件配置的package目录对应

  • 右键g4文件，点击Generate ANTLR

  • 生成结果

5. 测试

  • 新建测试代码ExpressionTest.java
package com.bobo.learn.antlr;
import com.bobo.learn.antlr.core.ExpressionBaseVisitor;
import com.bobo.learn.antlr.core.ExpressionLexer;
import com.bobo.learn.antlr.core.ExpressionParser;
import cn.hutool.core.util.ReUtil;
import lombok.extern.slf4j.Slf4j;
import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.apache.commons.lang3.StringUtils;

@Slf4j
public class ExpressionTest {
    public static void main(String[] args) {
        final String expr = "( [$.statusCode] == 200 OR [$.comments] == '成功' OR [$.comments] == ${v_hello} ) AND ${v_cardNo} != '12345' AND ${v_money} > 100.99";
        log.info(expr);
        CharStream input = CharStreams.fromString(expr);
        ExpressionLexer lexer = new ExpressionLexer(input);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        ExpressionParser parser = new ExpressionParser(tokens);
        ExpressionParser.ExpressionContext context = parser.expression();
        AssertExpressionVisitor visitor = new AssertExpressionVisitor();
        Object result = visitor.visit(context);
        log.info("Expression result: {}", result);
    }

    static class AssertExpressionVisitor extends ExpressionBaseVisitor<Object> {

        @Override
        public Object visitExpressionWithBr(ExpressionParser.ExpressionWithBrContext ctx) {
            return visit(ctx.getChild(1));
        }

        @Override
        public Object visitExpressionWithString(ExpressionParser.ExpressionWithStringContext ctx) {
            String left = ctx.getChild(0).getText();
            String right = ctx.getChild(2).getText();

            if(ctx.op != null) {
                log.info("原始：{} {} {}", left, ctx.op.getText(), right);
                String leftOperand = null;
                String rightOperand = null;

                if(left.startsWith("[")) {
                    leftOperand = extract(left) + "";
                }else if(left.startsWith("${")) {
                    leftOperand = getVariableValue(left) + "";
                }

                if(right.startsWith("[")) {
                    rightOperand = extract(right) + "";
                }else if(right.startsWith("${")) {
                    rightOperand = getVariableValue(right) + "";
                }else if(ctx.STRING() != null) {
                    rightOperand = ctx.STRING().getText();
                    rightOperand = rightOperand.substring(1, rightOperand.length() - 1);
                }
                log.info("实际：{} {} {}", leftOperand, ctx.op.getText(), rightOperand);

                switch (ctx.op.getType()) {
                    case ExpressionLexer.EQUAL:
                        return StringUtils.equals(leftOperand, rightOperand);
                    case ExpressionLexer.NOT_EQUAL:
                        return !StringUtils.equals(leftOperand, rightOperand);
                    default: throw new RuntimeException("unsupported operator type");
                }
            }
            return super.visitExpressionWithString(ctx);
        }

        @Override
        public Object visitExpressionWithNumber(ExpressionParser.ExpressionWithNumberContext ctx) {
            String left = ctx.getChild(0).getText();
            String right = ctx.getChild(2).getText();

            if(ctx.op != null) {
                log.info("原始：{} {} {}", left, ctx.op.getText(), right);
                Double leftOperand = null;
                Double rightOperand = Double.valueOf(right);
                Object leftString = null;
                if(left.startsWith("[")) {
                    leftString = extract(left);
                } else if(left.startsWith("${")) {
                    leftString = getVariableValue(left);
                }
                if(leftString != null && ReUtil.isMatch("([1-9][0-9]*)+(.[0-9]+)?", leftString.toString())) {
                    leftOperand = Double.valueOf(leftString.toString());
                }
                log.info("{} {} {}", leftOperand, ctx.op.getText(), rightOperand);
                if(leftOperand == null) {
                    return false;
                }

                switch (ctx.op.getType()) {
                    case ExpressionLexer.EQUAL:
                        return rightOperand.equals(leftOperand);
                    case ExpressionLexer.NOT_EQUAL:
                        return !rightOperand.equals(leftOperand);
                    case ExpressionLexer.LESS_THAN:
                        return leftOperand < rightOperand;
                    case ExpressionLexer.LESS_EUQAL:
                        return leftOperand <= rightOperand;
                    case ExpressionLexer.LARGER_THAN:
                        return leftOperand > rightOperand;
                    case ExpressionLexer.LARGER_EQUAL:
                        return leftOperand >= rightOperand;
                    default: throw new RuntimeException("unsupported operator type");
                }
            }
            return super.visitExpressionWithNumber(ctx);
        }

        @Override
        public Object visitOrOperation(ExpressionParser.OrOperationContext ctx) {
            Object left = visit(ctx.getChild(0));
            Object right = visit(ctx.getChild(2));
            log.info("实际：{} {} {}", left, ctx.OR().getText(), right);
            if(left instanceof Boolean && right instanceof Boolean) {
                return (Boolean)left || (Boolean)right;
            }
            return false;
        }

        @Override
        public Object visitAndOperation(ExpressionParser.AndOperationContext ctx) {
            Object left = visit(ctx.getChild(0));
            Object right = visit(ctx.getChild(2));
            log.info("{} {} {}", left, ctx.AND().getText(), right);
            if(left instanceof Boolean && right instanceof Boolean) {
                return (Boolean)left && (Boolean)right;
            }
            return false;
        }

        /**
         * 根据路径提取http响应参数的值
         * @param path
         * @return
         */
        public Object extract(String path) {
            if("[$.statusCode]".equalsIgnoreCase(path)) {
                return 200;
            }
            if("[$.comments]".equalsIgnoreCase(path)) {
                return "成功";
            }
            return "";
        }

        /**
         * 提取用例执行上下文中保存的变量的值
         * @param variableName
         * @return
         */
        public Object getVariableValue(String variableName) {
            return 100;
        }
    }
}
  • 执行测试代码，可以看到一个解析过程，测试结果如下

maven工程pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bobo</groupId>
    <artifactId>learn</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>


        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.18</version>
        </dependency>
        <dependency>
            <groupId>org.antlr</groupId>
            <artifactId>antlr4-runtime</artifactId>
            <version>4.12.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>


        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.26</version>
        </dependency>


        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>2.0.5</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>2.0.5</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>

@长风万里
关注
SPARKSQL3.0-Antlr4由浅入深&SparkSQL语法解析
探索大数据世界 - 深入解析数据存储、分布式计算与人工智能
11-16 3206
SPARKSQL3.0-Antlr4由浅入深&SparkSQL语法解析
antlr 生成 java 代码_使用antlr4, 用ts/js还原protobuf生成的java代码为pb (五)
weixin_32285357的博客
03-05 403
目录:test004.tsimport {ANTLRInputStream, CommonTokenStream} from "antlr4ts";import {JavaLexer} from "../antlr/Java/JavaLexer";import {CompilationUnitContext, JavaParser} from "../antlr/Java/JavaParser";...
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 | ';' ; .....
ANTLR4：高效构建语言解析器的秘密武器，让代码解析不再‘烧脑’，开发者必备技能
最新发布
skywalk8163的专栏
04-09 1113
ANTLR（ANother Tool for Language Recognition）是一款功能强大且灵活的工具，能够处理复杂的语法规则，支持多种语言特性的定义，ANTLR支持生成多种编程语言的解析器代码，如Java、C#、Python等，这大大方便了不同语言环境下的开发者使用，提高了工具的通用性和可移植性。个人感觉简单应用的话，Windows下安装不需要像官网讲的那样麻烦。python版本只需要pip安装即可，pip安装的时候会自动安装java，但考虑国内情况，还是建议手工安装java。
JAVA动态表达式：Antlr4 表达式树解析
℡メ㏑╭ァ小凯
06-13 746
这样通过循环你就能得到这串表达式的每个值：((1==1 and (2==2 or 3==3)) or (2==2 or 3==3)) and '啦啦啦'=='1'下面的RuleEntity rule对象，就是把上面的结构树给拿到了。比如，第一个是( ，第二个是(，第三个是1，第四个是==......目前已经实现了常理及分组常规表达式的解析。
antlr 解析 java method_在antlr4中精确解析n个参数
weixin_28235889的博客
03-05 581
我正在使用Antlr4与python3运行时 . 在我尝试解析的语言中，有许多操作(大约50个)接受 OPNAME [ parameter1, parameter2, parameter3 ] 形式的固定数量的参数我曾经有一个像这样的规则的语法：statement: OP1 '[' NUM ']'| OP2 '[' NUM ',' NUM ']'| OP3 '[' NUM ',' NUM ',' ...
antlr 解析 java method_antlr怎样解析java文件
weixin_30947859的博客
02-19 364
展开全部给个思路吧。没做过。首先分析java的关键字。最主要的32313133353236313431303231363533e78988e69d8331333339663932几个：package，import，class，private，public，protected关键字。第一步：把.java文件读进内存第二步：去掉行注释：按行读取，如果这行是“//”开头的就从文件中删除第三步：去掉块注释...
ANTLR解析Java文件
flyingzc的博客
11-25 1985
ANTLR解析Java文件 https://github.com/antlr/grammars-v4.git grammars-v4里提供了Java和其他常用的antlr语法. 最近看的一个项目里实体类会使用 @Model(name=“xxx”) 标注实体类.用@ModelField(name=“xxx”)标注关联的实体. 这里使用antlr解析实体类之间的关联. FileFilter filter = new FileFilter() { @Override public boolean
ANTLR 4权威指南：解析器构建实战
对于那些需要构建自定义语法解析器的开发者，ANTLR 4和这本书都提供了宝贵的资源和支持。 《The Definitive ANTLR 4 Reference》是一本深入浅出的ANTLR教程，无论是初学者还是经验丰富的开发者，都能从中受益，提升...
ANTLR与Java结合项目实战：语法创建与自动化测试
通过定义一种语法规则，ANTLR能够生成一个完整的解析器，从而使得处理特定语言结构变得简单。 本项目的目标包括： 1. 创建语法，这是ANTLR工作的基础。开发者需要编写语法规则，这些规则描述了输入语言的结构。 2. ...
ANTLR4计算器项目实战：Java实现及使用指南
资源摘要信息:"ANTLR4-calculator是一个基于ANTLR4的计算器示例项目，它展示了如何使用ANTLR工具从特定的语法定义生成解析器。ANTLR4是一个强大的解析器生成器，用于读取、处理、执行或翻译结构化文本或二进制文件。...
用Antlr 分析布尔表达式的例子
06-26
用antlr分析处理布尔表达式的例子，包括：语法定义.g文件；生成的词法分析和语法分析器；带有图形界面的分析器调用代码。 其中带有GUI的分析器ParserFrame，可以用于任何.g文件生成的词法、语法分析器，只要通过改变构造方法的参数即可，方便学习者使用。
antlr4入门例子
08-17
antlr4 hello world。antlr4 hello world。antlr4 hello world。antlr4 hello world
Java语言实现的简单数学表达式解析器
一旦定义了这些规则，ANTLR 就可以用来生成一个解析器，该解析器能够理解并处理符合这些规则的表达式。 该解释器的开发不仅涉及对 ANTLR 的应用，还涵盖了以下知识点： 1. 语法分析（Syntax Analysis）: 语法分析...
antlr java_ANTLR v4,JavaLexer和JavaParser将null作为解析树返回
weixin_35693014的博客
02-19 436
我正在使用antlr v4来提取java程序的解析树以用于其他目的.我从这个样本开始：ANTLR v4 visitor sample我已经测试了给定链接上的步骤,以检查它是否有效以及一切正常：java Runa = 1+2b = a^2c = a+b*(a-1)a+b+c^ZResult: 33.0然后我编写了自己的解析java程序如下面的结构：|_Java.g4|_Java.tokens|_Ja...
基于antlr的表达式解析器
novelly的专栏
10-31 1534
package formula; import java.util.HashMap; import java.util.List; import java.util.Map; import org.antlr.runtime.ANTLRStringStream; import org.antlr.runtime.CommonTokenStream; import org.antlr.runti
ANTLR4-实践
sunquan291的专栏
07-07 6825
最近在研究Yang模型转换，自然而然就看到了ANTLR4与Xtend的相关技术。简单学习下基本用法，以此作为记录。 对于ANTLR4是一款优秀的开源语法解析器。不仅如此，可以为开发者自己定义的语法提供识别解析计算的功能。从一个简单的小例子开始： 如定义一个语法： 数字 操作A操作B操作C操作D 数据 具象一点 10 +* 2 计算结果是  （10+2）*2=24 开发
Mark : Antlr4 入门
tianyeshiye
04-18 748
一.ANTRL 是什么 ANTLR 是用JAVA写的语言识别工具，它用来声明语言的语法，简称为“元语言”(meta-language)。 ANTLR 语法识别一般分为二个阶段： 1.词法分析阶段 （lexical analysis) 对应的分析程序叫做lexer，负责将符号（token）分组成符号类（token class or token type） 2.解析阶段 根据词法，...
ANTLR4规则解析生成器(三)：遍历语法分析树
追寻梦想的青春
02-29 2335
定义好词法和语法规则，就可以对提供的输入串进行词法分析和语法分析，得到语法分析树，antlr4提供了Listener和Visitor两种机制遍历语法分析树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值