web-dev-qa-db-fra.com

Java Runtime.getRuntime (): obtenir le résultat de l'exécution d'un programme en ligne de commande

J'utilise le moteur d'exécution pour exécuter les commandes d'invite de commande à partir de mon programme Java. Cependant, je ne sais pas comment obtenir la sortie renvoyée par la commande.

Voici mon code:

Runtime rt = Runtime.getRuntime();

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

Process proc = rt.exec(commands);

J'ai essayé de faire System.out.println(proc); mais cela n'a rien retourné. L'exécution de cette commande doit renvoyer deux nombres séparés par un point-virgule. Comment pourrais-je obtenir cela dans une variable à imprimer?

Voici le code que j'utilise maintenant:

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

Mais je ne reçois rien comme sortie, mais lorsque je lance cette commande moi-même, cela fonctionne bien.

javaruntime
126
user541597

Voici le chemin à parcourir:

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

Lisez la Javadoc pour plus de détails ici . ProcessBuilder serait un bon choix à utiliser.

208
Senthil

Voici un moyen plus rapide:

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

Ce qui est fondamentalement une version condensée de ceci:

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

Je sais que cette question est ancienne, mais je poste cette réponse parce que je pense que cela pourrait être plus rapide.

59
735Tesla

En plus d’utiliser ProcessBuilder comme Senthil le suggère, veillez à lire et à mettre en œuvre tous les recommandations de Lorsque Runtime.exec () a gagné 't .

11
Andrew Thompson

@Senthil et @Arend répondent ( https://stackoverflow.com/a/5711150/2268559 ) mentionné ProcessBuilder. Voici l'exemple utilisant ProcessBuilder avec la spécification de variables d'environnement et un dossier de travail pour la commande:

    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);
8
nidalpres

Nous pouvons également utiliser des flux pour obtenir le résultat de la commande:

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);
    }
5
Jackkobec

Si vous utilisez déjà Apache commons-io disponible sur le chemin de classe, vous pouvez utiliser:

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

Adapté de la réponse précédente:

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);
}
0
Derek Zhu