29

我在这里束手无策。我确信这很简单，而且我对 Java 和流的理解很可能存在巨大的漏洞。我认为有这么多的类，我有点不知所措，试图通过 API 找出我想何时以及如何使用大量输入/输出流。

我刚刚了解了 apache commons 库的存在（自学 java 失败），目前正在尝试将我的一些 Runtime.getRuntime().exec 转换为使用 commons - exec。已经修复了一些每 6 个月出现一次的问题，然后解决 exec 的风格问题。

该代码执行 perl 脚本，并在脚本运行时在 GUI 中显示脚本的标准输出。

调用代码在 swingworker 内部。

我迷失了如何使用pumpStreamHandler ...无论如何这是旧代码：

String pl_cmd = "perl script.pl"
Process p_pl = Runtime.getRuntime().exec( pl_cmd );

BufferedReader br_pl = new BufferedReader( new InputStreamReader( p_pl.getInputStream() ) );

stdout = br_pl.readLine();
while ( stdout != null )
{
    output.displayln( stdout );
    stdout = br_pl.readLine();
}

我想这就是我很久以前不完全理解的复制粘贴代码所得到的。上面我假设正在执行该过程，然后获取输出流（通过“getInputStream”？），将其放入缓冲读取器中，然后将在那里循环直到缓冲区为空。

我不明白为什么这里不需要“等待”风格的命令？是否有可能在一段时间内缓冲区为空，退出循环并在进程仍在进行时继续？当我运行它时，情况似乎并非如此。

无论如何，我正在尝试使用 commons exec 获得相同的行为，基本上再次来自谷歌找到的代码：

DefaultExecuteResultHandler rh = new DefaultExecuteResultHandler();
ExecuteWatchdog wd  = new ExecuteWatchdog( ExecuteWatchdog.INFINITE_TIMEOUT );
Executor exec = new DefaultExecutor();

ByteArrayOutputStream out = new ByteArrayOutputStream();
PumpStreamHandler psh = new PumpStreamHandler( out );

exec.setStreamHandler( psh );
exec.setWatchdog( wd );

exec.execute(cmd, rh );
rh.waitFor();

我试图弄清楚 pumpstreamhandler 在做什么。我假设这将从 exec 对象获取输出，并用 perl 脚本的 stdout/err 中的字节填充我提供的 OutputStream？

如果是这样，您将如何获得上述行为以使其逐行流式传输输出？在示例中，人们向您展示了最后调用 out.toString() ，我认为这只会在脚本运行完成后给我一个脚本的所有输出的转储？您将如何做到这一点，以便在逐行运行时显示输出？

------------未来编辑 ---------

通过谷歌找到这个并且效果很好：

public static void main(String a[]) throws Exception
{
    ByteArrayOutputStream stdout = new ByteArrayOutputStream();
    PumpStreamHandler psh = new PumpStreamHandler(stdout);
    CommandLine cl = CommandLine.parse("ls -al");
    DefaultExecutor exec = new DefaultExecutor();
    exec.setStreamHandler(psh);
    exec.execute(cl);
    System.out.println(stdout.toString());
}
4

4 回答 4

31

不要将 a 传递ByteArrayOutputStream给PumpStreamHandler，使用抽象类的实现org.apache.commons.exec.LogOutputStream。从javadoc：

该实现解析传入的数据以构造一行并将完整的行传递给用户定义的实现。

因此，LogOutputSram 正在对输出进行预处理，以使您能够控制处理单个行而不是原始字节。像这样的东西：

import java.util.LinkedList;
import java.util.List;
import org.apache.commons.exec.LogOutputStream;

public class CollectingLogOutputStream extends LogOutputStream {
    private final List<String> lines = new LinkedList<String>();
    @Override protected void processLine(String line, int level) {
        lines.add(line);
    }   
    public List<String> getLines() {
        return lines;
    }
}

然后在对您的阻塞调用之后，exec.execute您getLines()将获得您正在寻找的标准输出和标准错误。ExecutionResultHandler从仅执行进程的角度来看，这是可选的，并将所有 stdOut/stdErr 收集到行列表中。

于 2012-09-06T13:30:34.317 回答
3

我不明白为什么这里不需要“等待”风格的命令？是否有可能在一段时间内缓冲区为空，退出循环并在进程仍在进行时继续？当我运行它时，情况似乎并非如此。

readLine 块。也就是说，您的代码将等到一行被读取。

PumpStreamHandler

来自文档

将子进程的标准输出和错误复制到父进程的标准输出和错误。如果将输出或错误流设置为 null，则来自该流的任何反馈都将丢失。

于 2011-09-07T21:09:51.213 回答
3

根据 James A Wilson 的回答，我创建了辅助类“Execute”。它将他的答案包装到一个解决方案中，该解决方案还为方便起见提供了 exitValue。

以这种方式执行命令需要一行：

ExecResult result=Execute.execCmd(cmd,expectedExitCode);

以下 Junit Testcase 测试并展示了如何使用它：

Junit4测试用例：

package com.bitplan.newsletter;

import static org.junit.Assert.*;

import java.util.List;

import org.junit.Test;

import com.bitplan.cmd.Execute;
import com.bitplan.cmd.Execute.ExecResult;

/**
 * test case for the execute class
 * @author wf
 *
 */
public class TestExecute {
     @Test
   public void testExecute() throws Exception {
     String cmd="/bin/ls";
     ExecResult result = Execute.execCmd(cmd,0);
     assertEquals(0,result.getExitCode());
     List<String> lines = result.getLines();
     assertTrue(lines.size()>0);
     for (String line:lines) {
         System.out.println(line);
     }
   }
}

执行 Java 助手类：

package com.bitplan.cmd;

import java.util.LinkedList;
import java.util.List;
import java.util.logging.Level;

import org.apache.commons.exec.CommandLine;
import org.apache.commons.exec.DefaultExecutor;
import org.apache.commons.exec.LogOutputStream;
import org.apache.commons.exec.PumpStreamHandler;

/**
 * Execute helper using apache commons exed
 *
 *  add this dependency to your pom.xml:
   <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-exec</artifactId>
            <version>1.2</version>
        </dependency>

 * @author wf
 *
 */
public class Execute {

    protected static java.util.logging.Logger LOGGER = java.util.logging.Logger
            .getLogger("com.bitplan.cmd");

    protected final static boolean debug=true;

    /**
     * LogOutputStream
     * http://stackoverflow.com/questions/7340452/process-output-from
     * -apache-commons-exec
     * 
     * @author wf
     * 
     */
    public static class ExecResult extends LogOutputStream {
        private int exitCode;
        /**
         * @return the exitCode
         */
        public int getExitCode() {
            return exitCode;
        }

        /**
         * @param exitCode the exitCode to set
         */
        public void setExitCode(int exitCode) {
            this.exitCode = exitCode;
        }

        private final List<String> lines = new LinkedList<String>();

        @Override
        protected void processLine(String line, int level) {
            lines.add(line);
        }

        public List<String> getLines() {
            return lines;
        }
    }

    /**
     * execute the given command
     * @param cmd - the command 
     * @param exitValue - the expected exit Value
     * @return the output as lines and exit Code
     * @throws Exception
     */
    public static ExecResult execCmd(String cmd, int exitValue) throws Exception {
        if (debug)
            LOGGER.log(Level.INFO,"running "+cmd);
        CommandLine commandLine = CommandLine.parse(cmd);
        DefaultExecutor executor = new DefaultExecutor();
        executor.setExitValue(exitValue);
        ExecResult result =new ExecResult();
        executor.setStreamHandler(new PumpStreamHandler(result));
        result.setExitCode(executor.execute(commandLine));
        return result;
    }

}
于 2014-07-31T10:22:24.570 回答
0

它是一个非常古老的线程，但我不得不使用 Apache Commons Exec 并且必须解决同样的问题。我相信 2014 年发布的最新版本的 Apache Commons Exec，下面的解决方案在有和没有看门狗的情况下都能很好地工作；

class CollectingLogOutputStream implements ExecuteStreamHandler {
private final List<String> lines = new LinkedList<String>();
public void setProcessInputStream(OutputStream outputStream) throws IOException 
{
}
//important - read all output line by line to track errors
public void setProcessErrorStream(InputStream inputStream) throws IOException {
    InputStreamReader isr = new InputStreamReader(inputStream);
    BufferedReader br = new BufferedReader(isr);
    String line="";
    while( (line = br.readLine()) != null){
        //use lines whereever you want - for now just print on console
        System.out.println("error:"+line);
    }
}
//important - read all output line by line to track process output
public void setProcessOutputStream(InputStream inputStream) throws IOException 
{
    InputStreamReader isr = new InputStreamReader(inputStream);
    BufferedReader br = new BufferedReader(isr);
    String line="";
    while( (line = br.readLine()) != null){
        //use lines whereever you want - for now just print on console
        System.out.println("output:"+line);
    }
  }

public void start() throws IOException {
}

public void stop() throws IOException {
}
}

上面的类可以设置为执行器的StreamHandler，如下所示；

//set newly created class stream handler for the executor
executor.setStreamHandler(new CollectingLogOutputStream());

完整代码可在此处获得； https://github.com/raohammad/externalprocessfromjava

于 2019-05-16T09:56:04.697 回答