本文详细讲解在Java工程中集成Mozilla Rhino引擎执行JavaScript脚本的完整流程。内容涵盖Maven依赖配置、核心Context与Scriptable生命周期、Java与JS双向传参与函数调用示例、脚本预编译性能优化以及基于ClassShutter的安全沙箱实战。
Java集成Rhino引擎执行JS的基础教程与示例
时间:2026-11-19
浏览:540
文章目录
一、为什么选择 Rhino 与依赖引入
在 JDK 8 时代,Java 曾内置了 Nashorn 引擎,但 Nashorn 在 JDK 11 中被标记为废弃,并在 JDK 15 中被彻底移除。虽然 GraalVM JavaScript 性能极佳,但引入 GraalVM 通常需要庞大的运行时依赖或替换专用 JDK,对于希望保持标准 OpenJDK 依赖轻量性的工程而言门槛较高。Rhino 拥有超过二十年的演进历史,由纯 Java 编写,零本地动态链接库依赖,且在新版本(Rhino 1.7.14 及以上)中提供了良好的现代 ECMAScript(ES6+)语法支持,是构建内部规则引擎、数据处理转换管道的理想选择。
1. Maven 依赖配置
在 Maven 项目的 pom.xml 中直接加入官方依赖坐标。建议使用 1.7.14 或 1.7.15 稳定版本:
<!-- Mozilla Rhino JavaScript Engine -->
<dependency>
<groupId>org.mozilla</groupId>
<artifactId>rhino</artifactId>
<version>1.7.15</version>
</dependency>
2. Gradle 依赖配置
如果使用 Gradle 构建工具,在 build.gradle 中声明:
implementation 'org.mozilla:rhino:1.7.15'
二、核心概念与执行架构
要熟练运用 Rhino,必须准确理解其内部的两大核心对象:Context 与 Scriptable,它们分别代表了“运行时执行环境”与“全局变量存储空间”。
- Context(执行上下文):代表了当前执行线程的虚拟机状态。负责控制语言版本(如 ES6)、字节码编译优化级别、指令计数门限以及安全沙箱过滤器。
Context严格绑定到单个线程,不能跨线程并发访问。 - Scriptable(作用域对象):保存 JavaScript 的全局变量、函数定义以及内置对象(如
Object、Math、Array、JSON)。通常通过context.initStandardObjects()来创建。 - Script(已编译脚本):脚本源码编译后的可执行对象。通过预编译生成
Script实例后,可以反复、并发地在不同作用域中执行。
三、快速上手:执行基础 JS 表达式与生命周期规范
使用 Rhino 执行脚本必须遵守严格的生命周期模式:调用 Context.enter() 进入上下文,在 finally 块中必须调用 Context.exit() 释放资源。因为 Context 内部使用 ThreadLocal 维护线程调用栈,若未在 finally 中退出,在线程池环境下极易造成上下文泄漏或状态串扰。
下面是一个执行数学计算与基础字符串操作的完整 Java 代码示例:
import org.mozilla.javascript.Context;
import org.mozilla.javascript.Scriptable;
public class BasicRhinoDemo {
public static void main(String[] args) {
// 1. 进入 Rhino 执行上下文,绑定当前线程
Context cx = Context.enter();
try {
// 2. 设置语言版本为 ES6,确保兼容 let, const, 箭头函数等
cx.setLanguageVersion(Context.VERSION_ES6);
// 3. 初始化全局作用域与内置对象 (Math, Array, Object 等)
Scriptable scope = cx.initStandardObjects();
// 4. 定义需要执行的 JavaScript 代码
String script = "const a = 12.5; const b = 3.5; Math.sqrt(a * b) + 10;";
// 5. 执行求值
Object result = cx.evaluateString(scope, script, "calc.js", 1, null);
// 6. 将 JavaScript 返回值映射为 Java 强类型
Double doubleResult = (Double) Context.jsToJava(result, Double.class);
System.out.println("脚本计算结果: " + doubleResult);
} finally {
// 7. 必须在 finally 中退出上下文
Context.exit();
}
}
}
JavaScript 中的数字在 Rhino 内部默认均表示为 Double 类型。如果在 Java 端尝试直接将结果强制转换为 Integer 或 Long,会抛出 ClassCastException。标准做法是使用 Context.jsToJava(result, Double.class) 或先获取 Number 再调用 intValue()。
四、Java 与 JavaScript 的双向数据交互
在实际业务中,脚本往往不是自给自足的代码片段,而是需要从 Java 读取业务上下文(如当前下单用户、订单总额),并在计算完成后将结果返回给 Java,甚至直接调用 Java 端封装的持久化或远程服务。
1. 将 Java 对象注入 JavaScript 作用域
通过 ScriptableObject.put() 方法,可以将 Java 原生对象或自定义实体放入 JavaScript 的顶级作用域。Rhino 会自动通过 NativeJavaObject 包装器,让 JavaScript 可以像访问原生 JS 属性一样访问 Java 对象的公共字段与 Getter/Setter 方法。
2. 从 Java 中调用 JavaScript 定义的函数
可以在脚本中定义函数,然后在 Java 端通过 scope.get("functionName", scope) 获取到 org.mozilla.javascript.Function 引用,传入参数数组并执行。以下是完整的交互演示:
import org.mozilla.javascript.Context;
import org.mozilla.javascript.Function;
import org.mozilla.javascript.Scriptable;
import org.mozilla.javascript.ScriptableObject;
public class BiDirectionalDemo {
// 宿主 Java 业务实体类
public static class OrderDTO {
private String orderId;
private double amount;
private boolean isVip;
public OrderDTO(String orderId, double amount, boolean isVip) {
this.orderId = orderId;
this.amount = amount;
this.isVip = isVip;
}
// 标准 Getter 方法,可在 JS 中以 order.amount 或 order.isVip() 访问
public String getOrderId() { return orderId; }
public double getAmount() { return amount; }
public boolean isVip() { return isVip; }
}
public static void main(String[] args) {
Context cx = Context.enter();
try {
cx.setLanguageVersion(Context.VERSION_ES6);
Scriptable scope = cx.initStandardObjects();
// 1. 构造 Java 业务对象
OrderDTO order = new OrderDTO("ORD-20261118-001", 1200.0, true);
// 2. 将 Java 对象注入 JS 作用域,变量名为 "order"
Object wrappedOrder = Context.javaToJS(order, scope);
ScriptableObject.putProperty(scope, "order", wrappedOrder);
// 3. 执行脚本:在脚本中直接读取 Java 对象属性与方法
String script =
"function calculateDiscount(targetOrder) {\n" +
" let discountRate = 1.0;\n" +
" if (targetOrder.isVip()) {\n" +
" discountRate = targetOrder.amount > 1000 ? 0.85 : 0.90;\n" +
" }\n" +
" return targetOrder.amount * (1.0 - discountRate);\n" +
"}\n" +
"calculateDiscount(order);";
Object evalResult = cx.evaluateString(scope, script, "discount_rule.js", 1, null);
Double directDiscount = (Double) Context.jsToJava(evalResult, Double.class);
System.out.println("脚本直接计算出的优惠金额: " + directDiscount);
// 4. 演示单独调用 JS 函数 calculateDiscount
Object funcObj = scope.get("calculateDiscount", scope);
if (funcObj instanceof Function) {
Function discountFunc = (Function) funcObj;
// 构造入参并调度
Object[] functionArgs = new Object[] { wrappedOrder };
Object funcResult = discountFunc.call(cx, scope, scope, functionArgs);
System.out.println("通过 Function.call 调用优惠金额: " + funcResult);
}
} finally {
Context.exit();
}
}
}
五、脚本预编译与高并发场景下的性能优化
在生产系统(例如风控判定或动态路由)中,一条规则脚本可能会在每秒内被调用成千上万次。如果每次都调用 cx.evaluateString(),Rhino 将在每次请求时重新执行词法解析、语法分析和生成抽象语法树,吞吐量将受到严重制约。
1. 使用 compileString 预编译脚本
Rhino 提供了 Context.compileString() 方法,可以将 JavaScript 字符串编译为内存中的 org.mozilla.javascript.Script 实例。Script 是线程安全的不可变对象,只需在应用启动或规则发布时编译一次,即可在后续请求中并发复用。
// 启动期预编译并全局缓存
Script compiledScript = cx.compileString(scriptText, "rule_cache.js", 1, null);
// 运行时高并发复用:直接传入各请求专属的 scope 执行
Object result = compiledScript.exec(cx, requestScope);
2. 作用域共享与原型链隔离设计
调用 cx.initStandardObjects() 初始化包含全部 JavaScript 标准库的作用域耗时较长(约数毫秒且分配大量对象)。高并发服务应当采用单例共享顶级作用域(Shared Scope)+ 动态派生局部作用域(Dynamic Request Scope)的设计模式:
// 系统全局单例:共享标准对象库,设置为只读密封
Scriptable sharedScope = cx.initStandardObjects(null, true);
// 每次请求到达时:仅创建轻量子对象,并将 sharedScope 设为原型
Scriptable requestScope = cx.newObject(sharedScope);
requestScope.setPrototype(sharedScope);
requestScope.setParentScope(null);
// 仅向局部 requestScope 中注入当前请求独享的数据,完全隔离
ScriptableObject.putProperty(requestScope, "currentRequest", reqData);
compiledScript.exec(cx, requestScope);
六、安全沙箱:防范恶意代码与 ClassShutter 实战
Rhino 默认具备强大的反射桥接能力,脚本中可以通过诸如 Packages.java.lang.System.exit(0) 或 java.lang.Runtime.getRuntime().exec("rm -rf ...") 直接访问宿主 Java 运行时的系统底层 API。如果允许外部用户或未经严格审查的脚本直接运行,会带来灾难性的远程代码执行风险。
为了解决该隐患,Rhino 提供了 org.mozilla.javascript.ClassShutter 接口。通过实现该接口,可以在脚本尝试加载或访问任何 Java 全限定类名时进行拦截,只放行预先设定的安全白名单。
安全沙箱配置示例代码:
import org.mozilla.javascript.ClassShutter;
import org.mozilla.javascript.Context;
import org.mozilla.javascript.EcmaError;
import org.mozilla.javascript.Scriptable;
public class SecuritySandboxDemo {
public static void main(String[] args) {
Context cx = Context.enter();
try {
// 设定严格的白名单门禁
cx.setClassShutter(new ClassShutter() {
@Override
public boolean visibleToScripts(String fullClassName) {
// 仅允许基础计算、安全工具集合以及指定业务 DTO
if (fullClassName.startsWith("java.lang.Math") ||
fullClassName.startsWith("java.lang.Double") ||
fullClassName.startsWith("java.util.ArrayList") ||
fullClassName.startsWith("com.mycompany.dto.")) {
return true;
}
// 严厉拦截 System, Runtime, Reflect, IO, Net 等高危底层包
return false;
}
});
Scriptable scope = cx.initStandardObjects();
// 尝试执行恶意系统命令
String maliciousScript = "java.lang.System.exit(1);";
try {
cx.evaluateString(scope, maliciousScript, "attack.js", 1, null);
} catch (EcmaError e) {
System.out.println("沙箱成功拦截非法调用: " + e.getMessage());
}
} finally {
Context.exit();
}
}
}
七、核心要点与最佳实践总结
将 Rhino 成功应用于工业级生产项目,需要在性能、并发、安全与易用性之间取得平衡。下表整理了集成开发中最常见的核心问题与对应解决方案:
| 维度 | 常见问题 / 隐患 | 推荐最佳实践 |
|---|---|---|
| 线程并发 | 将 Context 实例缓存在类字段中跨线程共享,导致调用栈混乱 | Context 严格实行 Context.enter() 线程独占,并在 finally 块中退出 |
| 内存占用 | 高频调用 initStandardObjects() 造成大量 GC 压力 |
启动时初始化一个密封的 sharedScope,各线程仅创建轻量原型子作用域 |
| CPU 吞吐 | 反复使用字符串求值,重复进行词法与 AST 解析 | 采用 cx.compileString() 生成不可变的 Script 预编译对象并持久化复用 |
| 系统安全 | 恶意脚本通过 Packages 反射调用底层停机或文件读写 | 实现 ClassShutter 采用白名单放行策略,并结合指令计数器防范无限循环 |
通过遵循上述生命周期规范、作用域原型分层与安全门禁策略,开发者可以在保持 Java 项目轻量化部署的同时,安全、高效地引入强大的 JavaScript 动态逻辑执行能力。
实用工具推荐
绿化、压缩、噪点和虚拟水印,自由调节做旧程度。
选择画质和输出格式,预览压缩前后的大小。