Java Academy · Lektion

Förfrågningskroppar och headers

Skicka POST-data och ange headers.

Lektion 3 av 413 steg

Förfrågningskroppar och headers är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Begärandekroppar och headers

GET-begäranden behöver sällan en kropp, men POST, PUT och PATCH behöver det. JDK:s HTTP-klient använder objekt av typen BodyPublisher för att tillhandahålla begärandekroppar samt builder-metoder för att ange headers.

I den här lektionen går ni igenom hur data skickas och hur headers som Content-Type styrs.

BodyPublishers.ofString

Den enklaste publishern skickar en sträng som begärandekropp. Skicka den till metoden POST(...) på request-buildern.

BodyPublishers.noBody() finns för begäranden utan kropp.

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());
    }
}

Ange en header

Använd header(name, value) för att lägga till en header. När ni skickar JSON anger ni nästan alltid 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());
    }
}

Flera headers samtidigt

headers(name1, value1, name2, value2, ...) anger flera headers i ett enda anrop. Antalet argument måste vara jämnt, annars kastas IllegalArgumentException.

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-headers

Bearer-token skickas via headern Authorization. Skapa värdet som en sträng och logga aldrig token i 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 och DELETE

Buildern har särskilda metoder: PUT(publisher), DELETE() och den generiska method(name, publisher) för allt annat, till exempel 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());
    }
}

Formkodade begärandekroppar

För data av typen application/x-www-form-urlencoded bygger ni strängen för begärandekroppen manuellt, URL-kodar varje värde och skickar sedan strängen som en publisher.

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);
    }
}

Skicka en fil som begärandekropp

BodyPublishers.ofFile(path) strömmar en fil som begärandekropp utan att läsa in hela filen i minnet — idealiskt för uppladdningar.

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");
    }
}

Begärandekroppar som bytearrayer

När ni redan har byte i minnet skickar BodyPublishers.ofByteArray(byte[]) dem direkt. Det är användbart för binär nyttolast som skapas under körning.

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");
    }
}

Begränsade headers

Av säkerhetsskäl förbjuder klienten er att ange vissa headers, till exempel Host, Content-Length, Connection och Upgrade. Om ni försöker ange dem kastas IllegalArgumentException — klienten hanterar dem själv.

Sätta ihop allt

En typisk JSON-POST kombinerar en body-publisher med en header för innehållstyp:

.POST(BodyPublishers.ofString(json))
.header("Content-Type", "application/json")
lägg till .header("Authorization", "Bearer ...") om det behövs

Snabbkontroll

Kontrollera er förståelse av begärandekroppar och headers.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er att skicka data och styra headers:

BodyPublishers.ofString / ofByteArray / ofFile tillhandahåller begärandekroppar.
POST / PUT / DELETE / method(...) väljer HTTP-metoden.
header(...) och headers(...) anger headers för begäran.
Ange Content-Type för JSON och formulärdata; använd Authorization för token.
Vissa headers (Host, Content-Length) är begränsade och hanteras av klienten.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Förfrågningskroppar och headers” gratis?

Ja – hela texten till ”Förfrågningskroppar och headers” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Förfrågningskroppar och headers”?

Skicka POST-data och ange headers. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Förfrågningskroppar och headers”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Java Academy