JavaRuntime.exec教程：手把手教你用它执行外部命令

最近发现不少小伙伴都对文章很感兴趣，所以今天继续给大家介绍文章相关的知识，本文《Java中Runtime.exec怎么用？手把手教你执行外部命令》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

Runtime.exec()方法执行外部命令时需注意阻塞、安全和退出码处理问题。1. 阻塞问题通过异步读取输入流和错误流解决，使用多线程确保缓冲区及时清空；2. 安全风险主要为命令注入，应使用ProcessBuilder类分离命令与参数来防范；3. 退出码通过process.waitFor()获取，用于判断命令执行是否成功；4. 超时控制可通过Future和ExecutorService实现，超时后调用process.destroy()终止进程。

Java中Runtime.exec() 方法本质上是在Java程序里调用操作系统的命令。它有点像在命令行窗口里敲命令，但直接使用时坑不少。用得不好，程序就可能卡住，甚至崩溃。所以，理解它的用法和注意事项至关重要。

解决方案

Runtime.exec() 允许Java程序执行外部命令。基本用法很简单：

Process process = Runtime.getRuntime().exec("ls -l"); // Unix/Linux
// 或者
Process process = Runtime.getRuntime().exec("cmd /c dir"); // Windows

这行代码会启动一个新的进程来执行 "ls -l" (Linux) 或 "cmd /c dir" (Windows) 命令。 Process 对象允许你控制和监视这个新进程。

但是，问题来了。 Runtime.exec() 默认情况下不会为你处理进程的输入、输出和错误流。这意味着：

1. 输入流: 如果你需要向执行的命令传递输入，你需要获取 process.getOutputStream() 并写入数据。
2. 输出流: 命令执行的结果会写入 process.getInputStream()。 如果你不读取这个流，缓冲区可能会填满，导致进程阻塞。
3. 错误流: 命令执行的错误信息会写入 process.getErrorStream()。 同样，不读取这个流也可能导致阻塞。

所以，一个更完整的用法是：

import java.io.*;

public class ExecExample {

    public static void main(String[] args) throws IOException, InterruptedException {
        String command = "ls -l"; // 或者 "cmd /c dir"
        Process process = Runtime.getRuntime().exec(command);

        // 读取输出流
        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }

        // 读取错误流
        BufferedReader errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
        String errorLine;
        while ((errorLine = errorReader.readLine()) != null) {
            System.err.println(errorLine);
        }

        // 等待进程结束
        int exitCode = process.waitFor();
        System.out.println("Exited with code : " + exitCode);
    }
}

这个例子展示了如何读取输出流和错误流，以及如何等待进程结束。 process.waitFor() 非常重要，它能确保你的程序在外部命令执行完毕后继续执行。

如何避免Runtime.exec()的阻塞问题？

阻塞问题是使用 Runtime.exec() 时最常见的陷阱。 根本原因在于，操作系统为子进程的标准输出和标准错误输出分配的缓冲区大小有限。 如果子进程产生的数据量超过了这个缓冲区大小，并且你的 Java 程序没有及时读取这些数据，子进程就会被阻塞，等待缓冲区被清空。

解决这个问题的关键是异步读取子进程的标准输出和标准错误输出。 你可以使用多线程来实现这一点：

import java.io.*;
import java.util.concurrent.*;

public class AsyncExecExample {

    public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
        String command = "ls -l"; // 或者 "cmd /c dir"
        Process process = Runtime.getRuntime().exec(command);

        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 异步读取输出流
        Future outputFuture = executor.submit(() -> {
            StringBuilder output = new StringBuilder();
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    output.append(line).append("\n");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return output.toString();
        });

        // 异步读取错误流
        Future errorFuture = executor.submit(() -> {
            StringBuilder error = new StringBuilder();
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getErrorStream()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    error.append(line).append("\n");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return error.toString();
        });

        int exitCode = process.waitFor();
        System.out.println("Exited with code : " + exitCode);

        // 获取异步读取的结果
        String output = outputFuture.get();
        String error = errorFuture.get();

        System.out.println("Output:\n" + output);
        System.err.println("Error:\n" + error);

        executor.shutdown();
    }
}

在这个例子中，我们使用了 ExecutorService 来创建两个线程，分别负责读取标准输出和标准错误输出。 这样，即使子进程产生大量数据，也不会阻塞主线程。

Runtime.exec()有哪些安全风险，如何防范？

Runtime.exec() 最大的安全风险在于命令注入。 如果你将用户输入直接拼接到要执行的命令中，攻击者就可以通过构造恶意的输入来执行任意命令。

例如，假设你的程序需要执行一个命令来处理用户上传的文件：

String filename = userInput; // 用户输入的文件名
String command = "process_file " + filename;
Runtime.getRuntime().exec(command); // 存在命令注入风险

如果用户输入 "; rm -rf /"，那么实际执行的命令就会变成 "process_file ; rm -rf /"，这将导致你的系统被恶意删除。

为了避免命令注入，绝对不要直接拼接用户输入到命令字符串中。 而是应该使用 ProcessBuilder 类，它可以将命令和参数分开传递：

String filename = userInput;
ProcessBuilder builder = new ProcessBuilder("process_file", filename);
Process process = builder.start(); // 安全

ProcessBuilder 会正确地转义参数，防止命令注入。 它也更灵活，可以设置工作目录、环境变量等。

如何处理Runtime.exec()执行的命令的退出码？

Runtime.exec() 返回的 Process 对象提供了 waitFor() 方法来等待进程结束，并返回进程的退出码。 退出码是操作系统用来表示进程执行结果的整数。 通常，0 表示成功，非 0 值表示失败。

你可以使用 process.exitValue() 方法来获取进程的退出码，但必须在调用 waitFor() 之后才能调用 exitValue()。 如果在进程结束之前调用 exitValue()，会抛出 IllegalThreadStateException 异常。

Process process = Runtime.getRuntime().exec("ls -l");
int exitCode = process.waitFor();
System.out.println("Exit code: " + exitCode);

if (exitCode != 0) {
    System.err.println("Command failed!");
}

通过检查退出码，你可以判断命令是否成功执行，并采取相应的处理措施。 不同的命令和操作系统可能会使用不同的退出码来表示不同的错误类型。

如何设置Runtime.exec()执行命令的超时时间？

有时候，你希望限制 Runtime.exec() 执行的命令的运行时间，以防止命令无限期地运行。 Process 类本身没有提供直接设置超时时间的方法，但你可以使用 Future 和 ExecutorService 来实现：

import java.io.IOException;
import java.util.concurrent.*;

public class TimeoutExecExample {

    public static void main(String[] args) throws IOException, InterruptedException, ExecutionException, TimeoutException {
        String command = "sleep 5"; // 一个会运行5秒的命令
        Process process = Runtime.getRuntime().exec(command);

        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future future = executor.submit(() -> {
            try {
                return process.waitFor();
            } catch (InterruptedException e) {
                return -1; // 或者其他表示中断的值
            }
        });

        try {
            int exitCode = future.get(2, TimeUnit.SECONDS); // 设置超时时间为2秒
            System.out.println("Exit code: " + exitCode);
        } catch (TimeoutException e) {
            System.err.println("Command timed out!");
            process.destroy(); // 强制结束进程
        } finally {
            executor.shutdownNow();
        }
    }
}

在这个例子中，我们使用 ExecutorService 来异步地等待进程结束。 future.get(2, TimeUnit.SECONDS) 会等待最多 2 秒钟。 如果超过 2 秒钟进程还没有结束，就会抛出 TimeoutException 异常。 在 catch 块中，我们调用 process.destroy() 来强制结束进程。 finally 块中调用 executor.shutdownNow() 来停止 ExecutorService。

今天关于《JavaRuntime.exec教程：手把手教你用它执行外部命令》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！