Obsługa błędów w Futures
Poznaj strategie łagodnego obsługiwania wyjątków i niepowodzeń w asynchronicznych obliczeniach `Future`.
Obsługa błędów w Futures to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 3 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.
Obsługa błędów obiektów Future
Operacje asynchroniczne mogą zakończyć się niepowodzeniem! Tak jak kod synchroniczny może zgłaszać wyjątki, obiekt Future może zakończyć się błędem zamiast pomyślną wartością.
Umiejętność prawidłowej obsługi takich błędów ma kluczowe znaczenie przy tworzeniu niezawodnych aplikacji współbieżnych. Bez odpowiedniej obsługi błędów program może ulec awarii lub zachowywać się nieprzewidywalnie.
Wynik obiektu Future: Try
Po zakończeniu obiektu Future jego wynik jest opakowany w scala.util.Try. Obiekt Try może być typu Success(value) albo Failure(exception).
- Success: Zawiera obliczoną wartość.
- Failure: Zawiera wystąpiony wyjątek.
Wywołanie zwrotne onComplete otrzymuje ten obiekt Try, co pozwala obsłużyć oba wyniki.
Używanie onComplete do obsługi błędów
Metoda onComplete jest uniwersalnym odbiornikiem zakończenia obiektu Future. Przyjmuje funkcję akceptującą wartość Try[T].
Mogą Państwo użyć dopasowania wzorca dla obiektu Try, aby rozróżnić powodzenie od niepowodzenia.
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
}
}Metoda recover
recover pozwala obsłużyć wyjątek i podać wartość zastępczą, jeśli obiekt Future zakończy się niepowodzeniem. Przekształca obiekt Future[T] w inny obiekt Future[T].
Jeśli pierwotny obiekt Future zakończy się niepowodzeniem, podana funkcja częściowa zostanie zastosowana do wyjątku. Jeśli dopasowanie się powiedzie, zwracany jest nowy pomyślnie zakończony obiekt Future z wartością zastępczą.
Przykład recover
Jeśli w tym przykładzie wystąpi dzielenie przez zero, recover przechwytuje wyjątek ArithmeticException i zwraca obiekt Future z wartością 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
}
}Metoda recoverWith
recoverWith działa podobnie do recover, ale zamiast zwracać wartość zastępczą, zwraca zastępczy obiekt Future.
Jest to przydatne, gdy sama procedura odzyskiwania obejmuje inną operację asynchroniczną lub gdy chcą Państwo ponowić pierwotną operację.
Przykład recoverWith
Jeśli początkowy obiekt Future zakończy się niepowodzeniem, recoverWith udostępni nowy obiekt Future, który podejmie inną operację lub zwróci domyślną wartość asynchroniczną.
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
}
}Metoda fallbackTo
fallbackTo pozwala połączyć dwa obiekty Future. Jeśli pierwszy obiekt Future zakończy się niepowodzeniem, jego wynik zostanie zignorowany, a zamiast niego zostanie użyty wynik drugiego obiektu Future.
W przeciwieństwie do recoverWith, fallbackTo nie analizuje wyjątku. Po prostu oznacza: „Jeśli ten obiekt się nie powiedzie, spróbuj tamtego”.
Przykład fallbackTo
Jeśli w tym przykładzie obiekt failingFuture zakończy się niepowodzeniem, fallbackTo użyje wyniku obiektu 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: obsługa błędów
Jakiej metody użyją Państwo, jeśli chcą podać alternatywną operację asynchroniczną na wypadek niepowodzenia obiektu Future?
Podsumowanie: obsługa błędów obiektów Future
Omówiliśmy najważniejsze strategie obsługi błędów w obiektach Future w Scali:
onComplete: Reaguje zarówno na powodzenie, jak i niepowodzenie, korzystając z obiektuTry.recover: Udostępnia zastępczą wartość w przypadku wystąpienia wyjątku.recoverWith: Udostępnia zastępczy obiektFuturew przypadku wystąpienia wyjątku.fallbackTo: Używa zapasowego obiektuFuture, jeśli główny zakończy się niepowodzeniem, bez analizowania błędu.
Metody te są niezbędne do tworzenia odpornych systemów asynchronicznych!
Ucz się Scala dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 39
- Lekcje
- 143
Często zadawane pytania
Czy lekcja „Obsługa błędów w Futures” jest bezpłatna?
Tak — pełny tekst „Obsługa błędów w Futures” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 3 lekcji w sumie.
Co nauczysz się w „Obsługa błędów w Futures”?
Poznaj strategie łagodnego obsługiwania wyjątków i niepowodzeń w asynchronicznych obliczeniach `Future`. Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?
Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 3.
Ile czasu zajmuje lekcja „Obsługa błędów w Futures”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?
Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Wprowadzenie do Futures i Promises
- Łączenie operacji asynchronicznych
- Obsługa błędów w Futures