Différence entre ProcessBuilder et Runtime.exec ()

J'essaie d'exécuter une commande externe à partir du code java, mais il y a une différence que j'ai remarquée entre Runtime.getRuntime().exec(...)et new ProcessBuilder(...).start().

Lors de l'utilisation Runtime:

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

exitValue est 0 et la commande se termine ok.

Cependant, avec ProcessBuilder:

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

la valeur de sortie est 1001 et la commande se termine au milieu, bien qu'elle waitForretourne.

Que dois-je faire pour résoudre le problème ProcessBuilder?

Les différentes surcharges de Runtime.getRuntime().exec(...)prennent soit un tableau de chaînes, soit une seule chaîne. Les surcharges sur une seule chaîne de exec()tokeniseront la chaîne en un tableau d'arguments, avant de passer le tableau de chaînes sur l'une des exec()surcharges qui prend un tableau de chaînes. Les ProcessBuilderconstructeurs, en revanche, n'acceptent qu'un tableau varargs de chaînes ou Listde chaînes, où chaque chaîne du tableau ou de la liste est supposée être un argument individuel. Dans tous les cas, les arguments obtenus sont ensuite réunis en une chaîne qui est transmise au système d'exploitation pour s'exécuter.

Ainsi, par exemple, sous Windows,

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

exécutera un DoStuff.exeprogramme avec les deux arguments donnés. Dans ce cas, la ligne de commande est tokenisée et reconstituée. cependant,

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

échouera, à moins qu'il y ait un programme dont le nom figure DoStuff.exe -arg1 -arg2dans C:\. En effet, il n'y a pas de tokenisation: la commande à exécuter est supposée avoir déjà été tokenisée. Au lieu de cela, vous devriez utiliser

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

Ou bien

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

Regardez comment Runtime.getRuntime().exec()passe la commande String au ProcessBuilder. Il utilise un tokenizer et décompose la commande en tokens individuels, puis invoque exec(String[] cmdarray, ......)lequel construit unProcessBuilder .

Si vous construisez le ProcessBuilder avec un tableau de chaînes au lieu d'une seule, vous obtiendrez le même résultat.

Le ProcessBuilderconstructeur prend un String...vararg, donc passer la commande entière comme une seule chaîne a le même effet que l'appel de cette commande entre guillemets dans un terminal:

shell$ "command with args"

Il n'y a aucune différence entre ProcessBuilder.start()et Runtime.exec()parce que la mise en œuvre de Runtime.exec()est:

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();
}

Donc code:

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();

devrait être le même que:

Runtime.exec(command)

Merci dave_thompson_085 pour le commentaire

Oui, il y a une différence.

• La Runtime.exec(String)méthode prend une seule chaîne de commande qu'elle divise en une commande et une séquence d'arguments.

• Le ProcessBuilderconstructeur prend un tableau (varargs) de chaînes. La première chaîne est le nom de la commande et les autres sont les arguments. (Il existe un constructeur alternatif qui prend une liste de chaînes, mais aucun ne prend une seule chaîne composée de la commande et des arguments.)

Donc, ce que vous dites à ProcessBuilder de faire est d'exécuter une "commande" dont le nom contient des espaces et d'autres fichiers indésirables. Bien sûr, le système d'exploitation ne trouve pas de commande portant ce nom et l'exécution de la commande échoue.