Java如何调用JavaScript代码？-杰瑞科技汇

（H1）：Java调用JavaScript终极指南：从零开始，打通前后端壁垒

Meta描述： 想知道Java如何调用JavaScript吗？本文为你详解5种主流实现方式，包括Nashorn、GraalVM、ScriptEngine、Rhino及无引擎调用，提供完整代码示例与场景分析,助你轻松实现Java与JS的互操作。

引言（开篇吸睛，直击痛点）

作为一名Java开发者,你是否曾遇到过这样的场景？

遗留系统改造： 需要在一个庞大的Java后端系统中，集成一个由JavaScript编写的复杂业务逻辑模块,但又不想重构整个系统。
动态能力需求： 希望你的Java应用能够动态执行一段脚本，实现灵活的配置或热插拔的功能,而不需要重新编译和部署。
现代前端集成： 在服务器端渲染（SSR）或某些自动化测试场景中,需要让Java环境直接执行或操作JavaScript代码。

“Java调用JavaScript”，这个看似简单的问题，背后涉及的技术方案却多种多样，各有优劣，网上零散的教程让人眼花缭乱,不知道哪种才是最适合自己项目的。

别担心！作为你的专属技术专家，我将为你提供一份终极指南，本文将从最基础的原理讲起，深入剖析当前最主流的5种实现方式，并提供可直接运行的代码示例,让你彻底搞懂Java与JavaScript的互操作技术。

为什么Java需要调用JavaScript？

在深入技术细节之前，我们先明确一下为什么要做这件事，理解了应用场景,你才能更好地选择合适的技术。

复用JS生态： JavaScript拥有庞大的开源库（如数据处理、UI组件、工具函数），Java可以直接调用这些库,避免重复造轮子。
提升灵活性： 将业务逻辑或配置脚本化，允许在不修改Java代码的情况下，通过修改JS文件来调整行为，实现“热更新”。
遗留系统集成： 在金融、电信等传统行业，大量核心逻辑可能由JavaScript编写，Java调用JS是平滑过渡、保护投资的有效手段。
特定领域应用： 如游戏服务器中的脚本逻辑、自动化测试中的前端模拟等。

技术方案对比：5种主流实现方式

我们将从Java 8时代的“王者”讲到未来的“新贵”,全面覆盖各种技术选型。

方案名称	核心技术	关键依赖	性能	易用性	适用场景
Nashorn (已废弃)	JDK内置 (Java 8)	无	中等	简单	Java 8项目，不推荐新项目使用
GraalVM	JDK内置 (Java 11+)	无	极高	较复杂	新项目，追求极致性能和原生镜像
ScriptEngine (JSR 223)	JDK内置	可能需Rhino或GraalVM JS	中等	简单	标准化、跨引擎的通用需求
Rhino	独立引擎	`org.mozilla:rhino`	较低	简单	旧项目兼容或需要特定JS版本
无引擎调用	V8引擎集成	`com.github. graalvm:graalvm-js`	高	复杂	需要Node.js生态，性能要求高

Nashorn - Java 8时代的遗珠（已不推荐）

Java 8引入了Nashorn，旨在取代老旧的Rhino，它提供了一个命令行工具jjs和一套Java API来执行JS。

重要提示： Nashorn在Java 11中被标记为废弃，并在Java 15中被移除。新项目请勿使用！ 但了解它有助于你维护旧代码。

代码示例：

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class NashornExample {
    public static void main(String[] args) {
        // 1. 获取Nashorn引擎
        ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
        try {
            // 2. 执行简单的JS表达式
            engine.eval("var msg = 'Hello from JavaScript!';");
            Object result = engine.eval("print(msg);");
            System.out.println("Java received: " + result);
            // 3. Java调用JS函数
            engine.eval("function add(a, b) { return a + b; }");
            Object sum = engine.eval("add(10, 20);");
            System.out.println("The sum is: " + sum);
            // 4. 向JS传递Java对象
            Person person = new Person("Alice", 30);
            engine.put("javaPerson", person); // 将Java对象注入JS
            engine.eval("print('Name from Java: ' + javaPerson.name);");
            engine.eval("javaPerson.setAge(31);"); // 从JS调用Java方法
            System.out.println("Age updated in Java: " + person.getAge());
        } catch (ScriptException e) {
            e.printStackTrace();
        }
    }
    // 一个简单的Java类
    static class Person {
        private String name;
        private int age;
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public String getName() { return name; }
        public int getAge() { return age; }
        public void setAge(int age) { this.age = age; }
    }
}

GraalVM - 性能与未来的王者

GraalVM是Oracle推出的下一代多语言虚拟机，其JavaScript引擎（Graal.js）性能极高，并且支持提前编译（AOT），可以生成原生可执行文件，启动速度快,内存占用低。

前提： 确保你的JDK是包含GraalVM的版本（如GraalVM CE或Oracle JDK with GraalVM）。

代码示例：

import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.Source;
import org.graalvm.polyglot.Value;
public class GraalVmExample {
    public static void main(String[] args) {
        // 1. 创建一个隔离的上下文
        try (Context context = Context.create()) {
            // 2. 执行JS代码
            context.eval("js", "console.log('Hello from GraalVM JS!');");
            // 3. 执行JS文件
            // context.eval(Source.newBuilder("js", new File("my_script.js")).build());
            // 4. 调用JS函数并获取返回值
            Value result = context.eval("js", "add(15, 25);");
            System.out.println("Result from GraalVM JS: " + result.asInt());
            // 5. Java与JS互操作
            Value jsObj = context.eval("js", "({ name: 'Bob', greet: function() { return 'Hi, I am ' + this.name; } })");
            System.out.println(jsObj.getMember("greet").execute().asString()); // 调用JS方法
            jsObj.getMember("name").set("Charlie"); // 修改JS对象属性
            System.out.println("Updated name: " + jsObj.getMember("name").asString());
        }
    }
}

Maven依赖 (如果使用独立GraalVM JS引擎):

<dependency>
    <groupId>org.graalvm.js</groupId>
    <artifactId>js</artifactId>
    <version>23.1.0</version> <!-- 请使用与你的GraalVM版本匹配的版本 -->
</dependency>

ScriptEngine (JSR 223) - 标准化的通用接口

javax.script.ScriptEngine是Java平台的一个标准API（JSR 223），它定义了一套统一的接口来调用各种脚本语言，它的实现可以是Nashorn、Rhino,甚至是GraalVM。

优点： 代码与具体引擎解耦，你只需编写标准API,运行时可以轻松切换不同的JS引擎实现。

代码示例：

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class ScriptEngineExample {
    public static void main(String[] args) {
        // 1. 通过引擎名称获取引擎
        // 优先使用GraalVM，如果没有则回退到Nashorn (如果Java 8)
        ScriptEngine engine = new ScriptEngineManager().getEngineByName("graal.js");
        // 如果没有GraalVM，可以尝试 "nashorn" 或 "javascript"
        if (engine == null) {
            engine = new ScriptEngineManager().getEngineByName("nashorn");
            System.out.println("GraalVM not found, falling back to Nashorn.");
        }
        try {
            // 2. 执行JS代码
            engine.eval("var data = { value: 100 };");
            // 3. 获取JS变量
            Object dataValue = engine.get("data");
            System.out.println("Java got JS object: " + dataValue);
            // 4. 向JS传递Java变量
            engine.put("javaMultiplier", 2);
            engine.eval("data.value = data.value * javaMultiplier;");
            // 5. 从JS获取更新后的值
            Object updatedValue = engine.eval("data.value;");
            System.out.println("Updated value: " + updatedValue);
        } catch (ScriptException e) {
            e.printStackTrace();
        }
    }
}

Rhino - 历史的见证者

Rhino是Mozilla开发的纯Java实现的JavaScript引擎，在Nashorn出现之前，它是Java生态中唯一的JS引擎，虽然性能不如Nashorn和GraalVM，但它在某些需要完全无依赖（纯Java）或需要特定ECMAScript版本兼容性的场景下仍有价值。

Maven依赖:

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

代码示例：

import org.mozilla.javascript.Context;
import org.mozilla.javascript.Scriptable;
public class RhinoExample {
    public static void main(String[] args) {
        // 1. 创建一个Rhino上下文
        Context cx = Context.enter();
        // 2. 初始化作用域
        Scriptable scope = cx.initStandardObjects();
        try {
            // 3. 执行JS代码
            cx.evaluateString(scope, "var jsVar = 'Rhino is working!';", "myScript", 1, null);
            // 4. 从作用域中获取变量
            Object result = scope.get("jsVar", scope);
            System.out.println("JS Variable: " + Context.toString(result));
            // 5. 执行JS函数
            cx.evaluateString(scope, "function multiply(a, b) { return a * b; }", "myScript", 1, null);
            Object funcResult = cx.evaluateString(scope, "multiply(8, 9);", "myScript", 1, null);
            System.out.println("Multiply result: " + Context.toString(funcResult));
        } finally {
            // 6. 退出上下文
            Context.exit();
        }
    }
}

无引擎调用 - V8的强大魅力

在某些极端场景下，你可能需要直接调用Google的V8引擎（Chrome的JS引擎），这通常通过JNI（Java Native Interface）或JNA（Java Native Access）来实现，将V8的C++库链接到Java应用中。

优点：

性能之王： V8是公认最快的JS引擎之一。
完整的Node.js生态： 可以直接运行npm包。

缺点：

极其复杂： 配置繁琐,涉及跨平台编译。
平台依赖： 需要为不同操作系统（Windows, Linux, macOS）提供对应的V8动态链接库。
维护成本高： 升级V8版本可能意味着大量的适配工作。

适用场景： 对性能有极致要求，且必须使用Node.js特定模块的场景（如某些高性能的SSR框架或游戏服务器）。

由于实现过于复杂，这里不提供完整代码，但你可以关注一些开源项目，如 j2v8 (已停止维护) 或 libnode,它们封装了这些复杂的底层调用。

场景化选型建议：我该选哪个？

看完这么多方案，是不是还是有点选择困难？别急,这里给你一张清晰的决策图：

【新项目，使用Java 11+】
- 首选：GraalVM。 性能最好，是未来的方向，支持AOT编译,适合云原生和微服务。
- 次选：ScriptEngine + GraalVM。 如果你希望代码更具通用性，担心未来引擎替换，使用标准API,并配置GraalVM作为实现。
【维护旧项目，使用Java 8】
- 首选：Nashorn。 无需额外依赖，但请注意它已被废弃,规划未来迁移。
- 次选：Rhino。 如果Nashorn不满足需求（如需要特定JS特性）,可以引入Rhino依赖。
【需要极高性能，且不介意复杂度】
- 选择：V8集成。 在性能压倒一切的情况下，可以考虑这条路,但务必评估好开发和维护成本。
【需要通用性和灵活性】
- 选择：ScriptEngine。 编写与具体引擎无关的代码，是你的“万能钥匙”。

安全性与性能最佳实践

安全第一： 永远不要执行来自不可信源的JavaScript代码！ 恶意的JS代码可以通过Java反射API访问和修改你的文件系统、网络连接等，造成严重的安全风险（代码注入攻击），如果必须执行，务必在沙箱环境中运行（如GraalVM的隔离上下文）。
性能考量： 频繁地在Java和JS之间传递数据（尤其是大对象）会有性能开销，尽量在JS内部完成复杂计算,只将最终结果传回Java。
预热JIT： GraalVM等现代引擎的JIT（即时编译）需要时间预热，对于性能敏感的应用，在正式请求前先执行一些“热身”脚本,让JIT充分优化。

Java调用JavaScript是一项强大而灵活的技术，它打破了前后端的壁垒,为Java应用注入了动态和现代的基因。

对于未来， GraalVM 无疑是王道,它的性能和原生编译能力让它成为新项目的首选。
对于现在， ScriptEngine 提供了标准化的、可扩展的解决方案，而 Nashorn 则是维护旧代码的权宜之计。
对于极限性能， V8集成 提供了可能,但伴随着巨大的复杂度。

希望这份终极指南能帮助你拨开迷雾，根据自身项目需求，做出最明智的技术选择，是时候动手尝试,让Java和JavaScript在你的项目中协同工作了！

互动环节： 你在项目中使用过哪种方案？遇到过哪些有趣的问题？欢迎在评论区分享你的经验和见解！如果你觉得这篇文章对你有帮助，别忘了点赞、收藏和转发哦！

Java如何调用JavaScript代码？

（H1）：Java调用JavaScript终极指南：从零开始，打通前后端壁垒

引言（开篇吸睛，直击痛点）

为什么Java需要调用JavaScript？

技术方案对比：5种主流实现方式

Nashorn - Java 8时代的遗珠（已不推荐）

GraalVM - 性能与未来的王者

ScriptEngine (JSR 223) - 标准化的通用接口

Rhino - 历史的见证者

无引擎调用 - V8的强大魅力

场景化选型建议：我该选哪个？

安全性与性能最佳实践

99ANYc3cd6

WebLogic Java内存溢出如何排查？

Java exec在Linux中如何正确执行命令？

java的setvisible

iPhone5如何越狱？教程步骤详解

Java如何接收FormData数据？

Java Socket编程实例具体怎么实现？

哪里可以下载ASP.NET教程PDF？

Win7如何配置Java环境变量？

哪里找Protel教程PDF？

Java中如何准确判断Object的实际类型？

Java Web和Java核心区别是什么？

u盘装win7安装系统教程

java中volatile的作用

python urllib2 api

哪里可以下载access2007教程？

Python网络编程第3版PDF哪里能下载？

Java如何调用JavaScript代码？

（H1）：Java调用JavaScript终极指南：从零开始，打通前后端壁垒

引言（开篇吸睛，直击痛点）

为什么Java需要调用JavaScript？

技术方案对比：5种主流实现方式

Nashorn - Java 8时代的遗珠（已不推荐）

GraalVM - 性能与未来的王者

ScriptEngine (JSR 223) - 标准化的通用接口

Rhino - 历史的见证者

无引擎调用 - V8的强大魅力

场景化选型建议：我该选哪个？

安全性与性能最佳实践

相关推荐

Java Socket编程实例具体怎么实现？