Java Runtime.getRuntime (): Abrufen der Ausgabe beim Ausführen eines Befehlszeilenprogramms

Ich verwende die Laufzeit, um Eingabeaufforderungsbefehle von meinem Java-Programm auszuführen. Mir ist jedoch nicht bekannt, wie ich die vom Befehl zurückgegebene Ausgabe erhalten kann.

Hier ist mein Code:

Runtime rt = Runtime.getRuntime();

String[] commands = {"system.exe", "-send" , argument};

Process proc = rt.exec(commands);

Ich habe es versucht, System.out.println(proc);aber das brachte nichts zurück. Die Ausführung dieses Befehls sollte zwei durch ein Semikolon getrennte Zahlen zurückgeben. Wie könnte ich dies in einer Variablen zum Ausdrucken bringen?

Hier ist der Code, den ich jetzt verwende:

String[] commands = {"system.exe", "-get t"};

Process proc = rt.exec(commands);

InputStream stdIn = proc.getInputStream();
InputStreamReader isr = new InputStreamReader(stdIn);
BufferedReader br = new BufferedReader(isr);

String line = null;
System.out.println("<OUTPUT>");

while ((line = br.readLine()) != null)
     System.out.println(line);

System.out.println("</OUTPUT>");
int exitVal = proc.waitFor();
System.out.println("Process exitValue: " + exitVal);

Aber ich bekomme nichts als meine Ausgabe, aber wenn ich diesen Befehl selbst ausführe, funktioniert es gut.

Hier ist der richtige Weg:

Runtime rt = Runtime.getRuntime();
String[] commands = {"system.exe", "-get t"};
Process proc = rt.exec(commands);

BufferedReader stdInput = new BufferedReader(new 
     InputStreamReader(proc.getInputStream()));

BufferedReader stdError = new BufferedReader(new 
     InputStreamReader(proc.getErrorStream()));

// Read the output from the command
System.out.println("Here is the standard output of the command:\n");
String s = null;
while ((s = stdInput.readLine()) != null) {
    System.out.println(s);
}

// Read any errors from the attempted command
System.out.println("Here is the standard error of the command (if any):\n");
while ((s = stdError.readLine()) != null) {
    System.out.println(s);
}

Lesen Sie den Javadoc für weitere Details hier . ProcessBuilderwäre eine gute Wahl zu verwenden.

Ein schnellerer Weg ist folgender:

public static String execCmd(String cmd) throws java.io.IOException {
    java.util.Scanner s = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream()).useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}

Welches ist im Grunde eine komprimierte Version davon:

public static String execCmd(String cmd) throws java.io.IOException {
    Process proc = Runtime.getRuntime().exec(cmd);
    java.io.InputStream is = proc.getInputStream();
    java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
    String val = "";
    if (s.hasNext()) {
        val = s.next();
    }
    else {
        val = "";
    }
    return val;
}

Ich weiß, dass diese Frage alt ist, aber ich poste diese Antwort, weil ich denke, dass dies schneller gehen kann.

ProcessBuilderLesen und implementieren Sie neben der empfohlenen Verwendung von Senthil alle Empfehlungen von When Runtime.exec () .

Wenn für die Verwendung bereits Apache commons-io im Klassenpfad verfügbar ist, können Sie Folgendes verwenden:

Process p = new ProcessBuilder("cat", "/etc/something").start();
String stderr = IOUtils.toString(p.getErrorStream(), Charset.defaultCharset());
String stdout = IOUtils.toString(p.getInputStream(), Charset.defaultCharset());

Wir können auch Streams verwenden, um die Befehlsausgabe zu erhalten:

public static void main(String[] args) throws IOException {

        Runtime runtime = Runtime.getRuntime();
        String[] commands  = {"free", "-h"};
        Process process = runtime.exec(commands);

        BufferedReader lineReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        lineReader.lines().forEach(System.out::println);

        BufferedReader errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
        errorReader.lines().forEach(System.out::println);
    }

Antwort von @Senthil und @Arend ( https://stackoverflow.com/a/5711150/2268559 ) erwähnt ProcessBuilder. Hier ist das Beispiel ProcessBuildermit der Angabe von Umgebungsvariablen und Arbeitsordner für den Befehl:

    ProcessBuilder pb = new ProcessBuilder("ls", "-a", "-l");

    Map<String, String> env = pb.environment();
    // If you want clean environment, call env.clear() first
    //env.clear();
    env.put("VAR1", "myValue");
    env.remove("OTHERVAR");
    env.put("VAR2", env.get("VAR1") + "suffix");

    File workingFolder = new File("/home/user");
    pb.directory(workingFolder);

    Process proc = pb.start();

    BufferedReader stdInput = new BufferedReader(new InputStreamReader(proc.getInputStream()));

    BufferedReader stdError = new BufferedReader(new InputStreamReader(proc.getErrorStream()));

    // Read the output from the command:
    System.out.println("Here is the standard output of the command:\n");
    String s = null;
    while ((s = stdInput.readLine()) != null)
        System.out.println(s);

    // Read any errors from the attempted command:
    System.out.println("Here is the standard error of the command (if any):\n");
    while ((s = stdError.readLine()) != null)
        System.out.println(s);

Zum Zeitpunkt dieses Schreibens können alle anderen Antworten, die Code enthalten, zu Deadlocks führen.

Prozesse haben einen begrenzten Puffer für stdoutund eine begrenzte stderrAusgabe. Wenn Sie sie nicht gleichzeitig anhören, füllt sich einer von ihnen, während Sie versuchen, den anderen zu lesen. Beispielsweise könnten Sie darauf warten, gelesen zu werden, stdoutwährend der Prozess darauf wartet, darauf zu schreiben stderr. Sie können nicht aus dem stdoutPuffer lesen, da dieser leer ist und der Prozess nicht in den stderrPuffer schreiben kann, weil er voll ist. Sie warten alle für immer aufeinander.

Hier ist eine Möglichkeit, die Ausgabe eines Prozesses ohne das Risiko von Deadlocks zu lesen:

public final class Processes
{
    private static final String NEWLINE = System.getProperty("line.separator");

    /**
     * @param command the command to run
     * @return the output of the command
     * @throws IOException if an I/O error occurs
     */
    public static String run(String... command) throws IOException
    {
        ProcessBuilder pb = new ProcessBuilder(command).redirectErrorStream(true);
        Process process = pb.start();
        StringBuilder result = new StringBuilder(80);
        try (BufferedReader in = new BufferedReader(new InputStreamReader(process.getInputStream())))
        {
            while (true)
            {
                String line = in.readLine();
                if (line == null)
                    break;
                result.append(line).append(NEWLINE);
            }
        }
        return result.toString();
    }

    /**
     * Prevent construction.
     */
    private Processes()
    {
    }
}

Der Schlüssel ist zu verwenden, ProcessBuilder.redirectErrorStream(true)der stderrin den stdoutStream umleitet . Auf diese Weise können Sie einen einzelnen Stream lesen, ohne zwischen stdoutund wechseln zu müssen stderr. Wenn Sie dies manuell implementieren möchten, müssen Sie die Streams in zwei verschiedenen Threads verwenden , um sicherzustellen, dass Sie niemals blockieren.

Wenn Sie auf Kotlin schreiben, können Sie Folgendes verwenden:

val firstProcess = ProcessBuilder("echo","hello world").start()
val firstError = firstProcess.errorStream.readBytes().decodeToString()
val firstResult = firstProcess.inputStream.readBytes().decodeToString()

Angepasst an die vorherige Antwort:

public static String execCmdSync(String cmd, CmdExecResult callback) throws java.io.IOException, InterruptedException {
    RLog.i(TAG, "Running command:", cmd);

    Runtime rt = Runtime.getRuntime();
    Process proc = rt.exec(cmd);

    //String[] commands = {"system.exe", "-get t"};

    BufferedReader stdInput = new BufferedReader(new InputStreamReader(proc.getInputStream()));
    BufferedReader stdError = new BufferedReader(new InputStreamReader(proc.getErrorStream()));

    StringBuffer stdOut = new StringBuffer();
    StringBuffer errOut = new StringBuffer();

    // Read the output from the command:
    System.out.println("Here is the standard output of the command:\n");
    String s = null;
    while ((s = stdInput.readLine()) != null) {
        System.out.println(s);
        stdOut.append(s);
    }

    // Read any errors from the attempted command:
    System.out.println("Here is the standard error of the command (if any):\n");
    while ((s = stdError.readLine()) != null) {
        System.out.println(s);
        errOut.append(s);
    }

    if (callback == null) {
        return stdInput.toString();
    }

    int exitVal = proc.waitFor();
    callback.onComplete(exitVal == 0, exitVal, errOut.toString(), stdOut.toString(), cmd);

    return stdInput.toString();
}

public interface CmdExecResult{
    void onComplete(boolean success, int exitVal, String error, String output, String originalCmd);
}

Ziemlich genau wie andere Schnipsel auf dieser Seite, aber nur Dinge über eine Funktion organisieren , los geht's ...

String str=shell_exec("ls -l");

Die Klassenfunktion:

public String shell_exec(String cmd)
       {
       String o=null;
       try
         {
         Process p=Runtime.getRuntime().exec(cmd);
         BufferedReader b=new BufferedReader(new InputStreamReader(p.getInputStream()));
         String r;
         while((r=b.readLine())!=null)o+=r;
         }catch(Exception e){o="error";}
       return o;
       }

Versuchen Sie, InputStreamdie Laufzeit zu lesen :

Runtime rt = Runtime.getRuntime();
String[] commands = {"system.exe", "-send", argument};
Process proc = rt.exec(commands);
BufferedReader br = new BufferedReader(
    new InputStreamReader(proc.getInputStream()));
String line;
while ((line = br.readLine()) != null)
    System.out.println(line);

Möglicherweise müssen Sie auch den Fehlerstrom ( proc.getErrorStream()) lesen, wenn der Prozess eine Fehlerausgabe druckt. Sie können den Fehlerstrom bei Verwendung auf den Eingabestream umleiten ProcessBuilder.