Java调用Python脚本实现HelloWorld的示例详解_Java

作为程序员，我们经常会遇到需要在java项目中调用python脚本的场景。可能是为了复用现成的python工具库，也可能是需要利用python在数据处理上的优势。本文不聊太多理论，直接上手三种实用的调用方式，从基础到进阶，一步步实现java与python的"helloworld"交互。

一、环境准备

在开始之前，确保你的开发环境满足以下条件：

java环境：jdk 8+（推荐11），配置好java_home
python环境：python 3.6+，配置好path（命令行输入python --version能正常显示版本）
开发工具：任意ide，文本编辑器（用于写python脚本）

验证环境的小技巧：

# 检查java
java -version
# 检查python
python --version  # 或python3 --version（根据系统配置）

如果python命令无法识别，大概率是没配置环境变量。windows用户可以在"设置-系统-关于-高级系统设置-环境变量"中添加python安装路径；linux/mac用户可以在~/.bashrc或~/.zshrc中添加export path=$path:/usr/local/python3/bin（替换为实际路径）。

二、基础调用：使用 runtime.exec()

这是最直接的调用方式，通过java的runtime类启动python进程执行脚本。适合简单场景，无需复杂交互。

2.1 实现步骤

步骤1：编写python脚本

创建hello.py，放在java项目的根目录（或指定绝对路径）：

# 接收java传递的参数
import sys

if __name__ == "__main__":
    # 获取java传入的参数（第0个参数是脚本名）
    name = sys.argv[1] if len(sys.argv) > 1 else "world"
    # 输出结果（会被java捕获）
    print(f"hello, {name}! from python")

步骤2：编写java调用代码

创建javacallpythonbyruntime.java：

import java.io.bufferedreader;
import java.io.ioexception;
import java.io.inputstream;
import java.io.inputstreamreader;

public class javacallpythonbyruntime {
    public static void main(string[] args) {
        // 1. 定义python脚本路径和参数
        string pythonscriptpath = "hello.py";
        string param = "java";  // 要传递给python的参数

        // 2. 构建命令数组（推荐用数组形式，避免空格问题）
        string[] cmd = new string[]{"python", pythonscriptpath, param};

        try {
            // 3. 启动python进程
            process process = runtime.getruntime().exec(cmd);

            // 4. 读取python的输出（必须读取，否则可能导致进程阻塞）
            inputstream inputstream = process.getinputstream();
            bufferedreader reader = new bufferedreader(
                new inputstreamreader(inputstream, "utf-8")  // 指定编码，避免中文乱码
            );
            string line;
            while ((line = reader.readline()) != null) {
                system.out.println("python输出：" + line);
            }

            // 5. 等待进程执行完成并获取退出码（0表示成功）
            int exitcode = process.waitfor();
            system.out.println("进程退出码：" + exitcode);

        } catch (ioexception | interruptedexception e) {
            e.printstacktrace();
        }
    }
}

2.2 代码解析

命令数组：用string[]而不是单字符串，避免路径或参数包含空格时解析错误（比如脚本路径是d:\my script\hello.py）。
输入流处理：python的print输出会写入进程的输入流，java必须读取这些内容，否则缓冲区满了会导致进程卡住。
编码设置：inputstreamreader指定utf-8，解决windows系统下默认gbk编码导致的中文乱码问题。
退出码：process.waitfor()返回的退出码能帮我们判断脚本是否正常执行（非0通常表示出错）。

三、进阶调用：使用 processbuilder

processbuilder是jdk 5引入的类，比runtime.exec()更灵活，支持设置工作目录、环境变量等，适合复杂场景。

3.1 实现步骤

步骤1：复用python脚本

继续使用前面的hello.py，稍作修改支持从环境变量读取配置：

import sys
import os

if __name__ == "__main__":
    name = sys.argv[1] if len(sys.argv) > 1 else "world"
    # 读取java设置的环境变量
    app_name = os.getenv("app_name", "unknownapp")
    print(f"[{app_name}] hello, {name}! from python")

步骤2：编写java代码

创建javacallpythonbyprocessbuilder.java：

import java.io.bufferedreader;
import java.io.ioexception;
import java.io.inputstreamreader;
import java.util.map;

public class javacallpythonbyprocessbuilder {
    public static void main(string[] args) {
        try {
            // 1. 创建processbuilder，指定命令和参数
            processbuilder pb = new processbuilder(
                "python", "hello.py", "javadeveloper"
            );

            // 2. 设置工作目录（脚本所在目录，不设置则默认当前目录）
            pb.directory(new java.io.file("./scripts"));  // 假设脚本放在scripts子目录

            // 3. 设置环境变量（给python脚本传递配置）
            map<string, string> env = pb.environment();
            env.put("app_name", "javacallpythondemo");

            // 4. 重定向错误流到输入流（方便统一处理输出和错误）
            pb.redirecterrorstream(true);

            // 5. 启动进程
            process process = pb.start();

            // 6. 读取输出
            try (bufferedreader reader = new bufferedreader(
                new inputstreamreader(process.getinputstream(), "utf-8")
            )) {
                string line;
                while ((line = reader.readline()) != null) {
                    system.out.println("python输出：" + line);
                }
            }

            // 7. 等待进程完成
            int exitcode = process.waitfor();
            system.out.println("进程退出码：" + exitcode);

        } catch (ioexception | interruptedexception e) {
            e.printstacktrace();
        }
    }
}

3.2 代码解析

工作目录：pb.directory()指定脚本所在目录，避免路径混乱。比如脚本放在./scripts，就不用写全路径了。
环境变量：通过pb.environment()设置的变量，python可以用os.getenv()获取，适合传递配置信息（如api密钥、环境标识）。
错误流重定向：redirecterrorstream(true)将错误信息合并到输入流，不用单独处理geterrorstream()，简化代码。
资源自动关闭：try-with-resources语法确保bufferedreader自动关闭，避免资源泄漏。

四、服务化调用：http接口通信

当java和python需要频繁交互，或需要跨服务器调用时，将python脚本封装成http服务是更优的方案。这里用flask搭建简单接口。

4.1 实现步骤

步骤1：搭建python http服务

首先安装flask：

pip install flask

创建hello_service.py：

from flask import flask, request

app = flask(__name__)

@app.route('/hello', methods=['get'])
def hello():
    # 从请求参数获取name
    name = request.args.get('name', 'world')
    return f"hello, {name}! from python service"

if __name__ == '__main__':
    # 启动服务，允许外部访问
    app.run(host='0.0.0.0', port=5000, debug=true)

步骤2：编写java http客户端

创建javacallpythonbyhttp.java，使用jdk自带的httpclient（jdk 11+）：

import java.net.uri;
import java.net.http.httpclient;
import java.net.http.httprequest;
import java.net.http.httpresponse;
import java.time.duration;

public class javacallpythonbyhttp {
    public static void main(string[] args) {
        // 1. 创建httpclient
        httpclient client = httpclient.newbuilder()
                .connecttimeout(duration.ofseconds(5))
                .build();

        // 2. 构建请求（python服务地址）
        string name = "javahttpclient";
        httprequest request = httprequest.newbuilder()
                .uri(uri.create("http://localhost:5000/hello?name=" + name))
                .timeout(duration.ofseconds(3))
                .get()
                .build();

        try {
            // 3. 发送请求并获取响应
            httpresponse<string> response = client.send(
                request, httpresponse.bodyhandlers.ofstring()
            );

            // 4. 处理响应
            if (response.statuscode() == 200) {
                system.out.println("python服务响应：" + response.body());
            } else {
                system.err.println("请求失败，状态码：" + response.statuscode());
            }

        } catch (exception e) {
            e.printstacktrace();
        }
    }
}

4.2 代码解析

python服务：用flask创建/hello接口，通过request.args获取java传递的参数，返回字符串。debug=true方便开发时自动重启。
java客户端：jdk 11的httpclient比传统的httpurlconnection更简洁，支持异步调用（sendasync），这里用同步send更直观。
跨机器调用：只要python服务的host设为0.0.0.0，并开放5000端口，java可以通过服务器ip访问（如http://192.168.1.100:5000/hello）。

五、三种方法对比与选择建议

调用方式	优点	缺点	适用场景
runtime.exec()	简单直接，无需额外依赖	灵活性差，不便于设置环境和工作目录	简单脚本，一次性调用
processbuilder	支持环境变量、工作目录，错误流合并	代码稍复杂，仍需处理进程通信	复杂脚本，需要传递配置信息
http接口	松耦合，支持跨机器，可异步	需要维护http服务，有网络开销	频繁交互，分布式系统，跨语言调用