Sự khác biệt giữa ProcessBuilder và Runtime.exec ()

Tôi đang cố gắng thực thi một lệnh bên ngoài từ mã java, nhưng có một sự khác biệt mà tôi nhận thấy giữa Runtime.getRuntime().exec(...)và new ProcessBuilder(...).start().

Khi sử dụng Runtime:

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

exitValue là 0 và lệnh được kết thúc là ok.

Tuy nhiên, với ProcessBuilder:

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

giá trị thoát là 1001 và lệnh kết thúc ở giữa, mặc dù waitFortrả về.

Tôi nên làm gì để khắc phục sự cố với ProcessBuilder?

Các quá tải khác nhau của Runtime.getRuntime().exec(...)lấy một mảng chuỗi hoặc một chuỗi đơn. Quá tải chuỗi đơn của exec()sẽ chia nhỏ chuỗi đó thành một mảng đối số, trước khi chuyển mảng chuỗi vào một trong các exec()quá tải chiếm một mảng chuỗi. Mặt ProcessBuilderkhác, các hàm tạo chỉ lấy một mảng varargs các chuỗi hoặc một Listchuỗi, trong đó mỗi chuỗi trong mảng hoặc danh sách được giả định là một đối số riêng lẻ. Dù bằng cách nào, các đối số thu được sau đó được nối với nhau thành một chuỗi được chuyển đến HĐH để thực thi.

Vì vậy, ví dụ, trên Windows,

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

sẽ chạy một DoStuff.exechương trình với hai đối số đã cho. Trong trường hợp này, dòng lệnh được mã hóa và kết hợp lại với nhau. Tuy nhiên,

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

sẽ không thành công, trừ khi có một chương trình có tên DoStuff.exe -arg1 -arg2trong đó C:\. Điều này là do không có mã hóa: lệnh chạy được cho là đã được mã hóa. Thay vào đó, bạn nên sử dụng

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

Hay cách khác

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

Xem cách Runtime.getRuntime().exec()chuyển lệnh String đến ProcessBuilder. Nó sử dụng một trình mã hóa và phát nổ lệnh thành các mã thông báo riêng lẻ, sau đó gọi ra exec(String[] cmdarray, ......)cấu trúc nào a ProcessBuilder.

Nếu bạn tạo chuỗi ProcessBuilderbằng một mảng thay vì một chuỗi, bạn sẽ nhận được kết quả tương tự.

Hàm ProcessBuildertạo nhận một String...vararg, vì vậy việc chuyển toàn bộ lệnh dưới dạng một Chuỗi đơn có tác dụng giống như việc gọi lệnh đó trong dấu ngoặc kép trong một thiết bị đầu cuối:

shell$ "command with args"

Không có sự khác biệt giữa ProcessBuilder.start()và Runtime.exec()bởi vì việc triển khai Runtime.exec()là:

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

Vì vậy, mã:

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

phải giống như:

Runtime.exec(command)

Cảm ơn dave_thompson_085 đã bình luận

Có một sự khác biệt.

• Các Runtime.exec(String)phương pháp có một chuỗi lệnh duy nhất mà nó tách ra thành một câu lệnh và một chuỗi các đối số.

• Hàm ProcessBuildertạo nhận một mảng chuỗi (varargs). Chuỗi đầu tiên là tên lệnh và phần còn lại của chúng là các đối số. (Có một hàm tạo thay thế lấy một danh sách các chuỗi, nhưng không một hàm tạo nào nhận một chuỗi đơn bao gồm lệnh và các đối số.)

Vì vậy, những gì bạn đang yêu cầu ProcessBuilder làm là thực hiện một "lệnh" có tên có khoảng trắng và các thứ khác trong đó. Tất nhiên, hệ điều hành không thể tìm thấy lệnh có tên đó và việc thực thi lệnh không thành công.