https://gitee.com/aizuda/rule-engine-open
需求:使用上述开源框架进行改造,底层更换成AviatorScript ,函数实现改造。
原本实现方式
@Override
public Object run(ExecuteFunctionRequest executeTestRequest) {
Integer functionId = executeTestRequest.getId();
RuleEngineFunction engineFunction = this.ruleEngineFunctionManager.getById(functionId);
if (engineFunction == null) {
throw new ApiException(ErrorCodeEnum.RULE9999404.getCode(),"不存在函数:{}", functionId);
}
String executor = engineFunction.getExecutor();
if (this.applicationContext.containsBean(executor)) {
Object abstractFunction = this.applicationContext.getBean(executor);
// 函数测试均为固定值
List<ParamValue> paramValues = executeTestRequest.getParamValues();
Map<String, Value> param = new HashMap<>(paramValues.size());
for (ParamValue paramValue : paramValues) {
Constant constant = new Constant(paramValue.getValue(), ValueType.getByValue(paramValue.getValueType()));
param.put(paramValue.getCode(), constant);
}
Function function = new Function(functionId, abstractFunction, ValueType.STRING, param);
// 无规则参数 input==null
return function.getValue(null, new RuleEngineConfiguration());
} else {
throw new ApiException("容器中找不到{}函数", executor);
}
}
可以看到的是,他们首先拿到函数id,然后判断函数是否存在,然后去已经预制好的数据库表中去读取固定的函数名称,然后根据入参进行入参的判断,然后是执行。
因为我们要进行底层改造,我也就是了解了他的实现方式,并没有深入的去了解他的底层是如何实现的。
我们的话,可能入参没有那么复杂,我是自己新建了一个表来存储入参的,具体的实现也是不一样。
@Function
public class LetterToLowerCaseFunction extends AbstractFunction {
@Executor
public String executor(@Param(value = "letter",required = false) String letter) {
if (letter == null) {
return null;
}
return letter.toLowerCase();
}
@Override
public AviatorObject call(Map<String, Object> env, AviatorObject arg1) {
String letter = String.valueOf(arg1.getValue(env));
if (letter == null) {
return null;
}
return new AviatorString(letter.toLowerCase());
}
@Override
public String getName() {
return "letterToLowerCaseFunction";
}
}
这是他们原本的函数实现,是通过Function接口,将实体类注册到spring框架中,然后将类的名字预制到数据中,通过读取某个函数将函数名读取出来,处理问题。
public class TestAviator {
public static void main(String[] args) {
//注册函数
AviatorEvaluator.addFunction(new AddFunction());
System.out.println(AviatorEvaluator.execute("add(1, 2)")); // 3.0
System.out.println(AviatorEvaluator.execute("add(add(1, 2), 100)")); // 103.0
}
}
class AddFunction extends AbstractFunction {
@Override
public AviatorObject call(Map<String, Object> env,
AviatorObject arg1, AviatorObject arg2) {
Number left = FunctionUtils.getNumberValue(arg1, env);
Number right = FunctionUtils.getNumberValue(arg2, env);
return new AviatorDouble(left.doubleValue() + right.doubleValue());
}
public String getName() {
return "add";
}
}
AviatorScript 这个是他官方的一个实例文档,可以看的出来实现方式大大的不一样了
其实这个项目的首先的问题是,我们需要将rule-engine 的三个项目合到一个项目中,基于这块只有繁琐但是没有难度我这边就不再提了。
@Override
public Object runFunction(ExecuteFunctionRequest executeTestRequest) throws Exception{
Integer functionId = executeTestRequest.getId();
RuleEngineFunction2 engineFunction = this.ruleEngineFunction2Manager.getById(functionId);
if (engineFunction == null) {
throw new ApiException(ErrorCodeEnum.RULE9999404.getCode(),"不存在函数:{}", functionId);
}
//获取设置对应的方法名
String className = engineFunction.getClassName();
String functionName = engineFunction.getFunctionName();
if (this.applicationContext.containsBean(className)) {
AviatorFunction abstractFunction = (AviatorFunction)this.applicationContext.getBean(className);
QueryWrapper<RuleEngineFunctionParam2> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("function_id", engineFunction.getId());
//拿到对应的参数集合,参数集合
List<RuleEngineFunctionParam2> list = ruleEngineFunctionParam2Manager.list(queryWrapper);
// 入参参数集合
List<ParamValue> paramValues = executeTestRequest.getParamValues();
HashMap hashMap = composeParams(list, paramValues);
AviatorEvaluator.addFunction(abstractFunction);
String params = "";
for (RuleEngineFunctionParam2 ruleEngineFunctionParam2 : list) {
params = params +"arg1,";
}
params = params.substring(0, params.length() - 1);
String expression = functionName+"("+params+")";
Object execute = AviatorEvaluator.execute(expression, hashMap);
log.error(execute.toString());
return execute;
} else {
throw new ApiException("容器中找不到{}函数", className+functionName);
}
}
public HashMap composeParams(List<RuleEngineFunctionParam2> list,List<ParamValue> paramValues){
HashMap params = new HashMap();
for (int i = 0; i < list.size(); i++) {
RuleEngineFunctionParam2 ruleEngineFunctionParam2 = list.get(i);
String paramCode = ruleEngineFunctionParam2.getParamCode();
for (int j = 0; j < paramValues.size(); j++) {
ParamValue paramValue = paramValues.get(j);
String code = paramValue.getCode();
if (paramCode.equals(code)) {
if(ruleEngineFunctionParam2.getValueType().equals("STRING")){
params.put(paramCode, paramValue.getValue());
}else if(ruleEngineFunctionParam2.getValueType().equals("COLLECTION")){
String arr = paramValue.getValue();
List<String> items = Arrays.asList(arr.split(","));
params.put(paramCode, items);
}else if(ruleEngineFunctionParam2.getValueType().equals("NUMBER")){
int number = Integer.valueOf(paramValue.getValue());
params.put(paramCode, number);
}
}
}
}
return params;
}
这一块代码是我写的函数执行的底层改造,唯一的问题就是在于传参,不过在当时看来是没有问题的
@Function
public class LetterToUpperCaseFunction extends AbstractFunction {
@Executor
public String executor(@Param(value = "letter",required = false) String letter) {
if (letter == null) {
return null;
}
return letter.toUpperCase();
}
@Override
public AviatorObject call(Map<String, Object> env,AviatorObject arg1) {
String letter = env.get("letter").toString();
if (letter == null) {
return null;
}
return new AviatorString(letter.toUpperCase());
}
@Override
public String getName() {
return "letterToUpperCaseFunction";
}
}
在执行以上函数代码的时候一点问题都没有,那么问题出在了哪里呢,
String letter = env.get("letter").toString();
这个取值,因为我这边取了一个巧,我在发现入参的类型我不好判断之后,我放弃了使用顺序确认入参这个形势,我直接使用的key-value的形势,这样可以在传参的时候一点问题都不会,如果前端传过来的入参的顺序出现问题的情况下,也会如我计划的一样执行,但是确实面临了一个问题,因为后面需要实现一个公式规则的功能
这个的具体研发可以放在下一篇进行讲述,然后就发现了,因为这个牵扯到给函数传值以及给代码块传值,所以陷入了一个死局,需要进行函数入参的调整,很麻烦,也不是不能做。
后面就转换了实现思路,不在使用String letter = env.get("letter").toString();
方式去获取参数中的入参,尊重他人命运,前端传错了前端改吧,不过事实证明也没有出现问题,有点杞人忧天的意思了。
@Override
public Object runFunction(ExecuteFunctionRequest executeTestRequest) throws Exception{
Integer functionId = executeTestRequest.getId();
RuleEngineFunction2 engineFunction = this.ruleEngineFunction2Manager.getById(functionId);
if (engineFunction == null) {
throw new ApiException(ErrorCodeEnum.RULE9999404.getCode(),"不存在函数:{}", functionId);
}
//获取设置对应的方法名
String className = engineFunction.getClassName();
String functionName = engineFunction.getFunctionName();
if (this.applicationContext.containsBean(className)) {
AviatorFunction abstractFunction = (AviatorFunction)this.applicationContext.getBean(className);
QueryWrapper<RuleEngineFunctionParam2> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("function_id", engineFunction.getId());
// 入参参数集合
List<ParamValue> paramValues = executeTestRequest.getParamValues();
AviatorEvaluator.addFunction(abstractFunction);
String params = "";
for (int i = 0; i < paramValues.size(); i++) {
ParamValue paramValue = paramValues.get(i);
String value = paramValue.getValue();
if (paramValue.getValueType().equals("STRING"))
{
params = params + "'" + value +"'" + ",";
}else if (paramValue.getValueType().equals("NUMBER")){
params = params + value + ",";
}else if (paramValue.getValueType().equals("COLLECTION")){
params = params + "'" + value +"'" + ",";
}
}
params = params.substring(0, params.length() - 1);
String expression = functionName+"("+params+")";
Object execute = AviatorEvaluator.execute(expression);
log.error(execute.toString());
return execute;
} else {
throw new ApiException("容器中找不到{}函数", className+functionName);
}
}
修改函数显示底层,使用直接参数的方式,后端直接处理参数,方便后面代码块执行,大概是组成add(1, 2)
格式。
@Function
public class LetterToUpperCaseFunction extends AbstractFunction {
@Executor
public String executor(@Param(value = "letter",required = false) String letter) {
if (letter == null) {
return null;
}
return letter.toUpperCase();
}
@Override
public AviatorObject call(Map<String, Object> env,AviatorObject arg1) {
String letter = FunctionUtils.getStringValue(arg1, env);
if (letter == null) {
return null;
}
return new AviatorString(letter.toUpperCase());
}
@Override
public String getName() {
return "letterToUpperCaseFunction";
}
}
函数获取参数底层也进行响应的修改。