scala - 处理失败的 `Future`

Question

给定以下两种方法:

def f: Future[Int] = Future { 10 }
def g: Future[Int] = Future { 5 }

我想创作它们:

scala> import scala.concurrent.Future
import scala.concurrent.Future

scala> import scala.concurrent.Future._
import scala.concurrent.Future._

scala> import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.ExecutionContext.Implicits.global

scala> for { 
     |   a <- f
     |   b <- g
     | } yield (a+b)
res2: scala.concurrent.Future[Int] = scala.concurrent.impl.Promise$DefaultPromise@34f5090e

现在，我将调用 Await.result 来阻止，直到它完成。

scala> import scala.concurrent.duration._
import scala.concurrent.duration._

正如预期的那样，我得到了 15，因为 Await.result 采用了一个 Future[Int] 并返回了一个 Int.

scala> Await.result(res2, 5.seconds)
res6: Int = 15

为失败的 Future 定义 recoverFn:

scala> val recoverFn: PartialFunction[Throwable, Future[Int]] = 
    { case _ => Future{0} }
recoverFn: PartialFunction[Throwable,scala.concurrent.Future[Int]] = <function1>

我尝试定义一个失败的Future:

scala> def failedFuture: Future[Int] = Future { 666 }.failed.recoverWith{ recoverFn }
<console>:20: error: type mismatch;
 found   : scala.concurrent.Future[Any]
 required: scala.concurrent.Future[Int]
       def failedFuture: Future[Int] = Future { 666 }.failed.recoverWith{ recoverFn }
                                                                        ^

但是，我得到了上述编译时错误。

具体来说，我该如何解决这个错误？一般来说，Future#recoverWith 通常是如何处理失败的 Future 的？

Answer 1

问题是 Future#failed always 返回 Future[Throwable]。它的目的不是简单地使Future 失败，而是返回该Future 的失败投影。这意味着如果原来的 Future 失败了，它将被转换成一个 successful Future 来保存异常。如果原来的 Future 成功了，那么它就变成了失败，并持有 NoSuchElementException。您遇到的错误是因为您实际上是在使用 Future[Int] 恢复 Future[Throwable]，该 Future[Int] 的上限至少为 Future [任何].

如果你只是想玩失败的Future，试试这个:

scala> Future.failed[Int](new Exception("???")).recoverWith(recoverFn)
res4: scala.concurrent.Future[Int] = scala.concurrent.impl.Promise$DefaultPromise@6933711b

scala> res4.value.get
res5: scala.util.Try[Int] = Success(0)

recoverWith没有任何问题。