{"id":42,"date":"2023-11-27T15:26:00","date_gmt":"2023-11-27T14:26:00","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=42"},"modified":"2024-01-08T09:14:06","modified_gmt":"2024-01-08T08:14:06","slug":"externe-prozesse-in-java-starten-und-steuern","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=42","title":{"rendered":"Externe Prozesse in Java starten und steuern"},"content":{"rendered":"\n

Die Integration externer Programme in Java-Anwendungen ist eine h\u00e4ufige Notwendigkeit, sei es f\u00fcr die Automatisierung von Aufgaben, die Interaktion mit Systemressourcen oder die Kommunikation mit anderen Anwendungen. Die ProcessBuilder<\/code>-Klasse in Java bietet eine flexible M\u00f6glichkeit, externe Prozesse zu starten und mit ihnen zu interagieren. In diesem Artikel werden wir den Umgang mit ProcessBuilder<\/code> sowie verwandten Konzepten wie Umgebungsvariablen, Kommandozeilenparametern, stdin\/stdout und m\u00f6glichen Herausforderungen beim Lesen von Prozessausgaben besprechen.<\/p>\n\n\n\n

1. Prozesse starten mit ProcessBuilder<\/h2>\n\n\n\n

Die ProcessBuilder<\/code>-Klasse in Java erm\u00f6glicht es, externe Prozesse zu starten und mit ihnen zu interagieren. Um einen einfachen Prozess zu starten, k\u00f6nnen Sie ProcessBuilder<\/code> wie folgt verwenden:<\/p>\n\n\n

import<\/span> java.io.IOException;\n\npublic class<\/span> ExternalProcessExample<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        try<\/span> {\n            ProcessBuilder processBuilder = new<\/span> ProcessBuilder(\"command\"<\/span>, \"arg1\"<\/span>, \"arg2\"<\/span>);\n            Process process = processBuilder.start();\n\n            \/\/ Warten, bis der Prozess beendet ist<\/span>\n            int exitCode = process.waitFor();\n\n            System.out.println(\"Prozess beendet mit Exit-Code: \"<\/span> + exitCode);\n        } catch<\/span> (IOException | InterruptedException e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Hier wird ein externer Prozess mit einem Befehl („command“) und optionalen Argumenten („arg1“, „arg2“) gestartet. Der waitFor<\/code>-Aufruf blockiert, bis der gestartete Prozess beendet ist, und gibt den Exit-Code des Prozesses zur\u00fcck.<\/p>\n\n\n\n
2. Umgebungsvariablen und Kommandozeilenparameter setzen<\/h2>\n\n\n\n
Oftmals ist es erforderlich, Umgebungsvariablen oder Kommandozeilenparameter f\u00fcr den gestarteten Prozess festzulegen. Dies kann \u00fcber die environment()<\/code>-Methode von ProcessBuilder<\/code> erfolgen:<\/p>\n\n\n
import<\/span> java.io.IOException;\n\npublic class<\/span> ProcessWithEnvironment<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        try<\/span> {\n            ProcessBuilder processBuilder = new<\/span> ProcessBuilder(\"command\"<\/span>, \"arg1\"<\/span>, \"arg2\"<\/span>);\n\n            \/\/ Umgebungsvariablen setzen<\/span>\n            processBuilder.environment().put(\"KEY\"<\/span>, \"VALUE\"<\/span>);\n\n            Process process = processBuilder.start();\n\n            int exitCode = process.waitFor();\n\n            System.out.println(\"Prozess beendet mit Exit-Code: \"<\/span> + exitCode);\n        } catch<\/span> (IOException | InterruptedException e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
3. stdin und stdout steuern<\/h2>\n\n\n\n
Die ProcessBuilder<\/code>-Klasse erm\u00f6glicht auch die Steuerung von stdin und das Abfangen von stdout des gestarteten Prozesses. Dazu k\u00f6nnen Sie getOutputStream()<\/code> f\u00fcr die Eingabe und getInputStream()<\/code> f\u00fcr die Ausgabe verwenden:<\/p>\n\n\n
import<\/span> java.io.*;\n\npublic class<\/span> ProcessWithInputOutput<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        try<\/span> {\n            ProcessBuilder processBuilder = new<\/span> ProcessBuilder(\"command\"<\/span>);\n\n            \/\/ stdin des Prozesses abrufen<\/span>\n            OutputStream stdin = processBuilder.start().getOutputStream();\n\n            \/\/ Daten in stdin schreiben<\/span>\n            BufferedWriter writer = new<\/span> BufferedWriter(new<\/span> OutputStreamWriter(stdin));\n            writer.write(\"Input-Daten\"<\/span>);\n            writer.close();\n\n            \/\/ stdout des Prozesses abrufen<\/span>\n            InputStream stdout = processBuilder.start().getInputStream();\n\n            \/\/ Daten von stdout lesen<\/span>\n            BufferedReader reader = new<\/span> BufferedReader(new<\/span> InputStreamReader(stdout));\n            String<\/span> output = reader.readLine();\n\n            System.out.println(\"Prozessausgabe: \"<\/span> + output);\n        } catch<\/span> (IOException e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
4. Verwendung der StreamGobbler-Hilfsklasse<\/h2>\n\n\n\n
Um stdout und stderr des gestarteten Prozesses effizienter zu verarbeiten, ist es ratsam, eine Hilfsklasse wie StreamGobbler<\/code> zu verwenden. Diese Klasse liest die Ausgaben des Prozesses in einem separaten Thread und verhindert, dass die Puffer des Betriebssystems \u00fcberlaufen.<\/p>\n\n\n
import<\/span> java.io.BufferedReader;\nimport<\/span> java.io.IOException;\nimport<\/span> java.io.InputStream;\nimport<\/span> java.io.InputStreamReader;\n\npublic class<\/span> StreamGobbler<\/span> extends<\/span> Thread<\/span> <\/span>{\n    private InputStream inputStream;\n    private Consumer<String<\/span>> consumer;\n\n    public StreamGobbler(InputStream inputStream, Consumer<String<\/span>> consumer) {\n        this<\/span>.inputStream = inputStream;\n        this<\/span>.consumer = consumer;\n    }\n\n    @Override\n    public void<\/span> run() {\n        try<\/span> (BufferedReader reader = new<\/span> BufferedReader(new<\/span> InputStreamReader(inputStream))) {\n            reader.lines().forEach(consumer);\n        } catch<\/span> (IOException e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Die StreamGobbler<\/code>-Klasse erfasst den InputStream des Prozesses und leitet die Ausgaben an den angegebenen Consumer weiter. Dadurch k\u00f6nnen Sie die Ausgaben des Prozesses nach Bedarf verarbeiten, z.B. sie in einer Datei speichern oder analysieren.<\/p>\n\n\n\n
5. Warnung vor Blockaden bei stdout<\/h2>\n\n\n\n
Beim Lesen von stdout ist es wichtig, die Ausgaben des Prozesses kontinuierlich zu verarbeiten, um zu verhindern, dass die Puffer des Betriebssystems \u00fcberlaufen und der Prozess blockiert. Dies kann erreicht werden, indem Sie den StreamGobbler<\/code> oder einen \u00e4hnlichen Mechanismus verwenden, um die Ausgaben parallel zum Hauptprogramm zu verarbeiten – oder komplett zu ignorieren (denn die Hauptsache ist, dass der Stream ausgelesen wird)!<\/p>\n\n\n\n
Insgesamt bietet die ProcessBuilder<\/code>-Klasse in Java eine leistungsstarke M\u00f6glichkeit, mit externen Prozessen zu interagieren. Mit den oben genannten Konzepten k\u00f6nnen Sie nicht nur Prozesse starten, sondern auch Umgebungsvariablen setzen, Kommandozeilenparameter \u00fcbergeben und die stdin\/stdout-Streams effizient steuern. Die Verwendung von Hilfsklassen wie StreamGobbler<\/code> erleichtert zudem die Handhabung von Prozessausgaben und minimiert das Risiko von Blockaden durch volle Puffer.<\/p>\n","protected":false},"excerpt":{"rendered":"
Die Integration externer Programme in Java-Anwendungen ist eine h\u00e4ufige Notwendigkeit, sei es f\u00fcr die Automatisierung von Aufgaben, die Interaktion mit Systemressourcen oder die Kommunikation mit anderen Anwendungen. Die ProcessBuilder-Klasse in Java bietet eine flexible M\u00f6glichkeit, externe Prozesse zu starten und mit ihnen zu interagieren. In diesem Artikel werden wir den Umgang mit ProcessBuilder sowie verwandten […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-42","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/42","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=42"}],"version-history":[{"count":3,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/42\/revisions"}],"predecessor-version":[{"id":47,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/42\/revisions\/47"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=42"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=42"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=42"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}