Diferencia entre ProcessBuilder y Runtime.exec ()

Estoy tratando de ejecutar un comando externo desde el código Java, pero he notado una diferencia entre Runtime.getRuntime().exec(...)y new ProcessBuilder(...).start().

Al usar Runtime:

Process p = Runtime.getRuntime().exec(installation_path + 
                                       uninstall_path + 
                                       uninstall_command + 
                                       uninstall_arguments);
p.waitFor();

exitValue es 0 y el comando finaliza correctamente.

Sin embargo, con ProcessBuilder:

Process p = (new ProcessBuilder(installation_path +    
                                 uninstall_path +
                                 uninstall_command,
                                 uninstall_arguments)).start();
p.waitFor();

el valor de salida es 1001 y el comando termina en el medio, aunque waitForregresa.

¿Qué debo hacer para solucionar el problema ProcessBuilder?

Las diversas sobrecargas de Runtime.getRuntime().exec(...)toman una matriz de cadenas o una sola cadena. Las sobrecargas de una sola cadena de exec()tokenizarán la cadena en una matriz de argumentos, antes de pasar la matriz de cadenas a una de las exec()sobrecargas que toma una matriz de cadenas. Los ProcessBuilderconstructores, por otro lado, solo toman una matriz varargs de cadenas o una Listde cadenas, donde se supone que cada cadena en la matriz o lista es un argumento individual. De cualquier manera, los argumentos obtenidos se unen en una cadena que se pasa al sistema operativo para su ejecución.

Entonces, por ejemplo, en Windows,

Runtime.getRuntime().exec("C:\DoStuff.exe -arg1 -arg2");

ejecutará un DoStuff.exeprograma con los dos argumentos dados. En este caso, la línea de comandos se tokeniza y se vuelve a armar. Sin embargo,

ProcessBuilder b = new ProcessBuilder("C:\DoStuff.exe -arg1 -arg2");

fallará, a menos que haya un programa cuyo nombre esté DoStuff.exe -arg1 -arg2en C:\. Esto se debe a que no hay tokenización: se supone que el comando a ejecutar ya ha sido tokenizado. En su lugar, debes usar

ProcessBuilder b = new ProcessBuilder("C:\DoStuff.exe", "-arg1", "-arg2");

o alternativamente

List<String> params = java.util.Arrays.asList("C:\DoStuff.exe", "-arg1", "-arg2");
ProcessBuilder b = new ProcessBuilder(params);

Mira cómo Runtime.getRuntime().exec()pasa el comando String al ProcessBuilder. Utiliza un tokenizador y descompone el comando en tokens individuales, luego invoca exec(String[] cmdarray, ......)cuál construye un ProcessBuilder.

Si construye el ProcessBuildercon una matriz de cadenas en lugar de una sola, obtendrá el mismo resultado.

El ProcessBuilderconstructor toma un String...vararg, por lo que pasar el comando completo como una sola cadena tiene el mismo efecto que invocar ese comando entre comillas en una terminal:

shell$ "command with args"

No hay diferencia entre ProcessBuilder.start()y Runtime.exec()porque la implementación de Runtime.exec()es:

public Process exec(String command) throws IOException {
    return exec(command, null, null);
}

public Process exec(String command, String[] envp, File dir)
    throws IOException {
    if (command.length() == 0)
        throw new IllegalArgumentException("Empty command");

    StringTokenizer st = new StringTokenizer(command);
    String[] cmdarray = new String[st.countTokens()];
    for (int i = 0; st.hasMoreTokens(); i++)
        cmdarray[i] = st.nextToken();
    return exec(cmdarray, envp, dir);
}

public Process exec(String[] cmdarray, String[] envp, File dir)
    throws IOException {
    return new ProcessBuilder(cmdarray)
        .environment(envp)
        .directory(dir)
        .start();
}

Entonces codifique:

List<String> list = new ArrayList<>();
new StringTokenizer(command)
.asIterator()
.forEachRemaining(str -> list.add((String) str));
new ProcessBuilder(String[])list.toArray())
            .environment(envp)
            .directory(dir)
            .start();

debe ser el mismo que:

Runtime.exec(command)

Gracias dave_thompson_085 por comentar

Sí, hay una diferencia.

• El Runtime.exec(String)método toma una sola cadena de comando que divide en un comando y una secuencia de argumentos.

• El ProcessBuilderconstructor toma una matriz (varargs) de cadenas. La primera cadena es el nombre del comando y el resto son los argumentos. (Hay un constructor alternativo que toma una lista de cadenas, pero ninguno que toma una sola cadena que consta del comando y los argumentos).

Entonces, lo que le está diciendo a ProcessBuilder que haga es ejecutar un "comando" cuyo nombre tiene espacios y otra basura en él. Por supuesto, el sistema operativo no puede encontrar un comando con ese nombre y la ejecución del comando falla.