Java

Question

我正在尝试将一个进程的输出重定向到另一个进程的输入。即，管道。在 Windows DOS shell 中执行此操作时，它看起来像

C:\> dir /s/b . | findstr dat$

但是我正在尝试在 Java 中执行这样的命令，到目前为止它看起来像：

    Stopwatch sw = Stopwatch.createStarted();
    ProcessBuilder source = new ProcessBuilder("cmd", "/S/D/c", "dir", "/s/b", ".");
    ProcessBuilder target = new ProcessBuilder("cmd", "/S/D/c", "findstr", "dat$");
    source.directory(new File("C:/"));
    target.directory(source.directory());
    // I am messing with the below lines, nothing is working
    source.redirectInput(target.redirectInput());
    source.redirectOutput(ProcessBuilder.Redirect.PIPE);
    source.redirectOutput(target.redirectInput());
    source.redirectInput(target.redirectOutput());
    target.redirectOutput(source.redirectInput());

    Process pSource = source.start();
    Process pTarget = target.start();
    log.debug("Running {} | {}", source.command(), target.command());
    try (BufferedReader br = new BufferedReader(new InputStreamReader(pTarget.getInputStream()))) {

        String line;
        while ((line = br.readLine()) != null)
            log.debug("{}", line);
    } finally {
        log.debug("Ending process {} with exist code {} in time {}", target.command(),
                pTarget.destroyForcibly().exitValue(), sw);
    }

但我发现 readLine 上的代码停顿了，所以这里有些东西不起作用。如何正确使用 IO 重定向？

Answer 1

redirectInput() resp接受或返回的对象，redirectOutput()描述了某个策略；它们不代表实际频道。
因此，通过语句 source.redirectInput(target.redirectInput())，您只是指定两个进程应具有相同的策略，而不是链接通道。

事实上，在 Java8 中，直接链接两个进程的通道是不可能的。要达到类似的效果，最好的方法是启动一个后台线程，该线程将读取第一个进程的输出并将其写入第二个进程的输入：

static List<Process> doPipeJava8() throws IOException {
    Process pSource = new ProcessBuilder("cmd", "/S/D/c", "dir", "/s/b", ".")
                    .redirectInput(ProcessBuilder.Redirect.INHERIT)
                    .redirectError(ProcessBuilder.Redirect.INHERIT)
                    .start();
    Process pTarget;
    try {
        pTarget     = new ProcessBuilder("cmd", "/S/D/c", "findstr", "dat$")
                    .redirectErrorStream(true)
                    .redirectOutput(ProcessBuilder.Redirect.INHERIT)
                    .start();
    } catch(Throwable t) {
        pSource.destroyForcibly();
        throw t;
    }
    new Thread(() -> {
        try(InputStream srcOut = pSource.getInputStream();
            OutputStream dstIn = pTarget.getOutputStream()) {
            byte[] buffer = new byte[1024];
            while(pSource.isAlive() && pTarget.isAlive()) {
                int r = srcOut.read(buffer);
                if(r > 0) dstIn.write(buffer, 0, r);
            }
        } catch(IOException ex) {}
    }).start();
    return Arrays.asList(pSource, pTarget);
}

这会将错误通道、第一个进程的输入通道和最后一个进程的输出通道配置为 INHERIT，因此它们将使用我们的启动进程的控制台。第一个进程的输出和第二个进程的输入保持默认PIPE，这意味着建立一个管道到我们的启动进程，所以我们有责任从一个管道到另一个。

方法可以作为

List<Process> sub = doPipeJava8();
Process pSource = sub.get(0), pTarget = sub.get(1);
pSource.waitFor();
pTarget.waitFor();

如果我们从 pTarget 进程的构建器中删除 .redirectOutput(ProcessBuilder.Redirect.INHERIT)，我们可以读取最终输出：

List<Process> sub = doPipeJava8();
Process pSource = sub.get(0), pTarget = sub.get(1);
List<String> result = new BufferedReader(new InputStreamReader(pTarget.getInputStream()))
    .lines().collect(Collectors.toList());

Java 9 是第一个支持在 sub-processes 之间建立管道的 Java 版本。它简化了

的解决方案

static List<Process> doPipeJava9() throws IOException {
    return ProcessBuilder.startPipeline(
        List.of(new ProcessBuilder("cmd", "/S/D/c", "dir", "/s/b", ".")
                    .redirectInput(ProcessBuilder.Redirect.INHERIT)
                    .redirectError(ProcessBuilder.Redirect.INHERIT),
                new ProcessBuilder("cmd", "/S/D/c", "findstr", "dat$")
                    .redirectErrorStream(true)
                    .redirectOutput(ProcessBuilder.Redirect.INHERIT)) );
}

它与其他解决方案的作用相同¹；上面的示例配置为让第一个进程从控制台读取（如果需要），最后一个进程写入控制台。同样，如果我们从最后一个进程构建器中省略 .redirectOutput(ProcessBuilder.Redirect.INHERIT)，我们可以读取最后一个进程的输出。

¹ 除了它会在可能的情况下使用系统的本机管道功能

Java - 重定向进程 I/O（管道）正在停滞

Java - Redirecting Process I/O (piping) Is Stalling

pipe

process

piping

java-8