3

我正在尝试使用 Apache Commons exec 解决与命令行进程的交互。我坚持以下代码：

ByteArrayOutputStream out = new ByteArrayOutputStream();
ByteArrayOutputStream ins = new ByteArrayOutputStream();
OutputStreamWriter ow = new OutputStreamWriter(ins);
BufferedWriter writer = new BufferedWriter(ow);
ByteArrayInputStream in = new ByteArrayInputStream(ins.toByteArray());
PumpStreamHandler psh = new PumpStreamHandler(out, null, in);
CommandLine cl = CommandLine.parse(initProcess);
DefaultExecutor exec = new DefaultExecutor();
DefaultExecuteResultHandler resultHandler = new DefaultExecuteResultHandler();
exec.setStreamHandler(psh);
try {
    exec.execute(cl, resultHandler);
    int i = 0;
    while (true) {
        String o = out.toString();
        if (!o.trim().isEmpty()) {
            System.out.println(o);
            out.reset();
        }
        // --- PROBLEM start ---
        if (i == 3) {
            writer.write(internalProcessCommand); 
            // string with or without trailing \n, both tested
            writer.flush();
            writer.close();
            // tested even ins.write(internalProcessCommand.getBytes())
        }
        // --- PROBLEM end ---
        Thread.sleep(3000);
        i++;
    }
} catch (ExecuteException e) {
    System.err.println(e.getMessage());
}

我希望我的代码很清楚。我在清除流时连续阅读out并在 3 秒后打印它。问题是in传递给的输入PumpStreamHandler。我需要从代码本身连续动态地传递进程命令，就好像我正在通过 CLI 与进程交互一样。当我简单地System.in用作PumpStreamHandler参数时，我可以很好地从控制台编写进程命令。我怎样才能设法从代码中传递相同的结果？

编辑： 我也尝试连接PipedInputStream从 接收数据PipedOutputStream，但似乎只有在关闭后才能读取数据，PipedOutputStream这使得它无法重用，因此我无法实现交互性。

编辑2： 解决了自己。下面的答案中的解决方案。豪。:-)

4

3 回答 3

1

一个解决方案是复制PumpStreamHandler 和StreamPump的实现，比如说 ImmediatePumpStreamHandler 和 ImmediateStreamPump，并进行以下两个更改：

  • 在 ImmediateStreamPump 的第 108 行os.flush();之后直接添加。os.write(buf, 0, length);
  • 更改new StreamPumper(...)为new ImmediateStreamPump(...)ImmediatePumpStreamHandler 中的第 269 行。
于 2021-03-25T19:45:36.237 回答
0

好的，我使用内置工具而不是外部库解决了这个问题。多亏了独立的线程，我能够实现我的目标Process' InputStream：

ProcessBuilder builder = new ProcessBuilder(command);
Process process = builder.start();

BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()));
StreamReader outputReader = new StreamReader(process.getInputStream(), System.out);
outputReader.start();
StreamReader err = new StreamReader(process.getErrorStream(), System.err);
err.start();

for (int i = 0; i < 3; i++) {
    Thread.sleep(5000);
    writer.write(internalProcessCommand + "\n");
    writer.flush();
}
writer.write("exit\n");
writer.flush();

while (process.isAlive()) {
    System.out.println("alive?");
    Thread.sleep(100);
}
System.out.println("dead");
outputReader.shutdown();
err.shutdown();

流阅读器：

class StreamReader extends Thread {

    private AtomicBoolean running = new AtomicBoolean(false);
    private InputStream in;
    private OutputStream out;

    public StreamReader(InputStream in, OutputStream out) {
        this.in = in;
        this.out = out;
        running.set(true);
    }

    @Override
    public void run() {
        Scanner scanner = new Scanner(in);
        PrintWriter writer = new PrintWriter(out, true);
        while (running.get()) {
            if (scanner.hasNextLine()) {
                writer.println(scanner.nextLine());
            }
        }
        scanner.close();
    }

    public void shutdown() {
        running.set(false);
    }

}
于 2018-05-18T17:06:13.010 回答
0

根据@champagniac 给出的答案，我创建了一个简单的修复程序，它仅通过替换以下内容来引入额外的冲洗PumpStreamHandler：

public class PumpStreamHandlerFixed extends PumpStreamHandler
{
  public PumpStreamHandlerFixed()
  {
    super();
  }

  public PumpStreamHandlerFixed(OutputStream out, OutputStream err, InputStream input)
  {
    super(out, err, input);
  }

  public PumpStreamHandlerFixed(OutputStream out, OutputStream err)
  {
    super(out, err);
  }

  public PumpStreamHandlerFixed(OutputStream outAndErr)
  {
    super(outAndErr);
  }

  @Override
  protected Thread createPump(InputStream is, OutputStream os, boolean closeWhenExhausted)
  {
    os = new AutoFlushingOutputStream(os);

    final Thread result = new Thread(new StreamPumper(is, os, closeWhenExhausted), "Exec Stream Pumper");
    result.setDaemon(true);
    return result;
  }
}

class AutoFlushingOutputStream extends OutputStream
{
  private final OutputStream decorated;

  public AutoFlushingOutputStream(OutputStream decorated)
  {
    this.decorated = decorated;
  }

  @Override
  public void write(byte[] b, int off, int len) throws IOException
  {
    this.decorated.write(b, off, len);
    this.decorated.flush();
  }

  @Override
  public void write(int b) throws IOException
  {
    this.decorated.write(b);
    this.decorated.flush();
  }

  @Override
  public void close() throws IOException
  {
    this.decorated.close();
  }

  @Override
  public void flush() throws IOException
  {
    this.decorated.flush();
  }
}
于 2021-06-29T09:37:25.017 回答