Scala for Backend Engineering & Functional Programming · Aula

Tratamento de erros em Futures

Implemente estratégias para tratar exceções e falhas de forma adequada em computações assíncronas com `Future`.

Tratamento de erros em Futures é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 3 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 3 aulas no total.

Lidando com falhas de Future

As operações assíncronas podem falhar! Assim como o código síncrono pode lançar exceções, um Future pode ser concluído com um erro em vez de um valor bem-sucedido.

Entender como lidar adequadamente com essas falhas é essencial para criar aplicações concorrentes robustas. Sem um tratamento adequado de erros, seu programa pode falhar ou se comportar de maneira inesperada.

Resultado de Future: Try

Quando um Future é concluído, seu resultado é encapsulado em um scala.util.Try. Esse Try pode ser um Success(value) ou um Failure(exception).

Sucesso: contém o valor calculado.
Falha: contém a exceção ocorrida.

O retorno de chamada onComplete recebe esse objeto Try, permitindo que você lide com ambos os resultados.

Usando onComplete para lidar com erros

O método onComplete é um observador universal da conclusão de um Future. Ele recebe uma função que aceita um Try[T].

Você pode usar correspondência de padrões em Try para distinguir entre sucesso e falha.

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

O método recover

recover permite lidar com uma exceção e fornecer um valor alternativo se o Future falhar. Ele transforma um Future[T] em outro Future[T].

Se o Future original falhar, a função parcial fornecida será aplicada à exceção. Se houver correspondência, um novo Future bem-sucedido com o valor alternativo será retornado.

Exemplo de recover

Aqui, se ocorrer uma divisão por zero, recover captura a ArithmeticException e retorna um Future com o 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
  }
}

O método recoverWith

recoverWith é semelhante a recover, mas, em vez de retornar um valor alternativo, retorna um Future alternativo.

Isso é útil quando a própria ação de recuperação envolve outra operação assíncrona ou quando você deseja tentar novamente a operação original.

Exemplo de recoverWith

Se o future inicial falhar, recoverWith fornecerá um novo future que tentará uma operação diferente ou um valor assíncrono padrão.

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

O método fallbackTo

fallbackTo permite encadear dois Futures. Se o primeiro Future falhar, seu resultado será ignorado e o resultado do segundo Future será usado.

Diferentemente de recoverWith, fallbackTo não analisa a exceção. Ele simplesmente diz: "Se este falhar, tente aquele."

Exemplo de fallbackTo

Aqui, se failingFuture falhar, fallbackTo usará o 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
  }
}

Questionário sobre tratamento de erros

Qual método você usaria se quisesse fornecer uma operação assíncrona alternativa quando um Future falhasse?

Recapitulação: tratamento de erros de Future

Exploramos estratégias importantes para lidar com erros em Futures do Scala:

onComplete: reage tanto ao sucesso quanto à falha com um Try.
recover: fornece um valor alternativo quando ocorre uma exceção.
recoverWith: fornece um Future alternativo quando ocorre uma exceção.
fallbackTo: usa um Future de backup se o principal falhar, sem analisar o erro.

Esses métodos são essenciais para criar sistemas assíncronos resilientes!

Perguntas Frequentes

A aula “Tratamento de erros em Futures” é grátis?

Sim — o texto completo de “Tratamento de erros em Futures” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 3 aulas no total.

O que vou aprender em “Tratamento de erros em Futures”?

Implemente estratégias para tratar exceções e falhas de forma adequada em computações assíncronas com `Future`. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 3.

Quanto tempo leva a aula “Tratamento de erros em Futures”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming