Java集成Rhino引擎执行JS的基础教程与示例

作者:百宝袋

时间:2026-11-19

浏览:540

本文详细讲解在Java工程中集成Mozilla Rhino引擎执行JavaScript脚本的完整流程。内容涵盖Maven依赖配置、核心Context与Scriptable生命周期、Java与JS双向传参与函数调用示例、脚本预编译性能优化以及基于ClassShutter的安全沙箱实战。

文章目录
Java集成Rhino引擎执行JS的基础教程与示例
图 0:Java 集成 Rhino 架构定位与执行桥接全貌
Java 应用程序在很多业务场景下都需要动态执行逻辑,例如动态计费规则、风控校验公式以及多租户定制脚本。Mozilla Rhino 是一套纯 Java 编写的开源 JavaScript 引擎,能够以轻量 Jar 包形式直接嵌入任意 Java 或 Android 运行时。本文将以清晰的模块化步骤,完整讲解在 Java 项目中集成 Rhino 引擎的核心技术,包括环境依赖、生命周期管理、双向数据交互、脚本预编译以及基于 ClassShutter 的安全沙箱隔离。

一、为什么选择 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 实例后,可以反复、并发地在不同作用域中执行。
Java集成Rhino引擎执行JS的基础教程与示例
图 1:Rhino 核心架构与关键组件协作关系

三、快速上手:执行基础 JS 表达式与生命周期规范

使用 Rhino 执行脚本必须遵守严格的生命周期模式:调用 Context.enter() 进入上下文,在 finally 块中必须调用 Context.exit() 释放资源。因为 Context 内部使用 ThreadLocal 维护线程调用栈,若未在 finally 中退出,在线程池环境下极易造成上下文泄漏或状态串扰。

Java集成Rhino引擎执行JS的基础教程与示例
图 2:Rhino 脚本执行标准生命周期与状态流转

下面是一个执行数学计算与基础字符串操作的完整 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 端封装的持久化或远程服务。

Java集成Rhino引擎执行JS的基础教程与示例
图 3:Java 与 JavaScript 双向数据交互与上下文桥接

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 全限定类名时进行拦截,只放行预先设定的安全白名单。

Java集成Rhino引擎执行JS的基础教程与示例
图 4:Rhino ClassShutter 安全沙箱防护与调用拦截机制

安全沙箱配置示例代码:

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集成Rhino引擎执行JS的基础教程与示例
图 5:Java 集成 Rhino 核心要点与性能调优矩阵

通过遵循上述生命周期规范、作用域原型分层与安全门禁策略,开发者可以在保持 Java 项目轻量化部署的同时,安全、高效地引入强大的 JavaScript 动态逻辑执行能力。

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印,自由调节做旧程度。

使用 ›
图片压缩

选择画质和输出格式,预览压缩前后的大小。

使用 ›
相关文章