Java Academy · Leçon

Requêtes asynchrones

sendAsync et CompletableFuture

Requêtes asynchrones est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Requêtes asynchrones

Bloquer à chaque appel HTTP gaspille des fils d’exécution. Le client HTTP du JDK propose sendAsync, qui renvoie immédiatement un CompletableFuture et effectue le travail dans un exécuteur en arrière-plan.

Vous pouvez ainsi lancer de nombreuses requêtes simultanément et composer leurs résultats sans gérer manuellement les fils d’exécution.

send et sendAsync

Les signatures diffèrent par leur valeur de retour :

send renvoie HttpResponse<T> et bloque, en déclarant IOException et InterruptedException.
sendAsync renvoie CompletableFuture<HttpResponse<T>> et ne bloque jamais ; les erreurs apparaissent via le futur.

Un appel sendAsync simple

sendAsync prend la même requête et le même BodyHandler que send. Le futur renvoyé se termine lorsque la réponse est prête.

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

Transformer avec thenApply

Utilisez thenApply pour transformer le résultat une fois qu’il est arrivé — par exemple, pour extraire le corps de la réponse.

Cette opération s’exécute de manière synchrone sur le fil d’exécution qui a terminé l’étape précédente.

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

Consommer avec thenAccept

Lorsque vous souhaitez uniquement produire un effet secondaire sans valeur de retour, utilisez thenAccept. Cette méthode prend un Consumer et produit un 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();
    }
}

Bloquer avec join

Pour attendre un résultat asynchrone depuis main, appelez join() (sans vérification) ou get() (avec vérification). Dans un véritable serveur, vous enchaîneriez les étapes au lieu de bloquer.

join() enveloppe les échecs dans une CompletionException non vérifiée.

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

Gérer les erreurs avec exceptionally

exceptionally fournit une valeur de remplacement lorsqu’une étape échoue, ce qui rétablit l’enchaînement.

C’est ainsi que vous empêchez un flux HTTP asynchrone de s’arrêter à cause d’une erreur réseau.

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

Combiner deux requêtes

thenCombine attend deux futurs indépendants et fusionne leurs résultats. Avec HTTP asynchrone, cela récupère deux points de terminaison en parallèle et réunit leurs corps.

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

Lancer plusieurs requêtes en parallèle

Pour exécuter un lot de requêtes, rassemblez chaque futur dans une liste, puis utilisez CompletableFuture.allOf(...) pour attendre qu’elles soient toutes terminées.

allOf renvoie un CompletableFuture<Void> ; vous lisez ensuite les résultats individuels.

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

Récapitulatif du modèle asynchrone

Un enchaînement HTTP asynchrone typique ressemble à ceci :

client.sendAsync(req, BodyHandlers.ofString())
.thenApply(HttpResponse::body) pour obtenir le corps
.thenAccept(System.out::println) pour le consommer
.exceptionally(ex -> ...) pour récupérer l’erreur

Aucun fil d’exécution n’est jamais bloqué dans l’attente du réseau.

Quand passer à l’asynchrone

Choisissez sendAsync lorsque vous effectuez de nombreux appels concurrents, répartissez les appels entre plusieurs services ou exécutez le code dans un serveur réactif et non bloquant. Choisissez send pour les scripts simples et les appels ponctuels lorsque le blocage ne pose pas de problème.

Vérification rapide

Vérifiez votre compréhension des requêtes asynchrones.

Récapitulatif

Vous avez appris à effectuer des appels HTTP non bloquants :

sendAsync renvoie un CompletableFuture au lieu de bloquer.
thenApply / thenAccept transforment et consomment le résultat.
exceptionally fournit une valeur de remplacement en cas d’échec.
thenCombine fusionne deux appels parallèles ; allOf attend un lot de requêtes.
L’asynchrone convient aux serveurs à forte concurrence et réactifs ; le synchrone convient aux scripts simples.

Questions Fréquemment Posées

La leçon « Requêtes asynchrones » est-elle gratuite ?

Oui — le texte complet de « Requêtes asynchrones » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Requêtes asynchrones » ?

sendAsync et CompletableFuture Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Requêtes asynchrones » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Java Academy