50、Java 脚本编程全解析

Java 脚本编程全解析

1. 脚本语言的优缺点及 Java 脚本支持

脚本语言有其劣势。例如，动态类型利于编写更简单的代码，但当类型被错误解释时，就会成为一个缺点，你可能需要花费大量时间进行调试。

Java 对脚本的支持让你能兼顾两者的优势：你可以使用 Java 编程语言来开发应用程序中静态类型、可扩展且高性能的部分，同时使用适合特定领域需求的脚本语言来开发其他部分。

2. 脚本引擎概述

脚本引擎是执行用脚本语言编写的程序的软件组件。通常，它是脚本语言解释器的一种实现，但并非一定如此。已经有几种脚本语言的解释器用 Java 实现，它们会暴露编程接口，以便 Java 程序与之交互。

JDK 曾经捆绑过一个名为 Nashorn JavaScript 的脚本引擎，但在 Oracle 的 JDK 15 中，Nashorn 被移除了，不过在 OpenJDK 16 中仍能找到它。Java 可以执行任何为脚本引擎提供实现的脚本语言编写的脚本，例如 GraalVM JavaScript、Groovy、Jython、JRuby 等。

3. 在 Maven 中安装脚本引擎

如果你使用 Maven 作为构建工具，安装脚本引擎很容易。你只需在 pom.xml 中添加一个非标准仓库和特定依赖即可：

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation=
        "http://maven.apache.org/POM/4.0.0
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>your.project.group.id</groupId>
    <artifactId>your.project.artifact.id</artifactId>
    <version>your.project.version</version>
    <dependencies>
        <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy-jsr223</artifactId>
            <version>3.0.8</version>
        </dependency>
        <!-- Other script engines:-->
        <dependency>
            <groupId>org.scijava</groupId>
            <artifactId>scripting-jython</artifactId>
            <version>1.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.scijava</groupId>
            <artifactId>scripting-jruby</artifactId>
            <version>0.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.graalvm.js</groupId>
            <artifactId>js-scriptengine</artifactId>
            <version>21.1.0</version>
        </dependency>
        <dependency>
            <!-- needed for GraalVM.js -->
            <groupId>org.graalvm.truffle</groupId>
            <artifactId>truffle-api</artifactId>
            <version>21.1.0</version>
        </dependency>
        ...
    </dependencies>
    <repositories>
        <repository>
            <id>Maven Repo</id>
            <url>
                https://repo1.maven.org/maven2/
            </url>
        </repository>
        <repository>
            <id>Maven Repo 2</id>
            <url>
                http://maven.imagej.net/content/repositories/releases/
            </url>
        </repository>
    </repositories>
    ...
</project>

当然，你可以注释掉或移除不需要的脚本引擎。

4. 执行第一个脚本

下面将使用 Groovy 在标准输出上打印一条消息。使用其他脚本语言打印消息的步骤相同，唯一的区别是你需要使用特定脚本语言的代码来打印消息。在 Java 中运行脚本需要执行以下三个步骤：
1. 创建一个脚本引擎管理器。
2. 从脚本引擎管理器中获取一个脚本引擎实例。
3. 调用脚本引擎的 eval() 方法来执行脚本。

示例代码如下：

// Create an script engine manager
ScriptEngineManager manager = new ScriptEngineManager();
// Get the reference of the Groovy engine
ScriptEngine engine = manager.getEngineByName("Groovy");
// Store a Groovy script in a String
String script = "println('Hello Scripting!')";
try {
    engine.eval(script);
} catch (ScriptException e) {
    e.printStackTrace();
}

完整代码如下：

// HelloScripting.java
package com.jdojo.script;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class HelloScripting {
    public static void main(String[] args) {
        // Create a script engine manager
        ScriptEngineManager manager = new ScriptEngineManager();
        // Obtain a Groovy script engine from the manager
        ScriptEngine engine = manager.getEngineByName("Groovy");
        // Store the Groovy script in a String
        String script = """
            println('Hello Scripting!')
        """;
        try {
            // Execute the script
            engine.eval(script);
        } catch (ScriptException e) {
            e.printStackTrace();
        }
    }
}

5. 使用其他脚本语言

在 Java 程序中使用除 Groovy 之外的脚本语言非常简单。在使用脚本引擎之前，你只需完成一项任务：将特定脚本引擎的 JAR 文件包含到你的应用程序模块路径中，这些 JAR 文件由脚本引擎的实现者提供。

Java 的服务提供者机制会列出所有模块化 JAR 或 JAR 文件已包含在应用程序模块路径中的脚本引擎。 ScriptEngineFactory 接口的实例用于创建和描述脚本引擎。脚本引擎的提供者会为 ScriptEngineFactory 接口提供实现。 ScriptEngineManager 的 getEngineFactories() 方法会返回所有可用脚本引擎工厂的 List<ScriptEngineFactory> 。 ScriptEngineFactory 的 getScriptEngine() 方法会返回一个 ScriptEngine 实例。工厂的其他几个方法会返回有关引擎的元数据。

以下是打印所有可用脚本引擎详细信息的代码：

// ListingAllEngines.java
package com.jdojo.script;
import java.util.List;
import javax.script.ScriptEngineFactory;
import javax.script.ScriptEngineManager;
public class ListingAllEngines {
    public static void main(String[] args) {
        ScriptEngineManager manager = new ScriptEngineManager();
        // Get the list of all available engines
        List<ScriptEngineFactory> list = manager.getEngineFactories();
        // Print the details of each engine
        for (ScriptEngineFactory f : list) {
            System.out.println("Engine Name:" + f.getEngineName());
            System.out.println("Engine Version:" + f.getEngineVersion());
            System.out.println("Language Name:" + f.getLanguageName());
            System.out.println("Language Version:" + f.getLanguageVersion());
            System.out.println("Engine Short Names:" + f.getNames());
            System.out.println("Mime Types:" + f.getMimeTypes());
            System.out.println("----------------------------");
        }
    }
}

以下是使用不同脚本语言在标准输出上打印消息的代码：

// HelloEngines.java
package com.jdojo.script;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class HelloEngines {
    public static void main(String[] args) {
        // Get the script engine manager
        ScriptEngineManager manager = new ScriptEngineManager();
        // Try executing scripts in JavaScript, Groovy,
        // Jython, and JRuby
        execute(manager, "JavaScript", "print('Hello JavaScript')");
        execute(manager, "Groovy", "println('Hello Groovy')");
        execute(manager, "jython", "print 'Hello Jython'");
        execute(manager, "jruby", "puts('Hello JRuby')");
    }
    public static void execute(ScriptEngineManager manager, String engineName, String script) {
        // Try getting the engine
        ScriptEngine engine = manager.getEngineByName(engineName);
        if (engine == null) {
            System.out.println(engineName + " is not available.");
            return;
        }
        // If we get here, it means we have the engine
        // installed. So, run the script
        try {
            engine.eval(script);
        } catch (ScriptException e) {
            e.printStackTrace();
        }
    }
}

6. javax.script 包探索

Java 脚本 API 由少量的类和接口组成，它们位于 java.scripting 模块的 javax.script 包中。以下是对该包中部分类和接口的简要描述：
| 类/接口 | 描述 |
| ---- | ---- |
| ScriptEngine | Java 脚本 API 的主要接口，其实例用于执行用特定脚本语言编写的脚本。 |
| ScriptEngineFactory | 负责创建脚本引擎实例，并提供有关脚本引擎的信息，如引擎名称、版本、语言等。 |
| AbstractScriptEngine | 抽象类，为 ScriptEngine 接口提供部分实现，通常在实现脚本引擎时才会直接使用。 |
| ScriptEngineManager | 提供脚本引擎的发现和实例化机制，还维护一个键值对映射，存储所有由它创建的脚本引擎共享的状态。 |
| Compilable | 可选接口，脚本引擎可实现该接口以支持脚本编译，从而实现脚本的重复执行而无需重新编译。 |
| CompiledScript | 抽象类，由脚本引擎提供者扩展，用于存储编译后的脚本，可重复执行而无需重新编译。 |
| Invocable | 可选接口，脚本引擎可实现该接口以允许调用之前编译的脚本中的过程、函数和方法。 |
| Bindings | 实现该接口的类的实例是一个键值对映射，键必须是非空字符串，扩展了 java.util.Map 接口。 SimpleBindings 是其实现类。 |
| ScriptContext | 作为 Java 宿主应用程序和脚本引擎之间的桥梁，用于传递 Java 宿主应用程序的执行上下文，脚本引擎在执行脚本时可使用该上下文信息。 SimpleScriptContext 是其实现类。 |
| ScriptException | 异常类，脚本引擎在执行、编译或调用脚本时出错会抛出该异常，包含 getLineNumber() 、 getColumnNumber() 和 getFileName() 等有用方法。 |

7. 发现和实例化脚本引擎

你可以使用 ScriptEngineFactory 或 ScriptEngineManager 来创建脚本引擎。实际上， ScriptEngineFactory 始终负责创建脚本引擎实例。 ScriptEngineManager 的作用是使用服务提供者机制来定位所有可用的脚本引擎工厂，并查询这些工厂以获取符合条件的脚本引擎实例。

创建脚本引擎实例有三种方式：
1. 直接实例化脚本引擎类。
2. 直接实例化脚本引擎工厂类并调用其 getScriptEngine() 方法。
3. 使用 ScriptEngineManager 类的 getEngineByXxx() 方法之一。

建议使用 ScriptEngineManager 类来获取脚本引擎实例，这样可以让同一管理器创建的所有引擎共享一个状态，并且使你的代码无需了解实际的脚本引擎/工厂实现类。

8. 执行脚本

ScriptEngine 可以执行字符串和 Reader 中的脚本。使用 Reader 可以执行存储在网络或文件中的脚本。 ScriptEngine 的 eval() 方法有以下几种版本：
- Object eval(String script)
- Object eval(Reader reader)
- Object eval(String script, Bindings bindings)
- Object eval(Reader reader, Bindings bindings)
- Object eval(String script, ScriptContext context)
- Object eval(Reader reader, ScriptContext context)

第一个参数是脚本的来源，第二个参数可让你将宿主应用程序的信息传递给脚本引擎，供脚本执行时使用。

以下是一个使用文件存储脚本并执行的示例：

// ReaderAsSource.java
package com.jdojo.script;
import java.io.IOException;
import java.io.Reader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class ReaderAsSource {
    public static void main(String[] args) {
        // Construct the script file path
        String scriptFileName = "scripts/helloscript.groovy";
        Path scriptPath = Paths.get(scriptFileName);
        // Make sure the script file exists. If not,
        // print the full path of the script file and
        // terminate the program.
        if (!Files.exists(scriptPath)) {
            System.out.println(scriptPath.toAbsolutePath() + " does not exist.");
            return;
        }
        // Get the Groovy script engine
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("Groovy");
    }
}

文件 helloscript.groovy 的内容如下：

// Print a message
println('Hello from Groovy!')

通过以上内容，你可以全面了解 Java 中的脚本编程，包括脚本引擎的安装、脚本的执行以及相关 API 的使用。希望这些信息对你有所帮助，让你能够在 Java 项目中灵活运用脚本语言。

Java 脚本编程全解析

9. 执行脚本流程总结

为了更清晰地展示在 Java 中执行脚本的流程，下面用 mermaid 格式的流程图来呈现：

graph TD;
    A[开始] --> B[创建脚本引擎管理器];
    B --> C[获取脚本引擎实例];
    C --> D{脚本来源};
    D -- 字符串 --> E[使用 eval(String script) 执行];
    D -- Reader --> F[使用 eval(Reader reader) 执行];
    E --> G[结束];
    F --> G[结束];

这个流程图清晰地展示了在 Java 中执行脚本的主要步骤，从创建脚本引擎管理器开始，到根据脚本来源选择合适的 eval() 方法执行脚本，最后结束流程。

10. 不同脚本引擎使用对比

下面通过表格对比不同脚本引擎在使用时的一些特点：
| 脚本引擎 | 语言 | 适用场景 | 安装依赖 |
| ---- | ---- | ---- | ---- |
| Groovy | Groovy | 适合需要动态特性和简洁语法的场景，如自动化脚本、配置脚本等 | org.codehaus.groovy:groovy-jsr223:3.0.8 |
| Jython | Python | 当需要在 Java 环境中使用 Python 库和语法时适用 | org.scijava:scripting-jython:1.0.0 |
| JRuby | Ruby | 适用于需要 Ruby 语言特性和相关库的场景 | org.scijava:scripting-jruby:0.3.1 |
| GraalVM JavaScript | JavaScript | 用于在 Java 中执行 JavaScript 代码，支持高性能执行 | org.graalvm.js:js-scriptengine:21.1.0 和 org.graalvm.truffle:truffle-api:21.1.0 |

11. 脚本引擎的选择建议

在选择脚本引擎时，可以参考以下几点建议：
1. 功能需求 ：如果需要使用特定语言的库和特性，就选择对应语言的脚本引擎，如需要 Python 库就选择 Jython。
2. 性能要求 ：对于性能要求较高的场景，可以考虑支持编译的脚本引擎，如实现了 Compilable 接口的引擎。
3. 开发难度 ：如果追求简洁的语法和快速开发，Groovy 可能是一个不错的选择。

12. 异常处理与调试

在使用脚本引擎时， ScriptException 是一个常见的异常。当脚本执行、编译或调用出错时，脚本引擎会抛出该异常。以下是一个更完善的异常处理示例：

// HelloScripting.java
package com.jdojo.script;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class HelloScripting {
    public static void main(String[] args) {
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("Groovy");
        String script = "println('Hello Scripting!')";
        try {
            engine.eval(script);
        } catch (ScriptException e) {
            System.out.println("脚本执行出错！");
            System.out.println("错误位置：行 " + e.getLineNumber() + "，列 " + e.getColumnNumber());
            System.out.println("错误文件：" + e.getFileName());
            System.out.println("错误信息：" + e.getMessage());
            e.printStackTrace();
        }
    }
}

在这个示例中，当脚本执行出错时，会打印出详细的错误信息，包括错误位置、错误文件和错误信息，方便进行调试。

13. 脚本引擎的高级应用

除了基本的脚本执行，脚本引擎还有一些高级应用场景。例如，使用 Invocable 接口调用脚本中的函数：

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

public class InvokeScriptFunction {
    public static void main(String[] args) {
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("Groovy");
        String script = "def add(a, b) { return a + b }";
        try {
            engine.eval(script);
            if (engine instanceof Invocable) {
                Invocable invocable = (Invocable) engine;
                Object result = invocable.invokeFunction("add", 1, 2);
                System.out.println("函数调用结果：" + result);
            }
        } catch (ScriptException | NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，首先定义了一个 Groovy 函数 add ，然后通过 Invocable 接口调用该函数并输出结果。

14. 总结

通过以上内容，我们全面了解了 Java 中的脚本编程。从脚本语言的优缺点，到 Java 对脚本的支持，再到脚本引擎的安装、使用和管理，以及不同脚本引擎的特点和应用场景。同时，还介绍了异常处理、调试和高级应用等方面的内容。

在实际开发中，可以根据具体需求选择合适的脚本引擎，灵活运用 Java 脚本编程的特性，提高开发效率和代码的灵活性。希望这些知识能帮助你在 Java 项目中更好地使用脚本语言。

以下是一个总结性的列表，回顾 Java 脚本编程的关键要点：
1. 脚本语言有优缺点，Java 支持结合脚本语言和 Java 语言的优势。
2. 脚本引擎是执行脚本的核心组件，可通过 ScriptEngineManager 或 ScriptEngineFactory 获取。
3. 在 Maven 中安装脚本引擎只需添加相应依赖和仓库。
4. 执行脚本需创建脚本引擎管理器、获取脚本引擎实例并调用 eval() 方法。
5. 不同脚本引擎适用于不同场景，选择时要考虑功能需求、性能要求和开发难度。
6. 异常处理和调试可借助 ScriptException 的相关方法。
7. 脚本引擎还有高级应用，如使用 Invocable 接口调用脚本中的函数。