Perbedaan antara ProcessBuilder dan Runtime.exec ()

Saya mencoba untuk menjalankan perintah eksternal dari kode java, tetapi ada perbedaan yang saya perhatikan antara Runtime.getRuntime().exec(...)dan new ProcessBuilder(...).start().

Saat menggunakan Runtime:

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

exitValue adalah 0 dan perintah dihentikan dengan ok.

Namun, dengan ProcessBuilder:

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

nilai keluar adalah 1001 dan perintah berakhir di tengah, meskipun waitForkembali.

Apa yang harus saya lakukan untuk mengatasi masalah tersebut ProcessBuilder?

Berbagai kelebihan Runtime.getRuntime().exec(...)mengambil baik array string atau string tunggal. Overload string tunggal dari exec()akan mengubah string menjadi array argumen, sebelum meneruskan array string ke salah satu exec()kelebihan beban yang mengambil array string. The ProcessBuilderkonstruktor, di sisi lain, hanya mengambil varargs array dari string atau Liststring, di mana setiap string dalam array atau daftar diasumsikan argumen individu. Apa pun caranya, argumen yang diperoleh kemudian digabungkan menjadi string yang diteruskan ke OS untuk dieksekusi.

Jadi, misalnya, di Windows,

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

akan menjalankan DoStuff.exeprogram dengan dua argumen yang diberikan. Dalam kasus ini, baris perintah diberi tokenisasi dan disatukan kembali. Namun,

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

akan gagal, kecuali kebetulan ada program yang namanya ada DoStuff.exe -arg1 -arg2di C:\. Ini karena tidak ada tokenisasi: perintah yang akan dijalankan diasumsikan sudah di-tokenisasi. Sebaliknya, Anda harus menggunakan

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

atau sebagai alternatif

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

Lihatlah bagaimana Runtime.getRuntime().exec()melewatkan perintah String ke ProcessBuilder. Ia menggunakan tokenizer dan meledakkan perintah menjadi token individu, lalu memanggil exec(String[] cmdarray, ......)yang menyusun aProcessBuilder .

Jika Anda membuat file ProcessBuilder dengan larik string, bukan satu, Anda akan mendapatkan hasil yang sama.

The ProcessBuilderkonstruktor mengambil String...vararg, sehingga melewati seluruh perintah sebagai String tunggal memiliki efek yang sama seperti memanggil perintah yang dalam tanda kutip di terminal:

shell$ "command with args"

Tidak ada perbedaan antara ProcessBuilder.start()dan Runtime.exec()karena penerapannya Runtime.exec()adalah:

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

Jadi kode:

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

harus sama dengan:

Runtime.exec(command)

Terima kasih dave_thompson_085 atas komentarnya

Ya ada bedanya.

• The Runtime.exec(String)Metode mengambil string perintah tunggal yang terbagi menjadi perintah dan urutan argumen.

• The ProcessBuilderkonstruktor mengambil (varargs) array dari string. String pertama adalah nama perintah dan sisanya adalah argumen. (Ada konstruktor alternatif yang mengambil daftar string, tetapi tidak ada yang mengambil satu string yang terdiri dari perintah dan argumen.)

Jadi apa yang Anda perintahkan untuk dilakukan ProcessBuilder adalah menjalankan "perintah" yang namanya memiliki spasi dan sampah lain di dalamnya. Tentu saja, sistem operasi tidak dapat menemukan perintah dengan nama tersebut, dan eksekusi perintah gagal.