Python与Java互操作的五种主流方式_Java

前言

在企业级应用开发中，python 和 java 常常需要协同工作——python 擅长数据科学和快速原型开发，java 则在大型系统和高性能后端方面表现优异。本指南将全面介绍 python 与 java 互操作的 5 种主流方式，涵盖从简单调用到深度集成的各种场景。

一、jython：在 jvm 中运行 python

1.1 基本概念

jython 是将 python 实现为 java 字节码的解释器，允许 python 代码直接调用 java 类库。

适用场景：

已有 java 系统需要嵌入 python 脚本功能
希望复用 java 生态中的成熟库

1.2 实战示例

# 安装：pip install jython

from java.util import arraylist

# 创建 java arraylist
java_list = arraylist()
java_list.add("java元素")
java_list.add(123)

# 调用 java 方法
print(java_list.size())  # 输出: 2

# 继承 java 类
from javax.swing import jframe

class myframe(jframe):
    def __init__(self):
        self.settitle("jython 示例")
        self.setsize(300, 200)
        self.setdefaultcloseoperation(jframe.exit_on_close)

frame = myframe()
frame.setvisible(true)

限制：

仅支持 python 2.7 语法
无法使用基于 c 的 python 扩展（如 numpy）

二、jpype：在 python 中调用 java

2.1 核心机制

jpype 通过 jni 桥接技术，让 python 代码可以创建 jvm 并调用 java 类。

适用场景：

python 主导的项目需要特定 java 库功能
需要完整的 java 8+ 支持

2.2 完整流程示例

# 安装：pip install jpype1

import jpype

# 启动 jvm（指定 jvm.dll 路径）
jpype.startjvm(jpype.getdefaultjvmpath(), 
              "-ea",
              "-djava.class.path=/path/to/your.jar")

# 导入 java 类
arraylist = jpype.jclass("java.util.arraylist")
system = jpype.jclass("java.lang.system")

# 使用 java 对象
java_list = arraylist()
java_list.add("测试数据")
system.out.println(java_list)  # 输出: [测试数据]

# 调用静态方法
collections = jpype.jclass("java.util.collections")
collections.sort(java_list)

# 关闭 jvm（程序结束前调用）
jpype.shutdownjvm()

性能提示：

避免频繁启动/关闭 jvm
使用 @jimplements 实现 java 接口

三、py4j：双向网关模式

3.1 架构原理

py4j 在 java 进程中运行网关服务器，python 通过 socket 与之通信。

优势：

支持回调（java 调用 python）
独立的进程空间更稳定

3.2 双向调用示例

java 服务端：

// 添加 maven 依赖
// <dependency>
//   <groupid>net.sf.py4j</groupid>
//   <artifactid>py4j</artifactid>
//   <version>0.10.9.5</version>
// </dependency>

import py4j.gatewayserver;

public class mathservice {
    public int add(int a, int b) {
        return a + b;
    }
    
    public static void main(string[] args) {
        gatewayserver server = new gatewayserver(new mathservice());
        server.start();
        system.out.println("gateway server started");
    }
}

python 客户端：

# 安装：pip install py4j

from py4j.java_gateway import javagateway

gateway = javagateway()                   # 连接默认网关
math_service = gateway.entry_point        # 获取java对象

result = math_service.add(10, 20)
print(result)  # 输出: 30

# 回调示例
class pythonlistener:
    def __init__(self, gateway):
        self.gateway = gateway
    
    def notify(self, message):
        print("java回调:", message)
        return "python已处理"

listener = pythonlistener(gateway)
gateway.jvm.system.setproperty("python.listener", 
                              gateway.jvm.py4j.gatewayserver.default_python_proxy_port)

四、grpc 跨语言通信

4.1 方案特点

基于 protocol buffers 的 idl
支持流式通信
语言中立

4.2 实现步骤

步骤1：定义 proto 文件

syntax = "proto3";

service dataprocessor {
  rpc process (datarequest) returns (dataresponse);
}

message datarequest {
  string content = 1;
  int32 priority = 2;
}

message dataresponse {
  bool success = 1;
  string result = 2;
}

步骤2：生成代码

# python 端
python -m grpc_tools.protoc -i. --python_out=. --grpc_python_out=. data.proto

# java 端（maven配置）
<build>
  <extensions>
    <extension>
      <groupid>kr.motd.maven</groupid>
      <artifactid>os-maven-plugin</artifactid>
      <version>1.6.2</version>
    </extension>
  </extensions>
  <plugins>
    <plugin>
      <groupid>org.xolstice.maven.plugins</groupid>
      <artifactid>protobuf-maven-plugin</artifactid>
      <version>0.6.1</version>
      <configuration>
        <protocartifact>com.google.protobuf:protoc:3.19.2:exe:${os.detected.classifier}</protocartifact>
        <pluginid>grpc-java</pluginid>
        <pluginartifact>io.grpc:protoc-gen-grpc-java:1.47.0:exe:${os.detected.classifier}</pluginartifact>
      </configuration>
      <executions>
        <execution>
          <goals>
            <goal>compile</goal>
            <goal>compile-custom</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

步骤3：java 服务端实现

public class dataserviceimpl extends dataprocessorgrpc.dataprocessorimplbase {
    @override
    public void process(datarequest request, 
                       streamobserver<dataresponse> responseobserver) {
        system.out.println("收到请求: " + request.getcontent());
        
        dataresponse response = dataresponse.newbuilder()
            .setsuccess(true)
            .setresult("processed: " + request.getcontent().touppercase())
            .build();
        
        responseobserver.onnext(response);
        responseobserver.oncompleted();
    }
}

// 启动服务器
server server = serverbuilder.forport(50051)
    .addservice(new dataserviceimpl())
    .build()
    .start();

步骤4：python 客户端调用

import grpc
import data_pb2
import data_pb2_grpc

channel = grpc.insecure_channel('localhost:50051')
stub = data_pb2_grpc.dataprocessorstub(channel)

response = stub.process(data_pb2.datarequest(
    content="hello grpc",
    priority=1
))

print(response.result)  # 输出: processed: hello grpc

五、jni 原生扩展（高级方案）

5.1 架构设计

图表

代码

5.2 实现示例

步骤1：java 端准备 native 方法

public class nativebridge {
    static {
        system.loadlibrary("nativebridge");
    }
    
    public native string processdata(string input);
}

步骤2：生成 c 头文件

javac -h . nativebridge.java

步骤3：实现 c 层逻辑

#include <jni.h>
#include "nativebridge.h"
#include <python.h>

jniexport jstring jnicall java_nativebridge_processdata(
    jnienv *env, jobject obj, jstring input) {
    
    const char *str = (*env)->getstringutfchars(env, input, 0);
    
    // 初始化python解释器
    py_initialize();
    pyobject *pmodule = pyimport_importmodule("data_processor");
    pyobject *pfunc = pyobject_getattrstring(pmodule, "process");
    
    // 调用python函数
    pyobject *pargs = pytuple_pack(1, pyunicode_fromstring(str));
    pyobject *presult = pyobject_callobject(pfunc, pargs);
    
    const char *result = pyunicode_asutf8(presult);
    
    // 清理资源
    py_decref(pargs);
    py_decref(presult);share.aalatni.cn
    py_finalize();
    
    return (*env)->newstringutf(env, result);
}

步骤4：编译为动态库

# linux示例
gcc -shared -fpic -i${java_home}/include \
    -i${java_home}/include/linux \
    -i/usr/include/python3.8 \
    -o libnativebridge.so nativebridge.c \
    -lpython3.8

方案对比与选型建议

方案	适用场景	性能	复杂度	双向通信
jython	嵌入python到java应用	中	低	否
jpype	python调用java库	高	中	有限
py4j	复杂双向交互	中	中	是
grpc	跨网络服务调用	高	高	是
jni	极致性能需求	最高	最高	是

决策树：

是否需要双向调用？

是 → py4j 或 grpc

否 → 进入2

是否主要从python调用java？

是 → jpype

否 → 进入3

是否需要嵌入python到java？

是 → jython

否 → 考虑其他方案

常见问题解决方案

问题1：内存泄漏处理

jpype：确保及时调用 jpype.shutdownjvm()
py4j：使用 gateway.close() 释放资源
grpc：实现 __del__ 方法关闭channel

问题2：数据类型转换异常

数字类型：java的 long 对应 python 的 int
容器类型：使用 jpype.jarray 转换数组
日期类型：统一转为时间戳传输

问题3：调试技巧

开启jpype调试模式：

jpype.startjvm(..., "-djpype.debug=true")

py4j日志配置：

system.setproperty("py4j.logging", "py4j.logging.consolelogger")

进阶主题

性能优化技巧

对象池模式：重用java对象避免重复创建

# jpype对象池示例
class objectpool:aiqiyi.aalatni.cn
    def __init__(self, j_class, size=10):
        self.pool = [j_class() for _ in range(size)]
        
    def acquire(self):
        return self.pool.pop() if self.pool else none
        
    def release(self, obj):
        self.pool.append(obj)

批量操作：减少跨语言调用次数

// java端提供批量接口
public list<string> batchprocess(list<string> inputs) {
    return inputs.stream().map(this::process).collect(collectors.tolist());
}

安全注意事项

grpc：启用tls加密

# python客户端
creds = grpc.ssl_channel_credentials()tenxun.aalatni.cn
channel = grpc.secure_channel('localhost:50051', creds)

py4j：设置白名单

gatewayserver server = new gatewayserver(
    new mathservice(),
    gatewayserver.default_port,
    gatewayserver.default_connect_timeout,
    gatewayserver.default_read_timeout,
    new string[] {"192.168.1.*"}  // ip白名单
);

结语

python 与 java 的互操作虽然存在挑战，但通过选择合适的工具和模式，完全可以构建出高效稳定的跨语言系统。建议：xnj.gxglhxdec.com

从简单方案开始，逐步演进
做好接口抽象，降低耦合
建立完善的跨语言测试体系
监控性能关键指标

随着 graalvm 等新技术的发展，未来两种语言的互操作将更加无缝。但当前这些成熟方案，已经足以支撑大多数企业级应用的需求。

以上就是python与java互操作的五种主流方式的详细内容，更多关于python与java互操作方式的资料请关注代码网其它相关文章！

Python与Java互操作的五种主流方式

2025年11月04日 • Java •我要评论

前言