Java Academy · Lektion

Asynkrona förfrågningar

sendAsync och CompletableFuture.

Lektion 2 av 413 steg

Asynkrona förfrågningar är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 2 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.

Asynkrona begäranden

Att blockera vid varje HTTP-anrop slösar med trådar. JDK:s HTTP-klient erbjuder sendAsync, som omedelbart returnerar en CompletableFuture och utför arbetet i en executor i bakgrunden.

Det gör det möjligt att skicka många begäranden samtidigt och kombinera deras resultat utan att hantera trådar manuellt.

send jämfört med sendAsync

Signaturerna skiljer sig åt i vad de returnerar:

send returnerar HttpResponse<T> och blockerar samt deklarerar IOException och InterruptedException.
sendAsync returnerar CompletableFuture<HttpResponse<T>> och blockerar aldrig; fel blir tillgängliga via future-objektet.

Ett grundläggande sendAsync-anrop

sendAsync tar samma begäran och BodyHandler som send. Den returnerade future:n slutförs när svaret är klart.

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

Transformera med thenApply

Använd thenApply för att transformera resultatet när det anländer — till exempel för att hämta svarskroppen.

Detta körs synkront på den tråd som slutförde föregående steg.

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

Konsumera med thenAccept

När ni bara vill utföra en bieffekt och inte behöver något returvärde använder ni thenAccept. Den tar emot en Consumer och ger en CompletableFuture<Void>.

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

Blockera med join

Om ni vill vänta på ett asynkront resultat från main kan ni anropa join() (okontrollerat) eller get() (kontrollerat). På en riktig server skulle ni kedja steg i stället för att blockera.

join() omsluter fel i ett okontrollerat 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);
    }
}

Hantera fel med exceptionally

exceptionally tillhandahåller ett reservvärde när ett steg misslyckas och återställer därmed pipelinen.

På så sätt kan ett asynkront HTTP-flöde fortsätta även efter ett nätverksfel.

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

Kombinera två begäranden

thenCombine väntar på två oberoende futures och sammanfogar deras resultat. Med asynkron HTTP hämtar detta två endpoints parallellt och sammanfogar svarskropparna.

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

Starta många parallellt

Om ni vill köra en grupp begäranden samlar ni varje future i en lista och använder sedan CompletableFuture.allOf(...) för att vänta på alla.

allOf returnerar CompletableFuture<Void>; läs de enskilda resultaten efteråt.

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

Sammanfattning av det asynkrona mönstret

En typisk asynkron HTTP-pipeline ser ut så här:

client.sendAsync(req, BodyHandlers.ofString())
.thenApply(HttpResponse::body) för att hämta svarskroppen
.thenAccept(System.out::println) för att konsumera den
.exceptionally(ex -> ...) för att återhämta sig

Ingen tråd blockeras någonsin i väntan på nätverket.

När bör ni använda async

Välj sendAsync när ni gör många samtidiga anrop, skickar anrop till flera tjänster eller kör i en reaktiv/icke-blockerande server. Välj send för enkla skript och enstaka anrop där det går bra att blockera.

Snabbkontroll

Kontrollera er förståelse av asynkrona begäranden.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er att göra icke-blockerande HTTP-anrop:

sendAsync returnerar en CompletableFuture i stället för att blockera.
thenApply / thenAccept transformerar och konsumerar resultatet.
exceptionally tillhandahåller ett reservvärde vid fel.
thenCombine sammanfogar två parallella anrop; allOf väntar på en grupp.
Asynkronitet passar samtidiga och reaktiva servrar med hög belastning; synkrona anrop passar enkla skript.

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 ”Asynkrona förfrågningar” gratis?

Ja – hela texten till ”Asynkrona förfrågningar” 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 ”Asynkrona förfrågningar”?

sendAsync och CompletableFuture. 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 2 av 4.

Hur lång tid tar lektionen ”Asynkrona förfrågningar”?

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