RuleEngine规则引擎底层改造AviatorScript 之函数执行

最新推荐文章于 2024-07-19 20:39:11 发布

又是重名了

最新推荐文章于 2024-07-19 20:39:11 发布

阅读量664

点赞数 8

分类专栏： java 文章标签： RuleEngine AviatorScript java

本文链接：https://blog.csdn.net/weixin_44077141/article/details/137508448

版权

java 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

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";
    }
}

函数获取参数底层也进行响应的修改。

又是重名了

关注

8
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
1
评论
RuleEngine规则引擎底层改造AviatorScript 之函数执行

这个取值，因为我这边取了一个巧，我在发现入参的类型我不好判断之后，我放弃了使用顺序确认入参这个形势，我直接使用的key-value的形势，这样可以在传参的时候一点问题都不会，如果前端传过来的入参的顺序出现问题的情况下，也会如我计划的一样执行，但是确实面临了一个问题，因为后面需要实现一个公式规则的功能。可以看到的是，他们首先拿到函数id，然后判断函数是否存在，然后去已经预制好的数据库表中去读取固定的函数名称，然后根据入参进行入参的判断，然后是执行。后面就转换了实现思路，不在使用。
复制链接

扫一扫