java实现外部输入输出_[java调用外部可执行程序] 2. java输入输出重定向

继续讨论java调用外部可执行程序相关的问题，内容部分收集自网上。

问题一：取得Runtime.getRuntime().exec("cmd /c dir")的输入输出

调用Runtime.exec方法将产生一个本地的进程,并返回一个Process子类的实例,该实例可用于控制进程或取得进程的相关信息. 由于调用Runtime.exec方法所创建的子进程没有自己的终端或控制台,因此该子进程的标准IO(如stdin,stdou,stderr)都通过Process.getOutputStream(), Process.getInputStream(), Process.getErrorStream()方法重定向给它的父进程了.

例程1：

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.LineNumberReader;

public class ProcessIODemo {

/**

* @param args

*/

public static void main(String[] args) {

try {

String command = "cmd /c dir";

Process proc = Runtime.getRuntime().exec(command);

InputStreamReader ir = new InputStreamReader(proc.getInputStream());

LineNumberReader lnr = new LineNumberReader(ir);

String line;

while( (line = lnr.readLine()) != null)

{

System.out.println(line);

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

如果外部批处理脚本涉及到了重定向，需要换另外一种构造形式，如String[] cmd = { "/bin/sh", "-c", "/bin/ls | grep d > FILE" }; ，然后进行外部可执行程序调用。

问题二：利用ProcessBuilder来创建Process对象，执行外部可执行程序

ProcessBuilder类是J2SE 1.5在java.lang中新添加的一个新类，此类用于创建操作系统进程，它提供一种启动和管理进程(也就是应用程序)的方法。在J2SE 1.5之前，都是由Process类处来实现进程的控制管理。每个 ProcessBuilder 实例管理一个进程属性集。它的start() 方法利用这些属性创建一个新的 Process 实例。start() 方法可以从同一实例重复调用，以利用相同的或相关的属性创建新的子进程。

每个进程生成器(即ProcessBuilder对象)管理这些进程属性：

命令 是一个字符串列表，它表示要调用的外部程序文件及其参数(如果有)。在此，表示有效的操作系统命令的字符串列表是依赖于系统的。例如，每一个总体变量，通常都要成为此列表中的元素，但有一些操作系统，希望程序能自己标记 命令行字符串——在这种系统中，Java 实现可能需要命令确切地包含这两个元素。

环境 是从变量 到值 的依赖于系统的映射。初始值是当前进程环境的一个副本(请参阅 System.getenv())。

工作目录 默认值是当前进程的当前工作目录，通常根据系统属性 user.dir 来命名。

redirectErrorStream 属性 。最初，此属性为 false，意思是子进程的标准输出和错误输出被发送给两个独立的流，这些流可以通过 Process.getInputStream() 和 Process.getErrorStream() 方法来访问。如果将值设置为 true，标准错误将与标准输出合并。这使得关联错误消息和相应的输出变得更容易。在此情况下，合并的数据可从 Process.getInputStream() 返回的流读取，而从 Process.getErrorStream() 返回的流读取将直接到达文件尾。

注意，此类不是同步的。如果多个线程同时访问一个 ProcessBuilder，而其中至少一个线程从结构上修改了其中一个属性，它必须 保持外部同步。

例程2：

package study.java.lang;

import java.io.BufferedInputStream;

import java.io.BufferedReader;

import java.io.File;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.PipedInputStream;

import java.io.PipedOutputStream;

import java.io.PrintWriter;

public class ProcessBuilderDemo {

/**

* @param args

*/

public static void main(String[] args) {

//  //Eg1:

//  String address = null;

//

//  String os = System.getProperty("os.name");

//  System.out.println(os);

//

//  if (os != null) {

//   if (os.startsWith("Windows")) {

//    try {

//     ProcessBuilder pb = new ProcessBuilder("ipconfig", "/all");

//     Process p = pb.start();

//

//     BufferedReader br = new BufferedReader(

//       new InputStreamReader(p.getInputStream()));

//

//     String line;

//     while ((line = br.readLine()) != null) {

//      if (line.indexOf("Physical Address") != -1) {

//       int index = line.indexOf(":");

//       address = line.substring(index + 1);

//       break;

//      }

//     }

//     br.close();

//     address = address.trim();

//    } catch (IOException e) {

//     // TODO Auto-generated catch block

//     e.printStackTrace();

//    }

//   } else if (os.startsWith("Linux")) {

//    try {

//     ProcessBuilder pb = new ProcessBuilder(

//

//     "ifconfig", "/all");

//

//     Process p = pb.start();

//     BufferedReader br = new BufferedReader(

//       new InputStreamReader(p.getInputStream()));

//     String line;

//     while ((line = br.readLine()) != null) {

//      int index = line.indexOf("硬件地址");

//      if (index != -1) {

//       address = line.substring(index + 4);

//       break;

//      }

//     }

//     br.close();

//     address = address.trim();

//    } catch (IOException e) {

//     e.printStackTrace();

//    }

//   }

//  }

//  //Eg2:

//  try {

//   Process proc;

//   proc = Runtime.getRuntime().exec("cmd.exe");

//   BufferedReader read = new BufferedReader(new InputStreamReader(proc

//     .getInputStream()));

//   new Thread(new Echo(read)).start();

//

//   PrintWriter out = new PrintWriter(new OutputStreamWriter(proc

//     .getOutputStream()));

//   BufferedReader in = new BufferedReader(new InputStreamReader(

//     System.in));

//   String instr = in.readLine();

//   while (!"exit".equals(instr)) {

//    instr = in.readLine();

//    out.println(instr);

//    out.flush();

//   }

//

//   in.readLine();

//   read.close();

//   out.close();

//  } catch (IOException e) {

//   // TODO Auto-generated catch block

//   e.printStackTrace();

//  }

}

}

class Echo implements Runnable {

private BufferedReader read;

public Echo(BufferedReader read) {

this.read = read;

}

public void run() {

try {

String line = read.readLine();

while (line != null) {

System.out.println(line);

line = read.readLine();

}

System.out.println("---执行完毕:");

} catch (IOException ex) {

ex.printStackTrace();

}

}

}

问题三：如何协调外部进程与当前Java进程

1、waitFor方法

在windows平台上容易出现异常，建议不要使用，可以通过截获Process的输入输出流来等待Process进程完成。

在windows平台上，运行被调用程序的DOS窗口在程序执行完毕后往往并不会自动关闭，从而导致Java应用程序阻塞在waitfor( )。导致该现象的一个可能的原因是，该可执行程序的标准输出比较多，而运行窗口的标准输出缓冲区不够大。解决的办法是，利用Java提供的Process 类提供的方法让Java虚拟机截获被调用程序的DOS运行窗口的标准输出，在waitfor()命令之前读出窗口的标准输出缓冲区中的内容。一段典型的程序如下：

...

String ls_1;

Process process = Runtime.getRuntime().exec("cmd /c dir       windows");

BufferedReader bufferedReader = new BufferedReader( \

new InputStreamReader(process.getInputStream());

while ( (ls_1=bufferedReader.readLine()) != null)

System.out.println(ls_1);

process.waitfor( );

2、执行DOS的内部命令

如果要执行一条DOS内部命令，有两种方法。一种方法是把命令解释器包含在exec()的参数中。例如，执行dir命令，在NT上，可写成exec("cmd.exe /c dir")，在windows 95/98下，可写成“command.exe /c dir”，其中参数“/c”表示命令执行后关闭Dos立即关闭窗口。另一种方法是，把内部命令放在一个批命令my_dir.bat文件中，在Java程序中写成exec("my_dir.bat")。如果仅仅写成exec("dir")，Java虚拟机则会报运行时错误。前一种方法要保证程序的可移植性，需要在程序中读取运行的操作系统平台，以调用不同的命令解释器。后一种方法则不需要做更多的处理。