在Controller中使用Future的最佳实践（Play + Scala）

问题描述 投票：2回答：3

在我的Play网络应用程序中，我使用val resultRack = Await.result(futureList, Duration.Inf)从Future获得结果。还有另一种更好的方法（使用最佳实践）从数据库中获取结果吗？如果我使用onComplete或onSuccess我的COntroller完成执行，结果还没有在val。下面是我的Controller方法。一切正常，但我需要遵循Scala中的更多最佳实践。

编辑：我已经在其他方法上使用Action.async了。但在这一个我不能使用基本上因为either.fold。我想我需要一个围绕该方法的所有代码的map来验证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
        }
      }
    )
  }

使用flatMap和map的新方法。我的问题是我正在创建并填充控制器内的seq rackSeq。我用来创建这个对象的gpuSeq没有被评估，因为它来自Future。我该怎么做才能评估这个未来的gpeSeq？在我的结果我只能看到rackSeq，但gpuSeq列表总是空的。

此外，如果代码Util.toTime(at)抛出错误，我无法用recover捕获这个。据我所知，我可以做到这一点......

  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."))
    }
  }
scala playframework future
3个回答
8
投票

不要在Play控制器中使用Await.result。这将阻止线程并杀死使用像Play这样的反应式框架的主要好处之一。相反map或flatMap Future生成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))
}

你做的是，你使用Action.async并映射你的未来以产生一个结果：

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

如果您需要嵌套多个未来结果，请改用flatMap。

Edit:

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

Futures - map vs flatmap

我们来看一些例子：

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

看到？没有Await。然后我们有你的代码：

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？换句话说，为什么Await在fGpu而不是map它返回Future[Result]？

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

当然，你需要使用Action.async和flatMap作为f。

5
投票

这里有关于您的代码的事情，然后是关于您未来问题的事情：

  1. 不要将控制器与模型混合：一般来说，控制器是一组方法（在控制器类中），它获取请求并返回结果（OK，REDIRECT等）。模型是类/对象/接口中的一组方法，它们获取一组参数，处理外部资源并将其结果返回给控制器。
  2. 方法是你的朋友：你可以将你的代码分成更多不同的方法。例如，您的方法名称是addRack，但它的主体也包含一些处理，您可以将它们放在控制器或模型中的不同方法中;取决于他们属于何处。
  3. 从不等待：有一个原因，就是你占据了线程，并且在等待时间内不会让它们独自存在。这将导致您的应用程序在内存和CPU使用方面效率低下。
  4. 地图是你的朋友：当你调用一个返回未来的方法时使用地图。例如，您想要调用此方法：

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[Future[String]];并获得Future[String]。

  1. 对于失败的未来也要恢复：如果你没有得到结果怎么办？你使用恢复。例如： hiFromFuture.map{gotData => Ok("success")}.recover{case e: Exception => BadRequest}

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

2
投票

如果您的问题是如何管理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
      }
    }
  )
}

然后当你有嵌套的期货时，你应该按照marcospereira和Dave Rose的说明进行平面图

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.