扩展资料:Java与Python常用的交互手段

java                  import java.io.BufferedReader;                  import java.io.IOException;                  import java.io.InputStreamReader;                  public class JavaCallPythonCmd {                  public static void main(String[] args) {                  try {                  // 1. 定义Python脚本路径、Python解释器路径                  String pythonPath = "D:/Python311/python.exe"; // 本地Python解释器路径                  String scriptPath = "D:/test/script.py"; // Python脚本路径                  // 2. 传递参数（如Java向Python传递数据）                  String param1 = "Java传递的参数1";                  String param2 = "12345";                  // 3. 构建命令（数组形式，避免空格解析异常）                  String[] cmd = {pythonPath, scriptPath, param1, param2};                  // 4. 执行命令，创建子进程                  Process process = Runtime.getRuntime().exec(cmd);                  // 5. 读取Python脚本的输出结果（标准输出流）                  BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream(), "UTF-8"));                  String line;                  StringBuilder result = new StringBuilder();                  while ((line = br.readLine()) != null) {                  result.append(line);                  }                  // 6. 等待子进程执行完成，获取退出码（0表示正常执行）                  int exitCode = process.waitFor();                  if (exitCode == 0) {                  System.out.println("Python脚本执行成功，结果：" + result);                  } else {                  // 读取错误信息（标准错误流）                  BufferedReader errorBr = new BufferedReader(new InputStreamReader(process.getErrorStream(), "UTF-8"));                  String errorMsg = errorBr.readLine();                  System.out.println("Python脚本执行失败，错误信息：" + errorMsg);                  }                  // 关闭流资源                  br.close();                  process.destroy();                  } catch (IOException | InterruptedException e) {                  e.printStackTrace();                  }                  }                  }

python                  import sys                  # 接收Java传递的参数（sys.argv[0]是脚本本身，从sys.argv[1]开始是传递的参数）                  param1 = sys.argv[1]                  param2 = sys.argv[2]                  # 处理参数（示例：将param2转换为整数，做简单计算）                  try:                  param2_int = int(param2)                  result = f"参数1：{param1}，参数2（整数）：{param2_int}，计算结果：{param2_int * 2}"                  # 输出结果（Java侧通过输入流读取）                  print(result)                  except Exception as e:                  # 输出错误信息（Java侧读取错误流）                  print(f"参数处理失败：{str(e)}", file=sys.stderr)

python                  import socket                  import json                  # 1. 创建TCP socket                  server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)                  # 2. 绑定IP和端口（本地IP：127.0.0.1，端口：9999，避免端口冲突）                  server.bind(("127.0.0.1", 9999))                  # 3. 监听连接（最大等待连接数：5）                  server.listen(5)                  print("Python TCP服务器启动，等待Java客户端连接...")                  while True:                  # 4. 接受客户端连接（阻塞等待）                  client, addr = server.accept()                  print(f"Java客户端连接成功：{addr}")                  try:                  # 5. 接收Java发送的数据（指定缓冲区大小，根据实际数据调整）                  data = client.recv(1024).decode("UTF-8")                  if not data:                  break                  # 6. 解析JSON数据（Java传递的复杂数据）                  data_json = json.loads(data)                  print("接收Java数据：", data_json)                  # 7. 处理数据（示例：调用Python深度学习模型，返回结果）                  result = {                  "status": "success",                  "data": data_json["param1"] + "_processed",                  "msg": "处理完成"                  }                  # 8. 发送结果给Java（转换为JSON字符串）                  client.send(json.dumps(result).encode("UTF-8"))                  except Exception as e:                  error_msg = json.dumps({"status": "fail", "msg": str(e)})                  client.send(error_msg.encode("UTF-8"))                  finally:                  # 9. 关闭客户端连接                  client.close()                  # 关闭服务器（实际部署时可注释，保持长连接）                  # server.close()

java                  import java.io.OutputStream;                  import java.io.BufferedReader;                  import java.io.InputStreamReader;                  import java.net.Socket;                  import com.alibaba.fastjson.JSONObject; // 需导入fastjson依赖                  public class JavaSocketClient {                  public static void main(String[] args) {                  // 约定Python服务器的IP和端口（与Python侧一致）                  String serverIp = "127.0.0.1";                  int serverPort = 9999;                  try (Socket socket = new Socket(serverIp, serverPort)) {                  // 1. 构建发送给Python的数据（复杂数据，JSON格式）                  JSONObject sendData = new JSONObject();                  sendData.put("param1", "Java发送的复杂数据");                  sendData.put("param2", 6789);                  sendData.put("param3", true);                  // 2. 发送数据（转换为JSON字符串，编码为UTF-8）                  OutputStream os = socket.getOutputStream();                  os.write(sendData.toJSONString().getBytes("UTF-8"));                  os.flush(); // 强制刷新，确保数据发送完成                  // 3. 接收Python返回的结果                  BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));                  String result = br.readLine();                  // 4. 解析JSON结果                  JSONObject resultJson = JSONObject.parseObject(result);                  System.out.println("Python返回结果：" + resultJson);                  } catch (Exception e) {                  e.printStackTrace();                  }                  }                  }

python                  from flask import Flask, request, jsonify                  # 1. 创建Flask应用                  app = Flask(__name__)                  # 2. 定义接口（POST请求，接收Java传递的JSON数据）                  @app.route("/python/process", methods=["POST"])                  def process_data():                  try:                  # 接收Java传递的JSON数据                  data = request.get_json()                  if not data:                  return jsonify({"status": "fail", "msg": "未接收数据"}), 400                  # 处理数据（示例：调用Python算法、处理数据）                  param1 = data.get("param1")                  param2 = data.get("param2")                  processed_result = f"参数1：{param1}，参数2：{param2}，处理结果：{param1 + str(param2)}"                  # 返回结果（JSON格式，Java侧可直接解析）                  return jsonify({                  "status": "success",                  "data": processed_result,                  "msg": "接口调用成功"                  }), 200                  except Exception as e:                  return jsonify({"status": "fail", "msg": str(e)}), 500                  # 3. 启动服务（默认端口5000，可指定端口：app.run(port=8081)）                  if __name__ == "__main__":                  app.run(debug=True, host="0.0.0.0")# host=0.0.0.0允许外部访问

java                  import org.apache.http.client.methods.HttpPost;                  import org.apache.http.entity.StringEntity;                  import org.apache.http.impl.client.CloseableHttpClient;                  import org.apache.http.impl.client.HttpClients;                  import org.apache.http.util.EntityUtils;                  import com.alibaba.fastjson.JSONObject;                  public class JavaCallPythonHttp {                  public static void main(String[] args) {                  // Python接口地址（与Python侧Flask服务一致）                  String url = "http://127.0.0.1:5000/python/process";                  try (CloseableHttpClient httpClient = HttpClients.createDefault()) {                  // 1. 创建POST请求                  HttpPost httpPost = new HttpPost(url);                  // 2. 设置请求头（指定JSON格式）                  httpPost.setHeader("Content-Type", "application/json;charset=UTF-8");                  // 3. 构建请求参数（JSON格式）                  JSONObject requestParam = new JSONObject();                  requestParam.put("param1", "Java调用HTTP接口");                  requestParam.put("param2", 12345);                  // 4. 设置请求体（转换为JSON字符串）                  StringEntity entity = new StringEntity(requestParam.toJSONString(), "UTF-8");                  httpPost.setEntity(entity);                  // 5. 执行请求，获取响应                  org.apache.http.HttpResponse response = httpClient.execute(httpPost);                  // 6. 解析响应结果（判断响应码，200表示成功）                  if (response.getStatusLine().getStatusCode() == 200) {                  String result = EntityUtils.toString(response.getEntity(), "UTF-8");                  JSONObject resultJson = JSONObject.parseObject(result);                  System.out.println("Python接口返回结果：" + resultJson);                  } else {                  System.out.println("接口调用失败，响应码：" + response.getStatusLine().getStatusCode());                  }                  } catch (Exception e) {                  e.printStackTrace();                  }                  }                  }

java                  import org.python.util.PythonInterpreter;                  import org.python.core.PyObject;                  public class JavaCallPythonJython {                  public static void main(String[] args) {                  // 1. 初始化Python解释器                  PythonInterpreter interpreter = new PythonInterpreter();                  // 方式1：直接执行Python字符串（简单算法、代码片段）                  interpreter.exec("def add(a, b):\nreturn a + b"); // 定义Python函数                  PyObject addFunc = interpreter.get("add"); // 获取Python函数                  // 调用Python函数，传递参数（Java类型自动转换为Python类型）                  PyObject result1 = addFunc.__call__(new PyObject[]{new org.python.core.PyInteger(10), new org.python.core.PyInteger(20)});                  System.out.println("10+20=" + result1); // 输出：10+20=30                  // 方式2：调用Python脚本文件（复杂逻辑、多函数）                  interpreter.execfile("D:/test/script.py"); // 加载Python脚本                  PyObject multiplyFunc = interpreter.get("multiply"); // 获取脚本中的multiply函数                  PyObject result2 = multiplyFunc.__call__(new org.python.core.PyInteger(5), new org.python.core.PyInteger(6));                  System.out.println("5*6=" + result2); // 输出：5*6=30                  // 关闭解释器                  interpreter.close();                  }                  }

交互手段

核心优势

核心劣势

适用场景

命令行调用

简单易上手，无需额外依赖

效率低，仅支持单向交互，不适合高频、复杂数据

简单脚本调用、一次性数据处理

Socket通信

高频双向交互，效率高，支持长连接

需处理连接、重连逻辑，开发复杂度高

实时交互、高频数据传输（如模型调用、日志推送）

HTTP接口

解耦性强，易维护、易调试，跨平台

依赖网络，效率略低于Socket和Jython

企业级跨语言协同、多服务部署、复杂业务交互

Jython嵌入式

交互效率极高，无需独立进程

版本限制（支持Python 2.7），第三方库支持有限

Java频繁调用Python简单函数、算法片段

消息队列

解耦性极强，支持异步交互，可削峰填谷

实时性差，需部署消息队列服务

非实时交互、批量数据处理、跨服务器协同