Unterschied zwischen ProcessBuilder und Runtime.exec ()

Ich versuche, einen externen Befehl aus Java-Code auszuführen, aber es gibt einen Unterschied zwischen Runtime.getRuntime().exec(...)und new ProcessBuilder(...).start().

Bei Verwendung von Runtime:

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

Der exitValue ist 0 und der Befehl wird ok beendet.

Mit ProcessBuilder:

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

Der Exit-Wert ist 1001 und der Befehl endet in der Mitte, obwohl er waitForzurückkehrt.

Was soll ich tun, um das Problem zu beheben ProcessBuilder?

Die verschiedenen Überladungen von Runtime.getRuntime().exec(...)nehmen entweder ein Array von Zeichenfolgen oder eine einzelne Zeichenfolge. Die einzelnen Zeichenfolgenüberladungen von exec()werden die Zeichenfolge in ein Array von Argumenten umwandeln, bevor das Zeichenfolgenarray an eine der exec()Überladungen übergeben wird, die ein Zeichenfolgenarray benötigt. Die ProcessBuilderKonstruktoren verwenden dagegen nur ein varargs-Array von Zeichenfolgen oder ein Listvon Zeichenfolgen, wobei angenommen wird, dass jede Zeichenfolge im Array oder in der Liste ein einzelnes Argument ist. In beiden Fällen werden die erhaltenen Argumente zu einer Zeichenfolge zusammengefügt, die zur Ausführung an das Betriebssystem übergeben wird.

So zum Beispiel unter Windows,

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

führt ein DoStuff.exeProgramm mit den beiden angegebenen Argumenten aus. In diesem Fall wird die Befehlszeile mit einem Token versehen und wieder zusammengesetzt. Jedoch,

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

fehl, es sei denn , es Name , ein Programm zu sein , dessen geschieht DoStuff.exe -arg1 -arg2in C:\. Dies liegt daran, dass es keine Tokenisierung gibt: Es wird davon ausgegangen, dass der auszuführende Befehl bereits tokenisiert wurde. Stattdessen sollten Sie verwenden

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

oder alternativ

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

Sehen Sie sich an, wie Runtime.getRuntime().exec()der String-Befehl an das übergeben wird ProcessBuilder. Es verwendet einen Tokenizer und zerlegt den Befehl in einzelne Token. Anschließend wird aufgerufen, exec(String[] cmdarray, ......)welches a erstellt wird ProcessBuilder.

Wenn Sie die ProcessBuildermit einem Array von Zeichenfolgen anstelle einer einzelnen erstellen, erhalten Sie das gleiche Ergebnis.

Der ProcessBuilderKonstruktor nimmt ein String...vararg an. Die Übergabe des gesamten Befehls als einzelne Zeichenfolge hat also den gleichen Effekt wie das Aufrufen dieses Befehls in Anführungszeichen in einem Terminal:

shell$ "command with args"

Es gibt keinen Unterschied zwischen ProcessBuilder.start()und Runtime.exec()weil die Implementierung von Runtime.exec():

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

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

sollte das gleiche sein wie:

Runtime.exec(command)

Danke dave_thompson_085 für den Kommentar

Ja, da gibt es einen Unterschied.

• Die Runtime.exec(String)Methode verwendet eine einzelne Befehlszeichenfolge, die in einen Befehl und eine Folge von Argumenten aufgeteilt wird.

• Der ProcessBuilderKonstruktor verwendet ein (varargs) Array von Zeichenfolgen. Die erste Zeichenfolge ist der Befehlsname und der Rest sind die Argumente. (Es gibt einen alternativen Konstruktor, der eine Liste von Zeichenfolgen verwendet, aber keinen, der eine einzelne Zeichenfolge enthält, die aus dem Befehl und den Argumenten besteht.)

Sie fordern ProcessBuilder also auf, einen "Befehl" auszuführen, dessen Name Leerzeichen und anderen Müll enthält. Natürlich kann das Betriebssystem keinen Befehl mit diesem Namen finden und die Befehlsausführung schlägt fehl.