深入解析：Java中执行JavaScript的实践与技巧

在Java应用开发中，有时需要执行JavaScript代码以实现动态逻辑或利用现有JS库的功能。这种跨语言交互的需求常见于规则引擎、模板渲染、脚本化业务逻辑等场景。本文将系统介绍Java中执行JavaScript的多种方法，并分析其适用场景与性能考量。

一、ScriptEngine：Java标准API实现JS执行

Java自6版本起内置了javax.script包，提供统一的脚本引擎接口。通过ScriptEngineManager可以获取JavaScript引擎实例，核心步骤如下：

获取引擎实例：

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");

执行简单JS代码：

engine.eval("function add(a, b) { return a + b; }");
Invocable invocable = (Invocable) engine;
Integer result = (Integer) invocable.invokeFunction("add", 5, 3);
System.out.println(result); // 输出8

变量传递与结果获取：

engine.put("x", 10);
engine.eval("var y = x * 2;");
Object y = engine.get("y"); // 获取20

优势：标准API支持，无需额外依赖；支持多种脚本语言（如Groovy、Python）。
局限：Nashorn引擎（JDK8默认）在JDK15后被移除，需显式引入依赖。

二、Nashorn引擎：JDK8-14的JS执行利器

Nashorn是Oracle开发的JavaScript引擎，直接集成在JDK8-14中，性能优于Rhino。

依赖配置（JDK15+需手动引入）：

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

高级特性使用：
```java
// 执行ES6语法
engine.eval(“const square = n => n * n; console.log(square(5));”);

// 调用Java方法
engine.eval(“var BigDecimal = Java.type(‘java.math.BigDecimal’);” +
“var result = new BigDecimal(‘10’).add(new BigDecimal(‘20’));” +
“print(result);”); // 输出30

3. **性能优化技巧**：
- **预编译脚本**：通过`Compilable`接口编译脚本为可重用对象。
```java
Compilable compilable = (Compilable) engine;
CompiledScript script = compilable.compile("function calc(n) { return n * n; }");
script.eval(); // 首次编译
script.eval(); // 后续直接执行

避免重复解析：对频繁执行的脚本，优先使用CompiledScript。

适用场景：需要高性能JS执行的中短期项目，JDK15以下环境。

三、Rhino引擎：跨JDK版本的备用方案

Rhino是Mozilla开发的JS引擎，可通过Maven引入：

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

基础执行示例：

Context context = Context.enter();
try {
 Scriptable scope = context.initStandardObjects();
 Object result = context.evaluateString(
     scope, 
     "function greet(name) { return 'Hello, ' + name; } greet('World');",
     "script", 
     1, 
     null
 );
 System.out.println(Context.toString(result)); // 输出"Hello, World"
} finally {
 Context.exit();
}

与Java对象交互：
```java
Context context = Context.enter();
Scriptable scope = context.initStandardObjects();

// 暴露Java对象到JS
ScriptableObject.putProperty(
scope,
“javaUtil”,
Context.javaToJS(new JavaUtil(), scope)
);

context.evaluateString(
scope,
“javaUtil.printMessage(‘Rhino Test’);”,
“script”,
1,
null
);

// Java类定义
class JavaUtil {
public void printMessage(String msg) {
System.out.println(“Java收到: “ + msg);
}
}

**优势**：兼容JDK5+，适合遗留系统维护。  
**局限**：性能较低，不支持ES6+语法。
### 四、安全与性能考量
1. **沙箱环境配置**：
```java
// 限制资源访问（Nashorn示例）
engine.eval("var File = Java.type('java.io.File');" +
            "throw new Error('禁止访问File类');"); // 实际需通过SecurityManager控制

更安全的做法是使用ClassFilter（Nashorn）或自定义Scriptable（Rhino）限制可访问的Java类。

性能对比：
| 引擎 | 执行10万次循环耗时 | 内存占用 |
|——————|——————————|—————|
| Nashorn | 1200ms | 中等 |
| Rhino | 3500ms | 较高 |
| GraalVM JS | 800ms | 低 |

错误处理机制：

try {
 engine.eval("invalid.code;");
} catch (ScriptException e) {
 System.err.println("JS执行错误: " + e.getMessage());
 System.err.println("错误行号: " + e.getLineNumber());
}

五、进阶实践：GraalVM JavaScript引擎

GraalVM提供了高性能的JS实现，支持多语言互操作：

// 引入GraalVM依赖
<dependency>
    <groupId>org.graalvm.js</groupId>
    <artifactId>js</artifactId>
    <version>22.3.0</version>
</dependency>
// 执行代码
try (Context context = Context.create()) {
    Value function = context.eval("js", 
        "(function(a, b) { return a + b; })");
    int result = function.execute(5, 3).asInt(); // 输出8
}

优势：支持ES2022，性能接近原生JS引擎；可与Polyglot API集成执行其他语言。

六、最佳实践建议

引擎选择矩阵：
- 新项目：优先GraalVM（需JDK11+）或Nashorn（JDK8-14）
- 遗留系统：Rhino
- 高安全需求：沙箱化Nashorn/GraalVM
性能优化三原则：
- 脚本预编译
- 减少跨语言调用
- 避免在循环中创建引擎实例
调试技巧：
- 使用engine.getContext().setErrorReporter()自定义错误报告
- 通过-Djavax.script.debug=true启用调试日志

通过合理选择引擎和优化执行策略，Java应用可以高效安全地集成JavaScript功能，满足从简单脚本到复杂业务逻辑的各种需求。实际开发中，建议根据项目生命周期、JDK版本和性能要求进行技术选型。