Ejecutar Python desde Java: 4 formas
Ejecuta un script de Python desde Java con ProcessBuilder, JSR-223, Jython o Apache Commons Exec: código de ejemplo y cuándo conviene cada una de ellas.
1. Dos lenguajes, un proceso
Python es cada vez más popular como lenguaje de programación, especialmente en la comunidad científica por el gran número de bibliotecas disponibles para ciencia de datos y inteligencia artificial.
Pero no hay que olvidar que Java está muy presente en el mundo empresarial, así que no es raro que en algún momento sea necesario ejecutar Python desde una aplicación desarrollada en Java.
En este post, veremos algunas de las opciones más usadas para ejecutar código Python desde Java.
2. Código Python de ejemplo
En este post se va a usar un script sencillo en Python que guardaremos en el fichero hola.py:
1
print("Hola Mundo!")
Si necesitas repasar la sintaxis, la cheatsheet de Python tiene lo esencial en una página.
Asumo que ya tienes alguna versión instalada de Python, así que ejecutamos el script de la siguiente manera:
1
2
$ python hola.py
Hola Mundo!
3. Core Java
Cuatro caminos con el mismo destino; cambia quién gestiona el proceso.
En esta sección, vamos a ver dos formas de invocar un script en Python desde código Java.
3.1 Usando ProcessBuilder
No hay magia: Java arranca un proceso del sistema y lee su salida.
La primera opción es la API ProcessBuilder, que crea un proceso nativo del sistema operativo que lanza Python y ejecuta nuestro script.
1
2
3
4
5
6
7
8
9
public void usoProcessBuilder() throws Exception {
ProcessBuilder processBuilder = new ProcessBuilder("python", resolvePythonScriptPath("hola.py"));
processBuilder.redirectErrorStream(true);
Process process = processBuilder.start();
List<String> results = readProcessOutput(process.getInputStream());
int exitCode = process.waitFor();
}
En esta opción ejecutamos el comando python con un único argumento: nuestro script hola.py.
resolvePythonScriptPath y readProcessOutput son dos funciones auxiliares: la primera devuelve la ruta absoluta del script y la segunda lee la salida línea a línea. Una versión mínima:
1
2
3
4
5
6
7
8
9
private String resolvePythonScriptPath(String name) {
return Paths.get(name).toAbsolutePath().toString();
}
private List<String> readProcessOutput(InputStream input) throws IOException {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(input))) {
return reader.lines().collect(Collectors.toList());
}
}
Para ello creamos un objeto ProcessBuilder al que se le pasa el comando y el argumento en el constructor del objeto. Fíjate en la llamada a redirectErrorStream(true): si se produce un error, su salida se mezcla con la salida estándar (stdout).
Esta llamada a redirectErrorStream(true) es muy útil ya que vamos a obtener cualquier error que se produzca en la llamada por la salida estándar. Si no la activamos, habrá que leer la salida de estos errores por separado, en dos canales: el getInputStream() y el getErrorStream().
Una vez aclarado esto, podemos ejecutar el proceso usando el método start() para obtener un objeto Process. Este objeto nos proporcionará la salida estándar (stdout) usando el canal getInputStream().
Como he mencionado anteriormente, asumo que tienes una instalación válida de Python y que el comando python está definido en el PATH.
3.2 Usando la especificación JSR-223 (Scripting Engine)
La especificación JSR-223, que se introdujo en Java 6, define unas API con las funciones básicas de “scripting” en Java. Estos métodos proporcionan mecanismos para ejecutar scripts y compartir valores entre Java y el lenguaje de “scripting”. El objetivo principal de este estándar es proporcionar una forma uniforme para que Java pueda interactuar con los lenguajes de “scripting”.
Para usar este estándar, el lenguaje de scripting tiene que apoyarse en la arquitectura de scripting de la JVM. En el caso de Python, tenemos Jython, una implementación de Python escrita en Java que funciona sobre la JVM.
Suponiendo que tenemos Jython en nuestro CLASSPATH, el framework debería detectar que podemos usar este motor de scripting para llamar a código Python desde Java.
Puedes obtener Jython desde el repositorio de Maven Central, y incluirlo en tu pom.xml de la siguiente manera:
1
2
3
4
5
<dependency>
<groupId>org.python</groupId>
<artifactId>jython-slim</artifactId>
<version>2.7.4</version>
</dependency>
También se puede descargar y instalarlo directamente.
Una nota importante: Jython solo ejecuta Python 2.7, que no tiene soporte desde 2020, y no hay fecha para Python 3. La mayoría de las bibliotecas de Python actuales solo funcionan en Python 3. Si necesitas Python 3 dentro de la JVM, la alternativa hoy es GraalPy, una implementación de Python 3 sobre GraalVM que se añade como dependencia de Maven y se usa desde Java con su API polyglot.
Una vez que hemos incluido Jython en nuestro CLASSPATH, vamos a listar todos los motores de scripting que tenemos disponibles añadiendo el siguiente código:
1
ScriptEngineManagerUtils.listEngines();
ScriptEngineManagerUtils es otra clase auxiliar: recorre new ScriptEngineManager().getEngineFactories() e imprime el nombre, la versión, el lenguaje y los alias de cada motor. Si hemos añadido la biblioteca correctamente, la salida incluye Jython:
1
2
3
4
5
6
7
...
Engine name: jython
Version: 2.7.4
Language: python
Short Names:
python
jython
Con Jython disponible como motor de scripting, llamamos al script hola.py con el siguiente código:
1
2
3
4
5
6
7
8
9
10
public void usoJython() throws Exception {
StringWriter writer = new StringWriter();
ScriptContext context = new SimpleScriptContext();
context.setWriter(writer);
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("python");
engine.eval(new FileReader(resolvePythonScriptPath("hola.py")), context);
String output = writer.toString().trim(); // "Hola Mundo!"
}
Esta API es muy sencilla. Primero, establecemos el contexto usando ScriptContext que contiene un StringWriter. Este objeto va a almacenar la salida de nuestro script.
Una vez especificado el contexto, usamos el método getEngineByName(“python”) para obtener el “ScriptEngine” que nos permitirá llamar a nuestro código Python. En este caso podemos pasar “python” o “jython” que son los dos nombres admitidos por este motor.
Como en el anterior ejemplo, el paso final es leer la salida del script, que queda en el StringWriter.
4. Jython
Continuando con lo que hemos visto de Jython, también podemos incluir código Python en nuestro código Java. Para ello se usa la clase PythonInterpreter:
1
2
3
4
5
6
7
8
public void pythonInterpreter() {
try (PythonInterpreter pyInterp = new PythonInterpreter()) {
StringWriter output = new StringWriter();
pyInterp.setOut(output);
pyInterp.exec("print('Hola mundo!')");
}
}
El uso de la clase PythonInterpreter nos permite ejecutar código python definido en un String usando el método exec. Como hemos visto anteriormente podemos capturar la salida usando StringWriter.
Vamos a ver otro ejemplo simple en el que vamos a sumar dos números:
1
2
3
4
5
6
public void pythonInterpreterSuma2() {
try (PythonInterpreter pyInterp = new PythonInterpreter()) {
pyInterp.exec("x = 20+30");
PyObject x = pyInterp.get("x");
}
}
En este ejemplo podemos ver que usando el método get podemos acceder al valor de una variable de python.
A continuación, vamos a realizar un último ejemplo para ver qué ocurre cuando se produce un error:
1
2
3
try (PythonInterpreter pyInterp = new PythonInterpreter()) {
pyInterp.exec("import o2sa");
}
Cuando ejecutamos el anterior código se lanza una PyException y podemos ver el error como si estuviéramos ejecutando el código en el REPL de Python:
1
2
3
Traceback (most recent call last):
File "<string>", line 1, in <module>
ImportError: No module named o2sa
Algunos puntos a considerar:
Ya que PythonInterpreter implementa la interfaz AutoCloseable es una buena práctica usar try-with-resources cuando trabajemos con esta clase.
El nombre de la clase PythonInterpreter no implica que nuestro código Python sea interpretado. Jython compila los scripts en Python a bytecode Java antes de ejecutarlos.
Aunque Jython es una implementación de Python en Java, podría no contener todas las bibliotecas que nos ofrece la versión nativa de Python.
5. Apache Commons Exec
Otra biblioteca que podemos usar para llamar a código Python desde Java es Apache Commons Exec que intenta mitigar los problemas que se producen al usar Java Process API.
El artifact de esta biblioteca está disponible en Maven Central:
1
2
3
4
5
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-exec</artifactId>
<version>1.6.0</version>
</dependency>
A continuación podemos ver un ejemplo de cómo usar esta biblioteca para hacer la llamada de una forma muy similar a la que hemos visto anteriormente usando la API ProcessBuilder:
1
2
3
4
5
6
7
8
9
10
11
12
13
public void apacheCommonExec()
throws ExecuteException, IOException {
String line = "python " + resolvePythonScriptPath("hola.py");
CommandLine cmdLine = CommandLine.parse(line);
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
PumpStreamHandler streamHandler = new PumpStreamHandler(outputStream);
DefaultExecutor executor = DefaultExecutor.builder().get();
executor.setStreamHandler(streamHandler);
int exitCode = executor.execute(cmdLine);
}
Este ejemplo no es muy diferente al primer ejemplo que vimos usando ProcessBuilder. Como podemos observar, primero creamos un objeto CommandLine para la ejecución de nuestro comando. A continuación configuramos un handler para el stream que va a capturar la salida de nuestro proceso. Desde la versión 1.4, el constructor new DefaultExecutor() está obsoleto y el ejecutor se crea con DefaultExecutor.builder().get().
6. Tres formas de cruzar la frontera
Para ejecutar código Python desde Java, disponemos de varias opciones. ProcessBuilder y Apache Commons Exec lanzan Python como un proceso aparte; Jython, directamente o a través de JSR-223, ejecuta Python 2.7 dentro de la JVM, y GraalPy hace lo mismo con Python 3. Cada una tiene ventajas e inconvenientes; lo importante es ver cuál encaja mejor con las necesidades del proyecto.
La parte Java también envejece. Si subes de Java 21 a 25, tres fallos silenciosos no aparecen en el primer arranque y conviene cazarlos antes de tocar la integración.
