Java Academy · Les

Asynchrone verzoeken

sendAsync en CompletableFuture

Les 2 van 413 stappen

Asynchrone verzoeken is een gratis Java Academy-les op CoddyKit. Dit is les 2 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.

Asynchrone aanvragen

Bij elke HTTP-aanroep blokkeren verspilt threads. De JDK HTTP-client biedt sendAsync, dat onmiddellijk een CompletableFuture teruggeeft en het werk uitvoert met een achtergronduitvoerder.

Zo kun je veel aanvragen gelijktijdig uitvoeren en hun resultaten combineren zonder threads handmatig te beheren.

send versus sendAsync

De handtekeningen verschillen in wat ze teruggeven:

send geeft HttpResponse<T> terug en blokkeert, waarbij IOException en InterruptedException worden gedeclareerd.
sendAsync geeft CompletableFuture<HttpResponse<T>> terug en blokkeert nooit; fouten worden zichtbaar via de toekomstige waarde.

Een eenvoudige sendAsync-aanroep

sendAsync gebruikt dezelfde aanvraag en dezelfde BodyHandler als send. De teruggegeven toekomstige waarde wordt voltooid zodra het antwoord gereed is.

import java.net.URI;
import java.net.http.*;
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com"))
            .build();
        CompletableFuture<HttpResponse<String>> future =
            client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Request sent, future created");
    }
}

Transformeren met thenApply

Gebruik thenApply om het resultaat om te zetten zodra het binnenkomt — bijvoorbeeld door de inhoud uit het antwoord te halen.

Dit gebeurt synchroon in de thread die de vorige fase heeft voltooid.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) throws Exception {
        CompletableFuture<String> future =
            CompletableFuture.completedFuture("OK 200")
                .thenApply(body -> "Length=" + body.length());
        System.out.println(future.get());
    }
}

Verwerken met thenAccept

Als je alleen een neveneffect wilt en geen retourwaarde nodig hebt, gebruik je thenAccept. Deze methode gebruikt een Consumer en levert een CompletableFuture<Void> op.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) throws Exception {
        CompletableFuture<Void> done =
            CompletableFuture.completedFuture("payload")
                .thenAccept(b -> System.out.println("Received: " + b));
        done.get();
    }
}

Blokkeren met join

Als je vanuit main op een asynchroon resultaat wilt wachten, roep je join() (ongecontroleerd) of get() (gecontroleerd) aan. In een echte server zou je fasen aan elkaar koppelen in plaats van te blokkeren.

join() verpakt fouten in een ongecontroleerde CompletionException.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<Integer> f =
            CompletableFuture.supplyAsync(() -> 21).thenApply(n -> n * 2);
        int result = f.join();
        System.out.println("Result: " + result);
    }
}

Fouten verwerken met exceptionally

exceptionally levert een terugvalwaarde wanneer een fase mislukt en herstelt zo de verwerkingsketen.

Zo voorkom je dat een asynchrone HTTP-stroom stopt door een netwerkfout.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> f = CompletableFuture
            .<String>supplyAsync(() -> { throw new RuntimeException("boom"); })
            .exceptionally(ex -> "fallback: " + ex.getMessage());
        System.out.println(f.join());
    }
}

Twee aanvragen combineren

thenCombine wacht op twee onafhankelijke toekomstige resultaten en voegt die samen. Met asynchrone HTTP-aanroepen haalt dit twee eindpunten parallel op en voegt het de inhoud samen.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> "Hello");
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> "World");
        String combined = a.thenCombine(b, (x, y) -> x + " " + y).join();
        System.out.println(combined);
    }
}

Veel aanvragen parallel uitvoeren

Als je een reeks aanvragen wilt uitvoeren, verzamel je elke toekomstige waarde in een lijst en gebruik je vervolgens CompletableFuture.allOf(...) om op alle aanvragen te wachten.

allOf geeft CompletableFuture<Void> terug; daarna lees je de afzonderlijke resultaten.

import java.util.*;
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        List<CompletableFuture<Integer>> futures = new ArrayList<>();
        for (int i = 1; i <= 3; i++) {
            int n = i;
            futures.add(CompletableFuture.supplyAsync(() -> n * n));
        }
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
        for (var f : futures) System.out.println(f.join());
    }
}

Samenvatting van het asynchrone patroon

Een gebruikelijke asynchrone HTTP-verwerkingsketen ziet er zo uit:

client.sendAsync(req, BodyHandlers.ofString())
.thenApply(HttpResponse::body) om de inhoud te verkrijgen
.thenAccept(System.out::println) om deze te verwerken
.exceptionally(ex -> ...) om te herstellen

Geen enkele thread wordt ooit geblokkeerd terwijl op het netwerk wordt gewacht.

Wanneer je asynchroon werkt

Kies sendAsync wanneer je veel gelijktijdige aanroepen doet, meerdere diensten parallel benadert of binnen een reactieve/niet-blokkerende server werkt. Kies send voor eenvoudige scripts en eenmalige aanroepen waarbij blokkeren geen probleem is.

Korte toets

Toets je begrip van asynchrone aanvragen.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt geleerd hoe je niet-blokkerende HTTP-aanroepen doet:

sendAsync geeft een CompletableFuture terug in plaats van te blokkeren.
thenApply / thenAccept zetten het resultaat om en verwerken het.
exceptionally levert bij een fout een terugvalwaarde.
thenCombine voegt twee parallelle aanroepen samen; allOf wacht op een reeks.
Asynchrone aanroepen passen bij servers met veel gelijktijdigheid en reactieve servers; synchrone aanroepen passen bij eenvoudige scripts.

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 “Asynchrone verzoeken” gratis?

Ja — de volledige tekst van “Asynchrone verzoeken” 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 “Asynchrone verzoeken”?

sendAsync en CompletableFuture 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 2 van 4.

Hoe lang duurt de les “Asynchrone verzoeken”?

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