Groovy编写规则引擎学习_groovy规则引擎

一、Groovy与Java集成
Groovy脚本引擎的执行本质只是接受context对象，然后基于context对象中的关键信息进行逻辑判断，输出结果。
参考文章：
文章1
文章2
文章3
文章4

Java中运行Groovy
在java中运行Groovy脚本，有三种比较常用的类支持：GroovyShell、GroovyClassLoader 以及 Java-Script引擎(JSR-223).

GroovyShell
GroovyShell允许在Java类中（甚至Groovy类）求任意Groovy表达式的值。您可使用Binding对象输入参数给表达式，并最终通过GroovyShell返回Groovy表达式的计算结果。
通常用来运行"script片段"或者一些零散的表达式(Expression)

GroovyClassLoader
用 Groovy 的 GroovyClassLoader ，它会动态地加载一个脚本并执行它。GroovyClassLoader是一个Groovy定制的类装载器，负责解析加载Java类中用到的Groovy类。
如果脚本是一个完整的文件,特别是有API类型的时候,比如有类似于JAVA的接口,面向对象设计时,通常使用GroovyClassLoader.

GroovyScriptEngine
GroovyShell多用于推求对立的脚本或表达式，如果换成相互关联的多个脚本，使用GroovyScriptEngine会更好些。GroovyScriptEngine从您指定的位置（文件系统，URL，数据库，等等）加载Groovy脚本，并且随着脚本变化而重新加载它们。如同GroovyShell一样，GroovyScriptEngine也允许您传入参数值，并能返回脚本的值。

首先导入Groovy包

<properties>
    <groovy.version>2.5.6</groovy.version>
</properties>
<dependency>
    <groupId>org.codehaus.groovy</groupId>
    <artifactId>groovy-all</artifactId>
    <version>${groovy.version}</version>
</dependency>

注意：我的是这样导入包的，否则编译运行时会报异常：java.lang.ClassNotFoundException:org.codehaus.groovy.ast.MethodCallTransformation
参考解答：解决1 和 解决2
说白了就是springboot2.x版本和groovy2.5.x不能完全兼容。

二、SpringBoot动态运行groovy脚本
该小节是在参考这篇文章后，加入一些自己的理解完成的。

简介
在SpringBoot项目中，通过容器和依赖注入，可以很方便的实现开发功能。那么如何通过加载实例来动态编译脚本呢。
groovy支持通过GroovyShell预设对象，在groovy动态脚本中直接调用预设对象的方法。因此我们可以通过将spring的bean预设到GroovyShell运行环境中，在groovy动态脚本中直接调用spring容器中bean来调用其方法。

项目目录

项目解释
1、首先，自定义注解@GroovyFunction。用来标识用于绑定到GroovyShell的类。

import java.lang.annotation.*;

/**
 * @author Caocs
 * @date 2020/3/12
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE})
@Documented
public @interface GroovyFunction {
}

2、service层用来编写自定义的方法，用@GroovyFunction注解标识该方法可以被绑定到GroovyShell中。

import org.springframework.stereotype.Service;

/**
 * @author Caocs
 * @date 2020/3/12
 */
@Service
@GroovyFunction
public class TestService {
    public String testQuery(long id) {
        return "Test query success, id is " + id;
    }
}

3、然后，利用SpringBoot中的Configuration类来设置Binding
首先配置类实现org.springframework.context.ApplicationContextAware接口，用来获取应用上下文。然后在配置从上下文获取到的指定Bean实例，并注入到groovy的Binding中。
这里，我是利用上文提到的@GroovyFunction注解来过滤需要的实例。i

mport groovy.lang.Binding;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
import java.util.Map;
 
/**
 * @author Caocs
 * @date 2020/3/12
 */
@Configuration
public class GroovyBindingConfig implements ApplicationContextAware {
    // 实现ApplicationContextAware接口后的方法类，可以获取Spring中已经实例化的bean
    private ApplicationContext applicationContext;
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
    
    /**
     * 将标注@GroovyFunction注解的类对象绑定到Binding中，并在spring容器中实例化出一个对象
     * @return
     */
    @Bean("groovyBinding")
    public Binding groovyBinding() {
        Binding groovyBinding = new Binding();
        // 根据注解过滤掉不需要的实例
        Map<String, Object> beanMap = applicationContext.getBeansWithAnnotation(GroovyFunction.class);
        for (String beanName : beanMap.keySet()) {
            groovyBinding.setVariable(beanName, beanMap.get(beanName));
        }
        return groovyBinding;
    }
}

4、然后，定义一个请求类
这个其实没啥好说的，因为我不会再controller层请求两个参数。

import java.util.Map;

/**
 * @author Caocs
 * @date 2020/3/12
 */
public class ScriptRequest {
    private String expression;
    private Map<String, Object> paramMap;

    @Override
    public String toString() {
        return "ScriptRequest{" +
                "expression='" + expression + '\'' +
                ", paramMap=" + paramMap +
                '}';
    }

    public String getExpression() {
        return expression;
    }

    public void setExpression(String expression) {
        this.expression = expression;
    }

    public Map<String, Object> getParamMap() {
        return paramMap;
    }

    public void setParamMap(Map<String, Object> paramMap) {
        this.paramMap = paramMap;
    }
}

5、最后，在controller层中，实现动态脚本运行
注意：下面是我的一些想法和实现
(1)采用单例模式，将GroovyShell在初始化时就实例化出来。以后每次都直接调用该实例。
(2)通过依赖注入，将已经绑定自定义方法的Binding实例注入进来
(3)维护一个HashTable，用于存放~~<expression，Script>~~ 的映射关系，这样就可以重复利用已经实例化过的Script的实例。
(4)多个请求同时操作HashTable，所以需要注意线程安全问题。

import groovy.lang.Binding;
import groovy.lang.GroovyShell;
import groovy.lang.Script;
import org.codehaus.groovy.control.CompilerConfiguration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
 
import java.util.Hashtable;
import java.util.Map;
 
/**
 * @author Caocs
 * @date 2020/3/12
 */
// @RestController
@Controller
@RequestMapping("/groovy/single/script")
public class SingleScriptController {
 
    private static final Object lock = new Object();
    private static final GroovyShell groovyShell;
    private static Hashtable<String, Script> scriptCache = new Hashtable<>();
 
    @Autowired
    private Binding groovyBinding; // 默认绑定已有方法的实例
 
    static {
        CompilerConfiguration cfg = new CompilerConfiguration();
        groovyShell = new GroovyShell(cfg);
    }
 
    /**
     * 在客户端本地只实例化单例RuleExecutor
     * 然后多个线程同时操作scriptCache，需要保证线程安全。
     *
     * @param expression
     * @return
     */
    private Script getScriptFromCache(String expression) {
        if (scriptCache.containsKey(expression)) {
            return scriptCache.get(expression);
        }
        synchronized (lock) {
            if (scriptCache.containsKey(expression)) {
                return scriptCache.get(expression);
            }
            Script script = groovyShell.parse(expression);
            scriptCache.put(expression, script);
            return script;
        }
    }
 
    public Object ruleParse(String expression) {
        Script script = getScriptFromCache(expression);
        script.setBinding(groovyBinding);
        return script.run();
    }
 
    public Object ruleParse(String expression, Map<String, Object> paramMap) {
        Binding binding = groovyBinding;
        paramMap.forEach((key,value)->binding.setProperty(key,value));
        Script script = getScriptFromCache(expression);
        script.setBinding(binding);
        return script.run();
    }
 
    @WatchAspect
    @RequestMapping(value = "/execute", method = RequestMethod.POST)
    public @ResponseBody
    Object ruleExecutor(@RequestBody ScriptRequest request) {
        if (request.getParamMap() == null) {
            return ruleParse(request.getExpression());
        } else {
            return ruleParse(request.getExpression(), request.getParamMap());
        }
    }
}

使用postman进行测试，定义一个Post请求，执行后结果如下。
测试1：

测试2：

最后，因为个人能力问题，欢迎指正。

2020-03-26
突然发现代码会有问题（GC和线程安全问题）
详细内容参考：

JVM执行Groovy脚本导致堆外内存溢出问题排查
https://www.liangzl.com/get-article-detail-161916.html
————————————————
版权声明：本文为CSDN博主「愚愚是个大笨蛋」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_29698805/article/details/104639140