Różnica między ProcessBuilder i Runtime.exec ()

Próbuję wykonać zewnętrzne polecenie z kodu Java, ale zauważyłem różnicę między Runtime.getRuntime().exec(...)i new ProcessBuilder(...).start().

Podczas używania Runtime:

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

wartość exitValue wynosi 0, a polecenie zostało zakończone poprawnie.

Jednak z ProcessBuilder:

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

wartość wyjścia to 1001, a polecenie kończy się w środku, chociaż waitForzwraca.

Co mam zrobić, aby rozwiązać problem ProcessBuilder?

Różne przeciążenia Runtime.getRuntime().exec(...)przyjmują tablicę ciągów lub pojedynczy ciąg. Przeciążenia pojedynczego ciągu funkcji exec()spowodują tokenizację ciągu na tablicę argumentów przed przekazaniem tablicy ciągów do jednego z exec()przeciążeń, które pobiera tablicę ciągów. Z ProcessBuilderdrugiej strony konstruktory pobierają tylko tablicę łańcuchów varargs lub Listłańcuch ciągów, w których każdy ciąg w tablicy lub liście jest traktowany jako indywidualny argument. Tak czy inaczej, uzyskane argumenty są następnie łączone w ciąg, który jest przekazywany do systemu operacyjnego w celu wykonania.

Na przykład w systemie Windows

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

uruchomi DoStuff.exeprogram z dwoma podanymi argumentami. W takim przypadku wiersz poleceń zostanie poddany tokenizacji i ponownie złożony. Jednak,

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

zakończy się niepowodzeniem, chyba że jest program, którego nazwa jest DoStuff.exe -arg1 -arg2w C:\. Dzieje się tak, ponieważ nie ma tokenizacji: zakłada się, że polecenie do uruchomienia zostało już tokenizowane. Zamiast tego powinieneś użyć

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

lub alternatywnie

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

Zobacz, jak Runtime.getRuntime().exec()przekazuje polecenie String do ProcessBuilder. Używa tokenizera i rozbija polecenie na pojedyncze tokeny, a następnie wywołuje, exec(String[] cmdarray, ......)który konstruuje plik ProcessBuilder.

Jeśli skonstruujesz ProcessBuildertablicę ciągów zamiast jednego, uzyskasz ten sam wynik.

ProcessBuilderKonstruktor bierze String...vararg, więc przechodząc całą komendę jako pojedynczy ciąg ma taki sam efekt jak wywoływanie tego polecenia w cudzysłów w terminalu:

shell$ "command with args"

Nie ma różnicy między ProcessBuilder.start()i, Runtime.exec()ponieważ implementacja Runtime.exec()to:

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

Więc kod:

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

powinno być takie samo jak:

Runtime.exec(command)

Dzięki dave_thompson_085 za komentarz

Tak, jest różnica.

• Runtime.exec(String)Metoda przyjmuje pojedynczy łańcuch dowodzenia, że dzieli się na komendzie i sekwencja argumentów.

• ProcessBuilderKonstruktor bierze (varargs) szereg strun. Pierwszy ciąg to nazwa polecenia, a pozostałe to argumenty. (Istnieje alternatywny konstruktor, który pobiera listę ciągów, ale żaden z nich nie przyjmuje pojedynczego ciągu składającego się z polecenia i argumentów).

To, co każesz ProcessBuilderowi zrobić, to wykonanie „polecenia”, którego nazwa zawiera spacje i inne śmieci. Oczywiście system operacyjny nie może znaleźć polecenia o tej nazwie, a jego wykonanie kończy się niepowodzeniem.