// 基礎(chǔ)調(diào)用示例
public class RuntimeExecExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        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);
        }
        
        // 等待進程結(jié)束
        int exitCode = process.waitFor();
        System.out.println("Exit code: " + exitCode);
    }
}

String[] command = {
    "/usr/local/bin/python3",  // 指定Python解釋器路徑
    "/path/to/script.py",
    "param1",
    "param2"
};
Process process = Runtime.getRuntime().exec(command);

BufferedReader errorReader = new BufferedReader(
    new InputStreamReader(process.getErrorStream()));
while ((line = errorReader.readLine()) != null) {
    System.err.println("ERROR: " + line);
}

BufferedWriter writer = new BufferedWriter(
    new OutputStreamWriter(process.getOutputStream()));
writer.write("input data");
writer.newLine();
writer.flush();

public class ProcessBuilderExample {
    public static void main(String[] args) throws Exception {
        ProcessBuilder pb = new ProcessBuilder(
            "python", 
            "/path/to/script.py",
            "--input=data.json",
            "--output=result.json");
        
        // 設(shè)置工作目錄
        pb.directory(new File("/project/root"));
        
        // 合并錯誤流到標準輸出
        pb.redirectErrorStream(true);
        
        // 環(huán)境變量配置
        Map<String, String> env = pb.environment();
        env.put("PYTHONPATH", "/custom/modules");
        
        Process process = pb.start();
        
        // 輸出處理（同Runtime.exec）
        // ...
    }
}

// 將輸出重定向到文件
pb.redirectOutput(new File("output.log"));

if (!process.waitFor(30, TimeUnit.SECONDS)) {
    process.destroyForcibly();
    throw new TimeoutException();
}

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

import org.python.util.PythonInterpreter;

public class JythonExample {
    public static void main(String[] args) {
        PythonInterpreter interpreter = new PythonInterpreter();
        interpreter.exec("print('Hello from Python!')");
        interpreter.exec("import sys\nprint(sys.version)");
    }
}

interpreter.set("java_var", "Data from Java");
interpreter.exec("python_var = java_var.upper()");
String result = interpreter.get("python_var", String.class);

pip install JPype1

public interface Calculator {
    double calculate(double[] inputs);
}

public class JavaApp {
    public static void usePythonImpl(Calculator calc) {
        double result = calc.calculate(new double[]{1.2, 3.4});
        System.out.println("Result: " + result);
    }
}

from jpype import JImplements, JOverride

@JImplements("com.example.Calculator")
class PyCalculator:
    @JOverride
    def calculate(self, inputs):
        import numpy as np
        return np.mean(inputs) * 2

if __name__ == "__main__":
    import jpype
    jpype.startJVM(classpath=["/path/to/your.jar"])
    
    from java.lang import System
    System.out.println("Calling from Python!")
    
    from com.example import JavaApp
    JavaApp.usePythonImpl(PyCalculator())
    
    jpype.shutdownJVM()

jpype.startJVM(
    "-Xms1G", 
    "-Xmx4G",
    "-Djava.class.path=/path/to/classes")

Java App (HTTP Client) <-- REST --> Python Service (FastAPI/Flask)

from fastapi import FastAPI
import numpy as np

app = FastAPI()

@app.post("/calculate")
async def calculate(data: dict):
    arr = np.array(data["values"])
    return {"result": float(np.mean(arr) * 2)}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

public class ApiClient {
    private final WebClient webClient;
    
    public ApiClient(String baseUrl) {
        this.webClient = WebClient.create(baseUrl);
    }
    
    public Mono<Double> calculate(double[] inputs) {
        return webClient.post()
            .uri("/calculate")
            .bodyValue(Map.of("values", inputs))
            .retrieve()
            .bodyToMono(Map.class)
            .map(response -> (Double) response.get("result"));
    }
}

public double syncCalculate(double[] inputs) {
    return calculate(inputs).block(Duration.ofSeconds(30));
}

syntax = "proto3";

service Calculator {
    rpc Calculate (CalculationRequest) returns (CalculationResponse);
}

message CalculationRequest {
    repeated double inputs = 1;
}

message CalculationResponse {
    double result = 1;
}

from concurrent import futures
import grpc
import calculator_pb2
import calculator_pb2_grpc
import numpy as np

class CalculatorServicer(calculator_pb2_grpc.CalculatorServicer):
    def Calculate(self, request, context):
        arr = np.array(request.inputs)
        return calculator_pb2.CalculationResponse(result=float(np.mean(arr)*2))

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    calculator_pb2_grpc.add_CalculatorServicer_to_server(
        CalculatorServicer(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    server.wait_for_termination()

import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;

public class GrpcClient {
    private final CalculatorGrpc.CalculatorBlockingStub stub;
    
    public GrpcClient(String host, int port) {
        ManagedChannel channel = ManagedChannelBuilder.forAddress(host, port)
            .usePlaintext()
            .build();
        this.stub = CalculatorGrpc.newBlockingStub(channel);
    }
    
    public double calculate(double[] inputs) {
        CalculationRequest request = CalculationRequest.newBuilder()
            .addAllInputs(Arrays.stream(inputs).boxed().collect(Collectors.toList()))
            .build();
        CalculationResponse response = stub.calculate(request);
        return response.getResult();
    }
}

import org.graalvm.polyglot.*;

public class GraalExample {
    public static void main(String[] args) {
        try (Context context = Context.create()) {
            // 直接執(zhí)行Python代碼
            Value result = context.eval("python",
                "import math\n" +
                "math.sqrt(256)");
            System.out.println(result.asDouble());
            
            // 變量傳遞
            context.getBindings("python").putMember("java_data", 100);
            context.eval("python", "python_data = java_data * 2");
            Value pythonData = context.getBindings("python").getMember("python_data");
            System.out.println(pythonData.asInt());
        }
    }
}