How to use Process class in Java 9 to control the execution of external processes

How to use Process class to control the execution of external processes in Java 9

Overview:
In Java, by using Process class, we can easily interact with external processes. Java 9 introduces several new features, including a more secure and flexible approach when dealing with external processes. This article will explain how to use the Process class in Java 9 and demonstrate its usage with code examples.

1. Create an external process
   In Java 9, creating an external process is very simple. First, we need to create a ProcessBuilder object using the ProcessBuilder class and specify the command of the external process to be started. We can then start the external process using the start() method. The following is a sample code to create an external process:

import java.io.IOException;
public class ExternalProcessExample {
    public static void main(String[] args) {
        ProcessBuilder processBuilder = new ProcessBuilder("notepad.exe");
        try {
            Process process = processBuilder.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

In the above example, we created a ProcessBuilder object and specified the command of the external process to be started as 'notepad.exe'. Then, we use the start() method to start the external process.

2. Controlling the execution of external processes
   Once we start the external process, we can use the Process class to control its execution. The Process class provides some methods to help us monitor the status of external processes, obtain input/output streams, and interact with processes.

2.1 Listening to process exit status
We can use the waitFor() method to wait for the exit of an external process and obtain its exit status. The sample code is as follows:

try {
    int exitValue = process.waitFor();
    System.out.println("Process exited with value: " + exitValue);
} catch (InterruptedException e) {
    e.printStackTrace();
}

In the above example, we use the waitFor() method to wait for the exit of the external process and store the exit status in the exitValue variable.

2.2 Obtain the input/output stream of an external process
Sometimes, we need to obtain the input/output stream of an external process in order to interact with the process. The Process class provides getInputStream(), getOutputStream() and getErrorStream() methods to obtain the corresponding stream.

try {
    // 获取进程输入流并发送数据
    OutputStream outputStream = process.getOutputStream();
    outputStream.write("Hello".getBytes());
    
    // 获取进程输出流并读取数据
    InputStream inputStream = process.getInputStream();
    byte[] buffer = new byte[1024];
    int length = inputStream.read(buffer);
    String output = new String(buffer, 0, length);
    System.out.println("Process output: " + output);
    
    // 获取进程错误流并读取错误信息
    InputStream errorStream = process.getErrorStream();
    byte[] errorBuffer = new byte[1024];
    int errorLength = errorStream.read(errorBuffer);
    String errorMessage = new String(errorBuffer, 0, errorLength);
    System.out.println("Process error: " + errorMessage);
} catch (IOException e) {
    e.printStackTrace();
}

In the above example, we use the getInputStream() method to get the input stream of the process, and the getOutputStream() method to get the output stream of the process and the getErrorStream() method to get the error stream of the process. We can then use these streams to send data to the process, read the process' output, and read the process' error information.

3. Destruction and interruption of external processes
   Sometimes, we need to manually destroy external processes. We can use the destroy() method to destroy the process. The sample code is as follows:

process.destroy();

In addition, we can also use the destroyForcibly() method to force the destruction of the process, even if the process is unresponsive. The sample code is as follows:

process.destroyForcibly();

Sometimes, for some reasons, we need to interrupt the operation of waiting for the external process to exit. We can use the interrupt() method to interrupt operations. The sample code is as follows:

Thread currentThread = Thread.currentThread();
currentThread.interrupt();

4. Security and restrictions of external processes
   In Java 9, you can use new methods of the ProcessBuilder class to set and restrict the execution of external processes. Use the command(String...) method to more precisely specify the external process command to be executed. In addition, the error output stream can be redirected using the redirectError(ProcessBuilder.Redirect) method.

ProcessBuilder processBuilder = new ProcessBuilder()
    .command("ping", "www.google.com")
    .redirectError(ProcessBuilder.Redirect.INHERIT);

In the above example, we use the command(String...) method to specify the external process command as 'ping www.google.com'. We also use the redirectError(ProcessBuilder.Redirect) method to redirect the error output stream to the standard output stream.

Summary:
In Java 9, using the Process class to control the execution of external processes has become more secure and flexible. We can use the ProcessBuilder class to create and start external processes, and use the Process class to monitor process status, obtain input/output streams, and interact with the process. In addition, Java 9 also provides some new methods for setting and limiting the execution of external processes.

Reference materials:

1. Java 9 Process API Javadoc: https://docs.oracle.com/javase/9/docs/api/java/lang/Process.html
2. Java 9 ProcessBuilder API Javadoc: https://docs.oracle.com/javase/9/docs/api/java/lang/ProcessBuilder.html

The above is the detailed content of How to use Process class in Java 9 to control the execution of external processes. For more information, please follow other related articles on the PHP Chinese website!