ProcessBuilder：日常開發中系統命令調用的高效工具
前言
在日常開發過程中，調用系統命令是一種常見的需求。無論是執行腳本、操作文件、獲取系統信息，還是與其他程序進行交互，都可能需要通過調用系統命令來實現。而ProcessBuilder作為Java中用于創建進程的工具類，為開發者提供了便捷、靈活的系統命令調用方式。
基礎概念
ProcessBuilder是Java SE 5及以上版本中引入的一個類，位于java.lang包下。它主要用于創建操作系統進程，通過它可以啟動一個新的進程，并對該進程進行相關配置和操作。
與傳統的Runtime.getRuntime().exec() 方法相比，ProcessBuilder提供了更豐富、更直觀的API，讓開發者能夠更方便地設置進程的環境變量、工作目錄、輸入輸出流等參數。
核心優勢
（一）靈活的參數配置
ProcessBuilder允許開發者通過方法鏈的方式靈活地配置進程的各種參數。例如，可以輕松設置命令及其參數、工作目錄、環境變量等，無需像使用Runtime.getRuntime().exec()方法那樣處理復雜的參數數組。
（二）便捷的輸入輸出處理
通過ProcessBuilder可以方便地獲取進程的輸入流、輸出流和錯誤流，并且能夠對這些流進行重定向操作。這使得開發者可以更靈活地處理進程的輸入輸出，避免因流處理不當而導致的進程阻塞等問題。
（三）更好的可控性
使用ProcessBuilder能夠更精確地控制進程的啟動和執行。開發者可以等待進程執行完成，獲取進程的退出值，判斷進程的執行結果是否符合預期。同時，還可以通過destroy()方法終止進程，提高了對進程的可控性。
基本使用方法
創建 ProcessBuilder 對象
創建ProcessBuilder對象時，需要指定要執行的命令及其參數。可以通過構造方法傳入一個包含命令和參數的列表或數組。例如，要執行ls -l命令（在Linux系統中），可以這樣創建ProcessBuilder對象：
ProcessBuilder pb = new ProcessBuilder("ls", "-l");配置進程參數
設置工作目錄：通過directory()方法可以設置進程的工作目錄。例如，將工作目錄設置為/home/user：
pb.directory(new File("/home/user"));設置環境變量：ProcessBuilder的environment()方法返回一個Map對象，通過該Map可以設置進程的環境變量。例如，添加一個名為PATH的環境變量：
Map<String, String> env = pb.environment();
env.put("PATH", "/usr/local/bin:" + env.get("PATH"));重定向輸入輸出流：可以通過redirectInput()、redirectOutput()、redirectError()等方法對進程的輸入輸出流進行重定向。例如，將進程的輸出重定向到指定文件：
pb.redirectOutput(new File("output.txt"));啟動進程并獲取結果
等待進程執行完成Process對象的waitFor()方法會阻塞當前線程，直到進程執行完成。該方法返回一個int類型的值，表示進程的退出狀態，通常0表示進程正常退出。
Process process = pb.start();
int exitCode = process.waitFor();處理進程的輸入輸出：如果沒有對進程的輸入輸出流進行重定向，就需要通過Process對象的getInputStream()、getOutputStream()和getErrorStream ()方法獲取相應的流，并進行處理。需要注意的是，這些流的處理需要在單獨的線程中進行，否則可能會導致進程阻塞。例如，讀取進程的輸出流：
InputStream inputStream = process.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}進階技巧
當進程的輸出流數據量較大時，如果不及時讀取，可能會導致緩沖區滿而阻塞進程。因此，需要在單獨的線程中讀取輸出流和錯誤流。可以使用線程池來管理這些線程，提高效率。例如：
Process process = pb.start();
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(() -> {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
String line;
while ((line = reader.readLine()) != null) {
// 處理輸出內容
}
} catch (IOException e) {
e.printStackTrace();
}
});
executor.submit(() -> {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getErrorStream()))) {
String line;
while ((line = reader.readLine()) != null) {
// 處理錯誤內容
}
} catch (IOException e) {
e.printStackTrace();
}
});
int exitCode = process.waitFor();
executor.shutdown();在某些情況下，進程可能會因為各種原因長時間運行而無法結束，這會影響程序的正常執行。為了避免這種情況，可以為進程設置超時時間，如果超過指定時間進程仍未結束，則強制終止該進程。可以使用Process.waitFor (long timeout, TimeUnit unit)方法來實現，該方法會在指定時間內等待進程結束，如果超時則返回false。例如：
Process process = pb.start();
boolean finished = process.waitFor(5, TimeUnit.SECONDS);
if (!finished) {
process.destroy();
// 處理超時情況
}ProcessBuilder支持通過管道將多個進程連接起來，實現數據的傳遞和處理。例如，在Linux系統中，可以將ls -l命令的輸出通過管道傳遞給grep txt命令，篩選出包含txt的行。使用ProcessBuilder實現如下：
ProcessBuilder pb1 = new ProcessBuilder("ls", "-l");
ProcessBuilder pb2 = new ProcessBuilder("grep", "txt");
Process p1 = pb1.start();
Process p2 = pb2.start();
// 將p1的輸出流連接到p2的輸入流
try (InputStream p1Out = p1.getInputStream();
OutputStream p2In = p2.getOutputStream()) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = p1Out.read(buffer)) != -1) {
p2In.write(buffer, 0, bytesRead);
}
}
// 等待p2執行完成并處理結果
p2.waitFor();
try (BufferedReader reader = new BufferedReader(new InputStreamReader(p2.getInputStream()))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
}工具類
/**
* ProcessBuilder 工具類，簡化系統命令調用
*/
public class ProcessExecutor {
// 默認超時時間（毫秒）
private static final long DEFAULT_TIMEOUT = 30000;
// 緩沖區大小
private static final int BUFFER_SIZE = 1024;
// 命令及參數
private List<String> command;
// 工作目錄
private File workingDir;
// 環境變量
private Map<String, String> environment;
// 超時時間（毫秒）
private long timeout = DEFAULT_TIMEOUT;
/**
* 構造方法，初始化命令
* @param command 命令及參數（例如："ls", "-l"）
*/
public ProcessExecutor(String... command) {
this.command = Arrays.asList(command);
this.environment = new HashMap<>();
}
/**
* 設置工作目錄
*/
public ProcessExecutor workingDir(File workingDir) {
this.workingDir = workingDir;
return this;
}
/**
* 添加環境變量
*/
public ProcessExecutor addEnv(String key, String value) {
this.environment.put(key, value);
return this;
}
/**
* 設置超時時間（毫秒）
*/
public ProcessExecutor timeout(long timeout) {
this.timeout = timeout;
return this;
}
/**
* 執行命令并返回結果
* @return 命令執行結果（包含輸出、錯誤信息、退出碼）
* @throws IOException 輸入輸出異常
* @throws InterruptedException 線程中斷異常
* @throws TimeoutException 超時異常
*/
public Result execute() throws IOException, InterruptedException, TimeoutException {
// 1. 初始化 ProcessBuilder
ProcessBuilder pb = new ProcessBuilder(command);
// 2. 配置工作目錄
if (workingDir != null) {
pb.directory(workingDir);
}
// 3. 配置環境變量（合并系統環境變量和自定義變量）
Map<String, String> systemEnv = pb.environment();
systemEnv.putAll(environment);
// 4. 啟動進程
Process process = pb.start();
// 5. 異步處理輸出流和錯誤流
ExecutorService executor = Executors.newFixedThreadPool(2);
StringBuilder output = new StringBuilder();
StringBuilder error = new StringBuilder();
// 處理輸出流
Future<?> outputFuture = executor.submit(() -> readStream(process.getInputStream(), output));
// 處理錯誤流
Future<?> errorFuture = executor.submit(() -> readStream(process.getErrorStream(), error));
// 6. 等待進程執行完成（帶超時）
boolean finished = process.waitFor(timeout, TimeUnit.MILLISECONDS);
if (!finished) {
process.destroyForcibly(); // 強制終止進程
throw new TimeoutException("命令執行超時（" + timeout + "ms）：" + String.join(" ", command));
}
// 7. 等待流處理完成
try {
outputFuture.get(1, TimeUnit.SECONDS);
errorFuture.get(1, TimeUnit.SECONDS);
} catch (ExecutionException e) {
throw new IOException("流處理失敗", e.getCause());
} finally {
executor.shutdown();
}
// 8. 返回結果
return new Result(
output.toString(),
error.toString(),
process.exitValue()
);
}
/**
* 讀取輸入流并寫入字符串緩沖區
*/
private void readStream(InputStream inputStream, StringBuilder builder) throws IOException {
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(inputStream, StandardCharsets.UTF_8)
)) {
char[] buffer = new char[BUFFER_SIZE];
int bytesRead;
while ((bytesRead = reader.read(buffer)) != -1) {
builder.append(buffer, 0, bytesRead);
}
}
}
/**
* 命令執行結果封裝類
*/
public static class Result {
private final String output; // 命令輸出
private final String error; // 錯誤信息
private final int exitCode; // 退出碼
public Result(String output, String error, int exitCode) {
this.output = output;
this.error = error;
this.exitCode = exitCode;
}
// 是否執行成功（退出碼為0）
public boolean isSuccess() {
return exitCode == 0;
}
// getter 方法
public String getOutput() { return output; }
public String getError() { return error; }
public int getExitCode() { return exitCode; }
@Override
public String toString() {
return"Result{" +
"output='" + output + '\'' +
", error='" + error + '\'' +
", exitCode=" + exitCode +
'}';
}
}
// 示例用法
public static void main(String[] args) {
try {
// 執行 Linux 命令：ls -l /home
ProcessExecutor executor = new ProcessExecutor("ls", "-l", "/home")
.workingDir(new File("/")) // 設置工作目錄
.addEnv("LANG", "en_US.UTF-8") // 添加環境變量
.timeout(10000); // 設置超時時間
Result result = executor.execute();
if (result.isSuccess()) {
System.out.println("執行成功，輸出：");
System.out.println(result.getOutput());
} else {
System.err.println("執行失敗（" + result.getExitCode() + "），錯誤信息：");
System.err.println(result.getError());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}注意事項
跨平臺兼容性問題
不同的操作系統支持的命令和參數可能不同，因此在使用ProcessBuilder調用系統命令時，需要考慮跨平臺兼容性。例如Windows系統中的dir命令在Linux系統中對應的是ls命令。可以通過判斷當前操作系統類型，執行相應的命令。
安全問題
調用系統命令可能會帶來安全風險，特別是當命令中包含用戶輸入的內容時，可能會遭受命令注入攻擊。因此，在使用用戶輸入作為命令或參數時，需要進行嚴格的驗證和過濾，避免執行惡意命令。
流處理問題
進程的輸入流、輸出流和錯誤流都需要及時處理，否則可能會導致緩沖區滿而阻塞進程。在處理這些流時，要注意使用正確的方式，避免出現死鎖等問題。建議在單獨的線程中處理輸出流和錯誤流。
資源釋放問題
Process對象代表一個操作系統進程，它會占用系統資源。因此，在進程執行完成后，要及時釋放相關資源，包括關閉流和銷毀進程。可以使用try-with-resources語句來自動關閉流，確保資源的正確釋放。
