Estou no meu juízo final aqui. Tenho certeza de que isso é algo simples e provavelmente tenho enormes falhas no meu entendimento de java e córregos. Eu acho que existem tantas classes que estou um pouco sobrecarregado com a tentativa de vasculhar a API para descobrir quando e como eu quero usar a multiplicidade de fluxos de entrada / saíd

Acabei de aprender sobre a existência da biblioteca apache commons (falha de auto-aprendizado de java) e, atualmente, estou tentando converter parte do meu Runtime.getRuntime (). Exec para usar o commons-exec. Já que foi corrigido uma vez a cada 6 meses, esse problema surge e desaparece problemas de estilo com o exec.

O código executa um script perl e exibe o stdout do script na GUI enquanto está em execuçã

O código de chamada está dentro de um baloiç

Estou me perdendo como usar o pumpStreamHandler ... enfim, aqui está o código antigo:

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();
}

Acho que é isso que recebo pelo código de colar e copiar que não entendo completamente há muito tempo. O que eu presumo acima está executando o processo e, em seguida, agarra o fluxo de saída (via "getInputStream"?), Coloca-o em um leitor em buffer e depois faz um loop até o buffer ficar vazio.

O que eu não entendo é por que não há necessidade de um comando no estilo 'waitfor' aqui? Não é possível que haja algum tempo em que o buffer fique vazio, saia do loop e continue enquanto o processo ainda está em andamento? Quando o executo, isso não parece ser o cas

De qualquer forma, estou tentando obter o mesmo comportamento usando o commons exec, basicamente novamente no código encontrado pelo google:

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();

Estou tentando descobrir o que o pumpstreamhandler está fazendo. Suponho que isso pegue a saída do objeto exec e preencha o OutputStream que forneço com os bytes do stdout / err do script perl?

Se sim, como você obteria o comportamento acima para que ele transmitisse a linha de saída por linha? Em exemplos, as pessoas mostram que você chama out.toString () no final, e presumo que isso me daria um despejo de toda a saída do script, uma vez que a execução é executada? Como você faria isso para mostrar a saída enquanto está sendo executada linha por linha?

------------ Edição Futura ---------------------

Encontre isso via google e funciona bem também:

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());
}