Java Academy · Lektion

java.net.http.HttpClient

Skicka synkrona förfrågningar.

Lektion 1 av 413 steg

java.net.http.HttpClient är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 1 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.

Den moderna HTTP-klienten

Sedan Java 11 levererar JDK en modern HTTP-klient i paketet java.net.http. Den ersätter den äldre HttpURLConnection med ett rent, fluent API som stöder HTTP/1.1 och HTTP/2.

De tre centrala typerna är:

HttpClient — skickar begäranden och hanterar konfiguration (tidsgränser, proxyservrar och omdirigeringar).
HttpRequest — en oföränderlig beskrivning av det som ska skickas.
HttpResponse — resultatet, inklusive status, headers och body.

Skapa en HttpClient

Du bygger en klient med den statiska metoden newBuilder(). En enda klient kan återanvändas för många begäranden och är trådsäker.

Här konfigurerar vi HTTP/2 och en anslutningstidsgräns. newHttpClient() finns också för att snabbt skapa en instans med standardinställningar.

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

Skapa en begäran

HttpRequest är oföränderlig och byggs med en fluent builder. Som minst anger ni en URI; som standard utförs en GET-begäran.

Ni omvandlar en sträng till en URI med URI.create(...).

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

Skicka synkront

Metoden send blockerar den anropande tråden tills svaret anländer. Den behöver en BodyHandler som anger för klienten hur svarskroppen ska tolkas.

BodyHandlers.ofString() läser in kroppen i en 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 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());
    }
}

Läsa statuskoden

I svaret finns statusCode() som en int. Koder i intervallet 2xx betyder att anropet lyckades, 3xx är omdirigeringar, 4xx är klientfel och 5xx är serverfel.

Obs: HTTP-klienten kastar aldrig ett undantag för ett 4xx-/5xx-svar — ni måste själv kontrollera koden.

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

Läsa svarskroppen

Med BodyHandlers.ofString() returnerar response.body() en String. Det finns även andra hanterare för bytearrayer, filer och strömmar, vilket behandlas senare.

Det här kodexemplet simulerar det innehåll i svarskroppen som ni skulle ta emot.

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

Hantera omdirigeringar

Som standard följer klienten inte omdirigeringar. Konfigurera detta på buildern med followRedirects(...).

Alternativen i HttpClient.Redirect är NEVER, ALWAYS och NORMAL (följ omdirigeringar utom vid nedgradering från HTTPS till 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());
    }
}

Tidsgränser per begäran

Anslutningens tidsgräns finns på klienten. En begärans tidsgräns, alltså hur länge man väntar på ett svar, finns på begäran via timeout(...).

Om tidsgränsen överskrids kastar send ett HttpTimeoutException.

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

Inspektera svarshuvuden

Svaret innehåller ett HttpHeaders-objekt som är åtkomligt via headers(). Sökningar efter headers är inte skiftlägeskänsliga och kan returnera flera värden, så firstValue(...) returnerar en Optional<String>.

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

Kontrollerade undantag

Det synkrona send deklarerar två kontrollerade undantag:

IOException — nätverks- eller protokollfel.
InterruptedException — den blockerade tråden avbröts.

Ni måste fånga eller deklarera båda. Asynkrona anrop, som behandlas i nästa lektion, undviker detta genom att returnera en future.

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

En återanvändbar klient

Bästa praxis är att skapa en enda HttpClient och återanvända den i hela applikationen. Den använder en anslutningspool och är helt trådsäker.

Att skapa en ny klient för varje begäran slösar med resurser och omöjliggör HTTP/2-multiplexering.

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

Snabbkontroll

Kontrollera er förståelse av den synkrona HTTP-klienten.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er grunderna i JDK:s HTTP-klient:

HttpClient.newBuilder() konfigurerar version, tidsgräns och omdirigeringar; återanvänd en enda instans.
HttpRequest.newBuilder().uri(...).GET() bygger en oföränderlig begäran.
client.send(request, BodyHandlers.ofString()) blockerar och returnerar en HttpResponse<String>.
Läs resultaten med statusCode(), body() och headers().
Koder som inte är 2xx kastar inget undantag — kontrollera dem själv.

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 ”java.net.http.HttpClient” gratis?

Ja – hela texten till ”java.net.http.HttpClient” 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 ”java.net.http.HttpClient”?

Skicka synkrona förfrågningar. 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 1 av 4.

Hur lång tid tar lektionen ”java.net.http.HttpClient”?

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