Java運行Python腳本的幾種方式小結(jié)

更新時間：2024年12月13日 11:05:00 作者：牛肉胡辣湯

在跨語言編程中,有時候我們需要在 Java 應(yīng)用程序中執(zhí)行 Python 腳本,這可能是為了利用 Python 豐富的庫生態(tài)系統(tǒng),或者是為了在已有 Java 系統(tǒng)中集成一些 Python 特有的功能,本文給大家介紹了實現(xiàn)這幾種目標的方法,需要的朋友可以參考下

Java 運行 Python 腳本的幾種方式

1. 使用 Jython

Jython 是一個完全用 Java 實現(xiàn)的 Python 解釋器，它允許在 Java 虛擬機 (JVM) 上運行 Python 代碼。通過 Jython，你可以在 Java 程序中直接調(diào)用 Python 代碼，反之亦然。

import org.python.util.PythonInterpreter;
 
public class RunPythonWithJython {
    public static void main(String[] args) {
        PythonInterpreter interpreter = new PythonInterpreter();
        interpreter.exec("print('Hello, World from Jython!')");
    }
}

2. 使用 Jep

Jep (Java Embed Python) 是一個 Python 嵌入和解釋庫，它提供了在 Java 程序中調(diào)用 Python 代碼的接口。Jep 支持 CPython 寫的擴展模塊，并且能夠處理 Python 的異常。

import com.nativelibs4java.py.Py;
 
public class RunPythonWithJep {
    public static void main(String[] args) {
        Py.initialize();
        Py.runString("print('Hello, World from Jep!')");
        Py.finalize();
    }
}

3. 使用 ScriptEngineManager

Java 中的 ??ScriptEngineManager?? 類可以用來管理各種腳本引擎，包括 JSR-223 兼容的 Python 引擎。這種方法需要一個 JSR-223 兼容的 Python 腳本引擎，例如 ??javax.script?? 包中的 ??ScriptEngine??。

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
 
public class RunPythonWithScriptEngine {
    public static void main(String[] args) {
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("python");
        engine.eval("print('Hello, World from ScriptEngine!')");
    }
}

4. 使用 ProcessBuilder

如果你只是想運行一個 Python 腳本文件，而不是在 Java 程序中直接執(zhí)行 Python 代碼，你可以使用 ??ProcessBuilder?? 來啟動一個外部進程。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.List;
 
public class RunPythonScriptWithProcessBuilder {
    public static void main(String[] args) {
        List<String> command = List.of("python", "script.py");
        ProcessBuilder builder = new ProcessBuilder(command);
        try {
            Process process = builder.start();
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

以上是幾種在 Java 中運行 Python 腳本的方法。每種方法都有其特點和適用場景，選擇哪種方法取決于你的具體需求和偏好。例如，如果你需要深度集成 Python 和 Java，Jython 或 Jep 可能是更好的選擇；如果你只是想運行一個獨立的 Python 腳本，使用 ??ProcessBuilder?? 可能更簡單。在Java中運行Python腳本通常涉及到使用Jython，因為Jython提供了在Java虛擬機（JVM）上運行Python代碼的能力。Jython允許你直接從Java調(diào)用Python代碼，反之亦然。下面是幾種在Java中運行Python腳本的方式的示例代碼：

1. 使用??ScriptEngineManager??和??ScriptEngine??

Java的??javax.script??包提供了??ScriptEngineManager??和??ScriptEngine??類，它們可以用來執(zhí)行腳本語言，包括Jython。

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;
 
public class RunPythonScript {
    public static void main(String[] args) {
        try {
            // 獲取ScriptEngineManager實例
            ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
            // 獲取Jython ScriptEngine
            ScriptEngine jython = scriptEngineManager.getEngineByName("python");
            // 執(zhí)行Python腳本
            jython.eval("print('Hello, World!')");
        } catch (ScriptException e) {
            e.printStackTrace();
        }
    }
}

2. 使用??ProcessBuilder??

你也可以使用??ProcessBuilder??來運行Python腳本，這種方式可以讓你在Java中執(zhí)行任何系統(tǒng)命令，包括Python腳本。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.List;
 
public class RunPythonScript {
    public static void main(String[] args) {
        try {
            // 設(shè)置Python腳本的路徑
            String scriptPath = "path/to/your/python_script.py";
            // 創(chuàng)建ProcessBuilder對象
            List<String> command = List.of("python", scriptPath);
            ProcessBuilder processBuilder = new ProcessBuilder(command);
            // 啟動子進程
            Process process = processBuilder.start();
            // 讀取輸出
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. 使用??Runtime.getRuntime().exec()??

這是另一種使用??Runtime??類來執(zhí)行外部命令的方法，包括Python腳本。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class RunPythonScript {
    public static void main(String[] args) {
        try {
            // 設(shè)置Python腳本的路徑
            String scriptPath = "path/to/your/python_script.py";
            // 創(chuàng)建Process對象
            Process process = Runtime.getRuntime().exec("python " + scriptPath);
            // 讀取輸出
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. 使用??jpy??

??jpy??是一個輕量級的庫，它提供了在Java中調(diào)用Python腳本的簡單接口。

import jpy.PyObject;
import jpy.PyCallable;
import jpy.PyException;
 
public class RunPythonScript {
    public static void main(String[] args) {
        try {
            // 初始化JPy
            PyObject jpy = new PyObject("jpy");
            // 調(diào)用Python腳本
            PyObject result = jpy.call("your_python_script.py");
            // 處理返回值
            System.out.println(result.toString());
        } catch (PyException e) {
            e.printStackTrace();
        }
    }
}

請注意，上述代碼示例中的??path/to/your/python_script.py??需要替換為你實際的Python腳本路徑。此外，確保你的Java項目有合適的權(quán)限來執(zhí)行系統(tǒng)命令或訪問Jython庫。在Java中運行Python腳本主要有三種方式：

使用Jython Jython 是一個Python解釋器，它運行在Java虛擬機（JVM）上。這意味著您可以在Java環(huán)境中直接運行Python代碼。要使用Jython，您需要先將Jython的JAR文件添加到您的Java項目中，然后使用PythonInterpreter類來執(zhí)行Python腳本。
下面是一個簡單的Java代碼示例，它使用Jython來執(zhí)行一個Python腳本：

import org.python.util.PythonInterpreter;
 
public class RunPythonScript {
    public static void main(String[] args) {
        PythonInterpreter interpreter = new PythonInterpreter();
        interpreter.execfile("your_python_script.py"); // 替換為實際的Python腳本文件路徑
        // 或者使用字符串來執(zhí)行代碼
        // interpreter.exec("print('Hello, World!')");
        System.out.println("Python script executed successfully.");
    }
}

使用ScriptEngineManager Java的ScriptEngineManager類允許您使用不同的腳本引擎來執(zhí)行各種腳本的代碼，包括Python。您需要先添加一個支持Python的腳本引擎（如Jython）到您的Java項目中，然后使用ScriptEngineManager來獲取一個ScriptEngine對象，并通過它來執(zhí)行Python代碼。
下面是一個使用ScriptEngineManager的示例：

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
 
public class RunPythonScript {
    public static void main(String[] args) {
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("python");
        try {
            engine.eval("print('Hello, World!')"); // 或者使用文件路徑
            System.out.println("Python script executed successfully.");
        } catch (ScriptException e) {
            e.printStackTrace();
        }
    }
}

使用第三方庫 除了Jython，還有一些其他的第三方庫可以幫助您在Java中運行Python腳本，例如groovy-python。這些庫通常提供了更高級別的抽象，使得在Java中使用Python更加容易。
使用groovy-python的示例：

import groovy.lang.GroovyShell;
 
public class RunPythonScript {
    public static void main(String[] args) {
        GroovyShell shell = new GroovyShell();
        shell.evaluate("import sys; print('Hello, World!', file=sys.stdout)"); // 使用Groovy來執(zhí)行Python代碼
        System.out.println("Python script executed successfully.");
    }
}

請注意，上述代碼示例您已經(jīng)安裝并配置了相應(yīng)的庫（如Jython或??groovy-python??），并且您的Java項目能夠正確地引用這些庫。在實際使用時，請確保您已經(jīng)安裝并配置了所需的依賴項。

以上就是Java運行Python腳本的幾種方式小結(jié)的詳細內(nèi)容，更多關(guān)于Java運行Python腳本的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: