Scala Futures 中如何处理异常？

Question

我实现了一个简单的作业处理器，用于处理 futures 中的子作业（scala.actors.Futures）。这些 future 本身可以为处理子作业创建更多的 future。现在，如果这些子作业之一引发异常，我希望作业处理器回复该作业的错误消息。我有一个用于发现失败子作业的解决方案，但我不确定这是否是最佳解决方案。基本上它的工作原理是这样的：

sealed trait JobResult
case class SuccessResult(content: String) extends JobResult
case class FailedResult(message: String) extends JobResult

for(subjob <- subjobs) yield {
  future {
    try {
          SuccessResult(process(subjob))
    } catch {
      case e:Exception => FailedResult(e.getMessage)                              
    }
  }
}

顶层的结果是 JobResults 的列表的列表的递归列表...。我递归地在列表中搜索失败的结果，然后根据结果的类型返回错误或组合结果。 这可行，但我想知道是否有更优雅/更简单的解决方案来处理期货中的异常？

Answer 1

您现在所做的方式本质上就是 scala.Either 的设计目的。请参阅 http://www.scala-lang.org/api/current/ scala/Either.html

Answer 2

现代 scala future 与 Either 类似，因为它们要么包含成功的结果，要么包含 Throwable。如果你在 scala 2.10 中重新访问这段代码，我想你会发现这种情况非常愉快。

具体来说， scala.concurrent.Future [T] 从技术上讲只有“is-a”Awaitable[T]，但是 _.onComplete 和 Await.ready(_, timeout)。 value.get 都将其结果显示为 scala.util.Try[T]，它很像 Either[Throwable, T] 因为它要么是结果，要么是异常。

奇怪的是，_.transform需要两个映射函数，一个用于T =>; U 和一个 Throwable =>; Throwable 并且（除非我遗漏了一些东西）没有变压器将未来映射为 Try[T] =>尝试[U]。 Future 的 .map 将允许您通过简单地在映射函数中抛出异常来将成功转变为失败，但它仅将其用于原始 的成功。代码>未来。它的.recover，同样可以转败为胜。如果您希望能够将成功更改为失败，反之亦然，您需要自己构建一些由 _.map 和 _.recover 组合而成的东西或者使用 _.onComplete 链接到新的 scala.concurrent.Promise[U] 像这样：

import scala.util.{Try, Success, Failure}
import scala.concurrent.{Future, Promise}
import scala.concurrent.ExecutionContext

def flexibleTransform[T,U](fut: Future[T])(f: Try[T] => Try[U])(implicit ec: ExecutionContext): Future[U] = {
  val p = Promise[U]
  fut.onComplete { res =>
    val transformed = f(res)
    p.complete(transformed)
  }
  p.future
}

它会像这样使用：

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration.Duration.Inf

def doIt() {
  val a: Future[Integer] = Future {
    val r = scala.util.Random.nextInt
    if (r % 2 == 0) {
      throw new Exception("we don't like even numbers")
    } else if (r % 3 == 0) {
      throw new Exception("we don't like multiples of three")
    } else {
      r
    }
  }

  val b: Future[String] = flexibleTransform(a) {
    case Success(i) =>
      if (i < 0) {
        // turn negative successes into failures
        Failure(new Exception("we don't like negative numbers"))
      } else {
        Success(i.toString)
      }
    case Failure(ex) =>
      if (ex.getMessage.contains("three")) {
        // nevermind about multiples of three being a problem; just make them all a word.
        Success("three")
      } else {
        Failure(ex)
      }
  }

  val msg = try {
    "success: " + Await.result(b, Inf)
  } catch {
    case t: Throwable =>
      "failure: " + t
  }
  println(msg)
}

for { _ <- 1 to 10 } doIt()

这会给出类似这样的东西：（

failure: java.lang.Exception: we don't like even numbers
failure: java.lang.Exception: we don't like negative numbers
failure: java.lang.Exception: we don't like negative numbers
success: three
success: 1756800103
failure: java.lang.Exception: we don't like even numbers
success: 1869926843
success: three
failure: java.lang.Exception: we don't like even numbers
success: three

或者你可以“pimp”Future 到具有隐式 def 的 RichFutureWithFlexibleTransform 中，并使 flexibleTransform 成为其中的成员函数，删除 fut 参数并简单地使用 < code>this）

（更好的是采用 Try[T] => Future[U] 并将其命名为 flexibleFlatMap 这样你就可以做异步的事情在变换中）