RuleEngine规则引擎底层改造AviatorScript 之函数执行-编程知识

https://gitee.com/aizuda/rule-engine-open
需求：使用上述开源框架进行改造，底层更换成AviatorScript ，函数实现改造。
原本实现方式

    @Overridepublic 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==nullreturn function.getValue(null, new RuleEngineConfiguration());} else {throw new ApiException("容器中找不到{}函数", executor);}}

可以看到的是，他们首先拿到函数id，然后判断函数是否存在，然后去已经预制好的数据库表中去读取固定的函数名称，然后根据入参进行入参的判断，然后是执行。
因为我们要进行底层改造，我也就是了解了他的实现方式，并没有深入的去了解他的底层是如何实现的。
我们的话，可能入参没有那么复杂，我是自己新建了一个表来存储入参的，具体的实现也是不一样。

@Function
public class LetterToLowerCaseFunction extends AbstractFunction {@Executorpublic String executor(@Param(value = "letter",required = false) String letter) {if (letter == null) {return null;}return letter.toLowerCase();}@Overridepublic 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());}@Overridepublic 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.0System.out.println(AviatorEvaluator.execute("add(add(1, 2), 100)")); // 103.0}}class AddFunction extends AbstractFunction {@Overridepublic 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 的三个项目合到一个项目中，基于这块只有繁琐但是没有难度我这边就不再提了。

@Overridepublic 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 {@Executorpublic String executor(@Param(value = "letter",required = false) String letter) {if (letter == null) {return null;}return letter.toUpperCase();}@Overridepublic AviatorObject call(Map<String, Object> env,AviatorObject arg1) {String letter = env.get("letter").toString();if (letter == null) {return null;}return new AviatorString(letter.toUpperCase());}@Overridepublic String getName() {return "letterToUpperCaseFunction";}
}

在执行以上函数代码的时候一点问题都没有，那么问题出在了哪里呢，
String letter = env.get("letter").toString();这个取值，因为我这边取了一个巧，我在发现入参的类型我不好判断之后，我放弃了使用顺序确认入参这个形势，我直接使用的key-value的形势，这样可以在传参的时候一点问题都不会，如果前端传过来的入参的顺序出现问题的情况下，也会如我计划的一样执行，但是确实面临了一个问题，因为后面需要实现一个公式规则的功能
在这里插入图片描述
这个的具体研发可以放在下一篇进行讲述，然后就发现了，因为这个牵扯到给函数传值以及给代码块传值，所以陷入了一个死局，需要进行函数入参的调整，很麻烦，也不是不能做。
后面就转换了实现思路，不在使用String letter = env.get("letter").toString();方式去获取参数中的入参，尊重他人命运，前端传错了前端改吧，不过事实证明也没有出现问题，有点杞人忧天的意思了。

    @Overridepublic 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 {@Executorpublic String executor(@Param(value = "letter",required = false) String letter) {if (letter == null) {return null;}return letter.toUpperCase();}@Overridepublic AviatorObject call(Map<String, Object> env,AviatorObject arg1) {String letter = FunctionUtils.getStringValue(arg1, env);if (letter == null) {return null;}return new AviatorString(letter.toUpperCase());}@Overridepublic String getName() {return "letterToUpperCaseFunction";}
}