Scala Play：如何等到将来完成后，再将OK结果返回到前端

在我的playframework应用程序中，我希望等到我的未来完成并返回视图

我的代码如下所示：

 def getContentComponentUsageSearch: Action[AnyContent] = Action.async { implicit request =>
    println(request.body.asJson)
    request.body.asJson.map(_.validate[StepIds] match {
      case JsSuccess(stepIds, _) =>

        println("VALIDE SUCCESS -------------------------------")


        val fList: List[Seq[Future[ProcessTemplatesModel]]] = List() :+ stepIds.s.map(s => {
          processTemplateDTO.getProcessStepTemplate(s.processStep_id).flatMap(stepTemplate => {
            processTemplateDTO.getProcessTemplate(stepTemplate.get.processTemplate_id.get).map(a => {
              a.get
            })
          })
        })


        fList.map(u => {
          val a: Seq[Future[ProcessTemplatesModel]] = u

          Future.sequence(a).map(s => {
            println(s)
          })
        })


        Future.successful(Ok(Json.obj("id" -> "")))

      case JsError(_) =>
        println("NOT VALID -------------------------------")
        Future.successful(BadRequest("Process Template not create client"))
      case _ => Future.successful(BadRequest("Process Template create client"))
    }).getOrElse(Future.successful(BadRequest("Process Template create client")))
  }

pirntln（s）

正在打印成品。但我如何才能等到它完成并返回到视图

提前谢谢

更新：

我也试过：

  val process = for {

      fList: List[Seq[Future[ProcessTemplatesModel]]] <- List() :+ stepIds.s.map(s => {
        processTemplateDTO.getProcessStepTemplate(s.processStep_id).flatMap(stepTemplate => {
          processTemplateDTO.getProcessTemplate(stepTemplate.get.processTemplate_id.get).map(a => {
            a.get
          })
        })
      })

    } yield (fList)





    process.map({ case (fList) =>
      Ok(Json.obj(
        "processTemplate" -> fList
      ))
    })

val进程=for{
fList:List[Seq[Future[ProcessTemplatesModel]]{
processTemplateDTO.getProcessStepTemplate（s.processStep_id）.flatMap（stepTemplate=>{
processTemplateDTO.getProcessTemplate（stepTemplate.get.processTemplate_id.get）.map（a=>{
a、 得到
})
})
})
}收益率（fList）
process.map（{case（fList）=>
Ok（Json.obj(
“processTemplate”->fList
))
})

但后来我发现：

更新：

---

我的问题是，在返回OK结果之前，fList中的futures没有完成

问题中的代码似乎不可编译，因此下面是一个未经测试的非常粗略的草图，希望能为进一步搜索正确的解决方案提供足够的灵感：

def getContentComponentUsageSearch: = Action.async { implicit req =>
  req.body.asJson.map(_.validate[StepIds] match {
    case JsSuccess(stepIds, _) => {

      // Create list of futures
      val listFuts: List[Future[ProcessTemplatesModel]] = (stepIds.s.map(s => {
        processTemplateDTO.
          getProcessStepTemplate(s.processStep_id).
          flatMap{ stepTemplate => 
            processTemplateDTO.
              getProcessTemplate(stepTemplate.get.processTemplate_id.get).
              map(_.get)
          }
      })).toList

      // Sequence all the futures into a single future of list
      val futList = Future.sequence(listFuts)

      // Flat map this single future to the OK result
      for {
        listPTMs <- futList
      } yield {
        // Apparently some debug output? 
        listPTMs foreach printl

        Ok(Json.obj("id" -> ""))
      }
    }

    case JsError(_) => {
      println("NOT VALID -------------------------------")
      Future.successful(BadRequest("Process Template not create client"))
    }

    case _ => Future.successful(BadRequest("Process Template create client"))

  }).getOrElse(Future.successful(BadRequest("Process Template create client")))
}

然后，我将所有的未来组合成一个单一的未来列表，只有当每个元素都完成时，该列表才会完成：

  // Sequence all the futures into a single future of list
  val futList = Future.sequence(listFuts)

然后我使用了一个

for

-理解来确保

列表ptms

在返回

OK

之前完成计算：

  // Flat map this single future to the OK result
  for {
    listPTMs <- futList
  } yield {
    // Apparently some debug output? 
    listPTMs foreach printl

    Ok(Json.obj("id" -> ""))
  }

//将这个单一的未来简单地映射到OK结果
为了{
listPTMs“”）
}

---

产量的

（相当于此处的
map
）是在进行该行为之前确定完成时间的因素，以便在构建
OK
之前对
listPTMs
进行全面评估。
为了等待未来完成，最常见的做法是做以下两件事之一：

使用a进行理解，在执行
yield
部分中的任何操作之前，在幕后进行一系列映射和平面映射（有关更详细的解释，请参见Andrey的评论）。一个简化的例子：

def index: Action[AnyContent] = Action.async {    
  val future1 = Future(1)
  val future2 = Future(2)

  for {
    f1 <- future1
    f2 <- future2
  } yield {
    println(s"$f1 + $f2 = ${f1 + f2}") // prints 3
    Ok(views.html.index("Home"))
  }
}

如果存在多个期货：

def index: Action[AnyContent] = Action.async {

  val future1 = Future(1)
  val future2 = Future(2)

  future1.flatMap{
    f1 =>
      future2.map {
        f2 =>
          println(s"$f1 + $f2 = ${f1 + f2}")
          Ok(views.html.index("Home"))
      }
    }
  }
}

然而，当你有多个期货时，
对于收益率的理解力会变得更强，因为它更容易阅读。此外，您可能知道，但如果您从事期货业务，您可能需要进行以下导入：

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

不是完全重复的，因为异步将结果管道化到播放视图没有问题……等待不是一个可接受的解决方案。难道没有别的办法吗？再一次，和另一个问题一样的问题。你写“我想要”，然后你扔掉一大堆不可编译的代码，里面有上千个未定义的类型和变量，期望得到一个有意义的答案。请把它简化成一个简单的句子，并清楚地说明你尝试了什么以及确切的问题是什么。消除不必要的细节。将一个“hello”字符串从future传输到视图将是本质上相同的问题的一个示例，但没有依赖项和未定义的变量。问题只是等待future完成。一个最小的例子是不可能的。因为part I postet只是一个非常非常小的部分……不，你不想等到将来完成，因为游戏是建立在Akka之上的，在Akka中，一切都可以异步完成，而不会阻塞线程。你有没有把这个评论线程和链接评论线程搞混了，在链接评论线程中既没有播放也没有Akka，或者什么？
def index: Action[AnyContent] = Action.async {

  val future1 = Future(1)
  val future2 = Future(2)

  future1.flatMap{
    f1 =>
      future2.map {
        f2 =>
          println(s"$f1 + $f2 = ${f1 + f2}")
          Ok(views.html.index("Home"))
      }
    }
  }
}

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global