使用Scala和Play异步计算未来的布尔值

我有一个在播放控制器中返回未来[Boolean]的方法，我想使用async对其进行评估，但似乎无法将其编译。 以下工作将起作用：

  def health = Action {
    logger.info("Endpoint method: health")
    val isHealthy = healthCheckService.checkDynamo()
    val b: Boolean = Await.result(isHealthy, scala.concurrent.duration.Duration(5, "seconds"))
    Ok(Json.toJson(HealthCheckResponse(b.toString)))
  }

但我不想在那里等待。所以我尝试这样的事情却没有成功：

 def health =
    Action.async {
      Future {
        logger.info("Endpoint method: health")


        healthCheckService.checkDynamo() match {
          case Future.successful(true)  => Ok(Json.toJson("false"))
          case false => Ok(Json.toJson("true"))
        }



        val r = healthCheckService.checkDynamo() match {
          case true  => Ok(Json.toJson("false"))
          case false => Ok(Json.toJson("true"))
        }

      }
    }

我甚至不能编译它们来测试它们。 有什么建议吗？

试试这个：

def health = Action.async {
  healthCheckService.checkDynamo().map {
    case true => Ok(Json.toJson("false"))
    case false => Ok(Json.toJson("true"))
  }
}

让Play处理引擎盖下等待您的消息。也就是说，

Action.async

接受一个

Future

，该

checkDynamo（）

已经返回。您所要做的就是将它映射到适当的结果。

尝试以下方法：

def health = Action.async {
  healthCheckService.checkDynamo().map {
    case true => Ok(Json.toJson("false"))
    case false => Ok(Json.toJson("true"))
  }
}

---

让Play处理引擎盖下等待您的消息。也就是说，

Action.async

接受一个

Future

，该

checkDynamo（）

已经返回。你所要做的就是将它映射到适当的结果。

对于

期货

你必须使用组合词，如

map

和

flatMap

来表示最终值。例如：

Action.async {
  healthCheckService.checkDynamo()
    .map { result =>  // boolean
      HealthCheckResponse(result.toString)
    }
    .map(Json.toJson(_))
    .map(Ok(_))
}

（您可以将上面的

map

s合并为一个

map

，并在那里构造最终的

Ok

值；这或多或少是一个品味问题）

例如，如果您有两个异步调用，您希望执行它们并根据它们的结果返回结果，那么可以使用

flatMap

，这可以很容易地用

表示，以便理解：

Action.async {
  for {
    result1 <- someService.someCall()
    result2 <- anotherService.anotherCall(result1.someProperty)
    finalResult = SomeFinalResultType(result1, result2)
  } yield Ok(Json.toJson(finalResult))
}

Action.async{
为了{
结果1对于
Futures
您必须使用组合词，如
map
和
flatMap
来表示最终值。例如：

Action.async {
  healthCheckService.checkDynamo()
    .map { result =>  // boolean
      HealthCheckResponse(result.toString)
    }
    .map(Json.toJson(_))
    .map(Ok(_))
}

（您可以将上面的
map
s合并为一个
map
，并在那里构造最终的
Ok
值；这或多或少是一个品味问题）

例如，如果您有两个异步调用，您希望执行它们并根据它们的结果返回结果，那么可以使用
flatMap
，这可以很容易地用
表示，以便理解：

Action.async {
  for {
    result1 <- someService.someCall()
    result2 <- anotherService.anotherCall(result1.someProperty)
    finalResult = SomeFinalResultType(result1, result2)
  } yield Ok(Json.toJson(finalResult))
}

Action.async{
为了{
结果1