Java Runtime.getRuntime (): mendapatkan output dari menjalankan program baris perintah

Saya menggunakan runtime untuk menjalankan perintah command prompt dari program Java saya. Namun, saya tidak tahu bagaimana saya bisa mendapatkan output yang dikembalikan oleh perintah.

Ini kode saya:

Runtime rt = Runtime.getRuntime();

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

Process proc = rt.exec(commands);

Saya mencoba melakukan System.out.println(proc);tetapi itu tidak mengembalikan apa pun. Eksekusi perintah itu harus mengembalikan dua angka yang dipisahkan oleh tanda titik koma. Bagaimana saya bisa mendapatkan ini dalam variabel untuk dicetak?

Ini kode yang saya gunakan sekarang:

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

Tapi saya tidak mendapatkan apa pun sebagai output saya, tetapi ketika saya menjalankan sendiri perintah itu berfungsi dengan baik.

Inilah cara untuk pergi:

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

Baca Javadoc untuk lebih jelasnya di sini . ProcessBuilderakan menjadi pilihan yang baik untuk digunakan.

Cara yang lebih cepat adalah ini:

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

Yang pada dasarnya adalah versi kental ini:

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

Saya tahu pertanyaan ini sudah lama tetapi saya memposting jawaban ini karena saya pikir ini mungkin lebih cepat.

Selain menggunakan ProcessBuilderseperti yang disarankan Senthil, pastikan untuk membaca dan mengimplementasikan semua rekomendasi When Runtime.exec () tidak akan .

Jika penggunaan sudah memiliki Apache commons-io tersedia di classpath, Anda dapat menggunakan:

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

Kita juga dapat menggunakan stream untuk mendapatkan output perintah:

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

@Senthil dan @Arend jawaban ( https://stackoverflow.com/a/5711150/2268559 ) disebutkan ProcessBuilder. Berikut adalah contoh menggunakan ProcessBuilderdengan menentukan variabel lingkungan dan folder yang berfungsi untuk perintah:

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

Pada saat penulisan ini, semua jawaban lain yang menyertakan kode dapat mengakibatkan kebuntuan.

Proses memiliki buffer terbatas untuk stdoutdanstderr output . Jika Anda tidak mendengarkannya secara bersamaan, salah satunya akan terisi saat Anda mencoba membaca yang lain. Misalnya, Anda bisa menunggu untuk membaca dari stdoutsaat proses menunggu untuk menulis stderr. Anda tidak dapat membaca dari stdoutbuffer karena kosong dan proses tidak dapat menulis kestderr buffer karena penuh. Anda masing-masing saling menunggu selamanya.

Berikut adalah cara yang mungkin untuk membaca output dari suatu proses tanpa risiko kebuntuan:

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

Kuncinya adalah menggunakan ProcessBuilder.redirectErrorStream(true)yang akan mengarahkan ulang stderrke stdoutaliran. Ini memungkinkan Anda membaca aliran tunggal tanpa harus bergantian antara stdoutdan stderr. Jika Anda ingin menerapkan ini secara manual, Anda harus menggunakan stream di dua utas berbeda untuk memastikan Anda tidak pernah memblokir.

Jika Anda menulis di Kotlin, Anda dapat menggunakan:

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

Diadaptasi dari jawaban sebelumnya:

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

Hampir sama dengan cuplikan lainnya di laman ini tetapi hanya mengatur berbagai hal di atas suatu fungsi , ini dia ...

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

Fungsi kelas:

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

Coba baca InputStreamruntime:

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

Anda mungkin juga perlu membaca aliran kesalahan ( proc.getErrorStream()) jika proses mencetak keluaran kesalahan. Anda dapat mengalihkan aliran kesalahan ke aliran input jika Anda menggunakan ProcessBuilder.