Java调用JavaScript代码的三种主流方案对比

作者:栖木时间:2026-11-18 14:21:10浏览:258

深入对比Java执行JavaScript代码的三种主流方案:Nashorn、GraalVM JavaScript与Mozilla Rhino。全面剖析运行架构、代码示例、性能表现、ES规范兼容性及生产选型决策。

Java调用JavaScript代码的三种主流方案对比
图 0:Java 执行 JavaScript 三大主流运行方案概览
在 Java 应用程序中动态执行 JavaScript 代码,是实现业务规则动态求值、流程引擎条件分支计算、前端模板渲染以及轻量插件扩展的常用手段。当前 Java 生态中主要存在三种主流方案:基于 JSR-223 标准规范的 Nashorn、新一代高性能多语言运行时的 GraalVM JavaScript,以及纯 Java 实现的轻量级嵌入引擎 Mozilla Rhino。本文针对这三种方案的运行时架构、调用代码、性能开销、ES 规范兼容性及生产落地时的安全与线程模型进行横向对比,帮助读者根据具体业务场景完成技术选型。

一、三大方案的技术定位与底层架构

Java 与 JavaScript 之间的互操作需求由来已久。随着 JDK 版本的更迭与前端 ECMAScript 规范的演进,处理该需求的工具链经历了明显的演进分化:

  • Nashorn:作为 Oracle 在 JDK 8 中推出的内置引擎,替代了更早的 Rhino,依托 JVM 内部的 invokedynamic 特性将 JavaScript 编译为 JVM 字节码执行。虽然 Nashorn 在 JDK 11 标记废弃并在 JDK 15 正式从核心库移除,但其作为独立开源依赖包(OpenJDK Nashorn)仍在许多基于 JSR-223 接口的存量系统中稳定运行。
  • GraalVM JavaScript:Oracle Labs 基于 Truffle 语言实现框架构建的高性能多语言引擎。它不仅支持完整的 ECMAScript 2022+ 现代语法规范,还能在 Graal JIT 编译器的深度优化下达到接近原生运行的峰值性能,是目前现代 Java 应用对接 JavaScript 的旗舰级方案。
  • Mozilla Rhino:由 Mozilla 基金会主导并长期维护的纯 Java 脚本引擎。它不需要任何 C++ 原生动态链接库(JNI),仅凭单一 Jar 包即可运行在各类标准 JVM 以及 Android 运行时中,在轻量分发、跨环境无侵入部署场景中一直保持着旺盛的生命力。
Java调用JavaScript代码的三种主流方案对比
图 1:Nashorn、GraalVM JS 与 Rhino 的分层架构与底层执行管道对比

从架构分层来看,Nashorn 和 Rhino 都直接运行于标准 JVM 之上,执行机制是将 JS 语法树转换为 JVM 字节码或解释执行;而 GraalVM JavaScript 则构建在 Truffle 抽象语法树优化层之上,不仅具备出色的多语言互操作(Polyglot)能力,还拥有深度的运行时去虚化与内联优化管道。

二、方案一:Nashorn 引擎(JSR-223 标准与独立依赖)

Nashorn 的最大特征是天然遵循 Java 脚本标准规范(JSR-223)。在 JDK 8 到 JDK 14 中无需引入任何外部依赖即可直接通过 javax.script API 使用。在 JDK 15 及以上版本中,只需在项目中引入 OpenJDK 独立维护的依赖即可无缝继续使用。

1. 依赖配置

如果使用的是 JDK 15+,需在 Maven 项目的 pom.xml 中加入如下依赖:

<!-- JDK 15+ 引入独立 Nashorn 依赖 -->
<dependency>
    <groupId>org.openjdk.nashorn</groupId>
    <artifactId>nashorn-core</artifactId>
    <version>15.4</version>
</dependency>

2. 核心调用示例

Nashorn 通过标准 ScriptEngineManager 获取实例,并可通过 Bindings 与 Java 对象双向传递数据,使用 Invocable 接口直接调用 JS 中定义的函数:

import javax.script.Bindings;
import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

public class NashornExample {
    public static void main(String[] args) throws Exception {
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("nashorn");

        // 1. 注入上下文变量
        Bindings bindings = engine.createBindings();
        bindings.put("factor", 1.25);
        bindings.put("username", "Antigravity");

        // 2. 执行 JavaScript 脚本定义与简单表达式求值
        String script = 
            "function calculateBonus(baseSalary) { " +
            "    return baseSalary * factor; " +
            "} " +
            "var greeting = 'Hello, ' + username;";
        
        engine.eval(script, bindings);

        // 3. 读取 JS 执行后的全局变量
        Object greeting = bindings.get("greeting");
        System.out.println("Greeting: " + greeting); // 输出: Hello, Antigravity

        // 4. 调用 JS 命名函数
        Invocable invocable = (Invocable) engine;
        Object bonus = invocable.invokeFunction("calculateBonus", 8000);
        System.out.println("Bonus: " + bonus); // 输出: 10000.0
    }
}
特点总结:使用标准 JSR-223 接口,与 Java 生态集成平滑,冷启动非常轻量。但需注意,Nashorn 官方仅完整支持 ECMAScript 5.1 标准,即使在开启 --language=es6 标志后也仅涵盖部分 ES6 语法,无法使用 async/await、解构赋值或完整的 Promise 链。

三、方案二:GraalVM JavaScript(现代标准与高性能 Polyglot)

如果业务场景需要解析前端团队提交的现代 JavaScript 模块、处理 Promise 异步逻辑,或者规则运算量极大对执行耗时有硬性指标,GraalVM JavaScript 是目前最完备的方案。

1. 依赖配置

在任意标准 JDK 11+(无需安装整套 GraalVM JDK)项目中,引入以下依赖即可运行:

<!-- GraalVM Polyglot 核心与 JavaScript 引擎 -->
<dependency>
    <groupId>org.graalvm.polyglot</groupId>
    <artifactId>polyglot</artifactId>
    <version>24.1.1</version>
</dependency>
<dependency>
    <groupId>org.graalvm.polyglot</groupId>
    <artifactId>js</artifactId>
    <version>24.1.1</version>
    <type>pom</type>
</dependency>

2. 核心调用示例

GraalVM 不建议使用 JSR-223,而是通过原生的 org.graalvm.polyglot.Context 与 Value API 进行细粒度控制:

import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.HostAccess;
import org.graalvm.polyglot.Value;

public class GraalVmExample {
    // 供 JS 调用的 Java POJO
    public static class Order {
        public double amount;
        public int level;
        public Order(double amount, int level) {
            this.amount = amount;
            this.level = level;
        }
    }

    public static void main(String[] args) {
        // 构建安全的隔离 Context 上下文
        try (Context context = Context.newBuilder("js")
                .allowHostAccess(HostAccess.EXPLICIT) // 仅允许显式授权的 Java 交互
                .build()) {

            // 1. 注入 Java 对象到 JS 全局环境
            Order order = new Order(1500.0, 3);
            context.getBindings("js").putMember("currentOrder", order);

            // 2. 编写使用现代 ES6+ 语法(解构、箭头函数、模板字符串)的脚本
            String jsCode = 
                "const calcDiscount = ({ amount, level }) => { " +
                "    const rate = level >= 3 ? 0.85 : 0.95; " +
                "    return { payAmount: amount * rate, rate }; " +
                "}; " +
                "calcDiscount(currentOrder);";

            // 3. 执行并获取 Polyglot Value 结果
            Value result = context.eval("js", jsCode);

            // 4. 解析结果对象
            double payAmount = result.getMember("payAmount").asDouble();
            double rate = result.getMember("rate").asDouble();
            System.out.println("应付金额: " + payAmount + ", 享受折扣: " + rate);
        }
    }
}
多线程限制提醒:GraalVM 的 Context 严格要求单线程访问。如果多个线程尝试同时调用同一个 Context.eval(),会直接抛出 IllegalStateException: Multi-threaded access requested by thread... but is not allowed for language(s) js。在 Web 高并发环境中,必须通过 ThreadLocal<Context> 或通用对象池(如 Commons Pool)来管理 Context。

四、方案三:Mozilla Rhino(纯 Java 实现的轻量稳定之选)

Mozilla Rhino 的核心优势在于“纯粹”。它的全部代码由标准 Java 编写,编译后仅是一个独立的轻量级 Jar 包,不涉及平台相关的 JNI C++ 动态库加载,极其适合对部署包大小、跨平台一致性(如 Alpine Linux 极简容器、嵌入式或 Android)有严苛要求的项目。

1. 依赖配置

<!-- Mozilla Rhino 纯 Java 依赖 -->
<dependency>
    <groupId>org.mozilla</groupId>
    <artifactId>rhino</artifactId>
    <version>1.7.15</version>
</dependency>

2. 核心调用示例

Rhino 使用 Context.enter() 进入上下文,并通过 Scriptable 作用域对象管理运行环境:

import org.mozilla.javascript.Context;
import org.mozilla.javascript.Function;
import org.mozilla.javascript.Scriptable;
import org.mozilla.javascript.ScriptableObject;

public class RhinoExample {
    public static void main(String[] args) {
        // 1. 进入 Rhino 线程上下文
        Context cx = Context.enter();
        try {
            // 设置语言版本(例如 ES6 标准级别)
            cx.setLanguageVersion(Context.VERSION_ES6);

            // 2. 初始化标准顶级作用域
            Scriptable scope = cx.initStandardObjects();

            // 3. 向 JS 作用域注入 Java 对象
            Object wrappedOut = Context.javaToJS(System.out, scope);
            ScriptableObject.putProperty(scope, "out", wrappedOut);

            // 4. 定义 JS 逻辑并执行
            String script = 
                "function validateScore(score) { " +
                "    return score >= 60 ? 'PASS' : 'FAIL'; " +
                "} " +
                "var status = validateScore(85);";

            cx.evaluateString(scope, script, "scriptSource.js", 1, null);

            // 5. 获取执行结果
            Object status = ScriptableObject.getProperty(scope, "status");
            System.out.println("Result: " + Context.toString(status)); // 输出: PASS

            // 6. 单独调用命名函数
            Function validateFn = (Function) scope.get("validateScore", scope);
            Object[] functionArgs = { 45 };
            Object callResult = validateFn.call(cx, scope, scope, functionArgs);
            System.out.println("Call Result: " + Context.toString(callResult)); // 输出: FAIL
        } finally {
            // 7. 退出上下文,清理当前线程关联资源
            Context.exit();
        }
    }
}
Java调用JavaScript代码的三种主流方案对比
图 2:Java 调用 JavaScript 的通用执行步骤与生命周期管控

五、关键维度的横向深度对比

为了帮助开发团队根据性能指标与工程条件作出客观权衡,我们从五个核心维度对这三种方案进行横向归纳:

Java调用JavaScript代码的三种主流方案对比
图 3:三大方案关键技术维度评估矩阵
对比维度 Nashorn (JSR-223) GraalVM JavaScript Mozilla Rhino
语法规范支持 ECMAScript 5.1 完整支持,极少数基础 ES6 特性,无法执行现代前端打包代码。 ECMAScript 2022+ 完整特性支持,涵盖模块、Promise、async/await 等。 ECMAScript 6 基础常用特性,较新规范支持相对滞后。
峰值计算性能 中等。依托 JVM invokedynamic 与 ASM 编译为字节码。 极高。依托 Truffle AST 框架与 Graal JIT 深度优化,接近原生速度。 偏低。以解释执行和简易字节码编译为主,适合轻度逻辑。
冷启动与内存开销 极低。JDK8 内置零依赖,初始化仅数毫秒,内存占用极小。 偏重。依赖 Jar 包总体积约 80MB+,首次创建 Context 耗时约 200~400ms。 极低。单 Jar 仅约 4.5MB,秒级初始化,内存消耗极低。
多线程并发模型 单 ScriptEngine 实例线程安全,但多线程执行必须各自绑定独立的 Bindings。 严格单线程绑定。单个 Context 绝不允许并发,需通过 ThreadLocal 或对象池管理。 Context 与当前线程绑定,必须成对调用 enter() 与 exit()。
安全沙箱与类隔离 依赖传统的 ClassFilter 与 SecurityManager(高版本已被废弃)。 完备细粒度沙箱。内置 CPU 耗时上限、内存配额、主机类访问严格白名单。 通过实现 ClassShutter 接口过滤允许加载的 Java 类路径。

六、工程落地与选型决策指南

在实际项目落地中,脱离具体约束谈性能或先进性往往不够实用。选择哪种方案应根据系统现状、语法需求及部署限制做条件匹配:

Java调用JavaScript代码的三种主流方案对比
图 4:Java 调用 JavaScript 的业务选型决策路径推导

1. 选型匹配场景

  1. 选择 GraalVM JavaScript 的典型场景: 业务中需要执行现代 JavaScript 语法(如解构、箭头函数、可选链等),需要运行前端研发交付的代码片段或 NPM 模块;或者属于计算密集型的高频规则求值系统,愿意为了极高的峰值性能承受稍大的依赖体积和冷启动预热。
  2. 选择 Nashorn 的典型场景: 项目仍运行在 JDK 8 到 JDK 11 环境,现有架构深度依赖 javax.script.* 标准接口,业务脚本只涉及四则运算、数值比较等 ES5 级别的基础逻辑,且团队希望避免引入任何第三方依赖。
  3. 选择 Mozilla Rhino 的典型场景: 需要升级到高版本 JDK(17/21)但不想引入庞大的 GraalVM 全家桶;应用部署在资源受限的环境(如基础容器、嵌入式设备或 Android 系统),追求单个 Jar 包几兆级别的极简分发,同时需要清晰易控的 ClassShutter 沙箱隔离机制。

七、生产环境避坑与最佳实践

1. 脚本预编译与缓存复用

在任何高并发生产环境中,严禁每次请求都重复编译同一段 JS 脚本源码。脚本语法解析(Parse)与 AST 构造是主要的 CPU 消耗点:

  • 在 Nashorn 中,将 ScriptEngine 强转为 Compilable,调用 compile() 获取 CompiledScript 实例缓存复用。
  • 在 GraalVM 中,通过 Source.newBuilder("js", script, "name").cached(true).build() 构建可被所有 Context 共享的安全缓存对象。
  • 在 Rhino 中,调用 cx.compileString() 编译为 Script 字节码对象,随后直接对 Script.exec(cx, scope) 多次调用。

2. 严防类加载器与 Context 内存泄漏

动态执行脚本时,部分引擎会为每次执行动态生成匿名类或分配本地内存。在 GraalVM 中,务必使用 try (Context context = ...) 语法块确保上下文退出时显式关闭,释放非堆内存;在 Rhino 中,务必在 finally 块中执行 Context.exit(),防止 ThreadLocal 变量在线程池线程复用时持续残留堆积。

3. 防范用户脚本恶意执行与死循环

如果运行的 JavaScript 代码来源于外部用户输入,必须在调用前开启防御机制:

  • 禁止反射调用敏感类:禁止 JS 代码中访问 java.lang.System.exit()、java.lang.Runtime 或网络套接字。GraalVM 中使用 HostAccess.EXPLICIT,Rhino 中实现 ClassShutter。
  • 增加超时与看门狗机制:在宿主端通过 Future.get(timeout, TimeUnit.MILLISECONDS) 设置调用超时门限,超时后主动取消任务并关闭对应 Context,防止恶意脚本包含 while(true) 拖垮线程池。
作者最新文章
相关文章
更多