Come far funzionare le pipe con Runtime.exec ()?

Considera il codice seguente:

String commandf = "ls /etc | grep release";

try {

    // Execute the command and wait for it to complete
    Process child = Runtime.getRuntime().exec(commandf);
    child.waitFor();

    // Print the first 16 bytes of its output
    InputStream i = child.getInputStream();
    byte[] b = new byte[16];
    i.read(b, 0, b.length); 
    System.out.println(new String(b));

} catch (IOException e) {
    e.printStackTrace();
    System.exit(-1);
}

L'output del programma è:

/etc:
adduser.co

Quando corro dalla shell, ovviamente, funziona come previsto:

poundifdef@parker:~/rabbit_test$ ls /etc | grep release
lsb-release

Internet mi dice che, poiché il comportamento delle pipe non è multipiattaforma, le menti brillanti che lavorano nella fabbrica Java che produce Java non possono garantire che le pipe funzionino.

Come posso fare questo?

Non ho intenzione di eseguire tutta la mia analisi utilizzando costrutti Java anziché grep esed , poiché se voglio cambiare la lingua, sarò costretto a riscrivere il mio codice di analisi in quella lingua, il che è totalmente vietato.

Come posso fare in modo che Java esegua piping e reindirizzamento quando si richiamano i comandi della shell?

Scrivi uno script ed esegui lo script invece di comandi separati.

Pipe è una parte della shell, quindi puoi anche fare qualcosa del genere:

String[] cmd = {
"/bin/sh",
"-c",
"ls /etc | grep release"
};

Process p = Runtime.getRuntime().exec(cmd);

Mi sono imbattuto in un problema simile in Linux, tranne che era "ps -ef | grep someprocess".
Almeno con "ls" hai una sostituzione Java indipendente dalla lingua (anche se più lenta). Per esempio.:

File f = new File("C:\\");
String[] files = f.listFiles(new File("/home/tihamer"));
for (String file : files) {
    if (file.matches(.*some.*)) { System.out.println(file); }
}

Con "ps", è un po 'più difficile, perché Java non sembra avere un'API per questo.

Ho sentito che Sigar potrebbe essere in grado di aiutarci: https://support.hyperic.com/display/SIGAR/Home

La soluzione più semplice, tuttavia, (come sottolineato da Kaj) è eseguire il comando piped come un array di stringhe. Ecco il codice completo:

try {
    String line;
    String[] cmd = { "/bin/sh", "-c", "ps -ef | grep export" };
    Process p = Runtime.getRuntime().exec(cmd);
    BufferedReader in =
            new BufferedReader(new InputStreamReader(p.getInputStream()));
    while ((line = in.readLine()) != null) {
        System.out.println(line); 
    }
    in.close();
} catch (Exception ex) {
    ex.printStackTrace();
}

Quanto al motivo per cui l'array String funziona con pipe, mentre una singola stringa no ... è uno dei misteri dell'universo (specialmente se non hai letto il codice sorgente). Sospetto che sia perché quando a exec viene data una singola stringa, la analizza per prima (in un modo che non ci piace). Al contrario, quando a exec viene fornito un array di stringhe, lo passa semplicemente al sistema operativo senza analizzarlo.

In realtà, se prendiamo del tempo da una giornata impegnativa e guardiamo il codice sorgente (su http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/lang/ Runtime.java # Runtime.exec% 28java.lang.String% 2Cjava.lang.String []% 2Cjava.io.File% 29 ), troviamo che è esattamente ciò che sta accadendo:

public Process  [More ...] exec(String command, String[] envp, File dir) 
          throws IOException {
    if (command.length() == 0)
        throw new IllegalArgumentException("Empty command");
    StringTokenizer st = new StringTokenizer(command);
    String[] cmdarray = new String[st.countTokens()];
    for (int i = 0; st.hasMoreTokens(); i++)
        cmdarray[i] = st.nextToken();
    return exec(cmdarray, envp, dir);
}

Crea un runtime per eseguire ogni processo. Ottieni OutputStream dal primo Runtime e copialo in InputStream dal secondo.

La risposta accettata da @Kaj è per Linux. Questo è l'equivalente per Windows:

String[] cmd = {
"cmd",
"/C",
"dir /B | findstr /R /C:"release""
};
Process p = Runtime.getRuntime().exec(cmd);