Scala for Backend Engineering & Functional Programming · Lección

Gestión de errores en Futures

Implemente estrategias para gestionar excepciones y fallos correctamente en cálculos asíncronos con `Future`.

Gestión de errores en Futures es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 3 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 3 lecciones en total.

Gestión de errores de Future

¡Las operaciones asíncronas pueden fallar! Al igual que el código síncrono puede lanzar excepciones, un Future puede completarse con un error en lugar de con un valor correcto.

Comprender cómo gestionar estos fallos correctamente es fundamental para crear aplicaciones concurrentes robustas. Sin una gestión adecuada de errores, el programa podría bloquearse o comportarse de forma inesperada.

Resultado de Future: Try

Cuando un Future se completa, su resultado se encapsula en un scala.util.Try. Este Try puede ser un Success(value) o un Failure(exception).

Success: contiene el valor calculado.
Failure: contiene la excepción que se produjo.

La función de retorno onComplete recibe este objeto Try, lo que le permite gestionar ambos resultados.

Uso de onComplete para gestionar errores

El método onComplete es un listener universal para la finalización de un Future. Toma una función que acepta un Try[T].

Puede utilizar pattern matching sobre el Try para distinguir entre éxito y error.

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

El método recover

recover permite gestionar una excepción y proporcionar un valor alternativo si el Future falla. Transforma un Future[T] en otro Future[T].

Si el Future original falla, la función parcial proporcionada se aplica a la excepción. Si coincide, se devuelve un nuevo Future completado correctamente con el valor alternativo.

Ejemplo de recover

Aquí, si se produce una división por cero, recover captura la ArithmeticException y devuelve un Future con el valor 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
  }
}

El método recoverWith

recoverWith es similar a recover, pero en lugar de devolver un valor alternativo, devuelve un Future alternativo.

Resulta útil cuando la acción de recuperación implica otra operación asíncrona o cuando desea volver a intentar la operación original.

Ejemplo de recoverWith

Si el future inicial falla, recoverWith proporciona un nuevo future que intenta realizar otra operación o utilizar un valor asíncrono predeterminado.

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

El método fallbackTo

fallbackTo permite encadenar dos Future. Si el primer Future falla, se ignora su resultado y se utiliza el resultado del segundo Future.

A diferencia de recoverWith, fallbackTo no inspecciona la excepción. Simplemente indica: «Si este falla, pruebe con ese».

Ejemplo de fallbackTo

Aquí, si failingFuture falla, fallbackTo utilizará el resultado 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
  }
}

Cuestionario sobre gestión de errores

¿Qué método utilizaría si quisiera proporcionar una operación asíncrona alternativa cuando un Future falla?

Resumen: gestión de errores de Future

Hemos explorado estrategias clave para gestionar errores en Future de Scala:

onComplete: reacciona tanto al éxito como al error mediante un Try.
recover: proporciona un valor alternativo si se produce una excepción.
recoverWith: proporciona un Future alternativo si se produce una excepción.
fallbackTo: utiliza un Future de respaldo si falla el principal, sin inspeccionar el error.

¡Estos métodos son esenciales para crear sistemas asíncronos resistentes!

Preguntas frecuentes

¿La lección «Gestión de errores en Futures» es gratis?

Sí — el texto completo de «Gestión de errores en Futures» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 3 lecciones en total.

¿Qué aprenderé en «Gestión de errores en Futures»?

Implemente estrategias para gestionar excepciones y fallos correctamente en cálculos asíncronos con `Future`. Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 3.

¿Cuánto tiempo toma la lección «Gestión de errores en Futures»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Scala for Backend Engineering & Functional Programming