第一部分概述

Java中的脚本引擎(JDK6+)是一种能够在Java程序中执行脚本语言代码的工具。它为开发人员提供了在运行时执行脚本的能力，从而增强了应用程序的灵活性和可扩展性。脚本引擎可以用于各种场景，包括动态配置、业务规则引擎、自定义脚本功能等。

脚本引擎使用场景：

动态配置：将配置信息存储在外部脚本文件中，并在运行时动态加载和解析，以实现配置的灵活性和可管理性。
业务规则引擎：将业务规则定义为脚本，以便在不同情况下动态执行和调整规则逻辑。
自定义脚本功能：允许用户编写自定义脚本，以扩展应用程序的功能和行为。

脚本引擎优点：

灵活性：脚本可以在不重新编译应用程序的情况下进行修改和调整。
可扩展性：允许应用程序通过加载外部脚本来扩展功能。
可读性：脚本语言通常比Java代码更简洁易懂。

脚本引擎缺点：

性能：与直接使用Java编写的代码相比，执行脚本通常会带来一些性能损失。
安全性：动态加载和执行外部脚本可能存在安全风险，需要谨慎处理。

常用脚本引擎：

JavaScript引擎：基于Rhino或Nashorn实现，支持执行JavaScript脚本。
Groovy引擎：支持执行Groovy脚本，提供了与Java无缝集成的能力。
Python引擎：通过Jython实现，支持执行Python脚本。
Ruby引擎：通过JRuby实现，支持执行Ruby脚本。

第二部分 Java脚本引擎常用操作

提示

Java Scripting API有许多类和接口。它们在javax.script包中。

2.1 获取可用脚本引擎

在使用脚本引擎之前，可以利用脚本引擎相关API查询系统中支持的脚本引擎信息，示例代码如下：

java
ScriptEngineManager manager = new ScriptEngineManager();
List<ScriptEngineFactory> list = manager.getEngineFactories();
for (ScriptEngineFactory factory : list) {
    System.out.println("Engine Name:" + factory.getEngineName());
    System.out.println("Engine Version:" + factory.getEngineVersion());
    System.out.println("Language Name:" + factory.getLanguageName());
    System.out.println("Language Version:" + factory.getLanguageVersion());
    System.out.println("Engine Short Names:" + factory.getNames());
    System.out.println("Mime Types:" + factory.getMimeTypes());
    System.out.println("Extensions:" + factory.getExtensions());
    System.out.println("===");
}

运行之后可以查看系统中当前支持的脚本引擎信息：


Engine Name:Oracle Nashorn
Engine Version:1.8.0_191
Language Name:ECMAScript
Language Version:ECMA - 262 Edition 5.1
Engine Short Names:[nashorn, Nashorn, js, JS, JavaScript, javascript, ECMAScript, ecmascript]
Mime Types:[application/javascript, application/ecmascript, text/javascript, text/ecmascript]
Extensions:[js]
===

默认情况，JDK中支持javascript脚本引擎，上述示例代码运行环境为JDK8，默认集成的是Nashorn实现的javascript引擎，如果需要其他脚本引擎，需要手动将其添加到类路径中，Java可以通过SPI机制自动发现。

2.2 初始化脚本引擎

在上一节中，通过ScriptEngineManager#getEngineFactories方法可以获得脚本引擎的工厂对象(ScriptEngineFactory)，ScriptEngineFactory提供了getScriptEngine方法用于创建对应脚本引擎的实例对象。这种方式需要对获得的脚本引擎工厂进行遍历，使用相对复杂，在实际开发中，通常使用ScriptEngineManager提供的getEngineByXXX系列方法直接获取脚本引擎对象。

getEngineByName：该方法根据给定的引擎名称获取与之对应的脚本引擎实例。引擎名称通常是脚本语言的名称，例如JavaScript、Groovy等。此方法可以直接获取到指定名称的脚本引擎，方便直接使用。
getEngineByMimeType：该方法根据给定的MIME类型获取与之对应的脚本引擎实例。MIME类型是一种标准的多用途互联网邮件扩展类型，用于标识数据的类型和格式。对于一些脚本语言，可能有对应的MIME类型，例如 application/javascript、application/x-groovy等。此方法可以根据MIME类型获取到对应的脚本引擎。
getEngineByExtension：该方法根据给定的文件扩展名获取与之对应的脚本引擎实例。对于一些常见的脚本语言，通常会有对应的文件扩展名，例如.js表示 JavaScript、.groovy表示Groovy等。此方法可以根据文件扩展名获取到对应的脚本引擎。

上述三个方法中需要的参数信息可以通过ScriptEngineFactory提供的方法获得，详情参见2.1部分

实际使用中，getEngineByName方法最为常见，示例代码如下：

java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");
ScriptEngineFactory factory = engine.getFactory();
System.out.println("Engine Name:" + factory.getEngineName());
System.out.println("Engine Version:" + factory.getEngineVersion());
System.out.println("Language Name:" + factory.getLanguageName());
System.out.println("Language Version:" + factory.getLanguageVersion());
System.out.println("Engine Short Names:" + factory.getNames());
System.out.println("Mime Types:" + factory.getMimeTypes());
System.out.println("Extensions:" + factory.getExtensions());

示例代码运行结果如下：


Engine Name:Oracle Nashorn
Engine Version:1.8.0_191
Language Name:ECMAScript
Language Version:ECMA - 262 Edition 5.1
Engine Short Names:[nashorn, Nashorn, js, JS, JavaScript, javascript, ECMAScript, ecmascript]
Mime Types:[application/javascript, application/ecmascript, text/javascript, text/ecmascript]
Extensions:[js]

由此可以发现通过ScriptEngineManager#getEngineByName方法获取的脚本引擎实例和遍历脚本引擎工厂的信息是一致的，但是在使用上要更为简洁。

提示

使用ScriptEngineManager#getEngineByName方法获取脚本引擎示例时，参数可以使用ScriptEngineFactory#getNames结果中的任意一项。

2.3 运行脚本

最基本的运行脚本的方法是使用ScriptEngine#eval方法，脚本代码可以是任何支持的脚本语言，例如JavaScript、Groovy、Python等，取决于所使用的脚本引擎。该方法有很多重载形式。

Object eval(String script)
Object eval(Reader reader)
Object eval(String script, Bindings bindings)
Object eval(Reader reader, Bindings bindings)
Object eval(String script, ScriptContext context)
Object eval(Reader reader, ScriptContext context)

该方法执行完脚本代码后，会返回一个Object类型的结果，可以根据需要将其转换为具体的数据类型进行处理。

java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");
engine.eval("print('eval script by java.')");

运行上述示例代码后，可以在控制台观察到输出：


eval script by java.

提示

正常情况下，都应该使用ScriptEngine#eval方法先加载编译脚本再进行后续操作。

2.4 参数传递

在Java的脚本引擎中，不仅可以独立的运行脚本，还可以在运行中与脚本进行交互，最基本的操作就是参数的传递，Java脚本引擎支持向脚本传递参数，同时支持脚本向Java中传递参数(ScriptEngine#eval方法返回值就是脚本向Java中传递参数的一种方式)。

2.4.1 Java向脚本传递参数

ScriptEngine#put方法传参

创建脚本引擎后，运行脚本之前，通过ScriptEngine#put方法可以向引擎范围内的上下文中绑定参数，脚本中可以获取添加的参数并使用。

java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");
engine.put("input", "Java -> script");
engine.eval("print('eval script by java.' + input);");

运行上述示例代码后，可以在控制台观察到输出：


eval script by java.Java -> script

这样就实现了Java向脚本中传递参数。除了传递基本数据类型的参数，使用该方法还可以传递Java对象，对象中的属性与方法在脚本中同样可以使用。

java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");
engine.put("input", new Date());
engine.eval("print('eval script by java.' + input.getTime());");

运行上述示例代码后，可以在控制台观察到输出：


eval script by java.1714637865643

ScriptEngine#eval方法传参

在ScriptEngine#eval方法的重载方法中，同样提供了绑定参数的入参(Bindings、ScriptContext)，以Bindings为例，示例代码如下：

java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");
Bindings bindings = engine.createBindings();
bindings.put("input", new Date());
engine.eval("print('eval script by java.' + input.getTime());", bindings);

运行上述示例代码后，可以在控制台观察到输出：


eval script by java.1714638204958

2.4.3 脚本向Java传递参数

前文中提到过ScriptEngine#eval方法的返回值即为脚本运行后的表达式结果，通过一个简单的示例可以进行验证。

java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");
Object result = engine.eval("3 + 2");
System.out.println(result);
System.out.println(result.getClass());

运行上述示例代码后，可以在控制台观察到输出：


5
class java.lang.Integer

这种方式可以快速获得脚本的执行结果。有时候，除了脚本最终的结果，我们希望获取运行中产生的中间变量的结果，在ScriptEngine提供可get方法可以获取引擎上下文中的所有变量信息，利用该方法即可实现中间变量的获取。

java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");
Object result = engine.eval("var a = 1; var b = 2;a + b");
System.out.println(result);
System.out.println(engine.get("a"));
System.out.println(engine.get("b"));

运行上述示例代码后，可以在控制台观察到输出：


3.0
1
2

除了上述示例代码外，在Java脚本引擎中，还有一些其他传递参数的形式，本质上与上述示例大同小异，这里就不再赘述了。

2.5 执行函数

Java脚本引擎中，Java代码不仅可以运行脚本整体，也可以单独运行脚本中的某个函数，其实这也是脚本向Java传递参数的特殊使用，比如在脚本中定义一个sum方法，用于将两个数据进行相加，示例脚本如下：

js
function sum(a, b) {
    return a + b;
}

然后使用ScriptEngine#eval方法加载并编译脚本，最后使用ScriptEngine提供可get方法获取sum函数。

java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");
engine.eval("function sum(a, b) {\n" + "    return a + b;\n" + "}");
ScriptObjectMirror mirror = (ScriptObjectMirror) engine.get("sum");
System.out.println(mirror.call(null, 1, 2));

Nashorn引擎中，js的函数会被封装为ScriptObjectMirror对象，通过该对象的call方法即可实现脚本中函数的调用。运行上述示例代码后，可以在控制台观察到输出：

3.0

ScriptEngine#get方法是通用的，但是ScriptObjectMirror对象是 Nashorn引擎中特有的，当需要考虑通用性时，这种方式就不太合适了，此时可以尝试用Invocable接口，该接口表示一个可执行的脚本引擎，大部分的脚本引擎都会实现该接口，上述同样的功能可以使用Invocable接口进行等价实现。

java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");
engine.eval("function sum(a, b) {\n" + "    return a + b;\n" + "}");
Invocable inv = (Invocable) engine;
System.out.println(inv.invokeFunction("sum", 1, 2));

注意

为了确保程序运行正常，使用Invocable之前应先判断ScriptEngine是否已实现该接口，再进行强制转换。

有时候，脚本提供的并非一个独立的函数，而是将函数封装成了一个对象形式，此时可以使用Invocable#invokeMethod方法执行。

假设脚本内容如下：

js
var calculator = new Object();

calculator.add = function (n1, n2) n1 + n2;
calculator.subtract = function (n1, n2) n1 - n2;
calculator.multiply = function (n1, n2) n1 * n2;
calculator.divide = function (n1, n2) n1 / n2;

接下来，我们可以使用如下方式进行操作，调用calculator对象的add方法实现数字的相加。

java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");
engine.eval(script);
Invocable inv = (Invocable) engine;
Object calculator = engine.get("calculator");
System.out.println(inv.invokeMethod(calculator, "add", 1, 2));

2.6 脚本编译

Java脚本引擎允许将脚本编译为Java对象形式，后续使用过程中可以重复调用，为不需要像上述示例代码中一样，每次运行时进行加载。

首先，需要验证所使用的引擎是否支持编译

java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");

if (engine instanceof Compilable) {
    System.out.println("Script compilation is supported.");
} else {
    System.out.println("Script compilation is not supported.");
}

支持脚本编译的引擎，引擎实例会实现Compilable接口，利用该特性可以很容易进行引擎是否支持脚本编译判断。对于支持脚本编译的引擎可以继续进行后续操作。

java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");
Compilable compilable = (Compilable) engine;

CompiledScript compile = compilable.compile("print(n1 + n2)");

Bindings bindings = engine.createBindings();
bindings.put("n1", 2);
bindings.put("n2", 3);
compile.eval(bindings);

bindings.put("n1", 9);
bindings.put("n2", 7);
compile.eval(bindings);

与直接运行脚本不同，脚本编译时需要使用Compilable#compile方法加载并编译脚本，获得编译后的脚本对象，然后使用CompiledScript#eval方法指定脚本运行所需绑定参数或上下文信息后进行运行，上述示例运行结果如下：


5
16

这样可以一定程度上提升脚本运行的效率，同时避免每次运行脚本时进行脚本加载，相对而言，编码流程更加清晰。综上，在需要对同一段脚本片段重复执行时优先考虑脚本编译的方式执行，只有当脚本引擎不支持该模式时，再退而求其次使用ScriptEngine#eval方法。

2.7 实现接口

很多时候，项目中使用Java脚本引擎用于解决整体流程中变的部分，而对于主程序而言，基于特定的策略选择合适的实现进行处理，利用接口的特性，可以很好的使用变与不变更好的融合，除了使用脚本引擎，对于变得部分还可以使用其他方式，比如Java本身的实现类，所以将脚本转换为Java中可用的接口实现，可以使脚本与java之间的结合更加紧密与高效。在Java脚本引擎中同样提供了将脚本映射为接口实现类的方法，主程序中可以像调用其他Java实现一样执行脚本。

首先，定义一个Java接口，命名为：Calculator，接口具体定义如下：

java
public interface Calculator {
   double add (double n1, double n2);
}

第二步定义脚本函数，使之与接口方法签名对应：

js
function add(n1, n2) {
  n1 + n2;
}

注意

此处可以理解为脚本内容即为接口的实现类，脚本中的函数必须满足接口中的方法签名，否则再进行转换时会出现异常。

最后使用Invocable#getInterface方法获取接口的实现。

java
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");

if (!(engine instanceof Invocable)) {
    System.out.println("Interface implementation in script is not supported.");
    return;
}
Invocable inv = (Invocable) engine;
engine.eval(script);
Calculator calc = inv.getInterface(Calculator.class);
if (calc == null) {
    System.err.println("Calculator interface implementation not found.");
    return;
}
double x = 2.0;
double y = 1.0;
double addResult = calc.add(x, y);

System.out.println(addResult);

这样就实现了从脚本中获取Java接口实现的目的，在后续的使用中，可以像原生的Java对象一样直接执行，可以大大的提升执行效率，这种方式也是Java中使用脚本引擎最常用的一种方式。

第三部分常用引擎说明

3.1 JavaScript引擎

3.1.1 Rhino

Rhino是由Mozilla开发的一款开源的JavaScript引擎，最初是为了在Java应用程序中嵌入JavaScript解释器而开发的。JDK6和JDK7已集成，其它版本JDK需要添加依赖包。

xml
<dependency>
    <groupId>org.mozilla</groupId>
    <artifactId>rhino-engine</artifactId>
    <version>1.7.14</version>
</dependency>

特点：

稳定性高：Rhino已经存在很长时间，经过了广泛的测试和使用，具有较高的稳定性。
兼容性好：Rhino支持ECMAScript 5.1标准，并具有良好的兼容性。

优点：

成熟稳定：Rhino已经被广泛使用和测试，具有较高的稳定性和可靠性。
多用途性：Rhino可以用于各种用途，包括嵌入式脚本、动态配置等。

缺点：

性能相对较低：Rhino在性能上不如一些现代的JavaScript引擎，如V8。
不再维护：自从Java 8引入了Nashorn后，Rhino不再被推荐作为默认的JavaScript引擎使用。

3.1.2 Nashorn

Nashorn是在Java 8中引入的新一代JavaScript引擎，旨在取代Rhino，JDK8-JDK13已集成，其它版本JDK需要添加依赖包。

xml
<dependency>
    <groupId>org.openjdk.nashorn</groupId>
    <artifactId>nashorn-core</artifactId>
    <version>15.4</version>
</dependency>

特点：

高性能：Nashorn采用了基于JVM的即时编译技术，具有较高的性能。
ECMAScript 6支持：Nashorn支持ECMAScript 6标准，提供了更多现代 JavaScript特性的支持。

优点：

高性能：Nashorn的性能比Rhino更好，特别是在执行大量JavaScript代码时。
新特性支持：Nashorn支持ECMAScript 6标准，提供了箭头函数、模板字符串等现代JavaScript特性。

缺点：

兼容性问题：Nashorn在某些情况下可能与Rhino不兼容，需要进行一些调整和适配。
动态性降低：相比Rhino，Nashorn对动态性的支持略有降低，可能导致一些现有代码需要修改。

3.1.3 Rhino与Nashorn对比

性能：Nashorn在性能上优于Rhino，特别是在执行大量JavaScript代码时。
兼容性：Rhino已经被广泛使用和测试，具有较好的兼容性；Nashorn支持ECMAScript 6标准，但在某些情况下可能存在兼容性问题。
特性支持：Nashorn支持ECMAScript 6标准，提供了更多现代JavaScript特性的支持；Rhino则支持ECMAScript 5.1标准，功能相对较为受限。
维护状态：Rhino不再被推荐作为默认的JavaScript引擎使用，而Nashorn是Java 8引入的新一代JavaScript引擎，目前仍在维护中。

3.1.3 脚本中使用原生`Java`类

3.1.3.1 使用包全局对象

Nashorn将所有Java包都定义为名为Packages的全局变量的属性。例如，java.lang 和javax.swing包可以称为Packages.java.lang和Packages.javax.swing。

以下代码在Nashorn中使用java.util.List:

java
var list1 = new Packages.java.util.ArrayList();

Nashorn将java、javax、org、com、edu和net声明为全局变量，分别是 Packages.java、Packages.javax、Packages.org、Packages.com、Packages.edu和Packages.net的别名。所以，上述代码可以写为如下形式：

java
var list = new java.util.ArrayList();

3.1.3.2 使用Java全局对象

Nashorn定义了一个称为Java的新的全局对象，它包含许多有用的函数来使用Java包和类。Java对象的type()函数将Java类型导入脚本中。比如将java.util.ArrayList类导入到Nashorn并创建其对象:

java
var ArrayList = Java.type("java.util.ArrayList");

var list = new ArrayList();

3.1.4 自定义类加载器

在使用脚本引擎实现插件等场景中，可能会要求对脚本中引用的Java类进行限制，即需要自定义类加载器，提升主程序的安全性，在全局创建脚本引擎实例的过程中，未提供设置类加载器的方法。针对Nashorn引擎，可以在创建引擎时设置线程上下文的类加载器，通过该方式可实现自定义类加载器的效果，示例代码如下：

java
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
try {
    Thread.currentThread().setContextClassLoader(classLoader);
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("js");
    // DO SOMETHING
} finally {
    Thread.currentThread().setContextClassLoader(contextClassLoader);
}

如若不指定，则默认使用加载NashornScriptEngineFactory类的加载器作为后续的类加载器，可通过查看相关源代码进行验证。

java
public ScriptEngine getScriptEngine() {
    try {
        return new NashornScriptEngine(this, DEFAULT_OPTIONS, getAppClassLoader(), (ClassFilter)null);
    } catch (RuntimeException var2) {
        if (Context.DEBUG) {
            var2.printStackTrace();
        }

        throw var2;
    }
}

private static ClassLoader getAppClassLoader() {
        ClassLoader ccl = Thread.currentThread().getContextClassLoader();
    return ccl == null ? NashornScriptEngineFactory.class.getClassLoader() : ccl;
}

如果明确使用Nashorn引擎，也可以通过NashornScriptEngineFactory#getScriptEngine方法指定类加载，考虑到代码的通用性，建议使用第一种设置线程上下文类加载器的方式。

3.2 Groovy引擎

Groovy引擎依赖包：

xml
<dependency>
    <groupId>org.apache.groovy</groupId>
    <artifactId>groovy-all</artifactId>
    <version>4.0.21</version>
    <type>pom</type>
</dependency>

3.3 Python引擎

Python引擎依赖包：

xml
<dependency>
    <groupId>org.python</groupId>
    <artifactId>jython-standalone</artifactId>
    <version>2.7.3</version>
</dependency>

3.4 Ruby引擎

Ruby引擎依赖包：

xml
<dependency>
    <groupId>org.jruby</groupId>
    <artifactId>jruby-complete</artifactId>
    <version>9.4.7.0</version>
</dependency>

3.5 Lua引擎

Lua引擎依赖包：

xml
<dependency>
    <groupId>org.luaj</groupId>
    <artifactId>luaj-jse</artifactId>
    <version>3.0.1</version>
</dependency>

第四部分 Java动态编译

Java动态编译是指在程序运行时，使用Java代码将另外一段Java代码编译成字节码并加载到JVM（Java虚拟机）中执行的过程。这主要通过Java编译器API（javax.tools.JavaCompiler）实现，允许开发者在Java程序中调用编译器，从而在运行时生成字节码。动态编译可以用于实现动态代码生成、动态加载、插件化等功能。

4.1 JavaCompiler

使用Java动态编译的一般步骤如下：

获取JavaCompiler实例：使用ToolProvider.getSystemJavaCompiler()方法获取到系统Java编译器的实例。
准备源代码：可以是一个String类型的Java源代码，也可以是文件形式的Java源代码。
创建JavaFileObject实例：如果源代码是字符串形式，需要创建一个JavaFileObject的实现类实例，以表示源代码。
获取JavaFileManager实例：通过编译器实例调用getStandardFileManager方法获取标准的文件管理器，用于管理源文件和类文件。
诊断收集器（可选）：创建DiagnosticCollector的实例，用于收集编译过程中的诊断信息，如错误和警告。
创建CompilationTask实例：使用编译器实例的getTask方法创建一个编译任务，传入所需的参数，如输出流、文件管理器、诊断收集器、编译选项和编译单元。
执行编译任务：调用CompilationTask的call方法执行编译，这个方法会返回一个布尔值，表示编译是否成功。
关闭JavaFileManager：编译完成后，应该关闭文件管理器以释放资源。
加载编译后的类：如果编译成功，可以通过自定义类加载器或者URLClassLoader加载编译生成的类。
执行类中的方法：通过反射等机制调用加载后的类中的方法。

根据上述步骤，Java动态编译的示例代码如下：

java
public class DynamicCompilationTest {
    static class JavaSourceFromString extends SimpleJavaFileObject {
        private String code;

        public JavaSourceFromString(String name, String content) {
            super(URI.create(name), Kind.SOURCE);
            this.code = content;
        }

        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
            return code;
        }
    }

    @Test
    public void test() throws Exception {
        // 1. 获取JavaCompiler实例
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        // 2. 准备源代码
        String code = "public class DynamicCompilation {\n" +
                "    public static void main(String[] args) {\n" +
                "        System.out.println(\"Dynamic Compilation!\");\n" +
                "    }\n" +
                "}";
        // 3. 创建JavaFileObject实例
        JavaSourceFromString javaSource = new JavaSourceFromString("DynamicCompilation.java", code);
        // 3. 获取JavaFileManager实例
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
        // 5. 诊断收集器（可选）
        DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
        // 6. 创建CompilationTask实例
        Iterable<? extends JavaFileObject> compilationUnits = Collections.singletonList(javaSource);
        JavaCompiler.CompilationTask task = compiler
                .getTask(null, fileManager, diagnostics, null, null, compilationUnits);
        // 7. 执行编译任务
        boolean success = task.call();
        // 8. 关闭JavaFileManager
        fileManager.close();

        if (success) {
            System.out.println("Compilation succeeded.");
            // 9. 加载编译后的类并执行
            URLClassLoader classLoader = new URLClassLoader(new URL[] {
                new File(".").toURI().toURL() 
            });
            Class<?> clazz = classLoader.loadClass("DynamicCompilation");
            Method method = clazz.getMethod("main", String[].class);
            method.invoke(null, new Object[] { null });
        } else {
            System.out.println("Compilation failed.");
            for (Diagnostic<? extends JavaFileObject> diagnostic : diagnostics.getDiagnostics()) {
                System.out.println(diagnostic.getMessage(null));
            }
        }
    }
}

运行之后观察控制台输出：


Compilation succeeded.
Dynamic Compilation!

使用这种方式编译之后会在本地磁盘上生成一个DynamicCompilation.class文件，如果希望整个编译过程在内存中实现，不生成本地文件，可以参考JCompiler实现。

4.2 Janino

Janino是一个开源的轻量级Java编译器，它能够动态编译Java代码。不仅能够像javac一样编译 Java源文件，还可以在内存中编译Java表达式、代码块和类。Janino可以作为一个库被直接集成到 Java程序中，用于动态编译和执行Java代码，这在需要快速原型开发或者需要在运行时生成和执行代码的场景中非常有用。官网地址：https://janino-compiler.github.io/janino/

特点：

轻量级：Janino是一个轻量级的Java编译器，体积小巧，易于集成和使用。
简单易用：Janino提供了简单易用的API，使得开发人员可以轻松地在程序中实现动态编译功能。

xml
<dependency>
    <groupId>org.codehaus.janino</groupId>
    <artifactId>janino</artifactId>
    <version>3.1.12</version>
</dependency>

4.2.1 SimpleCompiler

使用Janino实现JavaCompiler相同功能可以参考如下示例：

java
String code = "public class DynamicCompilation {\n" +
        "    public static void main(String[] args) {\n" +
        "        System.out.println(\"Dynamic Compilation!\");\n" +
        "    }\n" +
        "}";
// 使用 Janino 动态编译类定义的字符串
SimpleCompiler compiler = new SimpleCompiler();
compiler.cook(code);
// 加载编译后的类
Class<?> clazz = compiler.getClassLoader().loadClass("DynamicCompilation");
// 调用静态方法
Method method = clazz.getMethod("main", String[].class);
method.invoke(null, new Object[] { null });

相比较而言，使用使用Janino比JavaCompiler原生实现，代码更加简洁且更容易实现。

4.2.2 ExpressionEvaluator

java
ExpressionEvaluator evaluator = new ExpressionEvaluator();
evaluator.cook("3 + 4");
System.out.println(evaluator.evaluate()); // Prints "7".

// Now here's where the story begins...
evaluator = new ExpressionEvaluator();

// The expression will have two "int" parameters: "a" and "b".
evaluator.setParameters(new String[] { "a", "b" }, new Class[] { int.class, int.class });

// And the expression (i.e. "result") type is also "int".
evaluator.setExpressionType(int.class);

// And now we "cook" (scan, parse, compile and load) the fabulous expression.
evaluator.cook("a + b");

// Eventually we evaluate the expression - and that goes super-fast.
int result = (Integer) evaluator.evaluate(new Object[] { 19, 23 });
System.out.println(result);

4.2.3 ScriptEvaluator

java
ScriptEvaluator evaluator = new ScriptEvaluator();
evaluator.cook(
        "static void method1() {\n"
        + "    System.out.println(1);\n"
        + "}\n"
        + "\n"
        + "method1();\n"
        + "method2();\n"
        + "\n"
        + "static void method2() {\n"
        + "    System.out.println(2);\n"
        + "}\n"
);
evaluator.evaluate();

提示

Janino不仅支持上述三种编译方式，还有很多更丰富的使用场景，进本满足常规的需求，更到示例请参考官方使用文档。

4.3 Apache Commons JCI (Java Compiler Interface)

Apache Commons JCI（Java Compiler Interface）是一个通用的Java编译器接口，它提供了一种更灵活和易用的方式来动态编译Java代码。Apache Commons JCI允许开发人员使用不同的编译器实现，以满足各种需求，并且支持在运行时动态地编译Java源代码。

特点：

灵活性：Apache Commons JCI提供了统一的接口，允许开发人员使用不同的编译器实现，例如Eclipse JDT Compiler、Janino、Groovy等，以满足不同的需求。
易用性：Apache Commons JCI提供了简单易用的API，使得开发人员可以轻松地在程序中集成动态编译功能。

xml
<dependency>
    <groupId>commons-jci</groupId>
    <artifactId>commons-jci-core</artifactId>
    <version>1.1</version>
</dependency>

4.3 Apache Commons JCI和Janino对比

4.3.1 Apache Commons JCI

灵活性：Apache Commons JCI提供了统一的接口，允许开发人员选择不同的编译器实现，例如Eclipse JDT Compiler、Janino、Groovy等，以满足不同的需求。这种灵活性使得可以根据具体情况选择最合适的编译器。
功能丰富：由于可以选择不同的编译器实现，Apache Commons JCI提供了丰富的功能和选项，例如编译选项、不同的编译器参数等，可以满足更多复杂场景的需求。
易用性：Apache Commons JCI提供了简单易用的API，使得开发人员可以轻松地在程序中集成动态编译功能，不需要关心底层的编译细节。

4.3.2 Janino

轻量级：Janino是一个轻量级的Java编译器，体积小巧，易于集成和使用。它不依赖于其他外部库，可以很容易地与项目集成。
简单易用：Janino提供了简单易用的API，使得开发人员可以方便地在程序中实现动态编译功能。它不需要额外的配置和依赖，可以快速上手并开始使用。
性能：由于Janino是专门为了动态编译而设计的，因此在性能方面可能会更优秀一些，特别是对于较小规模的代码编译。

4.3.3 对比

灵活性：Apache Commons JCI提供了更多选择，可以根据需求选择合适的编译器实现；而Janino是一个单一的轻量级解决方案。
功能：Apache Commons JCI提供了更丰富的功能和选项，适用于更多复杂的场景；而Janino更注重简洁和轻量级，适用于快速开发和简单应用。
性能：由于Janino是专门为动态编译而设计的，因此在性能方面可能更优秀；而Apache Commons JCI在灵活性和功能方面更胜一筹。

总的来说，Apache Commons JCI和Janino都是优秀的Java动态编译解决方案，开发人员可以根据项目的具体需求和偏好选择合适的实现方式。

第五部分 QLExpress

注

本节内容引用自QLExpress官方文档

5.1 背景介绍

由阿里的电商业务规则、表达式（布尔组合）、特殊数学公式计算（高精度）、语法分析、脚本二次定制等强需求而设计的一门动态脚本引擎解析工具。在阿里集团有很强的影响力，同时为了自身不断优化、发扬开源贡献精神，于2012年开源。

QLExpress脚本引擎被广泛应用在阿里的电商业务场景，具有以下的一些特性:

线程安全: 引擎运算过程中的产生的临时变量都是threadlocal类型。
高效执行: 比较耗时的脚本编译过程可以缓存在本地机器，运行时的临时变量创建采用了缓冲池的技术，和groovy性能相当。
弱类型脚本语言: 和groovy，javascript语法类似，虽然比强类型脚本语言要慢一些，但是使业务的灵活度大大增强。
安全控制: 可以通过设置相关运行参数，预防死循环、高危系统api调用等情况。
代码精简，依赖最小: 250k的jar包适合所有java的运行环境，在android系统的低端pos机也得到广泛运用。

5.2 依赖和调用说明

xml
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>QLExpress</artifactId>
  <version>3.3.3</version>
</dependency>

版本兼容性: 跳转查看

java
ExpressRunner runner = new ExpressRunner();
DefaultContext<String, Object> context = new DefaultContext<String, Object>();
context.put("a", 1);
context.put("b", 2);
context.put("c", 3);
String express = "a + b * c";
Object r = runner.execute(express, context, null, true, false);
System.out.println(r);

如果应用有让终端用户输入与执行QLExpress的功能，务必关注多级别安全控制，将QLExpress 的安全级别配置在白名单或以上。

5.3 语法介绍

5.3.1 操作符和java对象操作

5.3.1.1 普通java语法

java
//支持 +,-,*,/,<,>,<=,>=,==,!=,<>【等同于!=】,%,mod【取模等同于%】,++,--,
//in【类似sql】,like【sql语法】,&&,||,!,等操作符
//支持for，break、continue、if then else 等标准的程序控制逻辑
n = 10;
sum = 0;
for(i = 0; i < n; i++) {
   sum = sum + i;
}
return sum;

//逻辑三元操作
a = 1;
b = 2;
maxnum = a > b ? a : b;

和java语法相比，要避免的一些ql写法错误

不支持try{}catch{}
注释目前只支持/** **/，不支持单行注释//
不支持java8的lambda表达式
不支持for循环集合操作for (Item item : list)
弱类型语言，请不要定义类型声明,更不要用Template（Map<String, List>之类的）
array的声明不一样
min、max、round、print、println、like、in都是系统默认函数的关键字，请不要作为变量名

java
//java语法：使用泛型来提醒开发者检查类型
keys = new ArrayList<String>();
deviceName2Value = new HashMap<String, String>(7);
String[] deviceNames = {"ng", "si", "umid", "ut", "mac", "imsi", "imei"};
int[] mins = {5, 30};

//ql写法：
keys = new ArrayList();
deviceName2Value = new HashMap();
deviceNames = ["ng", "si", "umid", "ut", "mac", "imsi", "imei"];
mins = [5, 30];

//java语法：对象类型声明
FocFulfillDecisionReqDTO reqDTO = param.getReqDTO();
//ql写法：
reqDTO = param.getReqDTO();

//java语法：数组遍历
for(Item item : list) {
}
//ql写法：
for(i = 0; i < list.size(); i++){
    item = list.get(i);
}

//java语法：map遍历
for(String key : map.keySet()) {
    System.out.println(map.get(key));
}
//ql写法：
keySet = map.keySet();
objArr = keySet.toArray();
for (i = 0; i < objArr.length; i++) {
    key = objArr[i];
    System.out.println(map.get(key));
}

5.3.1.2 java的对象操作

java
import com.ql.util.express.test.OrderQuery;
//系统自动会import java.lang.*,import java.util.*;

query = new OrderQuery();           // 创建class实例，自动补全类路径
query.setCreateDate(new Date());    // 设置属性
query.buyer = "张三";                // 调用属性，默认会转化为setBuyer("张三")
result = bizOrderDAO.query(query);  // 调用bean对象的方法
System.out.println(result.getId()); // 调用静态方法

5.3.2 脚本中定义function

java
function add(int a, int b){
    return a + b;
};

function sub(int a, int b){
    return a - b;
};

a = 10;
return add(a, 4) + sub(a, 9);

5.3.3 扩展操作符：Operator

5.3.3.1 替换 if then else 等关键字

java
runner.addOperatorWithAlias("如果", "if", null);
runner.addOperatorWithAlias("则", "then", null);
runner.addOperatorWithAlias("否则", "else", null);

express = "如果 (语文 + 数学 + 英语 > 270) 则 {return 1;} 否则 {return 0;}";
DefaultContext<String, Object> context = new DefaultContext<String, Object>();
runner.execute(express, context, null, false, false, null);

注意

使用自定义操作符在编写表达式时应注意操作符与其他元素之间添加空格，避免莫名其妙的执行结果异常。

5.3.3.2 如何自定义Operator

java
import java.util.ArrayList;
import java.util.List;

/**
 * 定义一个继承自com.ql.util.express.Operator的操作符
 */
public class JoinOperator extends Operator {
    public Object executeInner(Object[] list) throws Exception {
        Object opdata1 = list[0];
        Object opdata2 = list[1];
        if (opdata1 instanceof List) {
            ((List)opdata1).add(opdata2);
            return opdata1;
        } else {
            List result = new ArrayList();
            for (Object opdata : list) {
                result.add(opdata);
            }
            return result;
        }
    }
}

5.3.3.3 如何使用Operator

java
//(1)addOperator
ExpressRunner runner = new ExpressRunner();
DefaultContext<String, Object> context = new DefaultContext<String, Object>();
runner.addOperator("join", new JoinOperator());
Object r = runner.execute("1 join 2 join 3", context, null, false, false);
System.out.println(r); // 返回结果 [1, 2, 3]

//(2)replaceOperator
ExpressRunner runner = new ExpressRunner();
DefaultContext<String, Object> context = new DefaultContext<String, Object>();
runner.replaceOperator("+", new JoinOperator());
Object r = runner.execute("1 + 2 + 3", context, null, false, false);
System.out.println(r); // 返回结果 [1, 2, 3]

//(3)addFunction
ExpressRunner runner = new ExpressRunner();
DefaultContext<String, Object> context = new DefaultContext<String, Object>();
runner.addFunction("join", new JoinOperator());
Object r = runner.execute("join(1, 2, 3)", context, null, false, false);
System.out.println(r); // 返回结果 [1, 2, 3]

5.3.4 绑定java类或者对象的method

addFunctionOfClassMethod + addFunctionOfServiceMethod

java
public class BeanExample {
    public static String upper(String abc) {
        return abc.toUpperCase();
    }
    public boolean anyContains(String str, String searchStr) {
        char[] s = str.toCharArray();
        for (char c : s) {
            if (searchStr.contains(c+"")) {
                return true;
            }
        }
        return false;
    }
}

runner.addFunctionOfClassMethod("取绝对值", Math.class.getName(), "abs", new String[] {"double"}, null);
runner.addFunctionOfClassMethod("转换为大写", BeanExample.class.getName(), "upper", new String[] {"String"}, null);

runner.addFunctionOfServiceMethod("打印", System.out, "println", new String[] { "String" }, null);
runner.addFunctionOfServiceMethod("contains", new BeanExample(), "anyContains", new Class[] {String.class, String.class}, null);

String express = "取绝对值(-100); 转换为大写(\"hello world\"); 打印(\"你好吗？\"); contains("helloworld",\"aeiou\")";
runner.execute(express, context, null, false, false);

5.3.5 macro 宏定义

java
runner.addMacro("计算平均成绩", "(语文+数学+英语)/3.0");
runner.addMacro("是否优秀", "计算平均成绩>90");
IExpressContext<String, Object> context = new DefaultContext<String, Object>();
context.put("语文", 88);
context.put("数学", 99);
context.put("英语", 95);
Object result = runner.execute("是否优秀", context, null, false, false);
System.out.println(r);
//返回结果true

5.3.6 编译脚本，查询外部需要定义的变量和函数

注意

注意以下脚本int和没有int的区别

java
String express = "int 平均分 = (语文 + 数学 + 英语 + 综合考试.科目2) / 4.0; return 平均分";
ExpressRunner runner = new ExpressRunner(true, true);
String[] names = runner.getOutVarNames(express);
for(String s:names){
    System.out.println("var : " + s);
}

//输出结果：
var : 数学
var : 综合考试
var : 英语
var : 语文

5.3.7 关于不定参数的使用

java
@Test
public void testMethodReplace() throws Exception {
    ExpressRunner runner = new ExpressRunner();
    IExpressContext<String, Object> expressContext = new DefaultContext<String, Object>();
    runner.addFunctionOfServiceMethod("getTemplate", this, "getTemplate", new Class[]{Object[].class}, null);

    //(1)默认的不定参数可以使用数组来代替
    Object r = runner.execute("getTemplate([11,'22', 33L, true])", expressContext, null, false, false);
    System.out.println(r);
    //(2)像java一样,支持函数动态参数调用,需要打开以下全局开关,否则以下调用会失败
    DynamicParamsUtil.supportDynamicParams = true;
    r = runner.execute("getTemplate(11, '22', 33L, true)", expressContext, null, false, false);
    System.out.println(r);
}

//等价于getTemplate(Object[] params)
public Object getTemplate(Object... params) throws Exception{
    String result = "";
    for(Object obj:params){
        result = result + obj + ",";
    }
    return result;
}

5.3.8 关于集合的快捷写法

java
@Test
public void testSet() throws Exception {
    ExpressRunner runner = new ExpressRunner(false, false);
    DefaultContext<String, Object> context = new DefaultContext<String, Object>();
    String express = "abc = NewMap(1:1, 2:2); return abc.get(1) + abc.get(2);";
    Object r = runner.execute(express, context, null, false, false);
    System.out.println(r);
    express = "abc = NewList(1, 2, 3); return abc.get(1) + abc.get(2)";
    r = runner.execute(express, context, null, false, false);
    System.out.println(r);
    express = "abc = [1, 2, 3]; return abc[1] + abc[2];";
    r = runner.execute(express, context, null, false, false);
    System.out.println(r);
}

5.3.9 集合的遍历

其实类似java的语法，只是ql不支持for(obj:list){}的语法，只能通过下标访问。

java
//遍历map
map = new HashMap();
map.put("a", "a_value");
map.put("b", "b_value");
keySet = map.keySet();
objArr = keySet.toArray();
for (i = 0; i < objArr.length; i++) {
    key = objArr[i];
    System.out.println(map.get(key));
}

5.4 运行参数和API列表介绍

QLExpressRunner如下图所示，从语法树分析、上下文、执行过程三个方面提供二次定制的功能扩展。

5.4.1 属性开关

5.4.1.1 isPrecise

java
/**
 * 是否需要高精度计算
 */
private boolean isPrecise = false;

高精度计算在会计财务中非常重要，java的float、double、int、long存在很多隐式转换，做四则运算和比较的时候其实存在非常多的安全隐患。所以类似汇金的系统中，会有很多BigDecimal转换代码。而使用QLExpress，只要关注数学公式本身订单总价 = 单价 * 数量 + 首重价格 + （总重量 - 首重） * 续重单价 ，然后设置这个属性即可，所有的中间运算过程都会保证不丢失精度。

5.4.1.2 isShortCircuit

java
/**
 * 是否使用逻辑短路特性
 */
private boolean isShortCircuit = true;

在很多业务决策系统中，往往需要对布尔条件表达式进行分析输出，普通的java运算一般会通过逻辑短路来减少性能的消耗。例如规则公式：star > 10000 and shopType in ('tmall', 'juhuasuan') and price between (100, 900)假设第一个条件star>10000不满足就停止运算。但业务系统却还是希望把后面的逻辑都能够运算一遍，并且输出中间过程，保证更快更好的做出决策。

5.4.1.3 isTrace

java
/**
 * 是否输出所有的跟踪信息，同时还需要log级别是DEBUG级别
 */
private boolean isTrace = false;

这个主要是是否输出脚本的编译解析过程，一般对于业务系统来说关闭之后会提高性能。

5.4.2 调用入参

java
/**
 * 执行一段文本
 * @param expressString 程序文本
 * @param context 执行上下文，可以扩展为包含ApplicationContext
 * @param errorList 输出的错误信息List
 * @param isCache 是否使用Cache中的指令集,建议为true
 * @param isTrace 是否输出详细的执行指令信息，建议为false
 * @return
 * @throws Exception
 */
Object execute(String expressString, IExpressContext<String, Object> context, 
        List<String> errorList, boolean isCache, boolean isTrace);

5.4.3 功能扩展API列表

QLExpress主要通过子类实现Operator提供的以下方法来最简单的操作符定义，然后可以被通过addFunction或者addOperator的方式注入到ExpressRunner中。

java
public abstract Object executeInner(Object[] list) throws Exception;

比如我们几行代码就可以实现一个功能超级强大、非常好用的join操作符:

java
_list = 1 join 2 join 3;_         -> [1,2,3]
_list = join(list, 4, 5, 6);_     -> [1,2,3,4,5,6]

java
import java.util.ArrayList;
import java.util.List;

public class JoinOperator extends Operator {
    public Object executeInner(Object[] list) throws Exception {
        List result = new ArrayList();
        Object opdata1 = list[0];
        if (opdata1 instanceof List) {
            result.addAll((List)opdata1);
        } else {
            result.add(opdata1);
        }
        for (int i = 1; i < list.length; i++) {
            result.add(list[i]);
        }
        return result;
    }
}

如果使用Operator的基类OperatorBase将获得更强大的能力，基本能够满足所有的要求。

5.4.3.1 function相关API

java
//通过name获取function的定义
OperatorBase getFunciton(String name);

//通过自定义的Operator来实现类似：fun(a, b, c)
void addFunction(String name, OperatorBase op);

//fun(a, b, c) 绑定 object.function(a, b, c)对象方法
void addFunctionOfServiceMethod(String name, Object aServiceObject, 
        String aFunctionName, Class<?>[] aParameterClassTypes, String errorInfo);

//fun(a, b, c) 绑定 Class.function(a, b, c)类方法
void addFunctionOfClassMethod(String name, String aClassName, String aFunctionName,
        Class<?>[] aParameterClassTypes, String errorInfo);

//给Class增加或者替换method，同时支持 a.fun(b), fun(a, b) 两种方法调用
//比如扩展String.class的isBlank方法:"abc".isBlank()和isBlank("abc")都可以调用
void addFunctionAndClassMethod(String name, Class<?> bindingClass, OperatorBase op);

5.4.3.2 Operator相关API

提到脚本语言的操作符，优先级、运算的目数、覆盖原始的操作符(+,-,*,/等等)都是需要考虑的问题，QLExpress统统帮你搞定了。

java
//添加操作符号,可以设置优先级
void addOperator(String name, Operator op);
void addOperator(String name, String aRefOpername, Operator op);

//替换操作符处理
OperatorBase replaceOperator(String name, OperatorBase op);

//添加操作符和关键字的别名，比如 if..then..else -> 如果。。那么。。否则。。
void addOperatorWithAlias(String keyWordName, String realKeyWordName, String errorInfo);

5.4.3.3 宏定义相关API

QLExpress的宏定义比较简单，就是简单的用一个变量替换一段文本，和传统的函数替换有所区别。

java
//比如addMacro("天猫卖家", "userDO.userTag &1024 == 1024")
void addMacro(String macroName, String express);

5.4.3.4 java class的相关api

QLExpress可以通过给java类增加或者改写一些method和field，比如链式调用："list.join("1").join("2")"，比如中文属性："list.长度"。

java
//添加类的属性字段
void addClassField(String field, Class<?>bindingClass, Class<?>returnType, Operator op);

//添加类的方法
void addClassMethod(String name, Class<?>bindingClass, OperatorBase op);

注意

这些类的字段和方法是执行器通过解析语法执行的，而不是通过字节码增强等技术，所以只在脚本运行期间生效，不会对jvm整体的运行产生任何影响，所以是绝对安全的。

5.4.3.5 语法树解析变量、函数的API

这些接口主要是对一个脚本内容的静态分析，可以作为上下文创建的依据，也可以用于系统的业务处理。比如：计算 "a + fun1(a) + fun2(a + b) + c.getName()" 包含的变量:a,b,c包含的函数:fun1,fun2

java
//获取一个表达式需要的外部变量名称列表
String[] getOutVarNames(String express);
String[] getOutFunctionNames(String express);

5.4.3.6 语法解析校验api

脚本语法是否正确，可以通过ExpressRunner编译指令集的接口来完成。

java
String expressString = "for(i = 0; i < 10; i++) {sum = i + 1;} return sum;";
InstructionSet instructionSet = expressRunner.parseInstructionSet(expressString);

如果调用过程不出现异常，指令集instructionSet就是可以被加载运行了！

5.4.3.7 指令集缓存相关的api

因为QLExpress对文本到指令集做了一个本地HashMap缓存，通常情况下一个设计合理的应用脚本数量应该是有限的，缓存是安全稳定的，但是也提供了一些接口进行管理。

java
//优先从本地指令集缓存获取指令集，没有的话生成并且缓存在本地
InstructionSet getInstructionSetFromLocalCache(String expressString);
//清除缓存
void clearExpressCache();

5.4.3.8 安全风险控制

5.4.3.8.1 防止死循环

java
try {
    express = "sum = 0; for(i = 0; i < 1000000000; i++) {sum = sum + i;} return sum;";
    //可通过timeoutMillis参数设置脚本的运行超时时间:1000ms
    Object r = runner.execute(express, context, null, true, false, 1000);
    System.out.println(r);
    throw new Exception("没有捕获到超时异常");
} catch (QLTimeOutException e) {
    System.out.println(e);
}

5.4.3.8.2 防止调用不安全的系统api

更加详细多级安全控制见多级别安全控制

java
ExpressRunner runner = new ExpressRunner();
QLExpressRunStrategy.setForbiddenInvokeSecurityRiskMethods(true);

DefaultContext<String, Object> context = new DefaultContext<String, Object>();
try {
    express = "System.exit(1);";
    Object r = runner.execute(express, context, null, true, false);
    System.out.println(r);
    throw new Exception("没有捕获到不安全的方法");
} catch (QLException e) {
    System.out.println(e);
}

5.4.3.9 增强上下文参数Context相关的api

5.4.3.9.1 与spring框架的无缝集成

上下文参数IExpressContext context非常有用，它允许put任何变量，然后在脚本中识别出来。在实际中我们很希望能够无缝的集成到spring框架中，可以仿照下面的例子使用一个子类。

java
public class QLExpressContext extends HashMap<String, Object> implements 
        IExpressContext<String, Object> {
    private final ApplicationContext context;

    // 构造函数，传入context 和 ApplicationContext
    public QLExpressContext(Map<String, Object> map, ApplicationContext aContext) {
        super(map);
        this.context = aContext;
    }

    /**
     * 抽象方法：根据名称从属性列表中提取属性值
     */
    public Object get(Object name) {
        Object result;
        result = super.get(name);
        try {
            if (result == null && this.context != null 
                && this.context.containsBean((String)name)) {
                // 如果在Spring容器中包含bean，则返回String的Bean
                result = this.context.getBean((String)name);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return result;
    }

    public Object put(String name, Object object) {
        return super.put(name, object);
    }
}

5.4.3.9.2 自定义函数操作符获取原始的context控制上下文

自定义的Operator需要直接继承OperatorBase，获取到parent即可，可以用于在运行一组脚本的时候，直接编辑上下文信息，业务逻辑处理上也非常有用。

java
public class ContextMessagePutTest {
    class OperatorContextPut extends OperatorBase {
        public OperatorContextPut(String aName) {
            this.name = aName;
        }

        @Override
        public OperateData executeInner(InstructionSetContext parent, ArraySwap list) 
                throws Exception {
            String key = list.get(0).toString();
            Object value = list.get(1);
            parent.put(key, value);
            return null;
        }
    }

    @Test
    public void test() throws Exception {
        ExpressRunner runner = new ExpressRunner();
        OperatorBase op = new OperatorContextPut("contextPut");
        runner.addFunction("contextPut", op);
        String express = "contextPut('success', 'false'); contextPut('error', '错误信息'); contextPut('warning', '提醒信息')";
        IExpressContext<String, Object> context = new DefaultContext<String, Object>();
        context.put("success", "true");
        Object result = runner.execute(express, context, null, false, true);
        System.out.println(result);
        System.out.println(context);
    }
}

5.4.4 多级别安全控制

QLExpress与本地JVM交互的方式有：

应用中的自定义函数/操作符/宏: 该部分不在QLExpress运行时的管控范围，属于应用开放给脚本的业务功能，不受安全控制，应用需要自行确保这部分是安全的
在QLExpress运行时中发生的交互: 安全控制可以对这一部分进行管理, QLExpress会开放相关的配置给应用
- 通过.操作符获取Java对象的属性或者调用Java对象中的方法
- 通过import可以导入JVM中存在的任何类并且使用, 默认情况下会导入java.lang, java.util以及java.util.stream 在不同的场景下，应用可以配置不同的安全级别，安全级别由低到高：

黑名单控制：QLExpress默认会阻断一些高危的系统API, 用户也可以自行添加, 但是开放对 JVM中其他所有类与方法的访问, 最灵活, 但是很容易被反射工具类绕过，只适用于脚本安全性有其他严格控制的场景，禁止直接运行终端用户输入。
白名单控制：QLExpress支持编译时白名单和运行时白名单机制, 编译时白名单设置到类级别, 能够在语法检查阶段就暴露出不安全类的使用, 但是无法阻断运行时动态生成的类(比如通过反射), 运行时白名单能够确保运行时只可以直接调用有限的Java方法, 必须设置了运行时白名单, 才算是达到了这个级别。
沙箱模式：QLExpress作为一个语言沙箱, 只允许通过自定义函数/操作符/宏与应用交互, 不允许与JVM中的类产生交互

5.4.4.1 黑名单控制

QLExpess目前默认添加的黑名单有：

java.lang.System.exit
java.lang.Runtime.exec
java.lang.ProcessBuilder.start
java.lang.reflect.Method.invoke
java.lang.reflect.Class.forName
java.lang.reflect.ClassLoader.loadClass
java.lang.reflect.ClassLoader.findClass

同时支持通过QLExpressRunStrategy.addSecurityRiskMethod额外添加

java
// 必须将该选项设置为 true
QLExpressRunStrategy.setForbidInvokeSecurityRiskMethods(true);
// 这里不区分静态方法与成员方法, 写法一致
// 不支持重载, riskMethod 的所有重载方法都会被禁止
QLExpressRunStrategy.addSecurityRiskMethod(RiskBean.class, "riskMethod");
ExpressRunner expressRunner = new ExpressRunner();
DefaultContext<String, Object> context = new DefaultContext<>();
try {
    expressRunner.execute("import com.ql.util.express.example.RiskBean;" +
                          "RiskBean.riskMethod()", context, null, true, false);
    fail("没有捕获到不安全的方法");
} catch (Exception e) {
    assertTrue(e.getCause() instanceof QLSecurityRiskException);
}

5.4.4.2 白名单控制

5.4.4.2.1 编译期白名单

编译期白名单是类维度的，脚本中只允许显式引用符合白名单条件的类，支持两种设置方式，精确设置某个类，以及设置某个类的全部子类。

java
// 设置编译期白名单
QLExpressRunStrategy.setCompileWhiteCheckerList(Arrays.asList(
    // 精确设置
    CheckerFactory.must(Date.class),
    // 子类设置
    CheckerFactory.assignable(List.class)
));
ExpressRunner expressRunner = new ExpressRunner();
// Date 在编译期白名单中, 可以显示引用
expressRunner.execute("new Date()", new DefaultContext<>(), null,
                      false, true);
// LinkedList 是 List 的子类, 符合白名单要求
expressRunner.execute("LinkedList ll = new LinkedList; ll.add(1); ll.add(2); ll",
                      new DefaultContext<>(), null, false, true);
try {
    // String 不在白名单中, 不可以显示引用
    // 但是隐式引用, a = 'mmm', 或者定义字符串常量 'mmm' 都是可以的
    expressRunner.execute("String a = 'mmm'", new DefaultContext<>(), null,
                          false, true);
} catch (Exception e) {
    assertTrue(e.getCause() instanceof QLSecurityRiskException);
}

// Math 不在白名单中
// 对于不满足编译期类型白名单的脚本无需运行, 即可通过 checkSyntax 检测出
assertFalse(expressRunner.checkSyntax("Math.abs(-1)"));

编译期白名单只能检测出脚本编译时能够确认的类型，任何运行时出现的类型都是无法检测的，诸如各种反射Class.forName, ClassLoader.loadClass，或者没有声明类型的变量等等，因为编译期白名单只能增加黑客的作案成本，是容易被绕过。因此建议编译期白名单只用来帮助脚本校验，如果需要接收终端用户输入，运行期白名单是务必要配置的。

5.4.4.2.2 运行期白名单

如果有白名单设置，所有的黑名单设置就都会无效，以白名单为准。默认没有白名单设置。

java
// 必须将该选项设置为 true
QLExpressRunStrategy.setForbidInvokeSecurityRiskMethods(true);
// 有白名单设置时, 则黑名单失效
QLExpressRunStrategy.addSecureMethod(RiskBean.class, "secureMethod");
// 白名单中的方法, 允许正常调用
expressRunner.execute("import com.ql.util.express.example.RiskBean;" +
                      "RiskBean.secureMethod()", context, null, true, false);
try {
    // java.lang.String.length 不在白名单中, 不允许调用
    expressRunner.execute("'abcd'.length()", context,
                          null, true, false);
    fail("没有捕获到不安全的方法");
} catch (Exception e) {
    assertTrue(e.getCause() instanceof QLSecurityRiskException);
}

// setSecureMethods 设置方式
Set<String> secureMethods = new HashSet<>();
secureMethods.add("java.lang.String.length");
secureMethods.add("java.lang.Integer.valueOf");
QLExpressRunStrategy.setSecureMethods(secureMethods);
// 白名单中的方法, 允许正常调用
Object res = expressRunner.execute("Integer.valueOf('abcd'.length())", context,
                                   null, true, false);
assertEquals(4, res);
try {
    // java.lang.Long.valueOf 不在白名单中, 不允许调用
    expressRunner.execute("Long.valueOf('abcd'.length())", context,
                          null, true, false);
    fail("没有捕获到不安全的方法");
} catch (Exception e) {
    assertTrue(e.getCause() instanceof QLSecurityRiskException);
}

白名单有两种设置方式：

添加：QLExpressRunStrategy.addSecureMethod
置换：QLExpressRunStrategy.setSecureMethods

在应用中使用的时，推荐将白名单配置在诸如etcd,configServer等配置服务中，根据需求随时调整。

5.4.4.3 沙箱模式

如果你厌烦上述复杂的配置，只是想完全关闭QLExpress和Java应用的自由交互，那么推荐使用沙箱模式。

在沙箱模式中，脚本不可以：

import Java类
显式引用Java类，比如String a = 'mmm'
取Java类中的字段：a = new Integer(11); a.value
调用Java类中的方法：Math.abs(12)

脚本可以：

使用QLExpress的自定义操作符/宏/函数，以此实现与应用的受控交互
使用.操作符获取Map的key对应的value，比如a在应用传入的表达式中是一个Map，那么可以通过a.b获取
所有不涉及应用Java类的操作

java
// 开启沙箱模式
QLExpressRunStrategy.setSandBoxMode(true);
ExpressRunner expressRunner = new ExpressRunner();
// 沙箱模式下不支持 import 语句
assertFalse(expressRunner.checkSyntax("import com.ql.util.express.example.RiskBean;"));
// 沙箱模式下不支持显式的类型引用
assertFalse(expressRunner.checkSyntax("String a = 'abc'"));
assertTrue(expressRunner.checkSyntax("a = 'abc'"));
// 无法用 . 获取 Java 类属性或者 Java 类方法
try {
    expressRunner.execute("'abc'.length()", new DefaultContext<>(),
                          null, false, true);
    fail();
} catch (QLException e) {
    // 没有找到方法:length
}
try {
    DefaultContext<String, Object> context = new DefaultContext<>();
    context.put("test", new CustBean(12));
    expressRunner.execute("test.id", context,
                          null, false, true);
    fail();
} catch (RuntimeException e) {
    // 无法获取属性:id
}

// 沙箱模式下可以使用 自定义操作符/宏/函数 和应用进行交互
expressRunner.addFunction("add", new Operator() {
    @Override
    public Object executeInner(Object[] list) throws Exception {
        return (Integer) list[0] + (Integer) list[1];
    }
});
assertEquals(3, expressRunner.execute("add(1,2)", new DefaultContext<>(),
                                      null, false, true));
// 可以用 . 获取 map 的属性
DefaultContext<String, Object> context = new DefaultContext<>();
HashMap<Object, Object> testMap = new HashMap<>();
testMap.put("a", "t");
context.put("test", testMap);
assertEquals("t", expressRunner.execute("test.a", context,
                                        null, false, true));

在沙箱模式下，为了进一步保障内存的安全，建议同时限制脚本能够申请的最大数组长度以及超时时间，设置方法如下：

java
// 限制最大申请数组长度为10, 默认没有限制
QLExpressRunStrategy.setMaxArrLength(10);
ExpressRunner runner = new ExpressRunner();
String code = "byte[] a = new byte[11];";
try {
    // 20ms 超时时间
    runner.execute(code, new DefaultContext<>(), null, false, false, 20);
    Assert.fail();
} catch (QLException e) {
}

QLExpressRunStrategy.setMaxArrLength(-1);
// 20ms 超时时间
runner.execute(code, new DefaultContext<>(), null, false, false, 20);

第六部分引用

QLExpress

目录

第一部分 概述

第二部分 Java脚本引擎常用操作

2.1 获取可用脚本引擎

2.2 初始化脚本引擎

2.3 运行脚本

2.4 参数传递

2.4.1 Java向脚本传递参数

2.4.3 脚本向Java传递参数

2.5 执行函数

2.6 脚本编译

2.7 实现接口

第三部分 常用引擎说明

3.1 JavaScript引擎

3.1.1 Rhino

3.1.2 Nashorn

3.1.3 Rhino与Nashorn对比

3.1.3 脚本中使用原生Java类

3.1.3.1 使用包全局对象

3.1.3.2 使用Java全局对象

3.1.4 自定义类加载器

3.2 Groovy引擎

3.3 Python引擎

3.4 Ruby引擎

3.5 Lua引擎

第四部分 Java动态编译

4.1 JavaCompiler

4.2 Janino

4.2.1 SimpleCompiler

4.2.2 ExpressionEvaluator

4.2.3 ScriptEvaluator

4.3 Apache Commons JCI (Java Compiler Interface)

4.3 Apache Commons JCI和Janino对比

4.3.1 Apache Commons JCI

4.3.2 Janino

4.3.3 对比

第五部分 QLExpress

5.1 背景介绍

5.2 依赖和调用说明

5.3 语法介绍

5.3.1 操作符和java对象操作

5.3.1.1 普通java语法

5.3.1.2 java的对象操作

5.3.2 脚本中定义function

5.3.3 扩展操作符：Operator

5.3.3.1 替换 if then else 等关键字

5.3.3.2 如何自定义Operator

5.3.3.3 如何使用Operator

5.3.4 绑定java类或者对象的method

5.3.5 macro 宏定义

5.3.6 编译脚本，查询外部需要定义的变量和函数

5.3.7 关于不定参数的使用

5.3.8 关于集合的快捷写法

5.3.9 集合的遍历

5.4 运行参数和API列表介绍

5.4.1 属性开关

5.4.1.1 isPrecise

5.4.1.2 isShortCircuit

5.4.1.3 isTrace

5.4.2 调用入参

5.4.3 功能扩展API列表

5.4.3.1 function相关API

5.4.3.2 Operator相关API

5.4.3.3 宏定义相关API

5.4.3.4 java class的相关api

5.4.3.5 语法树解析变量、函数的API

5.4.3.6 语法解析校验api

5.4.3.7 指令集缓存相关的api

5.4.3.8 安全风险控制

5.4.3.8.1 防止死循环

5.4.3.8.2 防止调用不安全的系统api

5.4.3.9 增强上下文参数Context相关的api

5.4.3.9.1 与spring框架的无缝集成

5.4.3.9.2 自定义函数操作符获取原始的context控制上下文

5.4.4 多级别安全控制

5.4.4.1 黑名单控制

5.4.4.2 白名单控制

5.4.4.2.1 编译期白名单

5.4.4.2.2 运行期白名单

5.4.4.3 沙箱模式

第一部分概述

第三部分常用引擎说明

3.1.3 脚本中使用原生`Java`类

第六部分引用