Java Academy · Lektion

Request-Bodies und Header

POST-Daten senden und Header setzen

Request-Bodies und Header ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Request-Bodys und Header

GET-Anfragen benötigen selten einen Body, POST, PUT und PATCH dagegen schon. Der JDK-HTTP-Client verwendet BodyPublisher-Objekte, um Request-Bodys bereitzustellen, sowie Builder-Methoden, um Header zu setzen.

In dieser Lektion geht es darum, Daten zu senden und Header wie Content-Type zu steuern.

BodyPublishers.ofString

Der einfachste Publisher sendet einen String-Body. Übergeben Sie ihn an die Methode POST(...) des Request-Builders.

BodyPublishers.noBody() ist für Anfragen ohne Body vorgesehen.

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

public class Main {
    public static void main(String[] args) {
        String json = "{\"name\":\"Ada\"}";
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/users"))
            .POST(BodyPublishers.ofString(json))
            .build();
        System.out.println("Method: " + request.method());
    }
}

Einen einzelnen Header setzen

Verwenden Sie header(name, value), um einen Header hinzuzufügen. Beim Senden von JSON setzen Sie fast immer Content-Type.

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

public class Main {
    public static void main(String[] args) {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/users"))
            .header("Content-Type", "application/json")
            .POST(BodyPublishers.ofString("{}"))
            .build();
        System.out.println("Has Content-Type: " +
            request.headers().firstValue("Content-Type").isPresent());
    }
}

Mehrere Header gleichzeitig setzen

headers(name1, value1, name2, value2, ...) setzt mehrere Header in einem Aufruf. Die Anzahl der Argumente muss gerade sein, andernfalls wird eine IllegalArgumentException ausgelöst.

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"))
            .headers(
                "Accept", "application/json",
                "Accept-Language", "en-US")
            .GET()
            .build();
        System.out.println(request.headers().map().keySet());
    }
}

Authorization-Header

Bearer-Tokens werden über den Authorization-Header gesendet. Erstellen Sie den Wert als String und protokollieren Sie niemals das Token im Klartext.

public class Main {
    public static void main(String[] args) {
        String token = "abc123";
        String headerValue = "Bearer " + token;
        System.out.println("Authorization: Bearer ***");
        System.out.println("Length: " + headerValue.length());
    }
}

PUT und DELETE

Der Builder bietet eigene Methoden: PUT(publisher), DELETE() und die generische Methode method(name, publisher) für alles Weitere, etwa PATCH.

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

public class Main {
    public static void main(String[] args) {
        HttpRequest patch = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/users/1"))
            .method("PATCH", BodyPublishers.ofString("{\"active\":true}"))
            .build();
        System.out.println("Method: " + patch.method());
    }
}

Formularcodierte Bodys

Für Daten im Format application/x-www-form-urlencoded erstellen Sie die Body-Zeichenkette manuell, indem Sie jeden Wert URL-codieren, und veröffentlichen sie anschließend als String.

import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public class Main {
    public static void main(String[] args) {
        String body = "name=" + URLEncoder.encode("Ada Lovelace", StandardCharsets.UTF_8)
            + "&role=" + URLEncoder.encode("engineer", StandardCharsets.UTF_8);
        System.out.println(body);
    }
}

Einen Datei-Body senden

BodyPublishers.ofFile(path) streamt eine Datei als Request-Body, ohne sie vollständig in den Speicher zu laden — ideal für Uploads.

import java.net.URI;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/upload"))
            .header("Content-Type", "application/octet-stream")
            .POST(BodyPublishers.ofFile(Path.of("data.bin")))
            .build();
        System.out.println("Upload request built");
    }
}

Byte-Array-Bodys

Wenn die benötigten Bytes bereits im Speicher vorhanden sind, sendet BodyPublishers.ofByteArray(byte[]) sie direkt. Das ist nützlich für Binärdaten, die zur Laufzeit erstellt werden.

import java.nio.charset.StandardCharsets;

public class Main {
    public static void main(String[] args) {
        byte[] payload = "raw-bytes".getBytes(StandardCharsets.UTF_8);
        // BodyPublishers.ofByteArray(payload) would wrap these bytes
        System.out.println("Payload size: " + payload.length + " bytes");
    }
}

Eingeschränkte Header

Aus Sicherheitsgründen verhindert der Client, dass Sie bestimmte Header wie Host, Content-Length, Connection und Upgrade setzen. Der Versuch, sie zu setzen, löst eine IllegalArgumentException aus — der Client verwaltet diese Header selbst.

Alles zusammenfügen

Ein typischer JSON-POST kombiniert einen Body-Publisher mit einem Content-Type-Header:

.POST(BodyPublishers.ofString(json))
.header("Content-Type", "application/json")
Fügen Sie bei Bedarf .header("Authorization", "Bearer ...") hinzu.

Kurztest

Testen Sie Ihr Verständnis von Request-Bodys und Headern.

Zusammenfassung

Sie haben gelernt, Daten zu senden und Header zu steuern:

BodyPublishers.ofString / ofByteArray / ofFile stellen Request-Bodys bereit.
POST / PUT / DELETE / method(...) wählen die HTTP-Methode aus.
header(...) und headers(...) setzen Request-Header.
Setzen Sie Content-Type für JSON- und Formulardaten und verwenden Sie Authorization für Tokens.
Einige Header (Host, Content-Length) sind eingeschränkt und werden vom Client verwaltet.

Häufig gestellte Fragen

Ist die Lektion „Request-Bodies und Header“ kostenlos?

Ja — der vollständige Text von „Request-Bodies und Header“ 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 „Request-Bodies und Header“?

POST-Daten senden und Header setzen 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 3 von 4.

Wie lange dauert die Lektion „Request-Bodies und Header“?

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