java脚本引擎Groovy实战

心已赠人 2024-03-17 16:07 131阅读 0赞

##  ##

--------------------

## 前言 ##

互联网时代随着业务的飞速发展，不仅产品迭代、更新的速度越来越快，个性化需求也是越来越多。如何快速的满足各种业务的个性化需求是我们要重点思考的问题。我们开发的系统如何才能做到热部署，不重启服务就能适应各种规则变化呢？实现业务和规则的解耦 和 系统高可用性。

好了，Java的ScriptEngine脚本引擎给了我们一个选择，它支持代码动态执行，代码修改后不需要重启JVM进程，就可以使用解析或编译方式执行，非常方便，在一些动态业务规则、[热更新][Link 1]、热修复等场景中会非常方便。

--------------------

## 一、场景描述 ##

在互联网项目中，我们为了引流常常会设计一些活动来吸引用户。而活动的规则呢，往往五花八门。活动和规则耦合太紧会导致系统很臃肿，难以维护，规则的变动往往需要重启服务器。我们思考是否可以将规则设计成一个黑盒子，我们传递相应的输入，期望得到相应的输出结果。

![f5e33b28ea584ef1b85b0f7e055a1205.png][]

![6e519144f0ce43f9ba3c9771e796fdc8.png][]

活动只需要知道规则脚本的位置，执行规则脚本而不需要知道它是如何执行的。规则脚本可以存储在数据库，磁盘文件等地方。

下面我们先介绍下各种引擎。

## 二、javascript语法引擎 ##

`ScriptEngineManager` 为 `ScriptEngine` 类实现一个发现和实例化机制，还维护一个键/值对集合来存储所有 Manager 创建的引擎所共享的状态。此类使用[服务提供者][Link 2]机制枚举所有的 `ScriptEngineFactory` 实现。  
  
`ScriptEngineManager` 提供了一个方法，可以返回一个所有工厂实现和基于语言名称、文件扩展名和 mime 类型查找工厂的实用方法所组成的数组。

键/值对的 `Bindings`（即由管理器维护的 "Global Scope"）对于 `ScriptEngineManager` 创建的所有 `ScriptEngine` 实例都是可用的。`Bindings` 中的值通常公开于所有脚本中。

#### JavaScriptEngine ####

public class JavaScriptTest {
       public static void main(String[] args) throws Exception {
            String js = " function add (a, b) { " +
                    "         var sum = a + b;  " +
                              //js调用java类
                    "         java.lang.System.out.println(\"Script sum=\" + sum); " +
                    "         return java.lang.Integer.valueOf(sum);  " +
                    "}";
            ScriptEngineManager manager = new ScriptEngineManager();
            ScriptEngine engine = manager.getEngineByName("js");
            engine.eval(js);
            Invocable jsInvoke = (Invocable) engine;
            Object result = jsInvoke.invokeFunction("add", new Object[]{1, 2});
        }
    }

[ScriptEngine (Java 2 Platform SE 6)][ScriptEngine _Java 2 Platform SE 6]

> #### getEngineByName ####
> 
>     public ScriptEngine getEngineByName(String shortName)
> 
> 查找并创建一个给定名称的 `ScriptEngine`。该算法首先查找一个 `ScriptEngineFactory`，该 `ScriptEngineFactory` 已经针对给定名称使用 `registerEngineName` 方法注册为处理程序。  
>   
> 如果没有找到这样的 ScriptEngineFactory，则搜索构造方法存储的 `ScriptEngineFactory` 实例数组，以获得具有指定名称的 ScriptEngineFactory。如果通过这两种方法之一找到了一个 `ScriptEngineFactory`，则用它来创建 `ScriptEngine` 实例。
> 
> **参数：**
> 
> `shortName` \- `ScriptEngine` 实现的短名称，由其 `ScriptEngineFactory` 的 `getNames` 方法返回。
> 
> **返回：**
> 
> 搜索到的工厂所创建的 `ScriptEngine`。如果没有找到这样的工厂，则返回 null。`ScriptEngineManager` 将它自己的 `globalScope` `Bindings` 设置为新建 `ScriptEngine` 的 `GLOBAL_SCOPE` `Bindings`。
> 
> **抛出：**
> 
> `NullPointerException` \- 如果 shortName 为 null

> #### eval ####
> 
>     Object eval(String script)  throws ScriptException
> 
> 执行指定的脚本。使用 `ScriptEngine` 的默认 `ScriptContext`。
> 
> **参数：**
> 
> `script` \- 要执行的脚本语言源。
> 
> **返回：**
> 
> 执行脚本所返回的值。
> 
> **抛出：**
> 
> `ScriptException` \- 如果脚本发生错误。
> 
> `NullPointerException` \- 如果参数为 null。

#### NashornScriptEngine ####

> 从 JDK 1.8 开始，Nashorn取代Rhino(JDK 1.6, JDK1.7) 成为 Java 的嵌入式 JavaScript 引擎。Nashorn 完全支持 ECMAScript 5.1 规范以及一些扩展。它使用基于 JSR 292 的新语言特性，其中包含在 JDK 7 中引入的 invokedynamic，将 JavaScript 编译成 Java 字节码。
> 
> 与先前的 Rhino 实现相比，这带来了 2 到 10倍的性能提升

public static void main(String[] args) throws Exception {
            String js = " function add (a, b) { " +
                    "       var sum = a + b;  " +
                            // js调用java类
                    "       java.lang.System.out.println(\"Script sum=\" + sum); " +
                    "       return java.lang.Integer.valueOf(sum);  " +
                    "}";
            ScriptEngineManager manager = new ScriptEngineManager();
            ScriptEngine engine = manager.getEngineByName("nashorn");
            engine.eval(js);
            Invocable jsInvoke = (Invocable) engine;
            Object result = jsInvoke.invokeFunction("add", new Object[]{1, 2});
        }

## 三、Groovy语法引擎 ##

### 一.使用GroovyClassLoader ###

用 Groovy 的 GroovyClassLoader ，它会动态地加载一个脚本并执行它。GroovyClassLoader是一个Groovy定制的类装载器，负责解析加载Java类中用到的Groovy类

Groovy是在Java虚拟机上实现的动态语言，提供了动态将java代码编译为Java Class对象的功能。需要添加依赖包

<dependency>
                <groupId>org.codehaus.groovy</groupId>
                <artifactId>groovy-all</artifactId>
                <version>3.0.16</version>
                <type>pom</type>
            </dependency>

> 代码如下（示例1）：

public class GroovyTest {
        public static void main(String[] args) throws Exception {
            GroovyClassLoader loader = new GroovyClassLoader();
            // java代码
            String java = " " +
                    "   public class Test { " +
                    "      public int add(double a, double b) { " +
                    "        double sum = a + b;  " +
                    "         System.out.println(\"Script sum=\" + sum);  " +
                    "         return sum.intValue(); " +
                    "      }  " +
                    "  } ";
            Class scriptClass = loader.parseClass(java);
            GroovyObject scriptInstance = (GroovyObject) scriptClass.getDeclaredConstructor().newInstance();
            Object result = scriptInstance.invokeMethod("add", new Object[]{1, 2});
            System.out.println("Groovy result=" + result);
        }
    }

> 代码如下（示例2）：

public class GroovyTest {
        public static void main(String[] args) throws Exception {   
            String groovy = " def call(int a,int b) { " +
                    "   return a + b " +
                    "}";
    
            GroovyClassLoader loader = new GroovyClassLoader();
            Class scriptClass = loader.parseClass(groovy);
            GroovyObject scriptInstance = (GroovyObject)         scriptClass.newInstance();
            result = scriptInstance.invokeMethod("call",new Object[] {1,2});
            System.out.println("Groovy result=" + result);
        }
    }

如果一切都需要在1行，那么你在return语句之前就错过了一个分号。 如：

boolean engineTest = false; if (!engineTest) { engineTest = true}; return engineTest;

### 二、原理 ###

GroovyClassLoader是一个定制的类装载器，在代码执行时动态加载groovy脚本为java对象。

大家都知道classloader的双亲委派，我们先来分析一下这个GroovyClassloader，看看它的祖先分别是啥：

使用idea 创建一个 Groovy项目

![b6dfdc6d6a414fd7990cea1d9012d8f5.png][]

运行结果：

> groovy.lang.GroovyClassLoader$InnerLoader@432038ec  
> groovy.lang.GroovyClassLoader@51891008  
> org.codehaus.groovy.tools.RootLoader@4d405ef7  
> sun.misc.Launcher$AppClassLoader@18b4aac2  
> sun.misc.Launcher$ExtClassLoader@ab7395e
> 
> 进程已结束,退出代码0

从而得出Groovy的ClassLoader体系：

>     Bootstrap ClassLoader  
>                  ↑  
>     sun.misc.Launcher.ExtClassLoader      // 即Extension ClassLoader  
>                  ↑  
>     sun.misc.Launcher.AppClassLoader      // 即System ClassLoader  
>                  ↑  
>     org.codehaus.groovy.tools.RootLoader  // 以下为User Custom ClassLoader  
>                  ↑  
>     groovy.lang.GroovyClassLoader  
>                  ↑  
>     groovy.lang.GroovyClassLoader.InnerLoader

### 三、调用groovy脚本实现方式 ###

#### 1.使用GroovyClassLoader ####

private static void invoke(String scriptText, String function, Object... objects) throws Exception {
            GroovyClassLoader classLoader = new GroovyClassLoader();
            Class groovyClass = classLoader.parseClass(scriptText);
            try {
                GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance();
                groovyObject.invokeMethod(function,objects);
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }

#### 2.使用ScriptEngine ####

private static final GroovyScriptEngineFactory scriptEngineFactory = new GroovyScriptEngineFactory();
     
    private static <T> T invoke(String script, String function, Object... objects) throws Exception {
        ScriptEngine scriptEngine = scriptEngineFactory.getScriptEngine();
        scriptEngine.eval(script);
        return (T) ((Invocable) scriptEngine).invokeFunction(function, objects);
    }

#### 3.使用GroovyShell ####

private static GroovyShell groovyShell = new GroovyShell();
    
    private static <T> T invoke(String scriptText, String function, Object... objects) throws Exception {
        Script script= groovyShell.parse(scriptText);
        return (T) InvokerHelper.invokeMethod(script, function, objects);
    }

### 四、性能优化 ###

项目在测试时发现，加载的类随着程序运行越来越多，而且垃圾收集也非常频繁。

groovy脚本执行的过程

GroovyClassLoader classLoader = new GroovyClassLoader();
            Class groovyClass = classLoader.parseClass(scriptText);
            try {
                GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance();
                groovyObject.invokeMethod(function,objects);
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

查看GroovyClassLoader.parseClass方法，发现如下代码：

public Class parseClass(String text) throws CompilationFailedException {
            return this.parseClass(text, "script" + 
                    System.currentTimeMillis() 
                    + Math.abs(text.hashCode()) + ".groovy");
        }
    
        
         public Class parseClass(final String text, final String fileName) throws CompilationFailedException {
            GroovyCodeSource gcs = (GroovyCodeSource)AccessController.doPrivileged(new PrivilegedAction<GroovyCodeSource>() {
                public GroovyCodeSource run() {
                    return new GroovyCodeSource(text, fileName, "/groovy/script");
                }
            });
            gcs.setCachable(false);
            return this.parseClass(gcs);
        }
    
        protected ClassCollector createCollector(CompilationUnit unit, SourceUnit su) {
            InnerLoader loader = (InnerLoader)AccessController.doPrivileged(new PrivilegedAction<InnerLoader>() {
                public InnerLoader run() {
                    return new InnerLoader(GroovyClassLoader.this);
                }
            });
            return new ClassCollector(loader, unit, su);
        }

**这两处代码的意思是：**

groovy每执行一次脚本，都会生成一个脚本的class对象，这个class对象的名字由 “script” + System.currentTimeMillis() +  
Math.abs(text.hashCode()组成，对于问题1：每次执行同一个StrategyLogicUnit时，产生的class都不同，每次执行规则脚本都会产生一个新的class。

**接着看问题2 InnerLoader部分：**

groovy每执行一次脚本都会new一个InnerLoader去加载这个对象，而对于问题2，我们可以推测：InnerLoader和脚本对象都无法在fullGC的时候被回收，因此运行一段时间后将PERM占满，一直触发fullGC。

### 五、解决方案 ###

把每次脚本生成的对象缓存起来

private final ConcurrentHashMap<Integer, GroovyObject> groovyMap = new ConcurrentHashMap();
    
    private final ReentrantLock lock = new ReentrantLock();
    
    public Object invoke(String scriptId)    {
    
        GroovyObject scriptInstance = groovyMap.get(scriptId);
    
        if (scriptInstance == null) {
             lock.lock();
             try {
                scriptInstance = groovyMap.get(scriptId);
    
                if (scriptInstance == null ) {
                   
                            GroovyClassLoader loader = new GroovyClassLoader();
                            Class scriptClass = loader.parseClass(script);
                            scriptInstance = (GroovyObject) scriptClass.getDeclaredConstructor().newInstance();
                            groovyMap.put(scriptId, scriptInstance);
                        }
                    } finally {
                        lock.unlock();
                    }
                }
    
                Object result = scriptInstance.invokeMethod("match", new Object[]{map});
                return result;
    }

###  ###

--------------------

## 四、项目实战 ##

#### 一、概述 ####

[Groovy][] is a multi-faceted language for the Java platform.

[Apache][] Groovy是一种强大的、可选的类型化和动态语言，具有静态类型和静态编译功能，用于Java平台，目的在于通过简洁、熟悉和易于学习的语法提高开发人员的工作效率。它可以与任何Java程序顺利集成，并立即向您的应用程序提供强大的功能，包括脚本编写功能、特定于域的语言编写、运行时和编译时元编程以及函数式编程。

Groovy是基于java虚拟机的，执行文件可以是简单的脚本片段，也可以是一个完整的groovy class，对于java程序员来说，学习成本低，可以完全用java语法编写。

#### 二、项目描述 ####

我们要 设计这样一个系统，根据用户的行为，赠送用户福利。比如阅读书籍时长超过300S，我们会赠送用户书券；用户注册为正式用户，我们赠送用户积分等操作。诸如此类多条件或并的复杂场景。

#### 三、设计Groovy模版表，存储Groovy脚本 ####

我们先设计脚本模版表groovy

<table style="width:500px;"> 
 <thead> 
  <tr> 
   <th>字段名称</th> 
   <th>字段类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>id</td> 
   <td>BIGINT(20)</td> 
   <td>主键</td> 
  </tr> 
  <tr> 
   <td>groovy_code</td> 
   <td>VARCHAR(32)</td> 
   <td>Groovy模版编码</td> 
  </tr> 
  <tr> 
   <td>groovy_name</td> 
   <td>VARCHAR(32)</td> 
   <td>Groovy模版名称</td> 
  </tr> 
  <tr> 
   <td>content</td> 
   <td>TEXT</td> 
   <td>模版内容</td> 
  </tr> 
  <tr> 
   <td>status</td> 
   <td>TINYINT(4)</td> 
   <td>状态 &nbsp;1:启用 &nbsp;2:停用</td> 
  </tr> 
  <tr> 
   <td>update_time</td> 
   <td>DATETIME</td> 
   <td>修改时间</td> 
  </tr> 
  <tr> 
   <td>updater</td> 
   <td>VARCHAR(32)</td> 
   <td>最后修改人</td> 
  </tr> 
  <tr> 
   <td>version</td> 
   <td>INT(10)</td> 
   <td>版本号</td> 
  </tr> 
 </tbody> 
</table>

数据储存如图：

![f9d5be89d3f84f3db7c7ad26ea84ffb5.png][]

#### 四、用户事件表 ####

![5b2a5f20891342c7b541cbc78c66ac5f.png][]

#### 五、Spring Bean ####

**不能使用@Autowired（autowired是在Spring启动后注入的，此时还未加载groovy代码，故无法注入）**

**建议实现ApplicationContextAware接口的工具（组件）来获取Spring Bean**

**调用****Spring Bean的脚本**

import com.xinwu.shushan.core.common.ApplicationContextHelper;
    import com.xinwu.shushan.launch.infra.cache.AdClickCache;
    
    public class Groovy {
        public Boolean match(Map<String, Object> map) {
            AdClickCache adClickCache = ApplicationContextHelper.getBean(AdClickCache.class);
            
            //阈值
            Integer threshold = (Integer) map.get("threshold");
            //用户ID
            Integer userId = (Integer) map.get("userId");
            //日期
            Date date = (Date) map.get("date");
            //产品线
            Integer productType = (Integer) map.get("productType");
            //广告点击数
            int adClickCount = adClickCache.get(date, productType, userId);
    
            return adClickCount >= threshold;
        }
    }

#### 六、单元测试 ####

import com.google.common.collect.Maps;
    import groovy.lang.GroovyClassLoader;
    import groovy.lang.GroovyObject;
    
    import java.util.Date;
    import java.util.Map;
    
    public class AdClickGroovyTest {
        public static void main(String[] args) throws Exception {
            String script = "" +
                    "import com.xinwu.shushan.core.common.ApplicationContextHelper;\n" +
                    "import com.xinwu.shushan.launch.infra.cache.AdClickCache;\n" +
                    " \n" +
                    "public class Groovy {\n" +
                    "    public Boolean match(Map<String, Object> map) {\n" +
                    "        AdClickCache adClickCache = ApplicationContextHelper.getBean(AdClickCache.class);\n" +
                    "        \n" +
                    "        //阈值\n" +
                    "        Integer threshold = (Integer) map.get(\"threshold\");\n" +
                    "        //用户ID\n" +
                    "        Integer userId = (Integer) map.get(\"userId\");\n" +
                    "        //日期\n" +
                    "        Date date = (Date) map.get(\"date\");\n" +
                    "        //产品线\n" +
                    "        Integer productType = (Integer) map.get(\"productType\");\n" +
                    "        //广告点击数\n" +
                    "        int adClickCount = adClickCache.get(date, productType, userId);\n" +
                    " \n" +
                    "        return adClickCount >= threshold;\n" +
                    "    }\n" +
                    "}";
            GroovyClassLoader loader = new GroovyClassLoader();
            Class scriptClass = loader.parseClass(script);
            GroovyObject scriptInstance = (GroovyObject) scriptClass.newInstance();
    
            Map<String, Object> map = Maps.newHashMap();
    
            map.put("threshold", 2);
            map.put("userId", 10001);
            map.put("date", new Date());
            map.put("productType", 1);
    
            Object result = scriptInstance.invokeMethod("match", new Object[]{map});
            System.out.println("Groovy result=" + result);
        }
    }

## 学习 ##

[复杂多变场景下的Groovy脚本引擎实战][Groovy 1]

[Link 1]: https://so.csdn.net/so/search?q=%E7%83%AD%E6%9B%B4%E6%96%B0&spm=1001.2101.3001.7020
[f5e33b28ea584ef1b85b0f7e055a1205.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/ad2b7bd6282d4154b97edc3064825f2b.png
[6e519144f0ce43f9ba3c9771e796fdc8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/ba68a8772e3a458c840ebd924b8623bd.png
[Link 2]: http://java.sun.com/javase/6/docs/technotes/guides/jar/jar.html#Service%20Provider
[ScriptEngine _Java 2 Platform SE 6]: https://www.oschina.net/uploads/doc/javase-6-doc-api-zh_CN/javax/script/ScriptEngine.html#eval%28java.lang.String%29
[b6dfdc6d6a414fd7990cea1d9012d8f5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/c210416da2b2494da0e9258dba1a3867.png
[Groovy]: https://so.csdn.net/so/search?q=Groovy&spm=1001.2101.3001.7020
[Apache]: https://so.csdn.net/so/search?q=Apache&spm=1001.2101.3001.7020
[f9d5be89d3f84f3db7c7ad26ea84ffb5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/f138129faac1432798292dc19503de0b.png
[5b2a5f20891342c7b541cbc78c66ac5f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/822a9aa1a2b34da08cbd14f2a56c65d4.png
[Groovy 1]: https://mp.weixin.qq.com/s?__biz=MzU0OTE4MzYzMw==&mid=2247517100&idx=5&sn=bbb34817a6fbf16cc6e9897da335033d&chksm=fbb10a52ccc6834483ef06c38c5bce3e902082bbb8f82b5c8906d51b91a3f48dc4edecff10b5&scene=27