Java运行Python脚本的几种方式小结

2024-12-13 11:05:01 作者：牛肉胡辣汤

在跨语言编程中,有时候我们需要在 Java 应用程序中执行 Python 脚本,这可能是为了利用 Python 丰富的库生态系统,或者是为了在已有 Java 系统中集成一些 Python 特有的功能,本文给大家介绍了实现这几种目标的方法,需要的朋友可以参考下

Java 运行 Python 脚本的几种方式

1. 使用 Jython

Jython 是一个完全用 Java 实现的 Python 解释器，它允许在 Java 虚拟机 (JVM) 上运行 Python 代码。通过 Jython，你可以在 Java 程序中直接调用 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 程序中调用 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 程序中直接执行 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调用Python代码，反之亦然。下面是几种在Java中运行Python脚本的方式的示例代码：

1. 使用ScriptEngineManager和ScriptEngine

Java的javax.script包提供了ScriptEngineManager和ScriptEngine类，它们可以用来执行脚本语言，包括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");
            // 执行Python脚本
            jython.eval("print('Hello, World!')");
        } catch (ScriptException e) {
            e.printStackTrace();
        }
    }
}

2. 使用ProcessBuilder

你也可以使用ProcessBuilder来运行Python脚本，这种方式可以让你在Java中执行任何系统命令，包括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 {
            // 设置Python脚本的路径
            String scriptPath = "path/to/your/python_script.py";
            // 创建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类来执行外部命令的方法，包括Python脚本。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class RunPythonScript {
    public static void main(String[] args) {
        try {
            // 设置Python脚本的路径
            String scriptPath = "path/to/your/python_script.py";
            // 创建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中调用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");
            // 调用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项目有合适的权限来执行系统命令或访问Jython库。在Java中运行Python脚本主要有三种方式：

使用Jython Jython 是一个Python解释器，它运行在Java虚拟机（JVM）上。这意味着您可以在Java环境中直接运行Python代码。要使用Jython，您需要先将Jython的JAR文件添加到您的Java项目中，然后使用PythonInterpreter类来执行Python脚本。
下面是一个简单的Java代码示例，它使用Jython来执行一个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脚本文件路径
        // 或者使用字符串来执行代码
        // interpreter.exec("print('Hello, World!')");
        System.out.println("Python script executed successfully.");
    }
}

使用ScriptEngineManager Java的ScriptEngineManager类允许您使用不同的脚本引擎来执行各种脚本的代码，包括Python。您需要先添加一个支持Python的脚本引擎（如Jython）到您的Java项目中，然后使用ScriptEngineManager来获取一个ScriptEngine对象，并通过它来执行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来执行Python代码
        System.out.println("Python script executed successfully.");
    }
}

请注意，上述代码示例您已经安装并配置了相应的库（如Jython或groovy-python），并且您的Java项目能够正确地引用这些库。在实际使用时，请确保您已经安装并配置了所需的依赖项。

以上就是Java运行Python脚本的几种方式小结的详细内容，更多关于Java运行Python脚本的资料请关注脚本之家其它相关文章！

Java运行Python脚本的几种方式小结