JDK 17移除Nashorn后,Java怎么执行JS脚本?

作者:夜航船时间:2026-11-17 11:59:41浏览:154

说明JDK 17移除Nashorn引擎后Java执行JavaScript脚本的三种主流替代方案:独立版nashorn-core、GraalJS与Mozilla Rhino,并提供选型依据、完整Maven配置、Java代码示例与安全注意事项。

JDK 17移除Nashorn后,Java怎么执行JS脚本?
图 1:JDK 17 移除内置 Nashorn 后,Java 通过外置依赖接入 JS 引擎的三条主流路径

JDK 17 已经不再内置任何 JavaScript 引擎,原来直接调用 ScriptEngineManager.getEngineByName("nashorn") 或 "javascript" 的代码会返回 null。要继续在 Java 中执行 JS 脚本,核心做法是在项目中通过 Maven 或 Gradle 引入外置引擎依赖:老项目求稳可选独立发布的 OpenJDK Nashorn(nashorn-core),新项目或需要现代 ES 语法建议选用 GraalJS,追求轻量纯 Java 规则计算则可以考虑 Mozilla Rhino。

一、为什么 JDK 17 跑不起来原来的 JS 代码?

从 JDK 8 开始,Oracle 和 OpenJDK 在标准库中内置了 Nashorn 引擎,开发者无需额外引入 Jar 包,就能通过 JSR 223 规范(javax.script 包)执行 JavaScript。但随着 ECMAScript 标准快速迭代,JDK 团队在 JDK 11(JEP 335)中将 Nashorn 标记为废弃,并在 JDK 15(JEP 372) 中连同 jjs 命令行工具一起正式移除。

JDK 17 作为长期支持版本(LTS),自然也不再包含 Nashorn。这并不意味着 javax.script.ScriptEngineManager 本身被删除了——标准接口依然保留在 java.scripting 模块中,只是 JDK 自身不再提供默认实现。如果类路径里没有注册第三方引擎,getEngineByName 就会返回 null,紧接着调用 engine.eval(...) 时便会抛出 NullPointerException。

JDK 17移除Nashorn后,Java怎么执行JS脚本?
图 2:JDK 8 到 JDK 17 中 Nashorn 的演进节点与 ScriptEngine 查找结果对比

二、三种主流替代方案怎么选?

目前在标准 OpenJDK 17(HotSpot JVM)上嵌入执行 JS 脚本,主要有三种成熟选择。它们的定位差异很明确,建议按代码改造成本、JS 语法版本和安全控制要求来决定,而不是盲目追新。

方案 ECMAScript 支持 接入成本 安全沙箱能力 最适合的场景
独立版 Nashorn
(nashorn-core)
ES5.1 为主,开启参数后支持部分 ES6 最低(保留 JSR 223 写法,几乎只需加依赖) 提供 ClassFilter 限制 Java 类访问 JDK 8/11 升级到 JDK 17 的老系统平滑迁移
GraalJS
(GraalVM JavaScript)
现代标准(ES2022+、模块化、Promise 等) 中等(推荐用 Polyglot API,也可兼容 JSR 223) 默认严格隔离,通过 HostAccess 精细放权 新项目、执行前端/现代 JS 规则、不可信脚本沙箱
Mozilla Rhino
(rhino)
ES5 为主,含部分 ES6 特性 中等(常用 Rhino 原生 Context API) 可通过 ClassShutter 控制可见类 轻量级公式计算、依赖体积敏感的纯 Java 工具
JDK 17移除Nashorn后,Java怎么执行JS脚本?
图 3:根据项目历史包袱、语法需求和生态依赖选择 JS 执行方案

三、操作流程与方案一:引入独立版 Nashorn(老项目低成本迁移)

无论采用哪种引擎,在 JDK 17 中恢复 JS 执行能力都遵循四个基本步骤:确定引擎、在构建文件中引入依赖、初始化引擎并收紧宿主机类访问权限,最后在调用结束后处理异常与上下文生命周期。

JDK 17移除Nashorn后,Java怎么执行JS脚本?
图 4:JDK 17 接入第三方 JS 引擎的四步标准流程

如果项目原本就是基于 JDK 8/11 的 Nashorn 编写的,最省事的办法并不是重写调用代码,而是引入 OpenJDK 团队独立拆出来的 nashorn-core。这个库已经发布到 Maven Central,要求运行在 JDK 11 及以上版本(完全兼容 JDK 17),并且继续通过 SPI 向 ScriptEngineManager 注册 "nashorn" 和 "javascript" 引擎名称。

1. 添加 Maven 依赖

在项目的 pom.xml 中加入以下依赖(版本号可按 Maven Central 上的最新稳定版调整,此处以 15.4 为例):

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

2. 在 JDK 17 中调用(保留 JSR 223 写法)

下面的完整示例演示了在 JDK 17 中加载 nashorn-core、定义 JS 函数,并通过 Invocable 接口传入参数计算折扣价(文件名 NashornDemo.java):

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

public class NashornDemo {
    public static void main(String[] args) throws ScriptException, NoSuchMethodException {
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("nashorn");
        if (engine == null) {
            throw new IllegalStateException("未找到 Nashorn 脚本引擎,请检查 nashorn-core 依赖");
        }

        engine.eval("function calcDiscount(price, rate) { return price * rate; }");
        Invocable invocable = (Invocable) engine;
        Object result = invocable.invokeFunction("calcDiscount", 200, 0.85);
        System.out.println("计算结果: " + result);
    }
}
示例输出
计算结果: 170.0

3. 如果老脚本里用到了部分 ES6 语法

Nashorn 默认以 ES5.1 模式解析脚本。如果脚本中包含 let、const 或箭头函数等部分 ES6 特性,可以通过 NashornScriptEngineFactory 显式传入 --language=es6 参数来初始化引擎:

import org.openjdk.nashorn.api.scripting.NashornScriptEngineFactory;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

public class NashornEs6Demo {
    public static void main(String[] args) throws ScriptException {
        NashornScriptEngineFactory factory = new NashornScriptEngineFactory();
        ScriptEngine engine = factory.getScriptEngine("--language=es6");
        engine.eval("const doubleVal = x => x * 2; print(doubleVal(21));");
    }
}
示例输出
42
注意模块化配置:如果你的项目启用了 Java 模块系统(包含 module-info.java),仅仅在 pom.xml 中加上依赖还不够,还需要在 module-info.java 中添加 requires org.openjdk.nashorn; 和 requires java.scripting;,否则运行时会找不到引擎。

四、方案二:使用 GraalJS(需要现代 ES 语法或安全沙箱)

如果脚本由现代前端或规则配置团队编写,里面用到 const、解构赋值、模板字符串、Array.prototype.includes 甚至 Promise,独立版 Nashorn 会频频报语法错误。这时应该选择 GraalJS。需要特别澄清一个常见误解:GraalJS 并不要求把整个服务器换成 GraalVM JDK,它在标准的 OpenJDK 17 / HotSpot JVM 上就能作为普通 Maven 依赖直接运行(只不过在 GraalVM JDK 上可额外启用 JIT 加速)。

1. 添加 Maven 依赖

GraalVM 23.1 及以上版本在 Maven 中采用了 Polyglot 聚合 POM 坐标。下面以 24.1.1 为例(具体版本可在 Maven Central 确认与你项目匹配的稳定版)。注意第二个依赖必须写明 <type>pom</type>,否则 Maven 默认按 jar 拉取会报错:

<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. 推荐写法:使用 Polyglot Context API

GraalJS 官方推荐直接用 org.graalvm.polyglot.Context 而不是 JSR 223,因为 Context 配合 try-with-resources 能自动释放资源,并且默认关闭宿主机文件 IO、网络和任意 Java 类访问,安全性更可控(文件名 GraalJsDemo.java):

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

public class GraalJsDemo {
    public static void main(String[] args) {
        try (Context context = Context.newBuilder("js")
                .allowHostAccess(HostAccess.EXPLICIT)
                .build()) {
            context.eval("js", "const calcDiscount = (price, rate) => price * rate;");
            Value fn = context.getBindings("js").getMember("calcDiscount");
            Value result = fn.execute(200, 0.85);
            System.out.println("计算结果: " + result.asDouble());
        }
    }
}
示例输出
计算结果: 170.0

3. 关于 JSR 223 兼容模式的两点提醒

如果实在需要沿用 ScriptEngineManager 接口,可以再引入 org.graalvm.js:js-scriptengine 依赖,并通过 getEngineByName("graal.js") 获取引擎。但要留意两点:第一,JSR 223 下默认禁用所有宿主 Java 对象访问,如果 JS 中要调用传入的 Java 对象方法,必须设置系统属性或在构建引擎时显式开启 allowHostAccess;第二,GraalJS 的依赖包体积(含 Truffle 运行时与 ICU 本地化数据)明显大于 Nashorn 和 Rhino,接入前需要确认应用对打包体积的预算。

五、方案三:使用 Mozilla Rhino(轻量级纯 Java 规则计算)

如果你的需求只是在后台执行一小段金额公式、字段校验或条件表达式,既不需要现代 ES6+ 语法,也不希望项目打包膨胀几十 MB,老牌的纯 Java 引擎 Mozilla Rhino 依然非常稳妥。它只有一个轻量的核心 Jar,不依赖复杂的底层运行时。

1. 添加 Maven 依赖

在 pom.xml 中引入 Rhino(以 1.7.15 为例):

<dependency>
    <groupId>org.mozilla</groupId>
    <artifactId>rhino</artifactId>
    <version>1.7.15</version>
</dependency>

2. 使用 Rhino 原生 Context 执行脚本

Rhino 最稳定的调用方式是使用其原生的 Context.enter() 与 Context.exit(),并务必把 Context.exit() 放进 finally 块中,确保每次线程绑定的上下文都能正常退出(文件名 RhinoDemo.java):

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

public class RhinoDemo {
    public static void main(String[] args) {
        Context cx = Context.enter();
        try {
            Scriptable scope = cx.initStandardObjects();
            cx.evaluateString(
                    scope,
                    "function calcDiscount(price, rate) { return price * rate; }",
                    "discount.js",
                    1,
                    null
            );

            Object fnObj = scope.get("calcDiscount", scope);
            if (fnObj instanceof Function) {
                Function fn = (Function) fnObj;
                Object result = fn.call(cx, scope, scope, new Object[]{200, 0.85});
                System.out.println("计算结果: " + Context.toNumber(result));
            }
        } finally {
            Context.exit();
        }
    }
}
示例输出
计算结果: 170.0

六、迁移和生产使用中容易踩的四个坑

  • 不要放任外部脚本访问任意 Java 类:如果脚本内容来自后台配置或用户输入,在 Nashorn 中默认可以通过 Java.type("java.lang.Runtime") 执行系统命令。生产环境务必通过 Nashorn 的 ClassFilter、Rhino 的 ClassShutter 或 GraalJS 的 HostAccess.EXPLICIT(仅放行带 @HostAccess.Export 注解的方法)做好白名单隔离。
  • 注意引擎与上下文的线程模型:ScriptEngine 在高并发下不要无限制每次请求都新建(编译和初始化开销较大),但同时要注意部分状态绑定(如全局 Bindings 变量)并非线程隔离;在 GraalJS 中,同一个 Context 不能被多个线程同时并发执行,高并发场景下应为每次任务创建独立的 Context,并配合共享同一个 org.graalvm.polyglot.Engine 来复用编译缓存。
  • 做好 getEngineByName 判空和降级提示:无论是切到 nashorn-core 还是 graal.js,获取引擎后第一时间判空并抛出清晰的依赖缺失异常,避免线上只看到一行难以定位的 NullPointerException。
  • 分清“嵌入引擎”和“Node.js 运行时”的边界:Nashorn、GraalJS(默认模式)和 Rhino 只提供 ECMAScript 语言引擎,不包含浏览器 DOM(如 window、document),也不直接等同于完整的 Node.js 生态(如大量依赖原生 C++ 插件的 npm 包)。如果业务逻辑重度依赖 Node.js 生态,正确的架构是把这段逻辑拆成独立的 Node.js 服务或通过 ProcessBuilder 调用外部脚本,而不是硬塞进 JVM 里执行。

七、总结与选型检查清单

JDK 17 移除 Nashorn 只是把 JS 引擎从标准库拆成了可自由选择的三方依赖。迁移或新接入时,可以对照下面这张速查图完成最终落地检查。

JDK 17移除Nashorn后,Java怎么执行JS脚本?
图 5:JDK 17 执行 JS 引擎选型落点与上线检查清单
作者最新文章
相关文章
更多