How to call external programs in Java

In Java, you can call external programs through the Runtime class or ProcessBuilder class.

Runtime class and ProcessBuilder class

Use the Runtime class:

Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec("外部程序路径");

Use the ProcessBuilder class:

ProcessBuilder builder = new ProcessBuilder("外部程序路径");
Process process = builder.start();

Parameter passing

Both of the above two methods can start an external process. If you need to pass parameters to an external process, you can pass a string array in exec() or the ProcessBuilder constructor

String[] cmdarray = {"外部程序路径", "参数1", "参数2"};Process process = runtime.exec(cmdarray);

Execution results

The return result of the external process can be passed process object acquisition. You can use the getInputStream() method to read the standard output stream of an external process, or the getErrorStream() method to read the error output stream.

InputStream inputStream = process.getInputStream(); // 标准输出流
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String line;
while ((line = bufferedReader.readLine()) != null) {
    System.out.println(line); // 输出每行结果
}

Note: Be careful when calling external programs because it may cause security issues and abnormal situations such as system crashes. It is recommended to fully test and verify the external program when using this function

Use of Runtime class

    @Test
    public void runtimeTest() {
        try {
            //获取执行进程
            Runtime runtime = Runtime.getRuntime();
            Process process = runtime.exec("ipconfig");
            //读取输入流
            InputStream inputStream = process.getInputStream();
            //将字节流转成字符流
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "gbk");
            //字符缓冲区
            char[] c = new char[1024];
            int len = -1;
            while ((len = inputStreamReader.read(c)) != -1) {
                String s = new String(c, 0, len);
                System.out.print(s);
            }
            inputStream.close();
            inputStreamReader.close();
            //阻塞当前线程，直到进程退出为止
            process.waitFor();
            int exitValue = process.exitValue();
            if (exitValue == 0) {
                System.out.println("进程正常结束");
            } else {
                System.out.println("进程异常结束");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

Use of ProcessBuilder class

No-parameter call

@Test
    public void processBuilderTest1() {
        ProcessBuilder processBuilder = new ProcessBuilder();
        processBuilder.command("java");
        //将标准输入流和错误输入流合并，通过标准输入流读取信息
        processBuilder.redirectErrorStream(true);
        try {
            //启动进程
            Process start = processBuilder.start();
            //获取输入流
            InputStream inputStream = start.getInputStream();
            //转成字符输入流
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "gbk");
            int len = -1;
            //字符缓冲区
            char[] c = new char[1024];
            //读取进程输入流中的内容
            while ((len = inputStreamReader.read(c)) !=-1){
                String s = new String(c, 0, len);
                System.out.print(s);
            }
            inputStreamReader.close();
            inputStream.close();
            //阻塞当前线程，直到进程退出为止
            start.waitFor();
            int exitValue = start.exitValue();
            if (exitValue == 0) {
                System.out.println("进程正常结束");
            } else {
                System.out.println("进程异常结束");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

##Simple parameter call

processBuilder.command("java","-version");

Complex parameter call

 List<String> command = new ArrayList<>();
        command.add("java");
        command.add("-version");
        processBuilder.command(command);

Apache Commons Exec library

Apache Commons Exec is a Java library used to execute external processes. It can easily start and control processes, and provides management and processing of input and output streams

Introduction to usage steps

1. Add dependencies and add the Apache Commons Exec library to the project

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-exec</artifactId>
            <version>1.3</version>
        </dependency>

2. Construct the command line object: Construct the external program that needs to be executed through the CommandLine object and parameters.

CommandLine cmdLine = CommandLine.parse("command argument1 argument2");

can be rewritten as: Creating an executor object requires the use of a DefaultExecutor object, and the working directory can be set as needed.

DefaultExecutor executor = new DefaultExecutor();
executor.setWorkingDirectory(new File("/your/workdir"));

4. Create a processor object: The PumpStreamHandler object can handle the input and output streams and store the standard output and standard error information of the process.

ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
PumpStreamHandler streamHandler = new PumpStreamHandler(outputStream);
executor.setStreamHandler(streamHandler);

Call the executor.execute method to execute the command and wait for the process to end. Call process.waitFor() to wait for the process to complete before continuing to perform the corresponding operation. After the execution is completed, the output results in the outputStream are processed.

executor.execute(cmdLine);
String output = outputStream.toString("UTF-8");
System.out.println(output);

Usage example

    public static void main(String[] args) throws IOException {
        CommandLine cmdLine = CommandLine.parse("java -version");
        DefaultExecutor executor = new DefaultExecutor();
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        PumpStreamHandler streamHandler = new PumpStreamHandler(outputStream);
        executor.setStreamHandler(streamHandler);
        executor.execute(cmdLine);
        String output = outputStream.toString("UTF-8");
        System.out.println(output);
    }

Execution output result:

java version "1.8.0_271"

Java(TM) SE Runtime Environment (build 1.8. 0_271-b09)
Java HotSpot(TM) 64-Bit Server VM (build 25.271-b09, mixed mode)

The above is the detailed content of How to call external programs in Java. For more information, please follow other related articles on the PHP Chinese website!