首页 > 其他分享 >RuleEngine规则引擎底层改造AviatorScript 之函数执行

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

时间:2024-04-08 15:31:46浏览次数:25  
标签:return String AviatorScript params letter new public RuleEngine 底层

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

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

标签:return,String,AviatorScript,params,letter,new,public,RuleEngine,底层
From: https://blog.csdn.net/weixin_44077141/article/details/137508448

相关文章

  • AI大模型探索之路:深度解析Transformer模型底层核心
    1、整体结构在Transformer之前,主要采用RNN(循环神经网络)来处理文本序列数据,当RNN将序列作为输入时,它会逐字处理句子。采用的是一种顺序化的处理,无法并行执行。另外,当此类序列太长时,模型容易忘记序列中远处位置的内容或将其与后续位置的内容混合在一起。Transformer提......
  • InnoDB引擎底层解析
    1.InnoDB引擎底层解析InnoDB的三大特性:双写机制BufferPool自适应Hash索引1.1.InnoDB记录存储结构和索引页结构InnoDB是一个将表中的数据存储到磁盘上的存储引擎,所以即使关机后重启我们的数据还是存在的。而真正处理数据的过程是发生在内存中的,所以需要把磁盘中的数据加......
  • Vue | 底层分析
    一、下载vueGit仓库地址:https://github.com/vuejs/vue.gitGitclonehttps://github.com/vuejs/vue.gitPnpminstall(vue是用pnpm管理工具,用npm会报错,用yarn会找不到依赖包)Pnpmrundev学习思路:先自己搜索->描述->再深入源码学习 二、变化侦测0、现象在da......
  • Photoshop混合模式的底层原理
        Photoshop虽然不是什么高手,但平时工作中难免会用到,处理部分需求还是可以胜任的。接触PS这么多年,对PS中图层的混合模式(BlendMode)一直就处于懵懂状态,即使是看了教材及视频后,有了一点感性认识,但在实际操作中仍旧无法运用起来。直至某一天,我在B站看到韩世麟的《把PS......
  • 读完了大学,依然是社会底层,读书的意义是什么
    1.70,80吃到了知识改变命运的红利,那这个红利是吃不完的吗?关于这个问题,我想告诉你社会的真实答案。20年前,只要是大学毕业,不是包分配就是工作前途一片光明,也就是现在的70,80后那帮人,那帮人不论是职业发展还是下海创业,基本上都赶上了经济蓬勃发展的好时机,大多数都做到了跨越阶层......
  • 深度解密京东中台底层支撑框架
    导读:近几年,除AIGC外,软件领域相关比较大的变化,就是各相关业务领域开始如火如荼地建设中台和去中台化了。本文不探讨中台对公司组织架构涉及的变化和影响,只是从中台化演进的思路,及使用的底层支撑技术框架进行分析探讨,重点对中台及前台协作涉及到的扩展点及热部署包的底层技术细节......
  • @ComponentScan注解 -【Spring底层原理
    案例已上传GitHub,欢迎star:https://github.com/oneStarLR/spring-annotation一、注解用法1.背景知识什么是组件?组件也是抽象的概念,可以理解为一些符合某种规范的类组合在一起就构成了组件,他可以提供某些特定的功能,但实际他们都是类,只不过有他们特殊的规定。组件......
  • 【前端】- 在使用Element UI 的el-tree组件时,从底层去研究如何去实现一键展开/关闭【t
    第一步:首先我们先去查看elementui官方文档,发现并没有提供这个方法,没办法,只能手写一个了,先给大家看看功能点击前效果:点击后效果:第二步:废话不多说直接上代码,然后我们简单解释下代码页面部分:这里是简单的数结构渲染,不多讲,$refs.Reftree获取的是el-tree的实例,具体作用请看下......
  • laravel 容器的底层原理&聚簇索引和非聚簇索引的区别&面试心得
    1.laravel容器的底层原理Laravel容器的实现原理是基于PHP的反射机制和依赖注入(DependencyInjection)的思想。在Laravel中,容器(Container)是一个用于解决类之间依赖关系的工具。它负责实例化对象,并处理对象之间的依赖关系。容器的实现原理主要包括以下几个步骤:注册绑定:通过容器......
  • Java中的流和IO操作及底层实现原理
    Java中的流和IO操作是Java编程中非常基础和重要的概念,它们主要用于处理数据的输入和输出。下面我会详细解释这两个概念。流(Stream)在Java中,流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输......