Gestion des erreurs dans les Futures
Mettez en œuvre des stratégies pour gérer élégamment les exceptions et les échecs au sein de calculs `Future` asynchrones.
Gestion des erreurs dans les Futures est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 3 sur 3. 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 Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 3 leçons au total.
Gérer les échecs des Future
Les opérations asynchrones peuvent échouer ! Tout comme le code synchrone peut lever des exceptions, un Future peut se terminer avec une erreur au lieu de produire une valeur valide.
Comprendre comment gérer ces échecs correctement est essentiel pour créer des applications concurrentes robustes. Sans gestion appropriée des erreurs, votre programme peut se bloquer ou adopter un comportement inattendu.
Résultat d’un Future : Try
Lorsqu’un Future se termine, son résultat est encapsulé dans un scala.util.Try. Ce Try peut être soit un Success(value), soit un Failure(exception).
- Succès : contient la valeur calculée.
- Échec : contient l’exception qui s’est produite.
Le rappel onComplete reçoit cet objet Try, ce qui vous permet de gérer les deux cas.
Utiliser onComplete pour les erreurs
La méthode onComplete est un écouteur universel de la fin d’un Future. Elle prend une fonction qui accepte un Try[T].
Vous pouvez effectuer une correspondance de motifs sur le Try afin de distinguer la réussite de l’échec.
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
}
}La méthode recover
recover vous permet de gérer une exception et de fournir une valeur de remplacement si le Future échoue. Elle transforme un Future[T] en un autre Future[T].
Si le Future d’origine échoue, la fonction partielle fournie est appliquée à l’exception. Si elle correspond, un nouveau Future terminé avec succès et contenant la valeur de remplacement est renvoyé.
Exemple de recover
Ici, si une division par zéro se produit, recover intercepte l’ArithmeticException et renvoie un Future contenant la valeur 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
}
}La méthode recoverWith
recoverWith ressemble à recover, mais au lieu de renvoyer une valeur de remplacement, elle renvoie un Future de remplacement.
Cette méthode est utile lorsque l’action de récupération elle-même implique une autre opération asynchrone, ou lorsque vous souhaitez réessayer l’opération d’origine.
Exemple de recoverWith
Si le futur initial échoue, recoverWith fournit un nouveau futur qui tente une autre opération ou une valeur asynchrone par défaut.
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
}
}La méthode fallbackTo
fallbackTo vous permet d’enchaîner deux Future. Si le premier Future échoue, son résultat est ignoré et celui du second Future est utilisé à la place.
Contrairement à recoverWith, fallbackTo n’examine pas l’exception. Il indique simplement : « Si celui-ci échoue, essayez celui-là. »
Exemple de fallbackTo
Ici, si failingFuture échoue, fallbackTo utilise le résultat de 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 sur la gestion des erreurs
Quelle méthode utiliseriez-vous si vous souhaitez fournir une opération asynchrone de remplacement lorsqu’un Future échoue ?
Récapitulatif : gestion des erreurs des Future
Nous avons étudié plusieurs stratégies importantes pour gérer les erreurs dans les Future Scala :
onComplete: réagit à la réussite comme à l’échec avec unTry.recover: fournit une valeur de remplacement lorsqu’une exception se produit.recoverWith: fournit unFuturede remplacement lorsqu’une exception se produit.fallbackTo: utilise unFuturede secours si le premier échoue, sans examiner l’erreur.
Ces méthodes sont essentielles pour créer des systèmes asynchrones résilients !
Questions Fréquemment Posées
La leçon « Gestion des erreurs dans les Futures » est-elle gratuite ?
Oui — le texte complet de « Gestion des erreurs dans les Futures » 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 Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Gestion des erreurs dans les Futures » ?
Mettez en œuvre des stratégies pour gérer élégamment les exceptions et les échecs au sein de calculs `Future` asynchrones. Tu pratiques Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming ?
Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming 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 3 sur 3.
Combien de temps prend la leçon « Gestion des erreurs dans les Futures » ?
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 Scala for Backend Engineering & Functional Programming ?
Oui. Chaque leçon Scala for Backend Engineering & Functional Programming 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
- Introduction aux Futures et aux Promises
- Composition d’opérations asynchrones
- Gestion des erreurs dans les Futures