Java 调用
Python 是可行的，但是否“方便”取决于具体的应用场景、技术选型以及集成方式。下面详细介绍 Java 如何调用
Python，常用的实现方法，以及各自的优缺点。
---
### ✅ 实现方式一：使用 `Runtime` 或 `ProcessBuilder` 执行
Python 脚本
这是最简单直接的方式，通过启动一个外部进程来运行
Python 脚本。
#### 示例代码：
```java
import java.io.*;
public class
PythonCaller {
public static void main(String[] args) {
try {
// 构建命令：
python script.py arg1 arg2
ProcessBuilder pb = new ProcessBuilder("
python", "hello.py", "Alice");
pb.redirectErrorStream(true);
Process process = pb.start();
// 读取
Python 脚本输出
BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
int exitCode = process.waitFor();
System.out.println("
Python script exited with code: " + exitCode);
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}
```
对应的 `hello.py` 文件：
```
python
import sys
name = sys.argv[1]
print(f"Hello from
Python, {name}!")
print("This is a test output.")
```
#### 解释：
- 使用 `ProcessBuilder` 启动
Python 解释器并执行 `.py` 文件。
- Java 可以传参给
Python 脚本（通过 `sys.argv`）。
- 输出通过标准输出流返回给 Java 程序。
- 适用于独立任务，如数据处理、机器学习推理等。
---
### ✅ 实现方式二：使用 **Jython**（不推荐用于现代项目）
[Jython](https://www.jython.org/) 是
Python 在 JVM 上的实现，可以直接在 Java 中调用
Python 代码。
#### 示例代码（Jython）：
```java
import org.
python.util.
PythonInterpreter;
import org.
python.core.*;
public class JythonExample {
public static void main(String[] args) {
try (
PythonInterpreter py = new
PythonInterpreter()) {
py.exec("print('Hello from Jython!')");
py.set("x", new PyInteger(42));
py.exec("y = x + 10");
PyObject y = py.get("y");
System.out.println("y = " + y.toString());
}
}
}
```
> 注意：需要引入 `jython-standalone` 依赖（Maven）：
```xml
<dependency>
<groupId>org.
python</groupId>
<artifactId>jython-standalone</artifactId>
<version>2.7.3</version>
</dependency>
```
#### 缺点：
- **仅支持
Python 2.7**，无法使用
Python 3 的语法和库（如 TensorFlow、PyTorch、pandas 等）。
- 社区维护缓慢，功能受限。
- 性能不如原生 C
Python。
✅
优点是完全嵌入 JVM，无缝交互对象。
❌ 因此 **不推荐用于生产环境**，尤其是涉及现代
Python 库时。
---
### ✅ 实现方式三：通过 **REST API / Flask/FastAPI 封装
Python 服务**
将
Python 功能封装为 Web 接口，Java 通过 HTTP 调用。
####
Python 服务示例（Flask）：
```
python
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route("/greet", methods=["POST"])
def greet():
data = request.json
name = data.get("name", "World")
return jsonify({"message": f"Hello, {name} from
Python!"})
if __name__ == "__main__":
app.run(port=5000)
```
#### Java 调用代码（使用 OkHttp 或 HttpURLConnection）：
```java
import okhttp3.*;
public class ApiService {
private static final MediaType JSON = MediaType.get("application/json; charset=utf-8");
private final OkHttpClient client = new OkHttpClient();
private final String url = "http://localhost:5000/greet";
public void call
PythonService() throws IOException {
String json = "{\"name\": \"JavaApp\"}";
RequestBody body = RequestBody.create(json, JSON);
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
try (Response response = client.newCall(request).execute()) {
if (response.isSuccessful() && response.body() != null) {
System.out.println(response.body().string());
} else {
System.err.println("Error: " + response.code());
}
}
}
public static void main(String[] args) throws IOException {
new ApiService().call
PythonService();
}
}
```
####
优点：
- 完全解耦，
语言无关。
- 支持复杂数据结构（JSON/XML）。
- 易于扩展、部署、监控。
- 可以利用成熟的
Python 框架（如 FastAPI、Flask、Django）。
#### 缺点：
- 需要额外启动服务，增加运维成本。
- 存在网络延迟、序列化开销。
- 需处理异常、超时、重试等。
---
### ✅ 实现方式四：使用 **Py4J**（推荐用于深度集成）
[Py4J](https://www.py4j.org/) 允许 Java 和
Python 在同一台机器上进行跨
语言通信。
Python 启动一个 gateway server，Java 连接它并调用其函数。
####
Python 端代码（gateway_server.py）：
```
python
from py4j.java_gateway import JavaGateway, GatewayServer
class MathOperations:
def add(self, a, b):
return a + b
def multiply(self, a, b):
return a * b
class Java:
# Magic for Py4J exposure
implements = ["com.example.MathOperations"]
if __name__ == "__main__":
gateway = GatewayServer(MathOperations(), port=25333)
print("Gateway Server started on port 25333")
gateway.start()
```
#### Java 接口定义（可选）：
```java
package com.example;
public interface MathOperations {
double add(double a, double b);
double multiply(double a, double b);
}
```
#### Java 调用端：
```java
import py4j.GatewayServer;
public class Py4JClient {
public static void main(String[] args) {
GatewayServer gatewayServer = new GatewayServer(null, 25333);
MathOperations math = (MathOperations) gatewayServer.get
PythonServerEntryPoint(new String[]{"com.example.MathOperations"});
System.out.println("Add: " + math.add(3.5, 4.5)); // 输出 8.0
System.out.println("Multiply: " + math.multiply(3, 4)); // 输出 12.0
}
}
```
> 需安装 Py4J：`pip install py4j`
####
优点：
- 实现近乎本地方法调用。
- 支持双向调用（Java ←→
Python）。
- 支持复杂对象传递（需注意类型映射）。
- 比进程通信更高效。
#### 缺点：
- 配置稍复杂。
- 需确保
Python 服务常驻或自动重启。
- 不适合高并发场景（单线程默认）。
---
## ✅ 总结：各种方式对比
| 方法 | 是否推荐 |
优点 | 缺点 |
|------|----------|------|--------|
| `Runtime/ProcessBuilder` | ⭐⭐⭐☆ | 简单易用，无需依赖 | 启动慢，难传复杂对象，错误处理弱 |
| Jython | ❌ | 完全集成 JVM | 不支持
Python 3，生态落后 |
| REST API | ⭐⭐⭐⭐⭐ | 解耦好，跨平台，易维护 | 多一层服务，有网络开销 |
| Py4J | ⭐⭐⭐⭐ | 高效、支持对象传递 | 需维护 gateway，学习曲线略高 |
---
## 🏁 建议选择策略：
- 如果只是偶尔调用
脚本 → 用 `ProcessBuilder`
- 如果要频繁交互且在同一主机 → 用 **Py4J**
- 如果是微服务架构 → 用 **REST API**
- 如果想避免外部依赖 → 不要用 Jython（已过时）
---
###
本文介绍了Python自动化在测试中的应用，强调了其节省人力、时间、优化资源分配以及提高软件可信度的优点。同时，提供了Python学习的路线图，包括基础到进阶的学习资源和实战案例，以及面试准备材料。
扫一扫
8511
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
