Comment appeler des programmes externes en Java

En Java, vous pouvez appeler des programmes externes via la Classe Runtime ou la Classe ProcessBuilder. 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); // 输出每行结果
}

注意

Classe Runtime et classe ProcessBuilder

Utilisez la classe Runtime :

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

Utilisez la classe ProcessBuilder :

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

Passage de paramètres

Les deux méthodes ci-dessus peuvent démarrer un processus externe. Si vous devez transmettre des paramètres à un processus externe, vous pouvez transmettre un tableau de chaînes dans le constructeur exec() ou ProcessBuilder

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

Résultats d'exécution

Le résultat de retour du processus externe peut être obtenu via l'objet processus. Vous pouvez utiliser la méthode getInputStream() pour lire le flux de sortie standard d'un processus externe, ou la méthode getErrorStream() pour lire le flux de sortie d'erreur.

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

Remarque : Soyez prudent lorsque vous appelez des programmes externes car cela peut entraîner des problèmes de sécurité et des situations anormales telles que des pannes du système. Il est recommandé de tester et de vérifier entièrement les programmes externes lors de l'utilisation de cette fonction. Appel de paramètres complexes

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

Bibliothèque Apache Commons Exec

Apache Commons Exec est une bibliothèque Java utilisée pour exécuter des processus externes. Elle peut facilement démarrer et contrôler le processus, et assure la gestion et le traitement des flux d'entrée et de sortie

Introduction à. étapes d'utilisation

1. Ajoutez des dépendances et ajoutez la bibliothèque Apache Commons Exec au projet

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

2. Construisez des objets de ligne de commande : construisez des programmes et des paramètres externes qui doivent être exécutés via l'objet CommandLine.

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

peut être réécrit comme suit : La création d'un objet exécuteur nécessite l'utilisation d'un objet DefaultExecutor et le répertoire de travail peut être défini selon les besoins.

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

4. Créez un objet processeur : l'objet PumpStreamHandler peut traiter les flux d'entrée et de sortie et stocker les informations de sortie standard et d'erreur standard du processus.

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

Appelez la méthode executor.execute pour exécuter la commande et attendez la fin du processus. Appelez process.waitFor() pour attendre la fin du processus avant de continuer à effectuer l'opération correspondante. Une fois l’exécution terminée, les résultats de sortie dans outputStream sont traités.

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

Exemple d'utilisation

rrreee

Résultat de sortie de l'exécution :

version Java "1.8.0_271"
Environnement d'exécution Java(TM) SE (build 1.8.0_271-b09)

Machine virtuelle de serveur Java HotSpot(TM) 64 bits ( build 25.271-b09, mode mixte)

🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!