{"id":233,"date":"2024-02-02T23:37:07","date_gmt":"2024-02-02T22:37:07","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=233"},"modified":"2024-02-23T23:40:45","modified_gmt":"2024-02-23T22:40:45","slug":"post-http-requests-mit-dem-java-httpclient","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=233","title":{"rendered":"POST-HTTP-Requests mit dem Java HttpClient"},"content":{"rendered":"\n

Das Senden von HTTP-POST-Requests ist eine grundlegende Funktion in der Programmierung, insbesondere wenn es um die Kommunikation zwischen Client und Server geht. In Java bietet die HttpClient<\/code>-Klasse eine leistungsstarke M\u00f6glichkeit, solche Anfragen zu erstellen und zu senden. In diesem Artikel werden wir uns ausf\u00fchrlich mit dem Senden von POST-HTTP-Requests mit dem Java HttpClient<\/code> befassen.<\/p>\n\n\n\n

Einf\u00fchrung in den Java HttpClient<\/h2>\n\n\n\n

Der HttpClient<\/code> ist eine Klasse, die in Java 11 und sp\u00e4teren Versionen eingef\u00fchrt wurde. Sie ersetzt die veraltete HttpURLConnection<\/code> und bietet eine modernere und benutzerfreundlichere API f\u00fcr die Arbeit mit HTTP-Anfragen und -Antworten. Der HttpClient<\/code> unterst\u00fctzt verschiedene HTTP-Methoden, darunter auch POST.<\/p>\n\n\n\n

Bevor wir uns jedoch mit dem Senden von POST-Anfragen befassen, m\u00fcssen wir sicherstellen, dass wir die richtigen Abh\u00e4ngigkeiten in unserem Projekt haben. Wenn Sie Maven verwenden, k\u00f6nnen Sie die folgende Abh\u00e4ngigkeit zu Ihrer pom.xml<\/code>-Datei hinzuf\u00fcgen:<\/p>\n\n\n

<dependency<\/span>><\/span>\n    <groupId<\/span>><\/span>org.apache.httpcomponents.client5<\/groupId<\/span>><\/span>\n    <artifactId<\/span>><\/span>httpclient5<\/artifactId<\/span>><\/span>\n    <version<\/span>><\/span>5.0<\/version<\/span>><\/span>\n<\/dependency<\/span>><\/span><\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
Alternativ k\u00f6nnen Sie JAR-Dateien herunterladen und sie zu Ihrem Projekt hinzuf\u00fcgen.<\/p>\n\n\n\n
Grundlegende POST-Anfrage erstellen<\/h2>\n\n\n\n
Um mit dem HttpClient<\/code> eine POST-Anfrage zu erstellen, m\u00fcssen Sie zun\u00e4chst eine Instanz von HttpClient<\/code> erstellen. Dies kann \u00fcber den HttpClient.newHttpClient()<\/code>-Aufruf erfolgen:<\/p>\n\n\n
import<\/span> java.net.URI;\nimport<\/span> java.net.http.HttpClient;\nimport<\/span> java.net.http.HttpRequest;\nimport<\/span> java.net.http.HttpResponse;\n\npublic class<\/span> HttpPostExample<\/span> <\/span>{\n\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        \/\/ Erstelle einen HttpClient<\/span>\n        HttpClient httpClient = HttpClient.newHttpClient();\n\n        \/\/ Definiere die URL, zu der die POST-Anfrage gesendet werden soll<\/span>\n        URI uri = URI.create(\"https:\/\/example.com\/api\/endpoint\"<\/span>);\n\n        \/\/ Erstelle einen HttpRequest mit der POST-Methode<\/span>\n        HttpRequest request = HttpRequest.newBuilder()\n                .uri(uri)\n                .header(\"Content-Type\"<\/span>, \"application\/json\"<\/span>) \/\/ Setze den Content-Type Header<\/span>\n                .POST(HttpRequest.BodyPublishers.ofString(\"{'key':'value'}\"<\/span>)) \/\/ Setze den Anfrage-Body<\/span>\n                .build();\n\n        \/\/ Sende die POST-Anfrage und erhalte die Antwort<\/span>\n        try<\/span> {\n            HttpResponse<String<\/span>> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());\n\n            \/\/ Verarbeite die Antwort<\/span>\n            System.out.println(\"Status Code: \"<\/span> + response.statusCode());\n            System.out.println(\"Response Body: \"<\/span> + response.body());\n        } catch<\/span> (Exception e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel wird eine einfache POST-Anfrage an die angegebene URL gesendet. Der Content-Type-Header wird auf „application\/json“ gesetzt, und der Anfrage-Body enth\u00e4lt JSON-Daten.<\/p>\n\n\n\n
Hinzuf\u00fcgen von Anfrageparametern<\/h2>\n\n\n\n
Oftmals m\u00fcssen POST-Anfragen zus\u00e4tzliche Parameter enthalten. Dies kann durch Hinzuf\u00fcgen von Parametern zum Anfrage-Body erreicht werden. Hier ist ein Beispiel:<\/p>\n\n\n
import<\/span> java.net.URI;\nimport<\/span> java.net.http.HttpClient;\nimport<\/span> java.net.http.HttpRequest;\nimport<\/span> java.net.http.HttpResponse;\nimport<\/span> java.net.URLEncoder;\nimport<\/span> java.nio.charset.StandardCharsets;\n\npublic class<\/span> HttpPostWithParameters<\/span> <\/span>{\n\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        HttpClient httpClient = HttpClient.newHttpClient();\n        URI uri = URI.create(\"https:\/\/example.com\/api\/endpoint\"<\/span>);\n\n        \/\/ Erstelle einen Anfrage-Body mit Parametern<\/span>\n        String<\/span> requestBody = \"param1=\"<\/span> + URLEncoder.encode(\"value1\"<\/span>, StandardCharsets.UTF_8)\n                + \"&param2=\"<\/span> + URLEncoder.encode(\"value2\"<\/span>, StandardCharsets.UTF_8);\n\n        HttpRequest request = HttpRequest.newBuilder()\n                .uri(uri)\n                .header(\"Content-Type\"<\/span>, \"application\/x-www-form-urlencoded\"<\/span>)\n                .POST(HttpRequest.BodyPublishers.ofString(requestBody))\n                .build();\n\n        try<\/span> {\n            HttpResponse<String<\/span>> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());\n\n            System.out.println(\"Status Code: \"<\/span> + response.statusCode());\n            System.out.println(\"Response Body: \"<\/span> + response.body());\n        } catch<\/span> (Exception e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel werden Anfrageparameter zum Anfrage-Body hinzugef\u00fcgt. Der Content-Type-Header wird auf „application\/x-www-form-urlencoded“ gesetzt, da dies der Standard f\u00fcr das Codieren von Formulardaten ist.<\/p>\n\n\n\n
Verwendung von JSON im Anfrage-Body<\/h2>\n\n\n\n
Wenn Sie JSON-Daten im Anfrage-Body senden m\u00fcssen, k\u00f6nnen Sie dies einfach tun, indem Sie den Content-Type-Header auf „application\/json“ setzen und den entsprechenden JSON-String im Anfrage-Body platzieren. Hier ist ein Beispiel:<\/p>\n\n\n
import<\/span> java.net.URI;\nimport<\/span> java.net.http.HttpClient;\nimport<\/span> java.net.http.HttpRequest;\nimport<\/span> java.net.http.HttpResponse;\n\npublic class<\/span> HttpPostWithJsonBody<\/span> <\/span>{\n\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        HttpClient httpClient = HttpClient.newHttpClient();\n        URI uri = URI.create(\"https:\/\/example.com\/api\/endpoint\"<\/span>);\n\n        \/\/ Erstelle einen JSON-String f\u00fcr den Anfrage-Body<\/span>\n        String<\/span> jsonBody = \"{\\\"key1\\\":\\\"value1\\\",\\\"key2\\\":\\\"value2\\\"}\"<\/span>;\n\n        HttpRequest request = HttpRequest.newBuilder()\n                .uri(uri)\n                .header(\"Content-Type\"<\/span>, \"application\/json\"<\/span>)\n                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))\n                .build();\n\n        try<\/span> {\n            HttpResponse<String<\/span>> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());\n\n            System.out.println(\"Status Code: \"<\/span> + response.statusCode());\n            System.out.println(\"Response Body: \"<\/span> + response.body());\n        } catch<\/span> (Exception e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel wird ein JSON-String als Anfrage-Body verwendet. Stellen Sie sicher, dass der Content-Type-Header auf „application\/json“ gesetzt ist, damit der Server den Anfrage-Body korrekt interpretieren kann.<\/p>\n\n\n\n
Hinzuf\u00fcgen von Benutzerauthentifizierung<\/h2>\n\n\n\n
F\u00fcr den Fall, dass der Server Benutzerauthentifizierung erfordert, k\u00f6nnen Sie diese Informationen einfach zur Anfrage hinzuf\u00fcgen. Hier ist ein Beispiel mit Basic Authentication:<\/p>\n\n\n
import<\/span> java.net.URI;\nimport<\/span> java.net.http.HttpClient;\nimport<\/span> java.net.http.HttpRequest;\nimport<\/span> java.net.http.HttpResponse;\nimport<\/span> java.nio.charset.StandardCharsets;\nimport<\/span> java.util.Base64;\n\npublic class<\/span> HttpPostWithAuthentication<\/span> <\/span>{\n\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        HttpClient httpClient = HttpClient.newHttpClient();\n        URI uri = URI.create(\"https:\/\/example.com\/api\/endpoint\"<\/span>);\n\n        \/\/ Benutzername und Passwort f\u00fcr die Basic Authentication<\/span>\n        String<\/span> username = \"yourUsername\"<\/span>;\n        String<\/span> password = \"yourPassword\"<\/span>;\n\n        \/\/ Erstelle den Basic Authentication Header<\/span>\n        String<\/span> auth = username + \":\"<\/span> + password;\n        String<\/span> encodedAuth = Base64.getEncoder().encodeToString(auth.getBytes(StandardCharsets.UTF_8));\n        String<\/span> authHeader = \"Basic \"<\/span> + encodedAuth;\n\n        \/\/ Erstelle die POST-Anfrage mit Basic Authentication<\/span>\n        HttpRequest request = HttpRequest.newBuilder()\n                .uri(uri)\n                .header(\"Content-Type\"<\/span>, \"application\/json\"<\/span>)\n                .header(\"Authorization\"<\/span>, authHeader)\n                .POST(HttpRequest.BodyPublishers.ofString(\"{\\\"key\\\":\\\"value\\\"}\"<\/span>))\n                .build();\n\n        try<\/span> {\n            HttpResponse<String<\/span>> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());\n\n            System.out.println(\"Status Code: \"<\/span> + response.statusCode());\n            System.out.println(\"Response Body: \"<\/span> + response.body());\n        } catch<\/span> (Exception e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel wird der Basic Authentication Header manuell erstellt und zur Anfrage hinzugef\u00fcgt. Beachten Sie, dass Benutzernamen und Passw\u00f6rter in einer sicheren Umgebung gespeichert oder \u00fcber sicherere Methoden \u00fcbertragen werden sollten, wenn Sie in einer produktiven Umgebung arbeiten.<\/p>\n\n\n\n
Verwendung von Asynchronit\u00e4t<\/h2>\n\n\n\n
Die HttpClient<\/code>-Klasse unterst\u00fctzt auch asynchrone Anfragen, die n\u00fctzlich sein k\u00f6nnen, um die Leistung zu verbessern, wenn viele Anfragen gleichzeitig gesendet werden m\u00fcssen. Hier ist ein einfaches Beispiel:<\/p>\n\n\n
import<\/span> java.net.URI;\nimport<\/span> java.net.http.HttpClient;\nimport<\/span> java.net.http.HttpRequest;\nimport<\/span> java.net.http.HttpResponse;\n\npublic class<\/span> HttpPostAsyncExample<\/span> <\/span>{\n\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        HttpClient httpClient = HttpClient.newHttpClient();\n        URI uri = URI.create(\"https:\/\/example.com\/api\/endpoint\"<\/span>);\n\n        \/\/ Erstelle eine POST-Anfrage<\/span>\n        HttpRequest request = HttpRequest.newBuilder()\n                .uri(uri)\n                .header(\"Content-Type\"<\/span>, \"application\/json\"<\/span>)\n                .POST(HttpRequest.BodyPublishers.ofString(\"{\\\"key\\\":\\\"value\\\"}\"<\/span>))\n                .build();\n\n        \/\/ Sende die Anfrage asynchron<\/span>\n        httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString())\n                .thenApply(response -> {\n                    System.out.println(\"Status Code: \"<\/span> + response.statusCode());\n                    System.out.println(\"Response Body: \"<\/span> + response.body());\n                    return<\/span> response;\n                })\n                .join(); \/\/ Warte auf Abschluss der asynchronen Anfrage<\/span>\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel wird die sendAsync<\/code>-Methode verwendet, die eine CompletableFuture zur\u00fcckgibt. Sie k\u00f6nnen dann asynchrone Operationen mit thenApply<\/code> oder anderen Methoden der CompletableFuture-API durchf\u00fchren.<\/p>\n\n\n\n
Fehlerbehandlung<\/h2>\n\n\n\n
Es ist wichtig, auch auf m\u00f6gliche Fehler w\u00e4hrend des HTTP-Anfrageprozesses vorbereitet zu sein. Hier ist ein Beispiel f\u00fcr die Fehlerbehandlung:<\/p>\n\n\n
import<\/span> java.net.URI;\nimport<\/span> java.net.http.HttpClient;\nimport<\/span> java.net.http.HttpRequest;\nimport<\/span> java.net.http.HttpResponse;\n\npublic class<\/span> HttpPostWithErrorHandling<\/span> <\/span>{\n\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        HttpClient httpClient = HttpClient.newHttpClient();\n        URI uri = URI.create(\"https:\/\/example.com\/api\/endpoint\"<\/span>);\n\n        \/\/ Erstelle eine POST-Anfrage<\/span>\n        HttpRequest request = HttpRequest.newBuilder()\n                .uri(uri)\n                .header(\"Content-Type\"<\/span>, \"application\/json\"<\/span>)\n                .POST(HttpRequest.BodyPublishers.ofString(\"{\\\"key\\\":\\\"value\\\"}\"<\/span>))\n                .build();\n\n        try<\/span> {\n            HttpResponse<String<\/span>> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());\n\n            \/\/ \u00dcberpr\u00fcfe den Statuscode der Antwort<\/span>\n            if<\/span> (response.statusCode() == 200<\/span>) {\n                System.out.println(\"Erfolgreiche Anfrage. Response Body: \"<\/span> + response.body());\n            } else<\/span> {\n                System.out.println(\"Fehlerhafte Anfrage. Status Code: \"<\/span> + response.statusCode());\n            }\n        } catch<\/span> (Exception 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 \u00fcberpr\u00fcft, ob der Statuscode der Antwort 200 ist. Wenn nicht, wird angenommen, dass die Anfrage fehlgeschlagen ist. In einer produktiven Umgebung sollten Sie diese \u00dcberpr\u00fcfung m\u00f6glicherweise anpassen, um spezifischere Fehlerinformationen zu erhalten.<\/p>\n\n\n\n
Zusammenfassung<\/h2>\n\n\n\n
In diesem Artikel haben wir uns ausf\u00fchrlich mit dem Senden von POST-HTTP-Requests mit dem Java HttpClient<\/code> befasst. Wir haben grundlegende POST-Anfragen, das Hinzuf\u00fcgen von Anfrageparametern, die Verwendung von JSON im Anfrage-Body, die Authentifizierung und asynchrone Anfragen behandelt. Es ist wichtig zu beachten, dass die genaue Implementierung je nach den Anforderungen Ihres Projekts variieren kann. Der HttpClient<\/code> bietet eine flexible API, mit der Sie HTTP-Anfragen auf vielf\u00e4ltige Weise anpassen k\u00f6nnen.<\/p>\n","protected":false},"excerpt":{"rendered":"
Das Senden von HTTP-POST-Requests ist eine grundlegende Funktion in der Programmierung, insbesondere wenn es um die Kommunikation zwischen Client und Server geht. In Java bietet die HttpClient-Klasse eine leistungsstarke M\u00f6glichkeit, solche Anfragen zu erstellen und zu senden. In diesem Artikel werden wir uns ausf\u00fchrlich mit dem Senden von POST-HTTP-Requests mit dem Java HttpClient befassen. Einf\u00fchrung […]<\/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-233","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\/233","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=233"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/233\/revisions"}],"predecessor-version":[{"id":234,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/233\/revisions\/234"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=233"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=233"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=233"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}