Java Academy · Lektion

Antworten verarbeiten

BodyHandlers und Statuscodes

Antworten verarbeiten ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Antworten behandeln

Jeder Aufruf des HTTP-Clients gibt ein HttpResponse<T> zurück. Der generische Typ T wird durch den übergebenen BodyHandler bestimmt. In dieser Lektion lernen Sie die verfügbaren Handler und den Umgang mit Statuscodes kennen.

Die HttpResponse-API

Wichtige Methoden von HttpResponse:

statusCode() — der Status als int.
body() — der decodierte Body vom Typ T.
headers() — Antwort-Header.
uri() — die endgültige URI (nach Weiterleitungen).
version() — HTTP/1.1 oder HTTP/2.

BodyHandlers.ofString

Der gebräuchlichste Handler decodiert den Body mithilfe des Zeichensatzes aus der Antwort in einen String; standardmäßig wird UTF-8 verwendet. Der Antworttyp ist HttpResponse<String>.

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

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

BodyHandlers.ofByteArray

Für Binärdaten wie Bilder verwenden Sie ofByteArray(). Der Body-Typ wird zu byte[], das Sie auf die Festplatte schreiben oder selbst decodieren können.

public class Main {
    public static void main(String[] args) {
        // ofByteArray() yields HttpResponse<byte[]>
        byte[] simulated = { 1, 2, 3, 4 };
        System.out.println("Bytes received: " + simulated.length);
    }
}

BodyHandlers.ofFile

ofFile(path) streamt die Antwort direkt auf die Festplatte und liefert ein HttpResponse<Path>. Dadurch wird verhindert, dass ein großer Download im Speicher gepuffert wird.

import java.net.URI;
import java.net.http.*;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/file.zip")).build();
        HttpResponse<Path> res = client.send(req,
            HttpResponse.BodyHandlers.ofFile(Path.of("out.zip")));
        System.out.println("Saved to: " + res.body());
    }
}

BodyHandlers.discarding

Wenn Sie nur der Status und die Header interessieren, verwirft discarding() den Body und erzeugt ein HttpResponse<Void>. Dadurch entfällt der Aufwand für das Puffern.

Auf Erfolg prüfen

Eine häufig verwendete Hilfsmethode prüft, ob der Status im Bereich 2xx liegt, bevor sie dem Body vertraut.

public class Main {
    static boolean isSuccess(int code) {
        return code >= 200 && code < 300;
    }
    public static void main(String[] args) {
        System.out.println(isSuccess(204));
        System.out.println(isSuccess(404));
    }
}

Auf Statuskategorien reagieren

Verwenden Sie die führende Ziffer in einer switch-Anweisung, um Ihre Logik für Erfolge, Weiterleitungen und Fehler zu verzweigen.

public class Main {
    static String classify(int code) {
        return switch (code / 100) {
            case 2 -> "Success";
            case 3 -> "Redirect";
            case 4 -> "Client error";
            case 5 -> "Server error";
            default -> "Unknown";
        };
    }
    public static void main(String[] args) {
        System.out.println(classify(503));
        System.out.println(classify(200));
    }
}

Bodys mit mapping abbilden

BodyHandlers.mapping(upstream, fn) kapselt einen anderen Handler und transformiert dessen Ergebnis. Sie können beispielsweise einen String-Body direkt innerhalb des Handlers in eine ganzzahlige Länge umwandeln.

Einen bestimmten Header lesen

Um den Wert eines Antwort-Headers zu lesen, verwenden Sie headers().firstValue(name), das ein Optional<String> zurückgibt. Für alle Werte eines mehrfach vorkommenden Headers verwenden Sie allValues(name).

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> len = Optional.of("1024");
        int contentLength = len.map(Integer::parseInt).orElse(0);
        System.out.println("Content-Length: " + contentLength);
    }
}

Den passenden Handler auswählen

ofString — Text- und JSON-APIs.
ofByteArray — kleine Binärdaten, die im Speicher gehalten werden.
ofFile — große Downloads, die auf die Festplatte gestreamt werden.
ofInputStream — den Body als Stream verarbeiten.
discarding — Anfragen, bei denen nur der Status benötigt wird.

Kurzer Test

Testen Sie Ihr Verständnis der Verarbeitung von Antworten.

Zusammenfassung

Sie haben gelernt, HTTP-Antworten zu interpretieren:

HttpResponse stellt statusCode(), body() und headers() bereit.
Der BodyHandler bestimmt den Typ des Inhalts: String, byte[], Path, Void oder einen Datenstrom.
Verwenden Sie ofFile für große Downloads, um eine hohe Speicherauslastung zu vermeiden.
Klassifizieren Sie Statuscodes anhand ihrer führenden Ziffer und prüfen Sie den Bereich 2xx auf Erfolg.
Lesen Sie Header mit firstValue / allValues aus.

Häufig gestellte Fragen

Ist die Lektion „Antworten verarbeiten“ kostenlos?

Ja — der vollständige Text von „Antworten verarbeiten“ 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 „Antworten verarbeiten“?

BodyHandlers und Statuscodes 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 4 von 4.

Wie lange dauert die Lektion „Antworten verarbeiten“?

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