Gestione degli errori nei Future
Implementi strategie per gestire con eleganza eccezioni e fallimenti nei calcoli asincroni con `Future`.
Gestione degli errori nei Future è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 3 di 3. 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 Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 3 lezioni in totale.
Gestire gli errori dei Future
Le operazioni asincrone possono fallire! Proprio come il codice sincrono può generare eccezioni, un Future può completarsi con un errore invece che con un valore positivo.
Capire come gestire correttamente questi errori è fondamentale per creare applicazioni concorrenti robuste. Senza una gestione adeguata degli errori, il programma potrebbe arrestarsi o comportarsi in modo imprevisto.
Il risultato di Future: Try
Quando un Future viene completato, il suo risultato è racchiuso in un scala.util.Try. Questo Try può essere un Success(value) oppure un Failure(exception).
- Success: contiene il valore calcolato.
- Failure: contiene l'eccezione che si è verificata.
Il callback onComplete riceve questo oggetto Try, consentendo di gestire entrambi gli esiti.
Usare onComplete per gli errori
Il metodo onComplete è un listener universale per il completamento di un Future. Accetta una funzione che riceve un Try[T].
È possibile eseguire il pattern matching sul Try per distinguere tra successo e errore.
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Success, Failure}
object Main {
def main(args: Array[String]): Unit = {
val failingFuture = Future {
if (true) throw new RuntimeException("Oops!")
10
}
failingFuture.onComplete {
case Success(value) => println(s"Success: $value")
case Failure(exception) => println(s"Failure: ${exception.getMessage}")
}
Thread.sleep(100) // Keep JVM alive for Future to complete
}
}Il metodo recover
recover consente di gestire un'eccezione e fornire un valore di fallback se il Future fallisce. Trasforma un Future[T] in un altro Future[T].
Se il Future originale fallisce, la funzione parziale fornita viene applicata all'eccezione. Se corrisponde, viene restituito un nuovo Future completato correttamente con il valore di fallback.
Esempio di recover
In questo caso, se si verifica una divisione per zero, recover intercetta l'ArithmeticException e restituisce un Future con valore 0.
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
object Main {
def main(args: Array[String]): Unit = {
val resultFuture = Future { 10 / 0 } // This will fail
val recoveredFuture = resultFuture.recover {
case e: ArithmeticException =>
println("Caught ArithmeticException, recovering...")
0 // Fallback value
}
recoveredFuture.foreach(value => println(s"Result: $value"))
Thread.sleep(100) // Keep JVM alive
}
}Il metodo recoverWith
recoverWith è simile a recover, ma invece di restituire un valore di fallback restituisce un Future di fallback.
È utile quando l'azione di recupero stessa coinvolge un'altra operazione asincrona o quando si vuole riprovare l'operazione originale.
Esempio di recoverWith
Se il future iniziale fallisce, recoverWith fornisce un nuovo future che tenta un'operazione diversa o un valore asincrono predefinito.
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
object Main {
def main(args: Array[String]): Unit = {
val primaryOperation = Future {
if (true) throw new Exception("Primary failed!")
100
}
val fallbackOperation = Future {
println("Running fallback operation...")
50
}
val finalFuture = primaryOperation.recoverWith {
case e: Exception =>
println(s"Primary failed: ${e.getMessage}. Using fallback.")
fallbackOperation
}
finalFuture.foreach(value => println(s"Final result: $value"))
Thread.sleep(200) // Keep JVM alive
}
}Il metodo fallbackTo
fallbackTo consente di concatenare due Future. Se il primo Future fallisce, il suo risultato viene ignorato e viene usato il risultato del secondo Future.
A differenza di recoverWith, fallbackTo non analizza l'eccezione. Dice semplicemente: "Se questo fallisce, prova quello."
Esempio di fallbackTo
In questo caso, se failingFuture fallisce, fallbackTo userà il risultato di backupFuture.
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
object Main {
def main(args: Array[String]): Unit = {
val failingFuture = Future {
if (true) throw new RuntimeException("Network error!")
"Data from primary"
}
val backupFuture = Future {
println("Using backup source...")
"Data from cache"
}
val finalResult = failingFuture.fallbackTo(backupFuture)
finalResult.foreach(value => println(s"Retrieved: $value"))
Thread.sleep(100) // Keep JVM alive
}
}Quiz sulla gestione degli errori
Quale metodo si userebbe per fornire un'operazione asincrona alternativa quando un Future fallisce?
Riepilogo: gestione degli errori dei Future
Sono state analizzate alcune strategie fondamentali per gestire gli errori nei Future di Scala:
onComplete: reagisce sia al successo sia all'errore tramite unTry.recover: fornisce un valore di fallback quando si verifica un'eccezione.recoverWith: fornisce unFuturedi fallback quando si verifica un'eccezione.fallbackTo: usa unFuturedi riserva se quello principale fallisce, senza analizzare l'errore.
Questi metodi sono essenziali per creare sistemi asincroni resilienti!
Impara Scala con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 39
- Lezioni
- 143
Domande Frequenti
La lezione «Gestione degli errori nei Future» è gratuita?
Sì — il testo completo di «Gestione degli errori nei Future» è 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 Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 3 lezioni in totale.
Cosa imparerò in «Gestione degli errori nei Future»?
Implementi strategie per gestire con eleganza eccezioni e fallimenti nei calcoli asincroni con `Future`. Eserciti Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 3.
Quanto tempo richiede la lezione «Gestione degli errori nei Future»?
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 Scala for Backend Engineering & Functional Programming?
Sì. Ogni lezione Scala for Backend Engineering & Functional Programming 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
- Introduzione a Future e Promise
- Composizione delle operazioni asincrone
- Gestione degli errori nei Future