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

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

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) {}

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

}

ProcessBuilder pb = new ProcessBuilder();                                                                

// pb测试数据mand("cmd /c dir"); 这样会报错                                                                 

// 或者写到new ProcessBuilder("cmd", "/c", "dir")                                                            

pb测试数据mand( "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();                                                                        

}

// 以非阻塞方式获取子进程执行的返回值（习惯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()