Scala for Backend Engineering & Functional Programming · Lektion

Fehlerbehandlung in Futures

Implementieren Sie Strategien, um Ausnahmen und Fehler innerhalb asynchroner `Future`-Berechnungen angemessen zu behandeln.

Fehlerbehandlung in Futures ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 3 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 3 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Handling Future Failures

Asynchronous operations can fail! Just like synchronous code can throw exceptions, a Future can complete with an error instead of a successful value.

Understanding how to gracefully handle these failures is crucial for building robust concurrent applications. Without proper error handling, your program might crash or behave unexpectedly.

Future's Result: Try

When a Future completes, its result is wrapped in a scala.util.Try. This Try can be either a Success(value) or a Failure(exception).

Success: Contains the computed value.
Failure: Contains the exception that occurred.

The onComplete callback receives this Try object, allowing you to handle both outcomes.

Using onComplete for Errors

The onComplete method is a universal listener for a Future's completion. It takes a function that accepts a Try[T].

You can pattern match on the Try to distinguish between success and failure.

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

The recover Method

recover allows you to handle an exception and provide a fallback value if the Future fails. It transforms a Future[T] into another Future[T].

If the original Future fails, the provided partial function is applied to the exception. If it matches, a new successful Future with the fallback value is returned.

recover Example

Here, if the division by zero occurs, recover catches the ArithmeticException and returns a Future with the value 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
  }
}

The recoverWith Method

recoverWith is similar to recover, but instead of returning a fallback value, it returns a fallback Future.

This is useful when your recovery action itself involves another asynchronous operation, or if you want to retry the original operation.

recoverWith Example

If the initial future fails, recoverWith provides a new future that attempts a different operation or a default async value.

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

The fallbackTo Method

fallbackTo allows you to chain two Futures. If the first Future fails, its result is ignored, and the result of the second Future is used instead.

Unlike recoverWith, fallbackTo doesn't inspect the exception. It simply says: "If this one fails, try that one."

fallbackTo Example

Here, if failingFuture fails, fallbackTo will use the result of 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
  }
}

Error Handling Quiz

Which method would you use if you want to provide an alternative asynchronous operation when a Future fails?

Recap: Future Error Handling

We've explored key strategies for handling errors in Scala Futures:

onComplete: Reacts to both success and failure with a Try.
recover: Provides a fallback value if an exception occurs.
recoverWith: Provides a fallback Future if an exception occurs.
fallbackTo: Uses a backup Future if the primary one fails, without inspecting the error.

These methods are essential for building resilient asynchronous systems!

Häufig gestellte Fragen

Ist die Lektion „Fehlerbehandlung in Futures“ kostenlos?

Ja — der vollständige Text von „Fehlerbehandlung in Futures“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Fehlerbehandlung in Futures“?

Implementieren Sie Strategien, um Ausnahmen und Fehler innerhalb asynchroner `Future`-Berechnungen angemessen zu behandeln. Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?

Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 3.

Wie lange dauert die Lektion „Fehlerbehandlung in Futures“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?

Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Scala for Backend Engineering & Functional Programming