scala 将 Object 添加到 Seq[Future[Model]] 并等待完成返回

Question

嗨，在我的scala应用程序中，我想将Seq[Model]返回到我的前端。

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 -------------------------------")
        var templates: Seq[Future[Option[ProcessTemplatesModel]]] = Future.sequence(stepIds.s.map(s => {
          processTemplateDTO.getProcessStepTemplate(s.processStep_id).flatMap(stepTemplate => {
            templates :+ processTemplateDTO.getProcessTemplate(stepTemplate.get.processTemplate_id.get)
          })
        }))
        templates.map(done => {
          Future.sequence(templates).map(a => {
            Ok(Json.obj("id" -> a))
          })
        })


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

我需要等到它完成，然后返回。实现这一目标的好方法是什么？

提前谢谢。

更新：

目前我尝试这个：

 val fList: List[Future[ProcessTemplatesModel]] +: stepIds.s.map(s => {
             processTemplateDTO.getProcessStepTemplate(s.processStep_id).map(stepTemplate => {
              processTemplateDTO.getProcessTemplate(stepTemplate.get.processTemplate_id.get).map(a => {
                a.get
              })
            })
          })
        Future.successful( Ok(Json.obj("id" -> fList)))

我认为在这种情况下，问题是+:。

Answer 1

我认为你只需要重写这部分：

templates.map(done => {
          Future.sequence(templates).map(a => {
            Ok(Json.obj("id" -> a))
          })
        })

如果你要做这样的事情：

val futSeqOpt: Future[Seq[Option[ProcessTemplatesModel]]] = Future.sequence(templates)
val futSeq: Future[Seq[ProcessTemplatesModel]] = futSeqOpt.map(_.getOrElse("defaultValue"))
futSeq.map(seq => Ok(Json.toJson(seq)))

它应该有效。(我只添加了用于演示的类型(。