// 使用Runtime.exec()調(diào)用Python腳本
Process process = Runtime.getRuntime().exec("python /path/to/script.py arg1 arg2");
BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line;
while ((line = reader.readLine()) != null) {
    System.out.println(line);
}

// Java端傳遞JSON參數(shù)
String jsonParam = "{"data":[1,2,3],"threshold":0.5}";
ProcessBuilder pb = new ProcessBuilder("python", "processor.py");
pb.redirectInput(ProcessBuilder.Redirect.PIPE);
Process process = pb.start();
try (OutputStream os = process.getOutputStream()) {
    os.write(jsonParam.getBytes());
}

import sys
import json
 
def main():
    data = json.load(sys.stdin)
    result = [x*2 for x in data['data'] if x > data['threshold']]
    print(json.dumps({"result": result}))
 
if __name__ == "__main__":
    main()

<dependency>
    <groupId>org.python</groupId>
    <artifactId>jython-standalone</artifactId>
    <version>2.7.3</version>
</dependency>

// Java代碼
PythonInterpreter interpreter = new PythonInterpreter();
interpreter.exec("print('Hello from Python 2.7')");
interpreter.set("java_var", "Data from Java");
interpreter.exec("python_var = java_var.upper()");
String result = interpreter.get("python_var", String.class);

from flask import Flask, request, jsonify
import numpy as np
 
app = Flask(__name__)
 
@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()
    matrix = np.array(data['values'])
    result = np.linalg.svd(matrix)
    return jsonify({
        'singular_values': result[1].tolist(),
        'status': 'success'
    })
 
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

// Java 11+ HttpClient示例
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("http://localhost:5000/predict"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString("""
        {
            "values": [[1,2,3],[4,5,6],[7,8,9]]
        }
        """))
    .build();
 
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

from py4j.java_gateway import JavaGateway, GatewayParameters
 
class MathOperations:
    def power(self, base, exponent):
        return base ** exponent
 
if __name__ == '__main__':
    gateway = JavaGateway(
        gateway_parameters=GatewayParameters(port=25333),
        python_server_entry_point=MathOperations()
    )
    gateway.awaitTermination()

<dependency>
    <groupId>net.sf.py4j</groupId>
    <artifactId>py4j</artifactId>
    <version>0.10.9.7</version>
</dependency>

public class Py4JClient {
    public static void main(String[] args) {
        GatewayServer gatewayServer = new GatewayServer(new GatewayServer.Callback() {
            @Override
            public Object callback(Object object) {
                return null; // 回調(diào)處理（本例未使用）
            }
        });
        gatewayServer.start();
        
        JavaGateway gateway = new JavaGateway(
            new GatewayParameters(new GatewayServer.GatewayServerBuilder().build())
        );
        MathOperations math = gateway.entryPoint;
        System.out.println("2^8 = " + math.power(2, 8));
    }
}

syntax = "proto3";
 
service DataProcessor {
    rpc Process (DataRequest) returns (DataResponse);
}
 
message DataRequest {
    repeated double values = 1;
    string algorithm = 2;
}
 
message DataResponse {
    repeated double result = 1;
    string status = 2;
}

pip install grpcio grpcio-tools

import grpc
from concurrent import futures
import numpy as np
import data_processor_pb2
import data_processor_pb2_grpc
 
class ProcessorServicer(data_processor_pb2_grpc.DataProcessorServicer):
    def Process(self, request, context):
        arr = np.array(request.values)
        if request.algorithm == "SVD":
            _, s, _ = np.linalg.svd(arr.reshape(3,3))
            return data_processor_pb2.DataResponse(
                result=s.tolist(),
                status="SUCCESS"
            )
        return data_processor_pb2.DataResponse(status="UNKNOWN_ALGORITHM")
 
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
data_processor_pb2_grpc.add_DataProcessorServicer_to_server(ProcessorServicer(), server)
server.add_insecure_port('[::]:50051')
server.start()
server.wait_for_termination()

<dependency>
    <groupId>io.grpc</groupId>
    <artifactId>grpc-netty-shaded</artifactId>
    <version>1.59.0</version>
</dependency>
<dependency>
    <groupId>io.grpc</groupId>
    <artifactId>grpc-protobuf</artifactId>
    <version>1.59.0</version>
</dependency>
<dependency>
    <groupId>io.grpc</groupId>
    <artifactId>grpc-stub</artifactId>
    <version>1.59.0</version>
</dependency>

public class GrpcClient {
    public static void main(String[] args) {
        ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 50051)
            .usePlaintext()
            .build();
        
        DataProcessorGrpc.DataProcessorBlockingStub stub = DataProcessorGrpc.newBlockingStub(channel);
        DataRequest request = DataRequest.newBuilder()
            .addAllValues(Arrays.asList(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0))
            .setAlgorithm("SVD")
            .build();
        
        DataResponse response = stub.process(request);
        System.out.println("Result: " + response.getResultList());
        channel.shutdown();
    }
}

// 跨平臺路徑處理方案
String os = System.getProperty("os.name").toLowerCase();
String pythonPath = os.contains("win") ? 
    "C:\Python39\python.exe" : 
    "/usr/local/bin/python3";
String scriptPath = new File("src/main/resources/scripts/processor.py").getAbsolutePath();
ProcessBuilder pb = new ProcessBuilder(pythonPath, scriptPath);

Process process = Runtime.getRuntime().exec("python error_script.py");
// 合并標(biāo)準(zhǔn)輸出和錯誤流
BufferedReader reader = new BufferedReader(new InputStreamReader(
    new SequenceInputStream(process.getInputStream(), process.getErrorStream())
));

Process process = Runtime.getRuntime().exec("python long_running.py");
boolean finished = process.waitFor(10, TimeUnit.SECONDS);
if (!finished) {
    process.destroyForcibly();
    throw new TimeoutException("Process execution timed out");
}