在控制器中使用Future的最佳实践（Play Scala）

Question

在我的Play web应用程序中，我使用的是val resultRack=wait。result（futureList，Duration.Inf）从未来获取结果。有没有其他更好的方法（使用最佳实践）从数据库中获得结果？如果我使用onComplete或onSuccess我的控制器完成执行，结果还不在val中。下面是我的控制器方法。一切正常，但我需要在Scala中遵循更多的最佳实践。

编辑：我已经在使用操作了。其他方法上的异步。但在这个例子中，我不能使用，基本上是因为。折叠。我想在验证json之前，我需要一个映射来包围该方法的所有代码。

  def addRack = Action(parse.json) { request =>
    val either = request.body.validate[Rack]
    either.fold(
      errors => BadRequest("invalid json Rack.\n"),
      rack => {
        val f: Future[Option[RackRow]] = rackRepository.getById(rack.id)
        val result = Await.result(f, Duration.Inf)
        result match {
          case Some(r) =>
            // If the Rack already exists we update the produced and currentTime properties
            val fGpu: Future[Seq[GpuRow]] = gpuRepository.getByRack(r.id)
            // val total = fGpu.map(_.map(_.produced).sum)
            val resultGpu = Await.result(fGpu, Duration.Inf)
            val total = resultGpu.map(_.produced).sum
            rackRepository.update(r.id, Some(total), Some(System.currentTimeMillis))
            Ok("Rack already exists! Updated produced and currentTime.\n")
          case None =>
            // If the Rack does not exist we create it.
            val rackRow = RackRow(rack.id, rack.produced, System.currentTimeMillis)
            rackRepository.insert(rackRow)
            Ok
        }
      }
    )
  }

使用平面地图和map的新方法。我的问题是，我正在创建和填充Controller内部的seqrackSeq。我用来创建此对象的gpuSeq没有计算，因为它来自Future。我应该如何计算此FuturegpuSeq？在我的结果中，我只能看到rackSeq，但是gpuSeq的列表总是空的。

此外，如果代码Util.to时间（at）抛出一个错误，我不能用恢复来捕捉这个错误。

  def getRacks(at: String) = Action.async { implicit request: Request[AnyContent] =>

    var rackSeq: Seq[Rack] = Seq.empty
    var gpuSeq: Seq[Gpu] = Seq.empty

    rackRepository.get(Util.toTime(at)).flatMap { resultRack: Seq[RackRow] =>
      resultRack.map { r: RackRow =>
        gpuRepository.getByRack(r.id).map { result: Seq[GpuRow] =>
          result.map { gpuRow: GpuRow =>
            gpuSeq = gpuSeq :+ Gpu(gpuRow.id, gpuRow.rackId, gpuRow.produced, Util.toDate(gpuRow.installedAt))
            println(gpuRow)
          }
        }
        val rack = Rack(r.id, r.produced, Util.toDate(r.currentHour), gpuSeq)
        rackSeq = rackSeq :+ rack
      }

      //      val result = Await.result(listGpu, Duration.Inf)
      //      result.foreach { gpuRow =>
      //        gpuSeq = gpuSeq :+ Gpu(gpuRow.id, gpuRow.rackId, gpuRow.produced, Util.toDate(gpuRow.installedAt))
      //      }
      Future.successful(Ok(Json.toJson(rackSeq)).as(JSON))
    }.recover {
      case pe: ParseException => BadRequest(Json.toJson("Error on parse String to time."))
      case e: Exception => BadRequest(Json.toJson("Error to get racks."))
      case _ => BadRequest(Json.toJson("Unknow error to get racks."))
    }
  }

Answer 1

如果您的问题是如何管理json验证的错误情况，在成功路径将返回Future的上下文中，您可以简单地将Result包装在已经成功完成的Future中，即Future.successful（BadRequest（...））。如下所示

def addRack = Action(parse.json).async { request =>
  val either = request.body.validate[Rack]
  either.fold(
    errors => Future.successful(BadRequest("invalid json Rack.\n")),
    rack => {
      rackRepository.getById(rack.id).map {
        case Some(r) =>
          //...

          Ok("Rack already exists! Updated produced and currentTime.\n")
        case None =>
          //...

          Ok
      }
    }
  )
}

然后，当你有嵌套期货时，你应该像马可斯佩雷拉和戴夫·罗斯所说的那样进行平面映射

Answer 2

这里有几件事是关于你的代码的，当然还有你关于未来的问题：

>

方法是你的朋友：你可以把你的代码分成不同的方法。例如，您的方法名为addRack，但它的主体也包含一些处理，您可以将它们放在控制器或模型中的不同方法中；取决于它们属于哪里。

永远不要等待：这是有原因的，那就是你正在占用线程，并且在等待期间不会让它们单独存在。这将导致应用程序在内存和cpu使用方面效率低下。

Map是你的朋友：当你调用一个返回未来的方法时，使用Map。例如，您希望调用此方法：

def hiFromFuture:Future[String]=Future{…}

hiFromFuture.map{
  futureResult: String => //when Future is successful 
}

如果您有多个连续的未来通话，也应该使用flatmap。例如，假设hiFromFuture2与hiFromFuture具有相同的签名/正文：

hiFromFuture.map{
  futureResult: String => hiFromFuture2.map{ futureResult => }

}

hiFromFuture.flatMap{
  futureResult: String => //when first future is successful 
    hiFromFuture2.map{ 
      futureResult => //when second future is successful 
    }
}

避免未来[Future[String]；并获取Future[String]。

对于失败的未来，恢复也是如此：如果你没有得到结果呢？你可以使用恢复。例如：

hiFromFuture。映射{gotData=

请注意，您可以使用恢复块中预期的任何异常。

Answer 3

永远不要在Play控制器中使用wait.result。这将阻塞线程，并扼杀使用像Play这样的反应式框架的主要好处之一。相反，map或平地图theFuture来生成Result。例如，假设您有以下RackRepository：

class RackRepository {
  def racks: Future[Seq[Rack]] = ???
}

在控制器中，而不是执行以下操作：

def wrong = Action {
  val racks: Future[Seq[Rack]] = rackRepository.racks
  // This is wrong, don't do that
  val racksSeq = Await.result(racks, Duration.Inf)
  Ok(Json.toJson(racksSeq))
}

你所做的是，你使用ction.async映射你的未来来生成一个结果：

def list = Action.async {
  rackRepository.racks.map { racks =>
    Ok(Json.toJson(racks))
  }
}

如果需要嵌套多个未来结果，则使用平映射代替。

从第一个示例中，您需要做的是理解map和flatMap之间的区别。这看起来是个好的开始：

未来-地图vs平面地图

让我们来看一些例子：

val firstFuture: Future[String] = ??? // it does not mater where it comes from
val secondFuture: Future[String] = ??? // it does not mater where it comes from

val f1: Future[Int] = firstFuture.map(_.toInt)
val f2: Future[Future[String]] = firstFuture.map(secondFuture)
val f3: Future[String] = firstFuture.flatMap(secondFuture)

// Let's start to combine the future values
val f4: Future[Future[String]] = firstFuture.map { first =>
  secondFuture.map { second =>
    first + second // concatenate
  }
}

// But what if we want a Future[String] instead of a Future[Future[String]]?
// flatMap to the rescue!
val f5: Future[String] = firstFuture.flatMap { first =>
  secondFuture.map { second =>
    first + second // concatenate
  }
}

看见否等待。然后我们有你的代码：

val fGpu: Future[Seq[GpuRow]] = gpuRepository.getByRack(r.id)
// val total = fGpu.map(_.map(_.produced).sum)
val resultGpu = Await.result(fGpu, Duration.Inf)

为什么不把flatMap和map结合起来，就像我对f5所做的那样？换句话说，为什么要在fGpu上等待，而不是map返回未来的[结果]？

gpuRepository.getByRack(r.id).map { gpuRows =>
  val total = gpuRows.map(_.produced).sum
  rackRepository.update(r.id, Some(total), Some(System.currentTimeMillis))
  Ok("Rack already exists! Updated produced and currentTime.\n")
}

当然，您需要使用操作。异步和flatMap用于f。