共计 11471 个字符，预计需要花费 29 分钟才能阅读完成。
一、背景介绍
由阿里的电商业务规定、表达式（布尔组合）、非凡数学公式计算（高精度）、语法分析、脚本二次定制等强需要而设计的一门动静脚本引擎解析工具。在阿里团体有很强的影响力，同时为了本身一直优化、发挥开源奉献精力，于 2012 年开源。二、依赖和调用阐明
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>QLExpress</artifactId>
<version>3.2.0</version>
</dependency>
ExpressRunner runner = new ExpressRunner();
DefaultContext<String, Object> context = new DefaultContext<String, Object>();
context.put("a",1);
context.put("b",2);
context.put("c",3);
String express = "a+b*c";
Object r = runner.execute(express, context, null, true, false);
System.out.println(r);
三、语法介绍
1、操作符和 java 对象操作
// 反对 +,-,*,/,<,>,<=,>=,==,!=,<>【等同于!=】,%,mod【取模等同于 %】,++,--,
//in【相似 sql】,like【sql 语法】,&&,||,!, 等操作符
// 反对 for，break、continue、if then else 等规范的程序控制逻辑
n=10;
for(sum=0,i=0;i<n;i++){sum=sum+i;}
return sum;
// 逻辑三元操作
a=1;
b=2;
max = a>b?a:b;
//java 的对象操作
import com.ql.util.express.test.OrderQuery;
// 零碎主动会 import java.lang.*,import java.util.*;
query = new OrderQuery();// 创立 class 实例, 会依据 classLoader 信息，主动补全类门路
query.setCreateDate(new Date());// 设置属性
query.buyer = "张三";// 调用属性, 默认会转化为 setBuyer("张三")
result = bizOrderDAO.query(query);// 调用 bean 对象的办法
System.out.println(result.getId());// 静态方法
2、脚本中定义 function
function add(int a,int b){return a+b;};
function sub(int a,int b){return a - b;};
a=10;
return add(a,4) + sub(a,9);
3、扩大操作符：Operator
替换 if then else 等关键字
runner.addOperatorWithAlias("如果", "if",null);
runner.addOperatorWithAlias("则", "then",null);
runner.addOperatorWithAlias("否则", "else",null);
exp = "如果 (语文 + 数学 + 英语 >270) 则 {return 1;} 否则 {return 0;}";
DefaultContext<String, Object> context = new DefaultContext<String, Object>();
runner.execute(exp,context,null,false,false,null);
// 如何自定义 Operator
// 定义一个继承自 com.ql.util.express.Operator 的操作符
public class JoinOperator extends Operator{public Object executeInner(Object[] list) throws Exception {Object opdata1 = list[0];
Object opdata2 = list[1];
if(opdata1 instanceof java.util.List){((java.util.List)opdata1).add(opdata2);
return opdata1;
}else{java.util.List result = new java.util.ArrayList();
result.add(opdata1);
result.add(opdata2);
return result;
}
}
}
// 如何应用 Operator
//(1)addOperator
ExpressRunner runner = new ExpressRunner();
DefaultContext<String, Object> context = new DefaultContext<String, Object>();
runner.addOperator("join",new JoinOperator());
Object r = runner.execute("1 join 2 join 3", context, null, false, false);
System.out.println(r);
// 返回后果 [1, 2, 3]
//(2)replaceOperator
ExpressRunner runner = new ExpressRunner();
DefaultContext<String, Object> context = new DefaultContext<String, Object>();
runner.replaceOperator("+",new JoinOperator());
Object r = runner.execute("1 + 2 + 3", context, null, false, false);
System.out.println(r);
// 返回后果 [1, 2, 3]
//(3)addFunction
ExpressRunner runner = new ExpressRunner();
DefaultContext<String, Object> context = new DefaultContext<String, Object>();
runner.addFunction("join",new JoinOperator());
Object r = runner.execute("join(1,2,3)", context, null, false, false);
System.out.println(r);
// 返回后果 [1, 2, 3]
4、绑定 java 类或者对象的 method
//addFunctionOfClassMethod+addFunctionOfServiceMethod
public class BeanExample {public static String upper(String abc) {return abc.toUpperCase();
}
public boolean anyContains(String str, String searchStr) {char[] s = str.toCharArray();
for (char c : s) {if (searchStr.contains(c+"")) {return true;}
}
return false;
}
}
runner.addFunctionOfClassMethod("取绝对值", Math.class.getName(), "abs",
new String[] { "double"}, null);
runner.addFunctionOfClassMethod("转换为大写", BeanExample.class.getName(),
"upper", new String[] { "String"}, null);
runner.addFunctionOfServiceMethod("打印", System.out, "println",new String[] {"String"}, null);
runner.addFunctionOfServiceMethod("contains", new BeanExample(), "anyContains",
new Class[] { String.class, String.class}, null);
String exp =“取绝对值(-100); 转换为大写(\"hello world\"); 打印(\"你好吗？\");contains("helloworld",\"aeiou\")”;
runner.execute(exp, context, null, false, false);
5、macro 宏定义
runner.addMacro("计算均匀问题", "(语文 + 数学 + 英语)/3.0");
runner.addMacro("是否优良", "计算均匀问题 >90");
IExpressContext<String, Object> context =new DefaultContext<String, Object>();
context.put("语文", 88);
context.put("数学", 99);
context.put("英语", 95);
Object result = runner.execute("是否优良", context, null, false, false);
System.out.println(r);
// 返回后果 true
6、编译脚本，查问内部须要定义的变量和函数。
// 留神以下脚本 int 和没有 int 的区别
String express = "int 平均分 = (语文 + 数学 + 英语 + 综合考试. 科目 2)/4.0;return 平均分";
ExpressRunner runner = new ExpressRunner(true,true);
String[] names = runner.getOutVarNames(express);
for(String s:names){System.out.println("var :" + s);
}
// 输入后果：var : 数学
var : 综合考试
var : 英语
var : 语文
7、对于不定参数的应用
@Test
public void testMethodReplace() throws Exception {ExpressRunner runner = new ExpressRunner();
IExpressContext<String,Object> expressContext = new DefaultContext<String,Object>();
runner.addFunctionOfServiceMethod("getTemplate", this, "getTemplate", new Class[]{Object[].class}, null);
//(1)默认的不定参数能够应用数组来代替
Object r = runner.execute("getTemplate([11,'22',33L,true])", expressContext, null,false, false);
System.out.println(r);
//(2)像 java 一样, 反对函数动静参数调用, 须要关上以下全局开关, 否则以下调用会失败
DynamicParamsUtil.supportDynamicParams = true;
r = runner.execute("getTemplate(11,'22',33L,true)", expressContext, null,false, false);
System.out.println(r);
}
// 等价于 getTemplate(Object[] params)
public Object getTemplate(Object... params) throws Exception{
String result = "";
for(Object obj:params){result = result+obj+",";}
return result;
}
8、对于汇合的快捷写法
@Test
public void testSet() throws Exception {ExpressRunner runner = new ExpressRunner(false,false);
DefaultContext<String, Object> context = new DefaultContext<String, Object>();
String express = "abc = NewMap(1:1,2:2); return abc.get(1) + abc.get(2);";
Object r = runner.execute(express, context, null, false, false);
System.out.println(r);
express = "abc = NewList(1,2,3); return abc.get(1)+abc.get(2)";
r = runner.execute(express, context, null, false, false);
System.out.println(r);
express = "abc = [1,2,3]; return abc[1]+abc[2];";
r = runner.execute(express, context, null, false, false);
System.out.println(r);
}
9、汇合的遍历
// 其实相似 java 的语法，只是 ql 不反对 for(obj:list){}的语法，只能通过下标拜访。// 遍历 map
map = new HashMap();
map.put("a", "a_value");
map.put("b", "b_value");
keySet = map.keySet();
objArr = keySet.toArray();
for (i=0;i<objArr.length;i++) {key = objArr[i];
System.out.println(map.get(key));
}
四、运行参数和 API 列表介绍
QLExpressRunner 如下图所示，从语法树剖析、上下文、执行过程三个方面提供二次定制的性能扩大。
1、属性开关
isPrecise
/**
* 是否须要高精度计算
*/
private boolean isPrecise = false;
高精度计算在会计财务中十分重要，java 的 float、double、int、long 存在很多隐式转换，做四则运算和比拟的时候其实存在十分多的安全隐患。所以相似汇金的零碎中，会有很多 BigDecimal 转换代码。而应用 QLExpress，你只有关注数学公式自身 订单总价 = 单价 * 数量 + 首重价格 +（总重量 - 首重）* 续重单价，而后设置这个属性即可，所有的两头运算过程都会保障不失落精度。isShortCircuit
/**
* 是否应用逻辑短路个性
*/
private boolean isShortCircuit = true;
在很多业务决策零碎中，往往须要对布尔条件表达式进行剖析输入，一般的 java 运算个别会通过逻辑短路来缩小性能的耗费。例如规定公式：star>10000 and shoptype in('tmall','juhuasuan') and price between (100,900) 假如第一个条件 star>10000 不满足就进行运算。但业务零碎却还是心愿把前面的逻辑都可能运算一遍，并且输入两头过程，保障更快更好的做出决策。参照单元测试:ShortCircuitLogicTest.java
isTrace
/**
* 是否输入所有的跟踪信息，同时还须要 log 级别是 DEBUG 级别
*/
private boolean isTrace = false;
这个次要是是否输入脚本的编译解析过程，个别对于业务零碎来说敞开之后会进步性能。2、调用入参
/**
* 执行一段文本
* @param expressString 程序文本
* @param context 执行上下文，能够扩大为蕴含 ApplicationContext
* @param errorList 输入的错误信息 List
* @param isCache 是否应用 Cache 中的指令集, 倡议为 true
* @param isTrace 是否输入具体的执行指令信息，倡议为 false
* @param aLog 输入的 log
* @return
* @throws Exception
*/
Object execute(String expressString, IExpressContext<String,Object> context,List<String> errorList, boolean isCache, boolean isTrace, Log aLog);
3、性能扩大 API 列表
QLExpress 次要通过子类实现 Operator.java 提供的以下办法来最简略的操作符定义，而后能够被通过 addFunction 或者 addOperator 的形式注入到 ExpressRunner 中。public abstract Object executeInner(Object[] list) throws Exception;
比方咱们几行代码就能够实现一个性能超级弱小、十分好用的 join 操作符:
//list = 1 join 2 join 3; -> [1,2,3] list = join(list,4,5,6); -> [1,2,3,4,5,6]
public class JoinOperator extends Operator{public Object executeInner(Object[] list) throws Exception {java.util.List result = new java.util.ArrayList();
Object opdata1 = list[0];
if(opdata1 instanceof java.util.List){result.addAll((java.util.List)opdata1);
}else{result.add(opdata1);
}
for(int i=1;i<list.length;i++){result.add(list[i]);
}
return result;
}
}
如果你应用 Operator 的基类 OperatorBase.java 将取得更弱小的能力，根本可能满足所有的要求。（1）function 相干 API
// 通过 name 获取 function 的定义
OperatorBase getFunciton(String name);
// 通过自定义的 Operator 来实现相似：fun(a,b,c)
void addFunction(String name, OperatorBase op);
//fun(a,b,c) 绑定 object.function(a,b,c)对象办法
void addFunctionOfServiceMethod(String name, Object aServiceObject,
String aFunctionName, Class<?>[] aParameterClassTypes,
String errorInfo);
//fun(a,b,c) 绑定 Class.function(a,b,c)类办法
void addFunctionOfClassMethod(String name, String aClassName,
String aFunctionName, Class<?>[] aParameterClassTypes,
String errorInfo);
// 给 Class 减少或者替换 method，同时 反对 a.fun(b)，fun(a,b) 两种办法调用
// 比方扩大 String.class 的 isBlank 办法:“abc”.isBlank()和 isBlank("abc")都能够调用
void addFunctionAndClassMethod(String name,Class<?>bindingClass, OperatorBase op);
（2）Operator 相干 API
提到脚本语言的操作符，优先级、运算的目数、笼罩原始的操作符 (+,-,*,/ 等等) 都是须要思考的问题，QLExpress 通通帮你搞定了。// 增加操作符号, 能够设置优先级
void addOperator(String name,Operator op);
void addOperator(String name,String aRefOpername,Operator op);
// 替换操作符解决
OperatorBase replaceOperator(String name,OperatorBase op);
// 增加操作符和关键字的别名，比方 if..then..else -> 如果。。那么。。否则。。void addOperatorWithAlias(String keyWordName, String realKeyWordName,
String errorInfo);
（3）宏定义相干 API
QLExpress 的宏定义比较简单，就是简略的用一个变量替换一段文本，和传统的函数替换有所区别。// 比方 addMacro("天猫卖家","userDO.userTag &1024 ==1024")
void addMacro(String macroName,String express)
（4）java class 的相干 api
QLExpress 能够通过给 java 类减少或者改写一些 method 和 field，比方 链式调用："list.join("1").join("2")"，比方中文属性："list. 长度"。// 增加类的属性字段
void addClassField(String field,Class<?>bindingClass,Class<?>returnType,Operator op);
// 增加类的办法
void addClassMethod(String name,Class<?>bindingClass,OperatorBase op);
留神，这些类的字段和办法是执行器通过解析语法执行的，而不是通过字节码加强等技术，所以只在脚本运行期间失效，不会对 jvm 整体的运行产生任何影响，所以是相对平安的。（4）语法树解析变量、函数的 API
这些接口次要是对一个脚本内容的动态剖析，能够作为上下文创立的根据，也能够用于零碎的业务解决。比方：计算“a+fun1(a)+fun2(a+b)+c.getName()”蕴含的变量:a,b,c 蕴含的函数:fun1,fun2
// 获取一个表达式须要的内部变量名称列表
String[] getOutVarNames(String express);
String[] getOutFunctionNames(String express);
（5）语法解析校验 api
脚本语法是否正确，能够通过 ExpressRunner 编译指令集的接口来实现。String expressString = "for(i=0;i<10;i++){sum=i+1}return sum;";
InstructionSet instructionSet = expressRunner.parseInstructionSet(expressString);
// 如果调用过程不出现异常，指令集 instructionSet 就是能够被加载运行（execute）了！（6）指令集缓存相干的 api
因为 QLExpress 对文本到指令集做了一个本地 HashMap 缓存，通常状况下一个设计正当的利用脚本数量应该是无限的，缓存是平安稳固的，然而也提供了一些接口进行治理。// 优先从本地指令集缓存获取指令集，没有的话生成并且缓存在本地
InstructionSet getInstructionSetFromLocalCache(String expressString);
// 革除缓存
void clearExpressCache();（6）加强上下文参数 Context 相干的 api
6.1 与 spring 框架的无缝集成
上下文参数 IExpressContext context 十分有用，它容许 put 任何变量，而后在脚本中辨认进去。在理论中咱们很心愿可能无缝的集成到 spring 框架中，能够仿照上面的例子应用一个子类。public class QLExpressContext extends HashMap<String, Object> implements
IExpressContext<String, Object> {
private ApplicationContext context;
// 构造函数，传入 context 和 ApplicationContext
public QLExpressContext(Map<String, Object> map,
ApplicationContext aContext) {super(map);
this.context = aContext;
}
/**
* 形象办法：依据名称从属性列表中提取属性值
*/
public Object get(Object name) {
Object result = null;
result = super.get(name);
try {
if (result == null && this.context != null
&& this.context.containsBean((String) name)) {
// 如果在 Spring 容器中蕴含 bean，则返回 String 的 Bean
result = this.context.getBean((String) name);
}
} catch (Exception e) {throw new RuntimeException(e);
}
return result;
}
public Object put(String name, Object object) {return super.put(name, object);
}
}
残缺的 demo 参照 SpringDemoTest.java
6.2 自定义函数操作符获取原始的 context 管制上下文
自定义的 Operator 须要间接继承 OperatorBase，获取到 parent 即可，能够用于在运行一组脚本的时候，间接编辑上下文信息，业务逻辑解决上也十分有用。public class ContextMessagePutTest {
class OperatorContextPut extends OperatorBase {public OperatorContextPut(String aName) {this.name = aName;}
@Override
public OperateData executeInner(InstructionSetContext parent, ArraySwap list) throws Exception {String key = list.get(0).toString();
Object value = list.get(1);
parent.put(key,value);
return null;
}
}
@Test
public void test() throws Exception{ExpressRunner runner = new ExpressRunner();
OperatorBase op = new OperatorContextPut("contextPut");
runner.addFunction("contextPut",op);
String exp = "contextPut('success','false');contextPut('error',' 错误信息 ');contextPut('warning',' 揭示信息 ')";
IExpressContext<String, Object> context = new DefaultContext<String, Object>();
context.put("success","true");
Object result = runner.execute(exp,context,null,false,true);
System.out.println(result);
System.out.println(context);
}
}
正文完
