0Pricing
Java Academy · Leçon

Gestion des erreurs et flux HTTP asynchrone

Gérez les erreurs avec exceptionally, handle et whenComplete, puis créez un flux de traitement client HTTP asynchrone.

Gestion des erreurs et flux HTTP asynchrone est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Pourquoi la gestion des erreurs asynchrones est importante

Dans les pipelines asynchrones, les exceptions ne se propagent pas de la même manière que dans le code synchrone. Vous devez gérer explicitement les erreurs à l'aide de exceptionally, handle ou whenComplete.

exceptionally : récupérer après les erreurs

exceptionally(Function<Throwable, T>) n’est appelé que si l’opération asynchrone se termine par une exception. Il fournit une valeur de repli, ce qui maintient la chaîne de traitement active.

CompletableFuture<String> safe = fetchUser(id)
    .thenApply(User::getName)
    .exceptionally(ex -> {
        log.warn("Fetch failed: " + ex.getMessage());
        return "Anonymous";
    });
System.out.println(safe.join()); // "Anonymous" if fetch failed

handle : transformer la réussite et l’échec

handle(BiFunction<T, Throwable, U>) est appelé en cas de réussite comme d’échec. L’un des deux arguments sera null.

fetchUser(id).handle((user, ex) -> {
    if (ex != null) return UserDto.empty();
    return UserDto.from(user);
}).thenAccept(dto -> sendResponse(dto));

whenComplete : effet secondaire après tout résultat

whenComplete(BiConsumer) est appelé une fois l’opération terminée, quelle qu’en soit l’issue. Il ne modifie pas le résultat — utilisez-le pour la journalisation, les métriques ou le nettoyage.

fetchUser(id)
    .whenComplete((user, ex) -> {
        if (ex != null) metrics.increment("user.fetch.error");
        else            metrics.increment("user.fetch.success");
    })
    .thenAccept(u -> sendResponse(u));

Réessayer les opérations asynchrones en échec

Implémentez la logique de nouvelle tentative en rappelant récursivement l’opération en cas d’échec, jusqu’à atteindre un nombre maximal de tentatives.

CompletableFuture<String> withRetry(Supplier<CompletableFuture<String>> task, int retries) {
    return task.get().exceptionallyCompose(ex -> {
        if (retries > 0) {
            System.out.println("Retrying... " + retries);
            return withRetry(task, retries - 1);
        }
        return CompletableFuture.failedFuture(ex);
    });
}

HttpClient Java 11 : GET asynchrone

Le HttpClient de Java 11 fournit des requêtes HTTP entièrement asynchrones via sendAsync(), en renvoyant un CompletableFuture<HttpResponse<String>>.

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/users/1"))
    .build();
CompletableFuture<String> body = client
    .sendAsync(req, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body);

Enchaîner plusieurs appels HTTP

Utilisez thenCompose pour enchaîner des appels HTTP dépendants : récupérez d’abord l’utilisateur, puis utilisez son identifiant pour récupérer ses commandes.

client.sendAsync(userReq, HttpResponse.BodyHandlers.ofString())
    .thenApply(r -> parseUser(r.body()))
    .thenCompose(user -> client.sendAsync(
        buildOrdersRequest(user.getId()),
        HttpResponse.BodyHandlers.ofString()))
    .thenApply(r -> parseOrders(r.body()))
    .thenAccept(orders -> System.out.println("Orders: " + orders.size()));

Appels HTTP parallèles avec allOf

Lancez plusieurs requêtes vers des points de terminaison en parallèle, puis rassemblez toutes les réponses lorsqu’elles sont terminées.

List<URI> endpoints = List.of(uri1, uri2, uri3);
List<CompletableFuture<String>> requests = endpoints.stream()
    .map(uri -> client.sendAsync(
            HttpRequest.newBuilder(uri).build(),
            HttpResponse.BodyHandlers.ofString())
        .thenApply(HttpResponse::body))
    .collect(Collectors.toList());
List<String> responses = CompletableFuture
    .allOf(requests.toArray(new CompletableFuture[0]))
    .thenApply(v -> requests.stream().map(CompletableFuture::join).collect(Collectors.toList()))
    .join();

Délai d’expiration des appels HTTP

Appliquez orTimeout directement à l’appel HTTP asynchrone pour l’annuler si le serveur met trop de temps à répondre.

CompletableFuture<String> result = client
    .sendAsync(req, HttpResponse.BodyHandlers.ofString())
    .orTimeout(5, TimeUnit.SECONDS)
    .thenApply(HttpResponse::body)
    .exceptionally(ex -> "timeout or error");

Validation du code d’état dans la chaîne de traitement

Utilisez thenApply pour vérifier le code d’état HTTP et lever une exception métier s’il indique une erreur, afin de conserver une gestion cohérente des erreurs dans la chaîne de traitement.

.thenApply(response -> {
    if (response.statusCode() != 200)
        throw new HttpResponseException(response.statusCode());
    return response.body();
})

Combiner récupération après erreur et journalisation

Ajoutez whenComplete pour la journalisation et exceptionally pour la récupération dans la même chaîne de traitement — ils se composent naturellement.

fetchData()
    .whenComplete((r, ex) -> { if (ex != null) log.error("Failed", ex); })
    .exceptionally(ex -> fallback())
    .thenAccept(result -> process(result));

Vérification rapide

Quelle méthode de CompletableFuture est appelée ONLY lorsque l’opération asynchrone échoue ?

Récapitulatif

Utilisez exceptionally pour les valeurs de repli, handle pour transformer les deux résultats possibles et whenComplete pour les effets secondaires. Construisez des chaînes de traitement HTTP asynchrones avec le HttpClient Java 11, thenCompose et allOf.

Questions Fréquemment Posées

La leçon « Gestion des erreurs et flux HTTP asynchrone » est-elle gratuite ?

Oui — le texte complet de « Gestion des erreurs et flux HTTP asynchrone » 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 « Gestion des erreurs et flux HTTP asynchrone » ?

Gérez les erreurs avec exceptionally, handle et whenComplete, puis créez un flux de traitement client HTTP asynchrone. 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 4 sur 4.

Combien de temps prend la leçon « Gestion des erreurs et flux HTTP asynchrone » ?

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

  1. Créer et terminer des CompletableFutures
  2. Enchaînement avec thenApply et thenCompose
  3. Combiner des futures : allOf et anyOf
  4. Gestion des erreurs et flux HTTP asynchrone
← Retour à Java Academy