Fejlhåndtering i Futures
Implementér strategier til elegant håndtering af undtagelser og fejl i asynkrone `Future`-beregninger.
Fejlhåndtering i Futures er en gratis Scala til backendudvikling og funktionel programmering-lektion på CoddyKit. Dette er lektion 3 af 3. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Scala til backendudvikling og funktionel programmering, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Scala til backendudvikling og funktionel programmering-kurset indeholder 3 lektioner i alt.
Håndtering af fejl i Future
Asynkrone handlinger kan mislykkes! Ligesom synkron kode kan kaste undtagelser, kan en Future blive fuldført med en fejl i stedet for en vellykket værdi.
Det er afgørende at forstå, hvordan du håndterer disse fejl på en god måde, hvis du vil bygge robuste samtidige applikationer. Uden korrekt fejlhåndtering kan dit program gå ned eller opføre sig uventet.
Resultatet af Future: Try
Når en Future bliver fuldført, pakkes resultatet ind i en scala.util.Try. Denne Try kan enten være en Success(value) eller en Failure(exception).
- Success: Indeholder den beregnede værdi.
- Failure: Indeholder den undtagelse, der opstod.
Tilbagekaldsfunktionen onComplete modtager dette Try-objekt, så du kan håndtere begge udfald.
Brug af onComplete til fejl
Metoden onComplete er en universel lytter til fuldførelsen af en Future. Den tager en funktion, der accepterer en Try[T].
Du kan udføre mønstergenkendelse på Try for at skelne mellem succes og fejl.
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
}
}Metoden recover
recover giver dig mulighed for at håndtere en undtagelse og angive en reserveværdi, hvis Future-objektet mislykkes. Den transformerer en Future[T] til en anden Future[T].
Hvis den oprindelige Future mislykkes, anvendes den angivne partielle funktion på undtagelsen. Hvis den matcher, returneres en ny vellykket Future med reserveværdien.
Eksempel på recover
Hvis division med nul sker her, opfanger recover ArithmeticException og returnerer en Future med værdien 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
}
}Metoden recoverWith
recoverWith minder om recover, men i stedet for at returnere en reserveværdi returnerer den en reserve-Future.
Det er nyttigt, når selve gendannelsen omfatter en anden asynkron handling, eller hvis du vil forsøge den oprindelige handling igen.
Eksempel på recoverWith
Hvis den første Future mislykkes, leverer recoverWith en ny Future, der forsøger en anden handling eller en standardværdi fra en asynkron handling.
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
}
}Metoden fallbackTo
fallbackTo giver dig mulighed for at kæde to Future-objekter. Hvis den første Future mislykkes, ignoreres dens resultat, og resultatet fra den anden Future bruges i stedet.
I modsætning til recoverWith undersøger fallbackTo ikke undtagelsen. Den siger blot: "Hvis denne mislykkes, så prøv den anden."
Eksempel på fallbackTo
Hvis failingFuture mislykkes her, bruger fallbackTo resultatet fra 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 om fejlhåndtering
Hvilken metode vil du bruge, hvis du vil angive en alternativ asynkron handling, når en Future mislykkes?
Opsummering: Fejlhåndtering i Future
Vi har gennemgået vigtige strategier til håndtering af fejl i Scala-Future-objekter:
onComplete: Reagerer på både succes og fejl med enTry.recover: Angiver en reserve-værdi, hvis der opstår en undtagelse.recoverWith: Angiver en reserve-Future, hvis der opstår en undtagelse.fallbackTo: Bruger en sikkerhedskopi-Future, hvis den primære mislykkes, uden at undersøge fejlen.
Disse metoder er afgørende for at bygge robuste asynkrone systemer!
Lær Scala med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 39
- Lektioner
- 143
Ofte stillede spørgsmål
Er lektionen “Fejlhåndtering i Futures” gratis?
Ja — hele teksten til “Fejlhåndtering i Futures” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Scala til backendudvikling og funktionel programmering-kurset, skal du opgradere til CoddyKit PRO. Scala til backendudvikling og funktionel programmering-kurset indeholder 3 lektioner i alt.
Hvad lærer jeg i “Fejlhåndtering i Futures”?
Implementér strategier til elegant håndtering af undtagelser og fejl i asynkrone `Future`-beregninger. Du øver dig i Scala til backendudvikling og funktionel programmering med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Scala til backendudvikling og funktionel programmering?
Der kræves ingen tidligere erfaring. Scala til backendudvikling og funktionel programmering på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 3.
Hvor lang tid tager lektionen “Fejlhåndtering i Futures”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Scala til backendudvikling og funktionel programmering-lektion?
Ja. Alle Scala til backendudvikling og funktionel programmering-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Introduktion til Futures og Promises
- Sammensætning af asynkrone operationer
- Fejlhåndtering i Futures