Java Academy · Lektion

java.net.http.HttpClient

Synchrone Anfragen senden

java.net.http.HttpClient ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Der moderne HTTP-Client

Seit Java 11 liefert das JDK einen modernen HTTP-Client im Paket java.net.http mit. Er ersetzt das alte HttpURLConnection durch eine übersichtliche, flüssige API, die HTTP/1.1 und HTTP/2 unterstützt.

Die drei zentralen Typen sind:

HttpClient — sendet Anfragen und verwaltet die Konfiguration (Zeitlimits, Proxys, Weiterleitungen).
HttpRequest — eine unveränderliche Beschreibung dessen, was gesendet werden soll.
HttpResponse — das Ergebnis einschließlich Status, Headern und Body.

Einen HttpClient erstellen

Sie erstellen einen Client mit der statischen Methode newBuilder(). Ein einzelner Client kann für viele Anfragen wiederverwendet werden und ist thread-sicher.

Hier konfigurieren Sie HTTP/2 und ein Zeitlimit für den Verbindungsaufbau. Für eine schnelle Standardinstanz steht auch newHttpClient() zur Verfügung.

import java.net.http.HttpClient;
import java.time.Duration;

public class Main {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(10))
            .build();
        System.out.println("Client version: " + client.version());
    }
}

Eine Anfrage erstellen

HttpRequest ist unveränderlich und wird mit einem Fluent-Builder erstellt. Sie geben mindestens eine URI an; standardmäßig wird eine GET-Anfrage ausgeführt.

Mit URI.create(...) wandeln Sie eine Zeichenkette in eine URI um.

import java.net.URI;
import java.net.http.HttpRequest;

public class Main {
    public static void main(String[] args) {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/data"))
            .GET()
            .build();
        System.out.println("Method: " + request.method());
        System.out.println("URI: " + request.uri());
    }
}

Synchron senden

Die Methode send blockiert den aufrufenden Thread, bis die Antwort eintrifft. Sie benötigt einen BodyHandler, der dem Client mitteilt, wie der Antwort-Body interpretiert werden soll.

BodyHandlers.ofString() liest den Body in einen String ein.

import java.net.URI;
import java.net.http.*;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com"))
            .build();
        HttpResponse<String> response =
            client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Status: " + response.statusCode());
    }
}

Den Statuscode lesen

Die Antwort stellt statusCode() als int bereit. Codes im Bereich 2xx bedeuten Erfolg, 3xx sind Weiterleitungen, 4xx sind Clientfehler und 5xx sind Serverfehler.

Hinweis: Der HTTP-Client löst bei einer 4xx- oder 5xx-Antwort niemals eine Exception aus — Sie müssen den Code selbst prüfen.

public class Main {
    public static void main(String[] args) {
        int status = 404;
        String label;
        if (status >= 200 && status < 300) label = "Success";
        else if (status >= 300 && status < 400) label = "Redirect";
        else if (status >= 400 && status < 500) label = "Client error";
        else label = "Server error";
        System.out.println(status + " -> " + label);
    }
}

Den Body lesen

Mit BodyHandlers.ofString() gibt response.body() einen String zurück. Es gibt auch andere Handler für Bytes, Dateien und Streams (diese werden später behandelt).

Dieses Snippet simuliert den Body-Inhalt, den Sie erhalten würden.

public class Main {
    public static void main(String[] args) {
        String body = "{\"message\":\"hello\"}";
        System.out.println("Body length: " + body.length());
        System.out.println("Body: " + body);
    }
}

Weiterleitungen behandeln

Standardmäßig folgt der Client keinen Weiterleitungen. Sie konfigurieren dies mit followRedirects(...) am Builder.

Die Optionen in HttpClient.Redirect sind NEVER, ALWAYS und NORMAL (folgt Weiterleitungen, außer bei einer Herabstufung von HTTPS auf HTTP).

import java.net.http.HttpClient;

public class Main {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newBuilder()
            .followRedirects(HttpClient.Redirect.NORMAL)
            .build();
        System.out.println("Redirect policy: " + client.followRedirects());
    }
}

Timeouts pro Anfrage

Das Verbindungs-Timeout wird am Client festgelegt. Ein Anfrage-Timeout (wie lange auf eine Antwort gewartet wird) wird über timeout(...) an der Anfrage festgelegt.

Wenn es abläuft, löst send eine HttpTimeoutException aus.

import java.net.URI;
import java.net.http.HttpRequest;
import java.time.Duration;

public class Main {
    public static void main(String[] args) {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com"))
            .timeout(Duration.ofSeconds(5))
            .build();
        System.out.println("Timeout set: " + request.timeout().isPresent());
    }
}

Antwort-Header untersuchen

Die Antwort enthält ein HttpHeaders-Objekt, auf das Sie über headers() zugreifen. Die Suche nach Headern unterscheidet nicht zwischen Groß- und Kleinschreibung und kann mehrere Werte liefern. Deshalb gibt firstValue(...) ein Optional<String> zurück.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        // Simulating a header lookup result
        Optional<String> contentType = Optional.of("application/json");
        System.out.println("Content-Type: " + contentType.orElse("unknown"));
    }
}

Geprüfte Exceptions

Das synchrone send deklariert zwei geprüfte Exceptions:

IOException — Netzwerk- oder Protokollfehler.
InterruptedException — der blockierte Thread wurde unterbrochen.

Sie müssen beide abfangen oder deklarieren. Asynchrone Aufrufe (in der nächsten Lektion) umgehen dies, indem sie ein Future zurückgeben.

import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try {
            // client.send(...) would go here
            throw new IOException("connection refused");
        } catch (IOException e) {
            System.out.println("Network problem: " + e.getMessage());
        }
    }
}

Ein wiederverwendbarer Client

Bewährte Praxis: Erstellen Sie einen HttpClient und verwenden Sie ihn in der gesamten Anwendung wieder. Er verwaltet einen Verbindungspool und ist vollständig thread-sicher.

Für jede Anfrage einen neuen Client zu erstellen, verschwendet Ressourcen und verhindert die Multiplexing-Funktion von HTTP/2.

import java.net.http.HttpClient;

public class Main {
    private static final HttpClient SHARED = HttpClient.newHttpClient();

    public static void main(String[] args) {
        System.out.println("Shared client ready: " + (SHARED != null));
    }
}

Kurztest

Testen Sie Ihr Verständnis des synchronen HTTP-Clients.

Zusammenfassung

Sie haben die Grundlagen des JDK-HTTP-Clients gelernt:

HttpClient.newBuilder() konfiguriert Version, Timeout und Weiterleitungen; verwenden Sie eine Instanz wieder.
HttpRequest.newBuilder().uri(...).GET() erstellt eine unveränderliche Anfrage.
client.send(request, BodyHandlers.ofString()) blockiert und gibt ein HttpResponse<String> zurück.
Lesen Sie die Ergebnisse mit statusCode(), body() und headers().
Nicht-2xx-Codes lösen keine Exception aus — prüfen Sie sie selbst.

Häufig gestellte Fragen

Ist die Lektion „java.net.http.HttpClient“ kostenlos?

Ja — der vollständige Text von „java.net.http.HttpClient“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „java.net.http.HttpClient“?

Synchrone Anfragen senden Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „java.net.http.HttpClient“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy