0Pricing
Java Academy · Lezione

Gestione degli errori e pipeline HTTP asincrona

Gestisca gli errori con exceptionally, handle e whenComplete, quindi costruisca una pipeline asincrona per un client HTTP.

Gestione degli errori e pipeline HTTP asincrona è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Perché è importante gestire gli errori asincroni

Nelle pipeline asincrone, le eccezioni non si propagano nello stesso modo del codice sincrono. Deve gestire esplicitamente gli errori utilizzando exceptionally, handle o whenComplete.

exceptionally: Recupero dagli errori

exceptionally(Function<Throwable, T>) viene chiamato solo se il future termina con un'eccezione. Fornisce un valore di fallback, mantenendo attiva la pipeline.

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: Trasformare successo e fallimento

handle(BiFunction<T, Throwable, U>) viene chiamato sia in caso di successo sia di errore. Uno dei due argomenti sarà null.

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

whenComplete: Effetto collaterale dopo qualsiasi esito

whenComplete(BiConsumer) viene chiamato al termine, indipendentemente dall'esito. Non modifica il risultato: lo utilizzi per il logging, le metriche o la pulizia.

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

Nuovi tentativi per i future falliti

Implementi la logica dei nuovi tentativi richiamando ricorsivamente l'operazione in caso di errore, fino a raggiungere il numero massimo di tentativi.

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

Java 11 HttpClient: GET asincrono

HttpClient di Java 11 fornisce HTTP completamente asincrono tramite sendAsync(), restituendo 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);

Concatenare più chiamate HTTP

Utilizzi thenCompose per concatenare chiamate HTTP dipendenti: prima recuperi l'utente, quindi utilizzi l'ID dell'utente per recuperare i relativi ordini.

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

Chiamate HTTP parallele con allOf

Invii richieste a diversi endpoint in parallelo, quindi raccolga tutte le risposte quando sono state completate.

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

Timeout nelle chiamate HTTP

Applichi orTimeout direttamente alla chiamata HTTP asincrona per annullarla se il server impiega troppo tempo.

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

Convalida del codice di stato nella pipeline

Utilizzi thenApply per verificare il codice di stato HTTP e lanciare un'eccezione di dominio se indica un errore, mantenendo coerente la gestione degli errori nella pipeline.

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

Combinare recupero dagli errori e logging

Inserisca whenComplete per il logging e exceptionally per il recupero nella stessa pipeline: i due componenti si combinano senza problemi.

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

Verifica rapida

Quale metodo di CompletableFuture viene chiamato SOLO quando il future fallisce?

Riepilogo

Utilizzi exceptionally per i valori di fallback, handle per trasformare entrambi gli esiti e whenComplete per gli effetti collaterali. Costruisca pipeline HTTP asincrone con Java 11 HttpClient + thenCompose + allOf.

Domande Frequenti

La lezione «Gestione degli errori e pipeline HTTP asincrona» è gratuita?

Sì — il testo completo di «Gestione degli errori e pipeline HTTP asincrona» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Gestione degli errori e pipeline HTTP asincrona»?

Gestisca gli errori con exceptionally, handle e whenComplete, quindi costruisca una pipeline asincrona per un client HTTP. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Gestione degli errori e pipeline HTTP asincrona»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Creazione e completamento di CompletableFuture
  2. Concatenare con thenApply e thenCompose
  3. Combinare i future: allOf e anyOf
  4. Gestione degli errori e pipeline HTTP asincrona
← Torna a Java Academy