杰瑞科技汇

Java如何调用并执行Shell脚本？

作者：99ANYc3cd6栏目：JAVA2026-04-04 04:552

下面我将为你详细介绍几种主流的方法，从简单到复杂,并分析它们的优缺点和适用场景。

核心思想

无论使用哪种方法，Java 调用 Shell 脚本的本质都是：

  1. 启动一个新的进程：Java 程序会通过操作系统的接口（如 Runtime.exec() 或 ProcessBuilder）启动一个新的进程来执行 Shell 解释器（如 /bin/sh 或 /bin/bash）。
  2. 传递命令：将你的 Shell 脚本路径或脚本中的命令作为参数传递给这个新的进程。
  3. 处理交互：Java 程序需要与这个新进程进行交互，包括：
    • 获取标准输出：脚本执行后打印的正常信息。
    • 获取标准错误：脚本执行时产生的错误信息。
    • 提供标准输入：如果脚本需要从键盘或文件读取数据。
    • 等待进程结束：并获取其退出状态码（exit code）,用于判断脚本是否成功执行。

使用 Runtime.exec() (不推荐，但最基础)

这是最原始、最直接的方法。强烈建议不要在生产环境中直接使用它，因为它存在很多陷阱,尤其是在处理输出流时。

示例代码

假设你有一个简单的 Shell 脚本 test.sh：

#!/bin/bash
echo "Hello from Shell script!"
echo "The current directory is:"
pwd
echo "Arguments received: $1, $2"
# 模拟一个错误
if [ "$1" = "error" ]; then
  echo "This is an error message" >&2
  exit 1
fi
echo "Script finished successfully."
exit 0

Java 代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class RuntimeExecExample {
    public static void main(String[] args) {
        // 脚本路径
        String scriptPath = "/path/to/your/test.sh"; // !!! 请务必替换为你的实际路径
        // 构建命令，传入参数
        String[] command = {
            "/bin/bash", // 使用 bash 解释器
            scriptPath,
            "param1",
            "error"     // 传入一个会导致错误的参数
        };
        try {
            // 1. 启动进程
            Process process = Runtime.getRuntime().exec(command);
            // 2. 获取输入流，读取标准输出
            // 必须在读取错误流之前或同时读取输出流，否则可能导致进程阻塞
            BufferedReader stdInput = new BufferedReader(new InputStreamReader(process.getInputStream()));
            BufferedReader stdError = new BufferedReader(new InputStreamReader(process.getErrorStream()));
            // 3. 读取输出
            System.out.println("--- Standard Output ---");
            String s;
            while ((s = stdInput.readLine()) != null) {
                System.out.println(s);
            }
            System.out.println("\n--- Standard Error ---");
            while ((s = stdError.readLine()) != null) {
                System.out.println(s);
            }
            // 4. 等待进程执行完成
            int exitCode = process.waitFor();
            System.out.println("\n--- Script Exited With Code: " + exitCode + " ---");
            if (exitCode == 0) {
                System.out.println("Script executed successfully.");
            } else {
                System.err.println("Script execution failed.");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt(); // 恢复中断状态
        }
    }
}

Runtime.exec() 的陷阱

  1. 死锁风险：如果子进程（你的 Shell 脚本）产生了大量的输出，而 Java 程序没有及时读取这些输出（InputStream），那么输出缓冲区会被填满，子进程会等待 Java 读取，而 Java 又在等待子进程结束，从而导致双方互相等待，形成死锁，上面的代码通过同时读取 InputStream 和 ErrorStream 来避免这个问题,但这增加了复杂性。
  2. 命令参数处理复杂：如果命令或路径中包含空格，直接拼接字符串会出错，你需要像上面例子一样,将命令和参数拆分成一个字符串数组。
  3. 功能有限：难以处理复杂的输入/输出重定向、管道等高级 Shell 特性。

使用 ProcessBuilder (推荐)

ProcessBuilder 是 Java 5 引入的，是 Runtime.exec() 的替代品，它提供了更强大、更灵活的控制，并且解决了 Runtime.exec() 的大部分问题。

示例代码

上面的 Java 代码用 ProcessBuilder 重写如下：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class ProcessBuilderExample {
    public static void main(String[] args) {
        String scriptPath = "/path/to/your/test.sh"; // !!! 请务必替换为你的实际路径
        // 1. 创建 ProcessBuilder 实例
        // 将命令和参数作为列表传入，它会自动处理空格等问题
        ProcessBuilder pb = new ProcessBuilder("/bin/bash", scriptPath, "param1", "error");
        // (可选) 设置工作目录
        // pb.directory(new File("/path/to/working/directory"));
        // 2. 合并错误流到输出流
        // 这是一个好习惯，可以简化读取逻辑，避免死锁
        // 所有的错误信息会和标准输出一起被读取
        pb.redirectErrorStream(true);
        try {
            // 3. 启动进程
            Process process = pb.start();
            // 4. 读取输出（因为错误流已合并，只需读取一个流）
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            System.out.println("--- Script Output ---");
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            // 5. 等待进程结束
            int exitCode = process.waitFor();
            System.out.println("\n--- Script Exited With Code: " + exitCode + " ---");
            if (exitCode == 0) {
                System.out.println("Script executed successfully.");
            } else {
                System.err.println("Script execution failed.");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }
    }
}

ProcessBuilder 的优点

  1. 避免死锁：通过 pb.redirectErrorStream(true); 可以将标准错误流合并到标准输出流，这样你只需要读取一个 InputStream,大大简化了代码并避免了死锁风险。
  2. 更清晰的 API：命令以列表形式提供，更直观,也更安全。
  3. 强大的控制能力：
    • directory(File)：可以轻松设置进程的工作目录。
    • redirectInput/Output/Error：可以轻松地将进程的输入/输出重定向到文件或另一个进程（实现管道）。
  4. 环境变量管理：可以通过 environment() 方法修改或添加进程的环境变量。

除非有特殊原因，否则 ProcessBuilder 是调用 Shell 脚本的首选方法。

使用第三方库 (更高级的封装)

如果你需要更高级的功能，比如异步执行、更友好的 API、超时控制等，可以考虑使用第三方库，这些库通常是对 ProcessBuilder 的进一步封装。

Apache Commons Exec

这是一个非常流行和功能强大的库，专门用于在 Java 中执行外部进程。

Maven 依赖:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-exec</artifactId>
    <version>1.3</version> <!-- 使用最新版本 -->
</dependency>

示例代码：

import org.apache.commons.exec.CommandLine;
import org.apache.commons.exec.DefaultExecutor;
import org.apache.commons.exec.PumpStreamHandler;
import org.apache.commons.exec.Executor;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class CommonsExecExample {
    public static void main(String[] args) {
        String scriptPath = "/path/to/your/test.sh";
        // 1. 创建命令行对象
        CommandLine cmdLine = new CommandLine("/bin/bash");
        cmdLine.addArgument(scriptPath);
        cmdLine.addArgument("param1");
        cmdLine.addArgument("success");
        // 2. 创建执行器
        DefaultExecutor executor = new DefaultExecutor();
        // (可选) 设置超时时间 (毫秒)
        executor.setWorkingDirectory(new java.io.File("/path/to/your")); // 设置工作目录
        executor.setExitValue(0); // 只有退出码为0时才认为成功，否则会抛出ExecuteException
        // 3. 创建流处理器来捕获输出
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        ByteArrayOutputStream errorStream = new ByteArrayOutputStream();
        PumpStreamHandler streamHandler = new PumpStreamHandler(outputStream, errorStream);
        executor.setStreamHandler(streamHandler);
        try {
            System.out.println("--- Executing script with Apache Commons Exec ---");
            // 4. 执行命令
            int exitCode = executor.execute(cmdLine);
            System.out.println("--- Standard Output ---");
            System.out.println(outputStream.toString());
            System.out.println("--- Standard Error ---");
            System.out.println(errorStream.toString());
            System.out.println("\n--- Script Exited With Code: " + exitCode + " ---");
        } catch (IOException e) {
            System.err.println("Execution failed.");
            e.printStackTrace();
        }
    }
}

Picocli

如果你的 Shell 脚本本质上是命令行工具，并且你希望用 Java 来实现类似的功能，Picocli 是一个非常好的选择,它让你可以用注解轻松地构建功能强大的命令行界面。

最佳实践与注意事项

  1. 路径问题：

    • 绝对路径：始终使用脚本的绝对路径,避免因工作目录不同导致脚本找不到。
    • 可执行权限：确保你的 Shell 脚本有可执行权限 (chmod +x script.sh)。
    • 跨平台：Windows 和 Linux/macOS 的 Shell 解释器不同（cmd.exe vs /bin/bash），如果你的应用需要跨平台,需要根据操作系统选择不同的命令。

  2. 安全性：

    • 不要拼接用户输入：绝对不要将用户提供的字符串直接拼接到命令中，这会命令注入漏洞。Runtime.getRuntime().exec("ls " + userPath) 是危险的，应该使用 ProcessBuilder 的列表形式，它会将参数作为独立的单元处理,从而防止注入。

  3. 性能：

    • 每次调用 exec() 或 ProcessBuilder 都会创建一个新的操作系统进程，这是一个相对昂贵的操作,避免在循环中频繁调用。

  4. 资源释放：

    • 虽然 Java 的垃圾回收最终会回收 Process 对象，但它关联的输入/输出流不会被自动关闭，最佳实践是使用 try-with-resources 来确保 Process 的 InputStream 和 OutputStream 被正确关闭。

    try-with-resources 示例：

    Process process = null;
try {
    ProcessBuilder pb = new ProcessBuilder("ls", "-l");
    process = pb.start();
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
    }
    // 等待进程结束
    int exitCode = process.waitFor();
    System.out.println("Exit code: " + exitCode);
} catch (IOException | InterruptedException e) {
    // 处理异常
} finally {
    if (process != null) {
        process.destroy(); // 强制销毁进程
    }
}
方法 优点 缺点 适用场景
Runtime.exec() 简单直接，无需引入新类 死锁风险高，API 设计有缺陷，功能弱 不推荐使用，仅用于学习或极简单场景。
ProcessBuilder 强烈推荐，功能强大，API清晰，可避免死锁，控制力强 需要手动处理流和等待 绝大多数 Java 调用 Shell 脚本的标准选择。
第三方库 (如 Commons Exec) API 更友好，支持超时、异步等高级功能 增加项目依赖 需要复杂进程管理、超时控制或更健壮的错误处理时。

对于绝大多数开发者来说，掌握并使用 ProcessBuilder 就足以应对所有在 Java 中调用 Shell 脚本的需求了。

99ANYc3cd6 99ANYc3cd6 管理员
分享：
扫描分享到社交APP
上一篇
下一篇

相关推荐

  • Java如何执行shell脚本？

    Java如何执行shell脚本？

    在Java中执行Shell脚本在Java中执行Shell脚本有几种常见方法,下面我将介绍几种主要的方式：使用Runtime.exec()这是最直接的方法,但需要注意处理输入流和错误流：importjava.io.BufferedReade...

    99ANYc3cd6 99ANYc3cd6
    2026-03-30
    8 0 0
99ANYc3cd6

99ANYc3cd6

  • 14660文章
  • 0评论
  • 0粉丝
  • 0被赞
最近发布
热门排行
猜您喜欢
热门标签
Copyright © 2022-2025 杰瑞科技汇 版权所有 沪ICP备2024102905号

侵权处理与合作：473708564#qq.com，#换成@就是邮箱

Powered By Z-BlogPHP · Theme By themeolnews