Java Academy · Les

java.net.http.HttpClient

Synchrone verzoeken versturen

Les 1 van 413 stappen

java.net.http.HttpClient is een gratis Java Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.

De moderne HTTP-client

Sinds Java 11 levert de JDK een moderne HTTP-client in het pakket java.net.http. Deze vervangt de oude HttpURLConnection door een heldere, vloeiende API die HTTP/1.1 en HTTP/2 ondersteunt.

De drie belangrijkste typen zijn:

HttpClient — verstuurt verzoeken en beheert de configuratie (time-outs, proxy's en omleidingen).
HttpRequest — een onveranderlijke beschrijving van wat je wilt versturen.
HttpResponse — het resultaat, inclusief status, headers en hoofdtekst.

Een HttpClient maken

Je bouwt een client met de statische methode newBuilder(). Eén client kan voor veel verzoeken worden hergebruikt en is threadveilig.

Hier configureren we HTTP/2 en een time-out voor het maken van de verbinding. newHttpClient() is ook beschikbaar voor snel gebruik met een standaardinstantie.

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

Een aanvraag opbouwen

HttpRequest is onveranderlijk en wordt opgebouwd met een builder met ketenbare aanroepen. Je geeft minimaal een URI op; standaard voert de client een GET uit.

Je zet een tekenreeks om in een URI met 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());
    }
}

Synchroon verzenden

De methode send blokkeert de aanroepende thread totdat het antwoord binnenkomt. De methode heeft een BodyHandler nodig die de client vertelt hoe de antwoordinhoud moet worden geïnterpreteerd.

BodyHandlers.ofString() leest de inhoud in een 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());
    }
}

De statuscode lezen

Het antwoord biedt statusCode() als een int. Codes in het bereik 2xx betekenen succes, 3xx zijn omleidingen, 4xx zijn fouten aan clientzijde en 5xx zijn serverfouten.

Let op: de HTTP-client genereert nooit een uitzondering bij een antwoord met 4xx/5xx — je moet de code zelf controleren.

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

De inhoud lezen

Met BodyHandlers.ofString() geeft response.body() een String terug. Er bestaan ook andere verwerkers voor bytes, bestanden en gegevensstromen (die later aan bod komen).

Dit fragment simuleert de inhoud die je zou ontvangen.

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

Omleidingen verwerken

Standaard volgt de client geen omleidingen. Je stelt dit in op de builder met followRedirects(...).

De opties in HttpClient.Redirect zijn NEVER, ALWAYS en NORMAL (volgt omleidingen, behalve overgangen van HTTPS naar 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());
    }
}

Time-outs per aanvraag

De verbindingstime-out staat op de client. Een aanvraag-time-out (hoe lang je op een antwoord wacht) staat via timeout(...) op de aanvraag.

Als deze verloopt, genereert send een 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());
    }
}

Antwoordkopteksten bekijken

Het antwoord bevat een object van het type HttpHeaders, dat toegankelijk is via headers(). Bij het opzoeken van kopteksten wordt geen onderscheid gemaakt tussen hoofdletters en kleine letters, en er kunnen meerdere waarden worden teruggegeven. Daarom geeft firstValue(...) een Optional<String> terug.

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

Gecontroleerde uitzonderingen

De synchrone methode send declareert twee gecontroleerde uitzonderingen:

IOException — netwerk- of protocolfout.
InterruptedException — de geblokkeerde thread is onderbroken.

Je moet beide afvangen of declareren. Asynchrone aanroepen (in de volgende les) vermijden dit door een toekomstige waarde terug te geven.

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

Een herbruikbare client

Best practice: maak één HttpClient en gebruik die opnieuw in de hele toepassing. De client gebruikt een verbindingspool en is volledig threadveilig.

Voor elke aanvraag een nieuwe client maken verspilt bronnen en maakt HTTP/2-multiplexing ongedaan.

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

Korte toets

Toets je begrip van de synchrone HTTP-client.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt de basis van de JDK HTTP-client geleerd:

HttpClient.newBuilder() stelt versie, time-out en omleidingen in; gebruik één instantie opnieuw.
HttpRequest.newBuilder().uri(...).GET() bouwt een onveranderlijke aanvraag.
client.send(request, BodyHandlers.ofString()) blokkeert en geeft een HttpResponse<String> terug.
Lees resultaten met statusCode(), body() en headers().
Niet-2xx-codes genereren geen uitzondering — controleer ze zelf.

Gratis beginnen

Leer Java met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 104
Lessen: 374

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “java.net.http.HttpClient” gratis?

Ja — de volledige tekst van “java.net.http.HttpClient” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.

Wat leer ik in “java.net.http.HttpClient”?

Synchrone verzoeken versturen Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Java Academy te beginnen?

Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “java.net.http.HttpClient”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Java Academy?

Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Java Academy