So rufen Sie einen Linux-Shell-Befehl von Java aus auf

Ich versuche, einige Linux-Befehle von Java aus mit Umleitung (> &) und Pipes (|) auszuführen. Wie kann Java aufrufen cshoder bashBefehle?

Ich habe versucht, dies zu verwenden:

Process p = Runtime.getRuntime().exec("shell command");

Es ist jedoch nicht mit Umleitungen oder Pipes kompatibel.

exec führt keinen Befehl in Ihrer Shell aus

Versuchen

Process p = Runtime.getRuntime().exec(new String[]{"csh","-c","cat /home/narek/pk.txt"});

stattdessen.

EDIT :: Ich habe kein csh auf meinem System, also habe ich stattdessen bash verwendet. Folgendes hat bei mir funktioniert

Process p = Runtime.getRuntime().exec(new String[]{"bash","-c","ls /home/XXX"});

Verwenden Sie ProcessBuilder, um Befehle und Argumente anstelle von Leerzeichen zu trennen. Dies sollte unabhängig von der verwendeten Shell funktionieren:

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public class Test {

    public static void main(final String[] args) throws IOException, InterruptedException {
        //Build command 
        List<String> commands = new ArrayList<String>();
        commands.add("/bin/cat");
        //Add arguments
        commands.add("/home/narek/pk.txt");
        System.out.println(commands);

        //Run macro on target
        ProcessBuilder pb = new ProcessBuilder(commands);
        pb.directory(new File("/home/narek"));
        pb.redirectErrorStream(true);
        Process process = pb.start();

        //Read output
        StringBuilder out = new StringBuilder();
        BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String line = null, previous = null;
        while ((line = br.readLine()) != null)
            if (!line.equals(previous)) {
                previous = line;
                out.append(line).append('\n');
                System.out.println(line);
            }

        //Check result
        if (process.waitFor() == 0) {
            System.out.println("Success!");
            System.exit(0);
        }

        //Abnormal termination: Log command parameters and output and throw ExecutionException
        System.err.println(commands);
        System.err.println(out.toString());
        System.exit(1);
    }
}

Aufbauend auf dem Beispiel von @ Tim, um eine eigenständige Methode zu erstellen:

import java.io.BufferedReader;
import java.io.File;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class Shell {

    /** Returns null if it failed for some reason.
     */
    public static ArrayList<String> command(final String cmdline,
    final String directory) {
        try {
            Process process = 
                new ProcessBuilder(new String[] {"bash", "-c", cmdline})
                    .redirectErrorStream(true)
                    .directory(new File(directory))
                    .start();

            ArrayList<String> output = new ArrayList<String>();
            BufferedReader br = new BufferedReader(
                new InputStreamReader(process.getInputStream()));
            String line = null;
            while ( (line = br.readLine()) != null )
                output.add(line);

            //There should really be a timeout here.
            if (0 != process.waitFor())
                return null;

            return output;

        } catch (Exception e) {
            //Warning: doing this is no good in high quality applications.
            //Instead, present appropriate error messages to the user.
            //But it's perfectly fine for prototyping.

            return null;
        }
    }

    public static void main(String[] args) {
        test("which bash");

        test("find . -type f -printf '%T@\\\\t%p\\\\n' "
            + "| sort -n | cut -f 2- | "
            + "sed -e 's/ /\\\\\\\\ /g' | xargs ls -halt");

    }

    static void test(String cmdline) {
        ArrayList<String> output = command(cmdline, ".");
        if (null == output)
            System.out.println("\n\n\t\tCOMMAND FAILED: " + cmdline);
        else
            for (String line : output)
                System.out.println(line);

    }
}

(Das Testbeispiel ist ein Befehl, der alle Dateien in einem Verzeichnis und seinen Unterverzeichnissen rekursiv in chronologischer Reihenfolge auflistet .)

Übrigens, wenn mir jemand sagen kann, warum ich dort vier und acht Backslashes anstelle von zwei und vier brauche, kann ich etwas lernen. Es gibt eine Ebene mehr Unausweichlichkeit als das, was ich zähle.

Bearbeiten: Habe gerade denselben Code unter Linux ausprobiert und dort stellt sich heraus, dass ich halb so viele Backslashes im Testbefehl benötige! (Das heißt: die erwartete Anzahl von zwei und vier.) Jetzt ist es nicht mehr nur seltsam, es ist ein Portabilitätsproblem.