如何处理 Scala 中嵌套的期货序列函数

Question

我想创建一个函数来返回成功操作的一系列期货的结果。我遇到的问题是返回类型为Unit，并且未来函数正在完成，而无需等待嵌套的未来序列完成。我尝试过不使用on完成函数，而是使用map或平面图，但没有成功。我还想避免使用wait

class SquareGenerator(){
  //if type is changed to Unit anything that calls this function receives a empty success
  def getSquare() : Future[Int] = Future{
    val sums = List(future1(), future2())

    val results = Future.sequence(sums)

    //compiler throws an error because this is returning a unit
    results.onComplete({ 
      case Success(result) =>{
        val sum = result(0) + result(1)
        sum * sum
      }
    })
  }

  private def future1() : Future[Int] = Future{
    //do something that takes time
    2
  }

  private def future2() : Future[Int] = Future{
    //do something that takes time
    3
  }
}

这个后来会这么叫

val squareGenerator = new SquareGenerator()
squareGenerator.getSquare().onComplete({
  case Success(result) =>{
    //do something with result
  }
  case Failure(e){//log failure}
})

Answer 1

回到这里的未来

def getSquare : Future[Future[List[Int]]] = Future{
    val sums = List(future1(), future2())
    Future.sequence(sums)
  }

并且，当你调用它时，检查结果的完整性

  squareGenerator.getSquare.onComplete({
    case Success(result) =>
      result.onComplete({
        case Success(result) => {
          val sum = result(0) + result(1)
          val square = sum * sum
          println(square)
        }
      })

    case Failure(e) => {
      //log failure
    }
  })

Answer 2

< code>onComplete生成一个< code >单元。您想要< code>map或< code>flatMap或其他实际产生值的东西。

  def getSquare() : Future[Int] = {
    val sums = List(future1(), future2())

    val results: Future[List[Int]] = Future.sequence(sums)

    results.map {
      result => 
        val sum = result(0) + result(1)
        sum * sum
    }
  }

使用数组索引是不安全的。为了安全起见，您可以使用折叠或图案匹配。

    results map {
      case m :: n :: Nil =>
        val sum = m + n
        sum * sum
      case _ =>
        println("did not get 2 numbers!")
        0
    }

Answer 3

而不是在完成，你应该做：

results.map{ result => 
                val sum = result(0) + result(1)
                sum * sum
            }.recover { case e => ...
                // write to log, throw e, or return the same type of sum
}

使用map，您可以在Future中转换返回类型，并且只有当它成功完成时，才会返回future。

这就是为什么您需要添加Recovery来处理未来失败的情况。

如果您这样做，就不需要在函数的开头使用< code>Future，因为您不需要创建新的< code>Future -您将使用< code>results中的< code>Future。