weidagang2046的专栏

 

Java's Runtime.exec() and External Applications
by Mitchell S. Baltuch ( mitch@unidata.ucar.edu)

 

Java was developed with an eye toward platform independence, freeing the software developer from the unpleasant and tedious task of cross-platform porting and testing of software. All too often, however, developers are not able to write completely new applications, but have to interface to existing legacy software and operating systems. This poses a problem as Java cannot make use of many utilities and system-dependent features that these programs have relied upon in the past.

There are two solutions to this problem, both of which sacrifice platform independence. The first is to make use of native methods in your Java code. You lose the portability, but achieve the result. Native methods can also be more difficult to implement, which can make them less desirable to use.

The second option is to satisfy the programming needs by executing external utilities and applications from within a Java program. In Java, this means employing the Runtime class exec() method. Like the fork(3) C function, Runtime.exec() allows you to execute a program; unlike fork(), it does not allow you to directly control the environment. Runtime.exec() provides a simple interface to platform-dependent utilities and applications, although at the expense of platform independence. In an environment where Java applications must coexist with other non-Java applications this will often be a valid trade-off.

In its simplest form, exec() is quite easy to use:

	Process p = Runtime.getRuntime().exec("/bin/ls");

The problem with this form is that it gets you nowhere. When Java forks a new process it redirects STDIN, STDOUT and STDERR. Therefore the results of "/bin/ls" do not go to the screen. Instead you must use the getInputStream(), getOutputStream() and getErrorStream() methods of the Process object to communicate with the program that you executed. Listing 1 shows an example using the Unix ls(1) command.

				  Listing 1
import	java.io.*;

class execInput {
    public static void main(String Argv[]) {
	try {
	    String ls_str;

	    Process ls_proc = Runtime.getRuntime().exec("/bin/ls -aFl");

	    // get its output (your input) stream

	    DataInputStream ls_in = new DataInputStream(
                                          ls_proc.getInputStream());

	    try {
		while ((ls_str = ls_in.readLine()) != null) {
		    System.out.println(ls_str);
		}
	    } catch (IOException e) {
		System.exit(0);
	    }
	} catch (IOException e1) {
	    System.err.println(e1);
	    System.exit(1);
	}

	System.exit(0);
    }
}

Some points to be aware of with this code. In the JDK1.0.2 implementation, you must supply a complete path to whatever it is that you are executing. There is no facility in that version of the JDK to get the shell environment that you are running in, hence no PATH variable is known. This is fixed in JDK1.1, however it is always good practice to fully qualify the path.

Shell built-in commands will not work here. A prime example of this is the DOS "dir" command. This is a built-in and will not execute. You would need to use "command \c dir" as the command string.

If you pass the executable command as a single String, the exec() method will break the string into multiple strings, breaking the original string on white space. This will cause some trouble when trying to do things like I/O redirection.

Consider the following line of code:

	Process p = Runtime.getRuntime().exec("/bin/sh -c /bin/ls > ls.out");

This is intended to execute a Bourne shell and have the shell execute the ls command, redirecting the output of ls to the file ls.out. The reason for using /bin/sh is to get around the problem of having stdout redirected by the Java internals. Unfortunately, if you try this nothing will happen. When this command string is passed to the exec() method it will be broken into an array of Strings with the elements being "/bin/sh", "-c", "/bin/ls", ">", and "ls.out". This will fail, as sh expects only a single argument to the "-c" switch. To make this work try:

	String[] cmd = {"/bin/sh", "-c", "/bin/ls > out.dat"};
	Process p = Runtime.getRuntime().exec(cmd);

Since the command line is already a series of Strings, the strings will simply be loaded into the command array by the exec() method and passed to the new process as is. Thus the shell will see a "-c" and the command "/bin/ls > ls.out" and execute correctly.

Using Runtime.exec() can make integration with system utilities, tools and legacy software achievable, although, as already noted, at the expense platform independence. If you must work with existing software and tools, it is often the easiest, and most straight-forward approach to the problem. But beware of the gotchas. They can often lead to unexpected results.

from: http://www.mountainstorm.com/publications/javazine.html