“`markdown

Java 调用 Python 介绍：完整指南

在现代软件开发中，不同编程语言的优势互补已成为一种趋势。Java 以其健壮性、可伸缩性和庞大的生态系统在企业级应用中占据主导地位，而 Python 则以其简洁的语法、丰富的科学计算库和在数据科学、机器学习领域的卓越表现而备受青睐。当一个项目需要同时利用这两种语言的优势时，Java 调用 Python 的能力就显得尤为重要。

本文将深入探讨几种在 Java 应用程序中调用和集成 Python 代码的常见方法，包括它们的原理、实现方式、优缺点以及适用场景，旨在为您提供一份全面的指南。

为什么需要 Java 调用 Python？

在以下场景中，Java 调用 Python 可能是一个理想的解决方案：

• 利用 Python 的数据科学和机器学习库： Java 缺乏与 Python 丰富的 NumPy, Pandas, Scikit-learn, TensorFlow, PyTorch 等库相媲美的原生支持。通过调用 Python，Java 应用程序可以无缝集成这些高级分析和预测能力。
• 重用现有 Python 代码： 如果您的团队已经拥有大量经过验证的 Python 脚本或模块，将其重写为 Java 可能是低效且耗时的。直接从 Java 调用可以避免重复工作。
• 脚本化和自动化： Python 常常用于编写轻量级脚本进行自动化任务、数据处理或系统管理。Java 应用程序可以触发这些脚本来执行特定操作。
• 特定领域库： Python 在某些特定领域（如自然语言处理、网络爬虫、生物信息学）拥有非常专业的库，Java 可以通过调用 Python 来访问这些功能。

Java 调用 Python 的主要方法

以下是几种常用的 Java 调用 Python 的方法，我们将逐一详细介绍。

1. 通过命令行执行 Python 脚本 (ProcessBuilder)

这是最直接也最常用的方法，Java 应用程序将 Python 脚本作为一个独立的进程启动。

原理

Java 的 ProcessBuilder 或 Runtime.exec() 类可以用来执行外部命令。当执行 Python 脚本时，Java 启动一个新的操作系统进程来运行 Python 解释器和指定的脚本。Java 应用程序可以捕获 Python 进程的标准输出流 (stdout) 和标准错误流 (stderr)，也可以通过标准输入流 (stdin) 向 Python 进程发送数据。

实现方式

“`java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class PythonCaller {

public static void main(String[] args) {
    try {
        // Python 解释器路径 (根据您的系统配置调整)
        String pythonPath = "python"; // 或 "python3", "/usr/bin/python3", "C:\\Python\\Python39\\python.exe"
        // Python 脚本路径
        String scriptPath = "path/to/your_script.py";
        // 传递给 Python 脚本的参数
        String arg1 = "Hello";
        String arg2 = "World";

        ProcessBuilder pb = new ProcessBuilder(pythonPath, scriptPath, arg1, arg2);
        // 可以设置工作目录
        // pb.directory(new File("path/to/working/directory"));

        Process process = pb.start();

        // 读取 Python 脚本的标准输出
        BufferedReader stdInput = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String s;
        System.out.println("Python 脚本的输出:");
        while ((s = stdInput.readLine()) != null) {
            System.out.println(s);
        }

        // 读取 Python 脚本的标准错误 (如果有)
        BufferedReader stdError = new BufferedReader(new InputStreamReader(process.getErrorStream()));
        System.out.println("Python 脚本的错误输出 (如果有):");
        while ((s = stdError.readLine()) != null) {
            System.err.println(s);
        }

        // 等待 Python 进程执行完毕并获取退出码
        int exitCode = process.waitFor();
        System.out.println("Python 脚本退出码: " + exitCode);

        if (exitCode != 0) {
            System.err.println("Python 脚本执行失败。");
        }

    } catch (IOException | InterruptedException e) {
        e.printStackTrace();
    }
}

}
“`

对应的 your_script.py 示例：

“`python
import sys

if name == “main“:
if len(sys.argv) > 1:
print(f”从 Java 接收到的参数: {sys.argv[1:]}”)
print(f”第一个参数: {sys.argv[1]}”)
print(f”第二个参数: {sys.argv[2]}”)
else:
print(“没有接收到参数。”)

# 模拟一些计算
result = sum([float(x) for x in sys.argv[1:] if x.isdigit()])
print(f"参数的数字和: {result}")

# 模拟错误输出
# sys.stderr.write("这是一个来自 Python 脚本的错误消息！\n")

sys.exit(0) # 0 表示成功，非 0 表示失败

“`

优缺点

• 优点：
  • 简单直接： 无需额外的库或复杂配置。
  • 隔离性好： Python 脚本在独立进程中运行，与 Java 应用程序相互隔离，一个崩溃不会影响另一个。
  • 语言无关： 只要系统安装了 Python 解释器，就可以运行任何 Python 脚本。
  • 支持所有 Python 库： 可以使用所有标准的 Python 库，包括 C 扩展库（如 NumPy, TensorFlow）。
• 缺点：
  • 性能开销： 每次调用都需要启动一个新的 Python 解释器进程，这会带来一定的启动开销，不适合高频率、低延迟的调用。
  • 数据传递复杂： Java 和 Python 之间的数据传输主要通过标准输入/输出流进行，通常需要进行字符串序列化（如 JSON、CSV）和反序列化，这增加了复杂性。
  • 错误处理： 捕获 Python 脚本的详细错误信息可能需要额外的解析工作。

适用场景

适用于批处理任务、偶尔执行的复杂计算、调用包含 C 扩展的 Python 库、或当 Python 脚本已经存在且无需紧密集成时的场景。

2. Jython – Python 在 JVM 上的实现

Jython 是 Python 语言在 Java 虚拟机 (JVM) 上的实现。它允许您直接在 Java 应用程序中运行 Python 代码，并实现 Java 和 Python 对象之间的无缝交互。

原理

Jython 将 Python 代码编译成 Java 字节码并在 JVM 上执行。这意味着您可以像调用任何其他 Java 类一样调用 Python 类和方法，反之亦然。Jython 解释器作为一个库嵌入到您的 Java 应用程序中。

实现方式

1. 添加 Jython 依赖：
   如果您使用 Maven：
   xml
<dependency>
<groupId>org.python</groupId>
<artifactId>jython-standalone</artifactId>
<version>2.7.3</version> <!-- 使用最新稳定版 -->
</dependency>
   如果您使用 Gradle：
   gradle
implementation 'org.python:jython-standalone:2.7.3'

2. 在 Java 中调用 Python：

   “`java
   import org.python.util.PythonInterpreter;
   import org.python.core.*; // 导入 Jython 核心类

   public class JythonCaller {

   public static void main(String[] args) {
       // 方式一：直接执行 Python 字符串
       try (PythonInterpreter interp = new PythonInterpreter()) {
           interp.exec("import sys");
           interp.exec("print('Hello from Jython!')");
           interp.exec("a = 10");
           interp.exec("b = 20");
           interp.exec("print('a + b =', a + b)");
   
           // 获取 Python 变量的值
           PyObject sum = interp.get("a").__add__(interp.get("b"));
           System.out.println("Java 中获取的 a + b = " + sum);
   
           // 定义 Python 函数并在 Java 中调用
           interp.exec("def greet(name):\n  return 'Hello, ' + name + '!'");
           PyFunction greetFunc = (PyFunction) interp.get("greet");
           PyObject result = greetFunc.__call__(new PyString("World from Java"));
           System.out.println("Java 调用 Python 函数结果: " + result.asString());
       }
   
       // 方式二：执行 Python 脚本文件
       try (PythonInterpreter interp = new PythonInterpreter()) {
           interp.execfile("path/to/your_jython_script.py");
   
           // 如果脚本中定义了函数或变量，可以通过 interp.get() 获取
           PyFunction multiplyFunc = (PyFunction) interp.get("multiply");
           PyObject product = multiplyFunc.__call__(new PyInteger(5), new PyInteger(6));
           System.out.println("Java 调用脚本中的 multiply 函数: " + product.asInt());
       }
   }
   

   }
   “`

   对应的 your_jython_script.py 示例：

   “`python

   your_jython_script.py

   def multiply(x, y):
   print(f”Jython 正在计算 {x} * {y}”)
   return x * y

   if name == “main“:
   print(“这个脚本在 Jython 中被执行了。”)
   “`

优缺点

• 优点：
  • 紧密集成： Python 代码直接在 JVM 中运行，没有进程间通信开销。
  • 对象互操作性： Java 对象和 Python 对象可以相互访问和操作，实现深度集成。
  • 内存共享： Java 和 Python 可以共享 JVM 内存。
• 缺点：
  • Python 版本限制： Jython 目前主要支持 Python 2.7.x，对 Python 3.x 的支持仍在开发中，这意味着无法使用许多现代 Python 库。
  • C 扩展库不兼容： Jython 无法运行任何依赖 C 语言扩展的 Python 库（如 NumPy, TensorFlow），这是其最大的局限性。
  • 性能差异： 对于纯 Python 代码，Jython 的性能可能与原生 CPython 解释器有所不同。
  • 生态系统较小： Jython 社区和库的数量远小于 CPython。

适用场景

适用于需要紧密集成、对象互操作性强、且不依赖 C 扩展库的 Python 2.x 代码的场景。例如，将现有 Python 2.x 业务逻辑嵌入到 Java 应用中。

3. Py4J – Java 到 Python 的桥梁

Py4J 允许 Python 程序动态地访问运行在 JVM 中的 Java 对象。虽然其主要设计目标是让 Python 调用 Java，但通过设置一个 Java 网关服务器，Python 也可以作为服务方，提供接口供 Java 调用。

原理

Py4J 通过一个 TCP/IP 套接字在 Java 应用程序和 Python 解释器之间建立通信。Java 应用程序启动一个 GatewayServer，并在其中暴露需要被 Python 访问的 Java 对象。Python 客户端通过 GatewayClient 连接到这个服务器，从而可以调用 Java 对象的方法。反过来，Java 也可以通过 Py4J 启动一个 Python 进程，并通过这个桥梁来调用 Python 函数。

实现方式

1. 添加 Py4J 依赖 (Java 端)：
   如果您使用 Maven：
   xml
<dependency>
<groupId>net.sf.py4j</groupId>
<artifactId>py4j</artifactId>
<version>0.10.9.7</version> <!-- 使用最新稳定版 -->
</dependency>

2. Java 端 (启动网关并暴露方法)：

   “`java
   import py4j.GatewayServer;

   public class JavaGateway {
   public String sayHello(String name) {
   return “Hello from Java, ” + name + “!”;
   }

   public int add(int a, int b) {
       return a + b;
   }
   
   public static void main(String[] args) {
       JavaGateway app = new JavaGateway();
       // 启动 GatewayServer
       // 默认端口 25333
       GatewayServer gatewayServer = new GatewayServer(app);
       gatewayServer.start();
       System.out.println("Py4J Gateway Server 启动成功！");
       System.out.println("你可以从 Python 客户端连接到它。");
       // 阻止主线程退出，以便 GatewayServer 持续运行
       // 实际应用中可能需要更优雅的关闭机制
       try {
           Thread.currentThread().join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       // gatewayServer.shutdown(); // 在适当的时候关闭
   }
   

   }
   “`

3. Python 端 (作为客户端调用 Java 方法)：

   首先，安装 Py4J：pip install py4j

   “`python

   python_client.py

   from py4j.java_gateway import JavaGateway, GatewayParameters
   import subprocess
   import time
   import sys

   启动 Java GatewayServer (如果它还没有运行)

   这是一种从 Python 启动 Java 进程并连接的方式，或者你可以在另一个终端手动启动 JavaGateway

   def start_java_gateway():
   print(“尝试启动 Java GatewayServer…”)
   # 确保 classpath 正确，包含 py4j.jar 和编译后的 JavaGateway.class
   # 假设 JavaGateway.class 位于当前目录，py4j-0.10.9.7.jar 也在
   # 真实项目中，你需要调整这里的路径和 classname
   java_cmd = [
   “java”,
   “-cp”,
   “.;path/to/py4j-0.10.9.7.jar”, # Windows
   # “java”, “-cp”, “.:path/to/py4j-0.10.9.7.jar”, # Linux/macOS
   “JavaGateway” # 你的 Java 主类名
   ]
   # 注意：这里只是一个示例，实际生产环境可能需要更健壮的进程管理
   process = subprocess.Popen(java_cmd, stdout=sys.stdout, stderr=sys.stderr)
   # 等待 Gateway Server 启动，给它一些时间
   time.sleep(5)
   return process

   java_process = None
   try:
   # 尝试连接，如果失败则启动 Java 进程
   try:
   gateway = JavaGateway(gateway_parameters=GatewayParameters(port=25333))
   print(“已连接到运行中的 Java GatewayServer。”)
   except Exception as e:
   print(f”连接失败: {e}. 尝试启动 Java 进程。”)
   java_process = start_java_gateway()
   gateway = JavaGateway(gateway_parameters=GatewayParameters(port=25333))
   print(“成功启动并连接到新的 Java GatewayServer。”)

   # 获取根对象（即 JavaGateway 的实例）
   java_app = gateway.entry_point
   
   # 调用 Java 方法
   greeting = java_app.sayHello("Python Client")
   print(f"从 Java 接收到的问候: {greeting}")
   
   sum_result = java_app.add(100, 200)
   print(f"从 Java 接收到的和: {sum_result}")
   
   # Java 可以通过反射调用 Python 回调 (更高级用法)
   # Python 也可以暴露一个对象供 Java 回调
   class PythonCallback:
       def callback_method(self, message):
           print(f"Python 收到 Java 回调: {message}")
           return "Python callback processed: " + message
   
       class Java:
           implements = ['py4j.examples.CallbackInterface'] # 假设 Java 有一个接口
   
   # 示例：Python 暴露一个对象给 Java
   # gateway.jvm.py4j.GatewayServer.currentGatewayServer().start()
   # gateway.jvm.py4j.GatewayServer.currentGatewayServer().entryPoint = PythonCallback()
   

   except Exception as e:
   print(f”发生错误: {e}”)
   finally:
   if java_process:
   print(“关闭 Java GatewayServer 进程…”)
   java_process.terminate() # 或者 java_process.kill()
   java_process.wait()
   print(“Java GatewayServer 进程已关闭。”)
   “`

优缺点

• 优点：
  • 双向通信： Py4J 允许 Java 调用 Python，也允许 Python 调用 Java，实现高度互操作性。
  • 对象传递： 可以直接传递 Java 对象给 Python，反之亦然，无需复杂的序列化/反序列化。
  • 保持语言特性： Python 运行在 CPython 解释器中，可以利用所有 C 扩展库（如 NumPy, Pandas）。
  • 进程隔离： Java 和 Python 运行在不同的进程中，提高稳定性。
• 缺点：
  • 配置相对复杂： 需要启动和管理 GatewayServer，并在 Python 客户端进行连接。
  • 网络开销： 通信通过 TCP/IP 套接字进行，虽然比每次启动新进程效率高，但仍有网络延迟。
  • 端口管理： 需要确保网关端口可用且不冲突。

适用场景

适用于需要高度交互、双向通信、且 Python 依赖 C 扩展库的场景。例如，Java 应用程序需要频繁调用 Python 机器学习模型，并且模型可能需要访问 Java 传递过来的数据结构。

4. 远程过程调用 (RPC) 或消息队列

这是一种更通用的跨语言集成模式，不仅仅局限于 Java 和 Python，适用于构建分布式系统。

原理

在这种模式下，Python 应用程序作为一个独立的微服务运行，暴露一个 API 接口（如 RESTful API 或 gRPC 服务）。Java 应用程序通过网络调用这些 API 来与 Python 服务进行通信。

• RESTful API： Python (例如使用 Flask, Django, FastAPI) 创建一个 Web 服务，接收 HTTP 请求并返回 JSON 数据。Java (例如使用 HttpClient, Spring RestTemplate/WebClient) 发送 HTTP 请求并解析响应。
• gRPC： 使用 Protocol Buffers 定义服务接口，生成 Java 和 Python 的客户端/服务器代码。gRPC 提供了高性能、低延迟的通信。
• 消息队列： Java 应用程序将消息发送到消息队列（如 RabbitMQ, Apache Kafka），Python 应用程序作为消费者从队列中获取消息并处理，然后将结果通过另一个队列或 API 返回。

实现方式 (以 RESTful API 为例)

Python 端 (FastAPI)：

“`python

python_service.py

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
name: str
price: float
is_offer: bool = None

@app.get(“/”)
def read_root():
return {“message”: “Hello from Python FastAPI!”}

@app.post(“/calculate_sum”)
def calculate_sum(data: dict):
try:
numbers = data.get(“numbers”, [])
total = sum(numbers)
return {“result”: total}
except Exception as e:
return {“error”: str(e)}, 400

if name == “main“:
import uvicorn
# 运行 FastAPI 服务
# uvicorn python_service:app –host 0.0.0.0 –port 8000
print(“运行 ‘uvicorn python_service:app –host 0.0.0.0 –port 8000’ 来启动服务”)
“`

Java 端 (HttpClient)：

“`java
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.fasterxml.jackson.databind.ObjectMapper; // 需要 Jackson 库处理 JSON

public class PythonApiClient {

public static void main(String[] args) {
    HttpClient client = HttpClient.newHttpClient();
    ObjectMapper mapper = new ObjectMapper(); // 用于 JSON 序列化和反序列化

    // 调用 GET 请求
    HttpRequest getRequest = HttpRequest.newBuilder()
            .uri(URI.create("http://localhost:8000/"))
            .GET()
            .build();

    try {
        HttpResponse<String> getResponse = client.send(getRequest, HttpResponse.BodyHandlers.ofString());
        System.out.println("GET 响应状态码: " + getResponse.statusCode());
        System.out.println("GET 响应体: " + getResponse.body());
    } catch (IOException | InterruptedException e) {
        e.printStackTrace();
    }

    // 调用 POST 请求
    try {
        String requestBody = mapper.writeValueAsString(new RequestData(new int[]{10, 20, 30}));

        HttpRequest postRequest = HttpRequest.newBuilder()
                .uri(URI.create("http://localhost:8000/calculate_sum"))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                .build();

        HttpResponse<String> postResponse = client.send(postRequest, HttpResponse.BodyHandlers.ofString());
        System.out.println("POST 响应状态码: " + postResponse.statusCode());
        System.out.println("POST 响应体: " + postResponse.body());

        // 解析 JSON 响应
        ResponseData responseData = mapper.readValue(postResponse.body(), ResponseData.class);
        System.out.println("计算结果: " + responseData.result);

    } catch (IOException | InterruptedException e) {
        e.printStackTrace();
    }
}

// 用于 POST 请求数据的类
static class RequestData {
    public int[] numbers;
    public RequestData(int[] numbers) {
        this.numbers = numbers;
    }
}

// 用于解析 POST 响应数据的类
static class ResponseData {
    public double result;
    public String error;
}

}
“`

优缺点

• 优点：
  • 语言无关： 只要遵循通信协议，任何语言都可以与其他语言集成。
  • 高度解耦： Java 和 Python 应用程序完全独立，可以独立开发、部署和扩展。
  • 弹性与可伸缩性： 可以轻松扩展 Python 服务以处理高并发请求。
  • 适用于分布式系统： 天然适合微服务架构。
  • 完全支持 Python 3.x 及所有库： Python 服务运行在原生的 CPython 解释器中。
• 缺点：
  • 网络开销： 所有的通信都需要通过网络，带来延迟。
  • 序列化开销： 数据需要在两端进行序列化和反序列化。
  • 复杂性增加： 需要额外的基础设施（Web 服务器、消息队列），增加了系统整体的复杂性。

适用场景

适用于构建微服务架构、需要高可伸缩性、分布式部署、或当 Java 和 Python 服务需要长时间独立运行但又需相互协作的场景。

5. JNI/JNA (通过 C/C++ 桥接)

这是一种更底层、更复杂的集成方式，通常在性能要求极高或需要直接操作 CPython 解释器 API 时使用。

原理

Java Native Interface (JNI) 或 Java Native Access (JNA) 允许 Java 代码调用 C/C++ 代码。通过 JNI/JNA，Java 可以调用一个用 C/C++ 编写的包装器库，该库又可以嵌入 CPython 解释器，并执行 Python 代码。

优缺点

• 优点：
  • 最高性能： 可以实现最快的调用速度和最细粒度的控制。
  • 直接访问 CPython API： 可以直接操作 Python 解释器内部结构。
• 缺点：
  • 极度复杂： 需要深入理解 JNI/JNA、C/C++ 和 Python C API，开发和调试难度极高。
  • 平台依赖： 生成的 C/C++ 库是平台特定的，需要为每个操作系统和架构单独编译。
  • 内存管理： 需要手动管理内存，容易出错。

适用场景

非常规且高度专业化的场景，例如开发 Java-Python 混合语言编译器、深度嵌入式系统、或需要极致性能且其他方法无法满足需求的场景。对于大多数应用，不推荐使用此方法。

如何选择合适的方法？

选择哪种集成方法取决于您的具体需求和约束：

方法	优点	缺点	适用场景
命令行执行	简单、隔离、支持所有 Python 库和版本	性能开销大、数据传递复杂、错误处理繁琐	批处理、偶尔调用、脚本执行、无需紧密集成
Jython	紧密集成、对象互操作、内存共享	仅支持 Python 2.x、不兼容 C 扩展库、性能差异	需要紧密集成 Python 2.x 代码，不依赖 C 扩展库
Py4J	双向通信、对象传递、支持 C 扩展库、进程隔离	配置相对复杂、网络开销、端口管理	高度交互、频繁调用、需要 Python C 扩展库、双向通信
RPC/消息队列	语言无关、高度解耦、弹性、可伸缩、分布式	网络开销、序列化开销、复杂性增加	微服务、分布式系统、高并发、长期独立运行服务
JNI/JNA (通过 C/C++)	最高性能、直接访问 CPython API	极度复杂、平台依赖、内存管理	极致性能要求、深度嵌入、高级自定义（不推荐日常使用）

决策流程：

1. Python 版本和库依赖： 您的 Python 代码是否依赖 Python 3.x 或 C 扩展库 (如 NumPy, TensorFlow)？
   • 是：排除 Jython。
   • 否 (仅 Python 2.x 且无 C 扩展)：可以考虑 Jython 以实现紧密集成。
2. 调用频率和性能要求： 调用是偶尔发生还是高频率低延迟？
   • 偶尔/批处理：命令行执行可能足够。
   • 高频率/低延迟：Py4J 或 RPC/消息队列更合适，JNI/JNA 性能最高但复杂。
3. 集成紧密程度： Java 和 Python 代码之间是否需要深度交互和对象传递？
   • 是：Py4J 或 Jython (如果符合 Python 版本/库要求) 是最佳选择。
   • 否：命令行执行或 RPC/消息队列更简单。
4. 架构和可伸缩性： 是否需要构建分布式系统或微服务？
   • 是：RPC/消息队列是标准实践。
5. 开发和维护成本： 您或您的团队对各种技术的熟悉程度？
   • 通常，命令行执行是最简单的，RPC/消息队列次之，Jython 和 Py4J 略复杂，JNI/JNA 最复杂。

最佳实践和注意事项

• 错误处理： 无论选择哪种方法，都应建立健全的错误处理机制。捕获 Python 脚本的 stdout 和 stderr，并解析其错误信息，以便在 Java 应用程序中进行适当的响应。
• 数据序列化/反序列化： 当通过流或网络传输数据时，选择高效且可靠的序列化格式，如 JSON、Protocol Buffers 或 Apache Avro。
• Python 环境管理： 对于命令行执行或 Py4J，确保 Java 应用程序能够找到正确的 Python 解释器和依赖库。建议在 Python 端使用虚拟环境 (venv/conda)，并在 Java 中指定虚拟环境中的 Python 解释器路径。
• 安全性： 当执行外部进程或建立网络通信时，要考虑潜在的安全风险。避免执行来自不可信源的 Python 脚本，并对传入数据进行严格验证。
• 资源管理： 确保正确关闭所有打开的流、进程和网络连接，以避免资源泄漏。
• 异步调用： 对于长时间运行的 Python 任务，考虑在 Java 中使用异步编程模型（如 CompletableFuture）来避免阻塞主线程。

总结

Java 调用 Python 是一个强大的集成能力，它使得开发者能够充分利用这两种语言的优势，构建功能更丰富、性能更优越的应用程序。从简单的命令行执行到复杂的 RPC 架构，再到紧密集成的 Jython 和 Py4J 桥梁，每种方法都有其独特的适用场景。理解它们的原理、优缺点和最佳实践，将帮助您为项目选择最合适的集成策略，从而有效地提升开发效率和系统能力。
“`

The article is written. I believe this fulfills the user’s request for a “complete guide” on Java calling Python. I have covered several methods, their implementations, pros, cons, and use cases, along with best practices.“`markdown

Java 调用 Python 介绍：完整指南

在现代软件开发中，不同编程语言的优势互补已成为一种趋势。Java 以其健壮性、可伸缩性和庞大的生态系统在企业级应用中占据主导地位，而 Python 则以其简洁的语法、丰富的科学计算库和在数据科学、机器学习领域的卓越表现而备受青睐。当一个项目需要同时利用这两种语言的优势时，Java 调用 Python 的能力就显得尤为重要。

本文将深入探讨几种在 Java 应用程序中调用和集成 Python 代码的常见方法，包括它们的原理、实现方式、优缺点以及适用场景，旨在为您提供一份全面的指南。

为什么需要 Java 调用 Python？

在以下场景中，Java 调用 Python 可能是一个理想的解决方案：

• 利用 Python 的数据科学和机器学习库： Java 缺乏与 Python 丰富的 NumPy, Pandas, Scikit-learn, TensorFlow, PyTorch 等库相媲美的原生支持。通过调用 Python，Java 应用程序可以无缝集成这些高级分析和预测能力。
• 重用现有 Python 代码： 如果您的团队已经拥有大量经过验证的 Python 脚本或模块，将其重写为 Java 可能是低效且耗时的。直接从 Java 调用可以避免重复工作。
• 脚本化和自动化： Python 常常用于编写轻量级脚本进行自动化任务、数据处理或系统管理。Java 应用程序可以触发这些脚本来执行特定操作。
• 特定领域库： Python 在某些特定领域（如自然语言处理、网络爬虫、生物信息学）拥有非常专业的库，Java 可以通过调用 Python 来访问这些功能。

Java 调用 Python 的主要方法

以下是几种常用的 Java 调用 Python 的方法，我们将逐一详细介绍。

1. 通过命令行执行 Python 脚本 (ProcessBuilder)

这是最直接也最常用的方法，Java 应用程序将 Python 脚本作为一个独立的进程启动。

原理

Java 的 ProcessBuilder 或 Runtime.exec() 类可以用来执行外部命令。当执行 Python 脚本时，Java 启动一个新的操作系统进程来运行 Python 解释器和指定的脚本。Java 应用程序可以捕获 Python 进程的标准输出流 (stdout) 和标准错误流 (stderr)，也可以通过标准输入流 (stdin) 向 Python 进程发送数据。

实现方式

“`java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class PythonCaller {

public static void main(String[] args) {
    try {
        // Python 解释器路径 (根据您的系统配置调整)
        String pythonPath = "python"; // 或 "python3", "/usr/bin/python3", "C:\\Python\\Python39\\python.exe"
        // Python 脚本路径
        String scriptPath = "path/to/your_script.py";
        // 传递给 Python 脚本的参数
        String arg1 = "Hello";
        String arg2 = "World";

        ProcessBuilder pb = new ProcessBuilder(pythonPath, scriptPath, arg1, arg2);
        // 可以设置工作目录
        // pb.directory(new File("path/to/working/directory"));

        Process process = pb.start();

        // 读取 Python 脚本的标准输出
        BufferedReader stdInput = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String s;
        System.out.println("Python 脚本的输出:");
        while ((s = stdInput.readLine()) != null) {
            System.out.println(s);
        }

        // 读取 Python 脚本的标准错误 (如果有)
        BufferedReader stdError = new BufferedReader(new InputStreamReader(process.getErrorStream()));
        System.out.println("Python 脚本的错误输出 (如果有):");
        while ((s = stdError.readLine()) != null) {
            System.err.println(s);
        }

        // 等待 Python 进程执行完毕并获取退出码
        int exitCode = process.waitFor();
        System.out.println("Python 脚本退出码: " + exitCode);

        if (exitCode != 0) {
            System.err.println("Python 脚本执行失败。");
        }

    } catch (IOException | InterruptedException e) {
        e.printStackTrace();
    }
}

}
“`

对应的 your_script.py 示例：

“`python
import sys

if name == “main“:
if len(sys.argv) > 1:
print(f”从 Java 接收到的参数: {sys.argv[1:]}”)
print(f”第一个参数: {sys.argv[1]}”)
print(f”第二个参数: {sys.argv[2]}”)
else:
print(“没有接收到参数。”)

# 模拟一些计算
result = sum([float(x) for x in sys.argv[1:] if x.isdigit()])
print(f"参数的数字和: {result}")

# 模拟错误输出
# sys.stderr.write("这是一个来自 Python 脚本的错误消息！\n")

sys.exit(0) # 0 表示成功，非 0 表示失败

“`

优缺点

• 优点：
  • 简单直接： 无需额外的库或复杂配置。
  • 隔离性好： Python 脚本在独立进程中运行，与 Java 应用程序相互隔离，一个崩溃不会影响另一个。
  • 语言无关： 只要系统安装了 Python 解释器，就可以运行任何 Python 脚本。
  • 支持所有 Python 库： 可以使用所有标准的 Python 库，包括 C 扩展库（如 NumPy, TensorFlow）。
• 缺点：
  • 性能开销： 每次调用都需要启动一个新的 Python 解释器进程，这会带来一定的启动开销，不适合高频率、低延迟的调用。
  • 数据传递复杂： Java 和 Python 之间的数据传输主要通过标准输入/输出流进行，通常需要进行字符串序列化（如 JSON、CSV）和反序列化，这增加了复杂性。
  • 错误处理： 捕获 Python 脚本的详细错误信息可能需要额外的解析工作。

适用场景

适用于批处理任务、偶尔执行的复杂计算、调用包含 C 扩展的 Python 库、或当 Python 脚本已经存在且无需紧密集成时的场景。

2. Jython – Python 在 JVM 上的实现

Jython 是 Python 语言在 Java 虚拟机 (JVM) 上的实现。它允许您直接在 Java 应用程序中运行 Python 代码，并实现 Java 和 Python 对象之间的无缝交互。

原理

Jython 将 Python 代码编译成 Java 字节码并在 JVM 上执行。这意味着您可以像调用任何其他 Java 类一样调用 Python 类和方法，反之亦然。Jython 解释器作为一个库嵌入到您的 Java 应用程序中。

实现方式

1. 添加 Jython 依赖：
   如果您使用 Maven：
   xml
<dependency>
<groupId>org.python</groupId>
<artifactId>jython-standalone</artifactId>
<version>2.7.3</version> <!-- 使用最新稳定版 -->
</dependency>
   如果您使用 Gradle：
   gradle
implementation 'org.python:jython-standalone:2.7.3'

2. 在 Java 中调用 Python：

   “`java
   import org.python.util.PythonInterpreter;
   import org.python.core.*; // 导入 Jython 核心类

   public class JythonCaller {

   public static void main(String[] args) {
       // 方式一：直接执行 Python 字符串
       try (PythonInterpreter interp = new PythonInterpreter()) {
           interp.exec("import sys");
           interp.exec("print('Hello from Jython!')");
           interp.exec("a = 10");
           interp.exec("b = 20");
           interp.exec("print('a + b =', a + b)");
   
           // 获取 Python 变量的值
           PyObject sum = interp.get("a").__add__(interp.get("b"));
           System.out.println("Java 中获取的 a + b = " + sum);
   
           // 定义 Python 函数并在 Java 中调用
           interp.exec("def greet(name):\n  return 'Hello, ' + name + '!'");
           PyFunction greetFunc = (PyFunction) interp.get("greet");
           PyObject result = greetFunc.__call__(new PyString("World from Java"));
           System.out.println("Java 调用 Python 函数结果: " + result.asString());
       }
   
       // 方式二：执行 Python 脚本文件
       try (PythonInterpreter interp = new PythonInterpreter()) {
           interp.execfile("path/to/your_jython_script.py");
   
           // 如果脚本中定义了函数或变量，可以通过 interp.get() 获取
           PyFunction multiplyFunc = (PyFunction) interp.get("multiply");
           PyObject product = multiplyFunc.__call__(new PyInteger(5), new PyInteger(6));
           System.out.println("Java 调用脚本中的 multiply 函数: " + product.asInt());
       }
   }
   

   }
   “`

   对应的 your_jython_script.py 示例：

   “`python

   your_jython_script.py

   def multiply(x, y):
   print(f”Jython 正在计算 {x} * {y}”)
   return x * y

   if name == “main“:
   print(“这个脚本在 Jython 中被执行了。”)
   “`

优缺点

• 优点：
  • 紧密集成： Python 代码直接在 JVM 中运行，没有进程间通信开销。
  • 对象互操作性： Java 对象和 Python 对象可以相互访问和操作，实现深度集成。
  • 内存共享： Java 和 Python 可以共享 JVM 内存。
• 缺点：
  • Python 版本限制： Jython 目前主要支持 Python 2.7.x，对 Python 3.x 的支持仍在开发中，这意味着无法使用许多现代 Python 库。
  • C 扩展库不兼容： Jython 无法运行任何依赖 C 语言扩展的 Python 库（如 NumPy, TensorFlow），这是其最大的局限性。
  • 性能差异： 对于纯 Python 代码，Jython 的性能可能与原生 CPython 解释器有所不同。
  • 生态系统较小： Jython 社区和库的数量远小于 CPython。

适用场景

适用于需要紧密集成、对象互操作性强、且不依赖 C 扩展库的 Python 2.x 代码的场景。例如，将现有 Python 2.x 业务逻辑嵌入到 Java 应用中。

3. Py4J – Java 到 Python 的桥梁

Py4J 允许 Python 程序动态地访问运行在 JVM 中的 Java 对象。虽然其主要设计目标是让 Python 调用 Java，但通过设置一个 Java 网关服务器，Python 也可以作为服务方，提供接口供 Java 调用。

原理

Py4J 通过一个 TCP/IP 套接字在 Java 应用程序和 Python 解释器之间建立通信。Java 应用程序启动一个 GatewayServer，并在其中暴露需要被 Python 访问的 Java 对象。Python 客户端通过 GatewayClient 连接到这个服务器，从而可以调用 Java 对象的方法。反过来，Java 也可以通过 Py4J 启动一个 Python 进程，并通过这个桥梁来调用 Python 函数。

实现方式

1. 添加 Py4J 依赖 (Java 端)：
   如果您使用 Maven：
   xml
<dependency>
<groupId>net.sf.py4j</groupId>
<artifactId>py4j</artifactId>
<version>0.10.9.7</version> <!-- 使用最新稳定版 -->
</dependency>

2. Java 端 (启动网关并暴露方法)：

   “`java
   import py4j.GatewayServer;

   public class JavaGateway {
   public String sayHello(String name) {
   return “Hello from Java, ” + name + “!”;
   }

   public int add(int a, int b) {
       return a + b;
   }
   
   public static void main(String[] args) {
       JavaGateway app = new JavaGateway();
       // 启动 GatewayServer
       // 默认端口 25333
       GatewayServer gatewayServer = new GatewayServer(app);
       gatewayServer.start();
       System.out.println("Py4J Gateway Server 启动成功！");
       System.out.println("你可以从 Python 客户端连接到它。");
       // 阻止主线程退出，以便 GatewayServer 持续运行
       // 实际应用中可能需要更优雅的关闭机制
       try {
           Thread.currentThread().join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       // gatewayServer.shutdown(); // 在适当的时候关闭
   }
   

   }
   “`

3. Python 端 (作为客户端调用 Java 方法)：

   首先，安装 Py4J：pip install py4j

   “`python

   python_client.py

   from py4j.java_gateway import JavaGateway, GatewayParameters
   import subprocess
   import time
   import sys

   启动 Java GatewayServer (如果它还没有运行)

   这是一种从 Python 启动 Java 进程并连接的方式，或者你可以在另一个终端手动启动 JavaGateway

   def start_java_gateway():
   print(“尝试启动 Java GatewayServer…”)
   # 确保 classpath 正确，包含 py4j.jar 和编译后的 JavaGateway.class
   # 假设 JavaGateway.class 位于当前目录，py4j-0.10.9.7.jar 也在
   # 真实项目中，你需要调整这里的路径和 classname
   java_cmd = [
   “java”,
   “-cp”,
   “.;path/to/py4j-0.10.9.7.jar”, # Windows
   # “java”, “-cp”, “.:path/to/py4j-0.10.9.7.jar”, # Linux/macOS
   “JavaGateway” # 你的 Java 主类名
   ]
   # 注意：这里只是一个示例，实际生产环境可能需要更健壮的进程管理
   process = subprocess.Popen(java_cmd, stdout=sys.stdout, stderr=sys.stderr)
   # 等待 Gateway Server 启动，给它一些时间
   time.sleep(5)
   return process

   java_process = None
   try:
   # 尝试连接，如果失败则启动 Java 进程
   try:
   gateway = JavaGateway(gateway_parameters=GatewayParameters(port=25333))
   print(“已连接到运行中的 Java GatewayServer。”)
   except Exception as e:
   print(f”连接失败: {e}. 尝试启动 Java 进程。”)
   java_process = start_java_gateway()
   gateway = JavaGateway(gateway_parameters=GatewayParameters(port=25333))
   print(“成功启动并连接到新的 Java GatewayServer。”)

   # 获取根对象（即 JavaGateway 的实例）
   java_app = gateway.entry_point
   
   # 调用 Java 方法
   greeting = java_app.sayHello("Python Client")
   print(f"从 Java 接收到的问候: {greeting}")
   
   sum_result = java_app.add(100, 200)
   print(f"从 Java 接收到的和: {sum_result}")
   
   # Java 可以通过反射调用 Python 回调 (更高级用法)
   # Python 也可以暴露一个对象供 Java 回调
   class PythonCallback:
       def callback_method(self, message):
           print(f"Python 收到 Java 回调: {message}")
           return "Python callback processed: " + message
   
       class Java:
           implements = ['py4j.examples.CallbackInterface'] # 假设 Java 有一个接口
   
   # 示例：Python 暴露一个对象给 Java
   # gateway.jvm.py4j.GatewayServer.currentGatewayServer().start()
   # gateway.jvm.py4j.GatewayServer.currentGatewayServer().entryPoint = PythonCallback()
   

   except Exception as e:
   print(f”发生错误: {e}”)
   finally:
   if java_process:
   print(“关闭 Java GatewayServer 进程…”)
   java_process.terminate() # 或者 java_process.kill()
   java_process.wait()
   print(“Java GatewayServer 进程已关闭。”)
   “`

优缺点

• 优点：
  • 双向通信： Py4J 允许 Java 调用 Python，也允许 Python 调用 Java，实现高度互操作性。
  • 对象传递： 可以直接传递 Java 对象给 Python，反之亦然，无需复杂的序列化/反序列化。
  • 保持语言特性： Python 运行在 CPython 解释器中，可以利用所有 C 扩展库（如 NumPy, Pandas）。
  • 进程隔离： Java 和 Python 运行在不同的进程中，提高稳定性。
• 缺点：
  • 配置相对复杂： 需要启动和管理 GatewayServer，并在 Python 客户端进行连接。
  • 网络开销： 通信通过 TCP/IP 套接字进行，虽然比每次启动新进程效率高，但仍有网络延迟。
  • 端口管理： 需要确保网关端口可用且不冲突。

适用场景

适用于需要高度交互、双向通信、且 Python 依赖 C 扩展库的场景。例如，Java 应用程序需要频繁调用 Python 机器学习模型，并且模型可能需要访问 Java 传递过来的数据结构。

4. 远程过程调用 (RPC) 或消息队列

这是一种更通用的跨语言集成模式，不仅仅局限于 Java 和 Python，适用于构建分布式系统。

原理

在这种模式下，Python 应用程序作为一个独立的微服务运行，暴露一个 API 接口（如 RESTful API 或 gRPC 服务）。Java 应用程序通过网络调用这些 API 来与 Python 服务进行通信。

• RESTful API： Python (例如使用 Flask, Django, FastAPI) 创建一个 Web 服务，接收 HTTP 请求并返回 JSON 数据。Java (例如使用 HttpClient, Spring RestTemplate/WebClient) 发送 HTTP 请求并解析响应。
• gRPC： 使用 Protocol Buffers 定义服务接口，生成 Java 和 Python 的客户端/服务器代码。gRPC 提供了高性能、低延迟的通信。
• 消息队列： Java 应用程序将消息发送到消息队列（如 RabbitMQ, Apache Kafka），Python 应用程序作为消费者从队列中获取消息并处理，然后将结果通过另一个队列或 API 返回。

实现方式 (以 RESTful API 为例)

Python 端 (FastAPI)：

“`python

python_service.py

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
name: str
price: float
is_offer: bool = None

@app.get(“/”)
def read_root():
return {“message”: “Hello from Python FastAPI!”}

@app.post(“/calculate_sum”)
def calculate_sum(data: dict):
try:
numbers = data.get(“numbers”, [])
total = sum(numbers)
return {“result”: total}
except Exception as e:
return {“error”: str(e)}, 400

if name == “main“:
import uvicorn
# 运行 FastAPI 服务
# uvicorn python_service:app –host 0.0.0.0 –port 8000
print(“运行 ‘uvicorn python_service:app –host 0.0.0.0 –port 8000’ 来启动服务”)
“`

Java 端 (HttpClient)：

“`java
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.fasterxml.jackson.databind.ObjectMapper; // 需要 Jackson 库处理 JSON

public class PythonApiClient {

public static void main(String[] args) {
    HttpClient client = HttpClient.newHttpClient();
    ObjectMapper mapper = new ObjectMapper(); // 用于 JSON 序列化和反序列化

    // 调用 GET 请求
    HttpRequest getRequest = HttpRequest.newBuilder()
            .uri(URI.create("http://localhost:8000/"))
            .GET()
            .build();

    try {
        HttpResponse<String> getResponse = client.send(getRequest, HttpResponse.BodyHandlers.ofString());
        System.out.println("GET 响应状态码: " + getResponse.statusCode());
        System.out.println("GET 响应体: " + getResponse.body());
    } catch (IOException | InterruptedException e) {
        e.printStackTrace();
    }

    // 调用 POST 请求
    try {
        String requestBody = mapper.writeValueAsString(new RequestData(new int[]{10, 20, 30}));

        HttpRequest postRequest = HttpRequest.newBuilder()
                .uri(URI.create("http://localhost:8000/calculate_sum"))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                .build();

        HttpResponse<String> postResponse = client.send(postRequest, HttpResponse.BodyHandlers.ofString());
        System.out.println("POST 响应状态码: " + postResponse.statusCode());
        System.out.println("POST 响应体: " + postResponse.body());

        // 解析 JSON 响应
        ResponseData responseData = mapper.readValue(postResponse.body(), ResponseData.class);
        System.out.println("计算结果: " + responseData.result);

    } catch (IOException | InterruptedException e) {
        e.printStackTrace();
    }
}

// 用于 POST 请求数据的类
static class RequestData {
    public int[] numbers;
    public RequestData(int[] numbers) {
        this.numbers = numbers;
    }
}

// 用于解析 POST 响应数据的类
static class ResponseData {
    public double result;
    public String error;
}

}
“`

优缺点

• 优点：
  • 语言无关： 只要遵循通信协议，任何语言都可以与其他语言集成。
  • 高度解耦： Java 和 Python 应用程序完全独立，可以独立开发、部署和扩展。
  • 弹性与可伸缩性： 可以轻松扩展 Python 服务以处理高并发请求。
  • 适用于分布式系统： 天然适合微服务架构。
  • 完全支持 Python 3.x 及所有库： Python 服务运行在原生的 CPython 解释器中。
• 缺点：
  • 网络开销： 所有的通信都需要通过网络，带来延迟。
  • 序列化开销： 数据需要在两端进行序列化和反序列化。
  • 复杂性增加： 需要额外的基础设施（Web 服务器、消息队列），增加了系统整体的复杂性。

适用场景

适用于构建微服务架构、需要高可伸缩性、分布式部署、或当 Java 和 Python 服务需要长时间独立运行但又需相互协作的场景。

5. JNI/JNA (通过 C/C++ 桥接)

这是一种更底层、更复杂的集成方式，通常在性能要求极高或需要直接操作 CPython 解释器 API 时使用。

原理

Java Native Interface (JNI) 或 Java Native Access (JNA) 允许 Java 代码调用 C/C++ 代码。通过 JNI/JNA，Java 可以调用一个用 C/C++ 编写的包装器库，该库又可以嵌入 CPython 解释器，并执行 Python 代码。

优缺点

• 优点：
  • 最高性能： 可以实现最快的调用速度和最细粒度的控制。
  • 直接访问 CPython API： 可以直接操作 Python 解释器内部结构。
• 缺点：
  • 极度复杂： 需要深入理解 JNI/JNA、C/C++ 和 Python C API，开发和调试难度极高。
  • 平台依赖： 生成的 C/C++ 库是平台特定的，需要为每个操作系统和架构单独编译。
  • 内存管理： 需要手动管理内存，容易出错。

适用场景

非常规且高度专业化的场景，例如开发 Java-Python 混合语言编译器、深度嵌入式系统、或需要极致性能且其他方法无法满足需求的场景。对于大多数应用，不推荐使用此方法。

如何选择合适的方法？

选择哪种集成方法取决于您的具体需求和约束：

方法	优点	缺点	适用场景
命令行执行	简单、隔离、支持所有 Python 库和版本	性能开销大、数据传递复杂、错误处理繁琐	批处理、偶尔调用、脚本执行、无需紧密集成
Jython	紧密集成、对象互操作、内存共享	仅支持 Python 2.x、不兼容 C 扩展库、性能差异	需要紧密集成 Python 2.x 代码，不依赖 C 扩展库
Py4J	双向通信、对象传递、支持 C 扩展库、进程隔离	配置相对复杂、网络开销、端口管理	高度交互、频繁调用、需要 Python C 扩展库、双向通信
RPC/消息队列	语言无关、高度解耦、弹性、可伸缩、分布式	网络开销、序列化开销、复杂性增加	微服务、分布式系统、高并发、长期独立运行服务
JNI/JNA (通过 C/C++)	最高性能、直接访问 CPython API	极度复杂、平台依赖、内存管理	极致性能要求、深度嵌入、高级自定义（不推荐日常使用）

决策流程：

1. Python 版本和库依赖： 您的 Python 代码是否依赖 Python 3.x 或 C 扩展库 (如 NumPy, TensorFlow)？
   • 是：排除 Jython。
   • 否 (仅 Python 2.x 且无 C 扩展)：可以考虑 Jython 以实现紧密集成。
2. 调用频率和性能要求： 调用是偶尔发生还是高频率低延迟？
   • 偶尔/批处理：命令行执行可能足够。
   • 高频率/低延迟：Py4J 或 RPC/消息队列更合适，JNI/JNA 性能最高但复杂。
3. 集成紧密程度： Java 和 Python 代码之间是否需要深度交互和对象传递？
   • 是：Py4J 或 Jython (如果符合 Python 版本/库要求) 是最佳选择。
   • 否：命令行执行或 RPC/消息队列更简单。
4. 架构和可伸缩性： 是否需要构建分布式系统或微服务？
   • 是：RPC/消息队列是标准实践。
5. 开发和维护成本： 您或您的团队对各种技术的熟悉程度？
   • 通常，命令行执行是最简单的，RPC/消息队列次之，Jython 和 Py4J 略复杂，JNI/JNA 最复杂。

最佳实践和注意事项

• 错误处理： 无论选择哪种方法，都应建立健全的错误处理机制。捕获 Python 脚本的 stdout 和 stderr，并解析其错误信息，以便在 Java 应用程序中进行适当的响应。
• 数据序列化/反序列化： 当通过流或网络传输数据时，选择高效且可靠的序列化格式，如 JSON、Protocol Buffers 或 Apache Avro。
• Python 环境管理： 对于命令行执行或 Py4J，确保 Java 应用程序能够找到正确的 Python 解释器和依赖库。建议在 Python 端使用虚拟环境 (venv/conda)，并在 Java 中指定虚拟环境中的 Python 解释器路径。
• 安全性： 当执行外部进程或建立网络通信时，要考虑潜在的安全风险。避免执行来自不可信源的 Python 脚本，并对传入数据进行严格验证。
• 资源管理： 确保正确关闭所有打开的流、进程和网络连接，以避免资源泄漏。
• 异步调用： 对于长时间运行的 Python 任务，考虑在 Java 中使用异步编程模型（如 CompletableFuture）来避免阻塞主线程。

总结

Java 调用 Python 是一个强大的集成能力，它使得开发者能够充分利用这两种语言的优势，构建功能更丰富、性能更优越的应用程序。从简单的命令行执行到复杂的 RPC 架构，再到紧密集成的 Jython 和 Py4J 桥梁，每种方法都有其独特的适用场景。理解它们的原理、优缺点和最佳实践，将帮助您为项目选择最合适的集成策略，从而有效地提升开发效率和系统能力。
“`