Java魔法堂之調用外部程序的方法

Posted on by

前言

Java雖然五臟俱全但總有軟肋，譬如獲取CPU等硬件信息，當然我們可以通過JNI調用C/C++來獲取，但對於對C/C++和Windows API不熟的碼農是一系列復雜的學習和踩坑過程。那能不能通過簡單一些、學習成本低一些的方式呢？答案是肯定的，在功能實現放在首位的情況下，借他山之石是最簡潔有力的做法。

認識java.lang.Runtime#exec方法

作用：用於調用外部程序，並重定向外部程序的標準輸入、標準輸出和標準錯誤到緩沖池。功能就是和windows的“運行”一樣。

重載方法說明

Runtime#exec(String command);
Runtime#exec(String command, String[] envp);
Runtime#exec(String command, String[] envp, File workdir);
Runtime#exec(String[] cmdArray);
Runtime#exec(String[] cmdArray, String[] envp);
Runtime#exec(String[] cmdArray, String[] envp, File workdir);

String[] envp 作為調用命令前設置的會話級環境變量。
1.1. 變量作用域：命令運行結束後，通過該參數設置的環境變量將失效；
1.2. 設置方式：variableName=variableValue，如Process proc = r.exec("cmd /c dir > %dest%", new String[]{"dest=c:\\dir.txt"});File workdir 用於設置當前工作目錄，譬如我們需要執行位於D:\tools下的echo.exe程序，那麼可以這樣調用Process proc = r.exec("echo.exec", null, new File("D:\\tools"));String command 即為需要調用的外部程序，以及命令行參數等。Windows下調用系統命令，像dir等命令是由cmd解析器解釋執行的，因此若直接寫”dir”則會被認為在當前工作目錄下有一個”dir.exe”文件，那麼當然會執行失敗；在Linux下調用ls等是同樣道理，因此請按如下方式調用cmd和shell命令：
3.1. 調用CMD命令的方式為Process proc = r.exec(String.format("cmd /c %s", "cmd命令，如dir、type等"))，若要啟動一個新的Console執行命令，隻需要將dir改寫為start dir即可；
3.2. 調用Shell命令的方式為Process proc = r.exec(String.format("/bin/sh -c %s", "shell命令，如ls、cat等"))，若要啟動一個新的Terminal執行命令，隻需要將ls改寫為xterm -e ls即可；String[] cmdArray 功能和String command一樣，但命令行的每個部分將作被獨立分隔出來作為數組中的元素。如cmd /c dir必須分割為new String[]{"cmd", "/c", "dir"}，而不能分割為new String[]{"cmd /c", "dir"}。

輸入重定向

廢話少說，直接看代碼！

try {                                                      
 String cmd = "cmd /c start cmd.exe";                                    
 Process child = Runtime.getRuntime().exec(cmd);                               
 OutputStream output = child.getOutputStream();                               
 output.write("cd C:/ /r/n".getBytes());                                   
 output.flush();                                               
 output.write("dir /r/n".getBytes());                                    
 output.close();                                               
}                                                        
catch (IOException e) {}

輸出重定向

註意：不支持直接使用>或>>執行標準輸出重定向。

String cmd = "/path/to/getipconfig.bat"; // 自己寫的bat腳本文件，裡面包含ipconfig /all命令。
Process p;                                                   
                                                           
try {                                                      
 p = Runtime.getRunTime().exec(cmd);                                     
 InputStream input = p.getInputStream();                                   
 InputStreamReader streamReader = new InputStreamReader(input);                       
 BufferedReader bufReader = new BufferedReader(streamReader);                        
 String line = null;                                             
                                                           
 while ((line = bufReader.readLine()) != null) {                               
  System.out.println(line);                                          
 }                                                      
}                                                        
catch (IOException e) {}

為什麼不能使用>和>>實現輸出重定向呢？

通過Process實例.getInputStream()和Process實例.getErrorStream()獲取的輸入流和錯誤信息流是緩沖池是當前Java程序提供的，而不是直接獲取外部程序的標準輸出流和標準錯誤流。
即通過Runtime#exec調用外部程序時，外部程序的標準輸出流和標準錯誤流已經被Java程序接管。那麼在命令中企圖通過>和>>實現輸出重定向顯然已無效果。

另外，緩沖池的容量是一定的，因此若外部程序在運行過程中不斷向緩沖池輸出內容，當緩沖池填滿，那麼外部程序將暫停運行直到緩沖池有空位可接收外部程序的輸出內容為止。（采用xcopy命令復制大量文件時將會出現該問題）
解決辦法就是當前的Java程序不斷讀取緩沖池的內容，從而為騰出緩沖池的空間。如：

Runtime r = Runtime.getRuntime();
try{
 Process proc = r.exec("cmd /c dir"); // 假設該操作為造成大量內容輸出
 // 采用字符流讀取緩沖池內容，騰出空間
 BufferedReader reader = new BufferedReader(new InputStreamReader(proc.getInputStream(), "gbk")));
 String line = null;
 while ((line = reader.readLine()) != null){
   System.out.println(line);
 }

 // 或采用字節流讀取緩沖池內容，騰出空間
 // ByteArrayOutputStream pool = new ByteArrayOutputStream();
 // byte[] buffer = new byte[1024];
 // int count = -1;
 // while ((count = proc.getInputStream().read(buffer)) != -1){
 //  pool.write(buffer, 0, count);
 //  buffer = new byte[1024];
 // }
 // System.out.println(pool.toString("gbk"));

 int exitVal = proc.waitFor();
 System.out.println(exitVal == 0 ? "成功" : "失敗");
}
catch(Exception e){
 e.printStackTrace();
}

註意：外部程序在執行結束後將會自動關閉，否則不管是字符流還是字節流均由於既讀不到數據，又讀不到流結束符而出現阻塞Java進程運行的情況。

簡化輸入輸出重定向的java.lang.ProcessBuilder

功能和java.lang.runtime#exec一樣，隻是java.lang.ProcessBuilder僅接收命令行以數組形式傳遞給java.lang.ProcessBuilder#command()而已。

基本使用

ProcessBuilder pb = new ProcessBuilder();                                                                 
// pb.command("cmd /c dir"); 這樣會報錯                                                                  
// 或者寫到new ProcessBuilder("cmd", "/c", "dir")                                                             
pb.command("cmd", "/c", "dir");                                                                      
try {                                                                                   
 Process process = pb.start();                                                                     
 // 後面都是操作Process實例的方法                                                                    
}                                                                                     
catch (IOException e){}

重定向

public ProcessBuilder redirectInput(File file) // 輸入重定向                                                       
public ProcessBuilder redirectOutput(File file) // 輸出重定向                                                       
public ProcessBuilder redirectError(File file) // 異常重定向

示例

try {                                                                                  
 ProcessBuilder pb = new ProcessBuilder("cmd");                                                            
 // 在標準輸入中，通過換行符分隔多行命令。                                                              
 // commands.txt的內容為                                                                       
 // javac Demo.java                                                                          
 // java Demo                                                                             
 File commands = new File("/path/to/commands.txt");                                                          
 File error = new File("/path/to/error");                                                               
 File output = new File("/path/to/output");                                                              
                                                                                         
 pd.redirectInput(commands);                                                                     
 pd.redirectOutput(output);                                                                      
 pd.redirectError(error);                                                                       
                                                                                         
 pd.start();                                                                             
}                                                                                    
catch(Exception e) {                                                                           
 e.printStackTrace();                                                                         
}

java.lang.ProcessAPI說明

// 以非阻塞方式獲取子進程執行的返回值（習慣0表示正常結束）。若子進程尚未完成時調用該方法，則會報異常`java.lang.IllegalThreadStateException`
int exitValue()      
// 以阻塞方式獲取子進程執行的返回值。若進程尚未完成則會等待子進程完成後才恢復當前線程。
// 問題：若子進程無法正常關閉，則會導致Java線程一直掛起；
// 返回值為子進程的退出碼
int waitFor()。                                  
// 如果超時前子進程結束，那麼返回`true` ，否則返回`false`
boolean waitFor(long timeout, TimeUnit unit)
// 強行終止子進程，但調用後子進程不會馬上被終止，所以立即調`boolean isAlive()`方法可能會返回`true`，因此需配合`waitFor`使用。
void destory()
// 默認實現為調用`void destory()`方法。從JDK1.8開始提供。
Process destoryForcibly()
// 如果子進程還沒結束則返回`true` 。從JDK1.8開始提供。                                          
boolean isAlive()
// 獲取子進程的異常輸出流，如果子進程以`ProcessBuilder`創建，且通過`ProcessBuilder.redirectError`設置重定向，那麼該方法返回`null`                          
InputStream getErrorStream()
// 獲取子進程的標準輸出流，如果子進程以`ProcessBuilder`創建，且通過`ProcessBuilder.redirectOutput`設置重定向，那麼該方法返回`null`
InputStream getInputStream() 
// 獲取子進程的標準輸入流，如果子進程以`ProcessBuilder`創建，且通過`ProcessBuilder.redirectInput`設置重定向，那麼該方法返回`null`
OutputStream getOutputStream()

總結

到此這篇關於Java魔法堂：調用外部程序的文章就介紹到這瞭,更多相關Java調用外部程序內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：