So rufen Sie externe Programme in Java auf

In Java können Sie externe Programme über die Runtime-Klasse oder ProcessBuilder-Klasse aufrufen. Runtime类或ProcessBuilder类来实现调用外部程序。

Runtime类与ProcessBuilder类

使用Runtime类：

Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec("外部程序路径");

使用ProcessBuilder类：

ProcessBuilder builder = new ProcessBuilder("外部程序路径");
Process process = builder.start();

参数传递

以上两种方法均可启动一个外部进程。如果需要向外部进程传递参数，可以在exec() 或ProcessBuilder构造函数中传递字符串数组

String[] cmdarray = {"外部程序路径", "参数1", "参数2"};Process process = runtime.exec(cmdarray);

执行结果

外部进程的返回结果可以通过process对象获取。可以使用getInputStream() 方法读取外部进程的标准输出流，或者使用getErrorStream() 方法读取错误输出流。

InputStream inputStream = process.getInputStream(); // 标准输出流
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String line;
while ((line = bufferedReader.readLine()) != null) {
    System.out.println(line); // 输出每行结果
}

注意

Runtime-Klasse und ProcessBuilder-Klasse

Verwenden Sie die Runtime-Klasse:

    @Test
    public void runtimeTest() {
        try {
            //获取执行进程
            Runtime runtime = Runtime.getRuntime();
            Process process = runtime.exec("ipconfig");
            //读取输入流
            InputStream inputStream = process.getInputStream();
            //将字节流转成字符流
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "gbk");
            //字符缓冲区
            char[] c = new char[1024];
            int len = -1;
            while ((len = inputStreamReader.read(c)) != -1) {
                String s = new String(c, 0, len);
                System.out.print(s);
            }
            inputStream.close();
            inputStreamReader.close();
            //阻塞当前线程，直到进程退出为止
            process.waitFor();
            int exitValue = process.exitValue();
            if (exitValue == 0) {
                System.out.println("进程正常结束");
            } else {
                System.out.println("进程异常结束");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

Verwenden Sie die ProcessBuilder-Klasse:

@Test
    public void processBuilderTest1() {
        ProcessBuilder processBuilder = new ProcessBuilder();
        processBuilder.command("java");
        //将标准输入流和错误输入流合并，通过标准输入流读取信息
        processBuilder.redirectErrorStream(true);
        try {
            //启动进程
            Process start = processBuilder.start();
            //获取输入流
            InputStream inputStream = start.getInputStream();
            //转成字符输入流
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "gbk");
            int len = -1;
            //字符缓冲区
            char[] c = new char[1024];
            //读取进程输入流中的内容
            while ((len = inputStreamReader.read(c)) !=-1){
                String s = new String(c, 0, len);
                System.out.print(s);
            }
            inputStreamReader.close();
            inputStream.close();
            //阻塞当前线程，直到进程退出为止
            start.waitFor();
            int exitValue = start.exitValue();
            if (exitValue == 0) {
                System.out.println("进程正常结束");
            } else {
                System.out.println("进程异常结束");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

Parameterübergabe

Die beiden oben genannten Methoden können einen externen Prozess starten. Wenn Sie Parameter an einen externen Prozess übergeben müssen, können Sie ein String-Array im exec()- oder ProcessBuilder-Konstruktor übergeben

processBuilder.command("java","-version");

Ausführungsergebnisse

Das Rückgabeergebnis des externen Prozesses kann über das Prozessobjekt abgerufen werden. Sie können die Methode getInputStream() verwenden, um den Standardausgabestream eines externen Prozesses zu lesen, oder die Methode getErrorStream(), um den Fehlerausgabestream zu lesen.

 List<String> command = new ArrayList<>();
        command.add("java");
        command.add("-version");
        processBuilder.command(command);

Hinweis: Seien Sie vorsichtig, wenn Sie externe Programme aufrufen, da dies zu Sicherheitsproblemen und ungewöhnlichen Situationen wie Systemabstürzen führen kann. Es wird empfohlen, externe Programme vollständig zu testen und zu verifizieren, wenn diese Funktion verwendet wird

Komplexer Parameteraufruf

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-exec</artifactId>
            <version>1.3</version>
        </dependency>

Apache Commons Exec-Bibliothek

Apache Commons Exec ist eine Java-Bibliothek zum Ausführen externer Prozesse. Sie kann den Prozess einfach starten und steuern und ermöglicht die Verwaltung und Verarbeitung von Eingabe- und Ausgabeströmen. Einführung in Verwendungsschritte

1. Abhängigkeiten hinzufügen und die Apache Commons Exec-Bibliothek zum Projekt hinzufügen

CommandLine cmdLine = CommandLine.parse("command argument1 argument2");

2. Erstellen Sie Befehlszeilenobjekte: Erstellen Sie externe Programme und Parameter, die über das CommandLine-Objekt ausgeführt werden müssen.

DefaultExecutor executor = new DefaultExecutor();
executor.setWorkingDirectory(new File("/your/workdir"));

kann umgeschrieben werden als: Das Erstellen eines Executor-Objekts erfordert die Verwendung eines DefaultExecutor-Objekts, und das Arbeitsverzeichnis kann nach Bedarf festgelegt werden.

ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
PumpStreamHandler streamHandler = new PumpStreamHandler(outputStream);
executor.setStreamHandler(streamHandler);

4. Erstellen Sie ein Prozessorobjekt: Das PumpStreamHandler-Objekt kann die Eingabe- und Ausgabeströme verarbeiten und die Standardausgabe- und Standardfehlerinformationen des Prozesses speichern.

executor.execute(cmdLine);
String output = outputStream.toString("UTF-8");
System.out.println(output);

Rufen Sie die Methode executor.execute auf, um den Befehl auszuführen, und warten Sie, bis der Vorgang beendet ist. Rufen Sie process.waitFor() auf, um auf den Abschluss des Prozesses zu warten, bevor Sie mit der Ausführung des entsprechenden Vorgangs fortfahren. Nachdem die Ausführung abgeschlossen ist, werden die Ausgabeergebnisse im OutputStream verarbeitet.

    public static void main(String[] args) throws IOException {
        CommandLine cmdLine = CommandLine.parse("java -version");
        DefaultExecutor executor = new DefaultExecutor();
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        PumpStreamHandler streamHandler = new PumpStreamHandler(outputStream);
        executor.setStreamHandler(streamHandler);
        executor.execute(cmdLine);
        String output = outputStream.toString("UTF-8");
        System.out.println(output);
    }

Verwendungsbeispiel

rrreee

Ergebnis der Ausführungsausgabe:

Java-Version „1.8.0_271“
Java(TM) SE Runtime Environment (Build 1.8.0_271-b09)
Java HotSpot(TM) 64-Bit Server VM ( Build 25.271-b09, gemischter Modus)

Das obige ist der detaillierte Inhalt vonSo rufen Sie externe Programme in Java auf. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!