playframework scala Seq[未来[模型]]删除未来

我有以下问题,

我有一个

Seq[Future[ProcessStepTemplatesModel]

，我想删除内部Future

我期望得到的是一个

Seq[ProcessStepTemplatesModel]

完整的代码如下所示

Future.sequence {
        processSteps.map { step => // This is a "for each" over a Seq[ProcessStepTemplatesModel]
            val prerequisiteFuture = processStepPrerequisitesDTO.getProcessStepPrerequisiteProcessTemplateIds(step.id.get)

            prerequisiteFuture.map(prereqTemplates => {

             processTemplateDTO.getProessTemplatesForStepPreqrequsites(prereqTemplates).map(pres => {
                 step.stepPrerequisites ++Some(pres)
                 step
                })

            })
        }
      }

谢谢

更新：

def getEditProcessTemplateData(processTemplateId: Int) = Action.async {
    //Get all steps of this process templates
    val stepIds: Future[Seq[Int]] = processTemplateDTO.getProcessStepTemplateIds(processTemplateId)

    val process = for {
      allApprovedProcessTemplates <- processTemplateDTO.getApprovedProcessTemplates //Get all approved process templates
      processTemplate <- processTemplateDTO.getProcessTemplate(processTemplateId) // Get the Process Template
      prerequisites <- getProcessTemplateForEdit(processPrerequisitesDTO.getProcessPrerequisiteProcessTemplateIdsByProcessTemplateId(processTemplateId))
      postConditions <- getProcessTemplateForEdit(processPostConditionsDTO.getProcessPostConditionProcessTemplateIdsByProcessTemplateId(processTemplateId))
      approvedProcessTemplate <- processTemplateDTO.getProcessTemplate(processTemplate.get.approveprocess)
      trainedProcessTemplate <- processTemplateDTO.getProcessTemplate(processTemplate.get.trainingsprocess)
      processSteps <- processTemplateDTO.getProcessStepTemplates(processTemplateId)
      // Step prerequisites
      processStepsPrerequisites <- getProcessStepsPrerequisites(stepIds)
      processStepsPrerequisiteProcessTemplate <- getProcessStepsPrerequisiteProcessTemplate(stepIds)
      processTemplatesForStepPrerequisites <- getProcessTemplateForStepPrerequisite(stepIds)
      // Step post conditions
      processStepsPostConditions <- getProcessStepsPostConditions(stepIds)
      processStepPostConditionProcessTemplate <- getProcessStepPostConditionProcessTemplate(stepIds)
      processTemplatesForStepPostConditions <- getProcessTemplateForStepPostCondition(stepIds)
      // Derived processes
      derivedProcesses <- getDerivedProcesses(stepIds)
      processTemplatesForStepDerivedProcesses <- getProcessStepsDerivedProcesses(stepIds)
      // Process to process step
      processStepsTemplates_ProcessTemplates <- getProcessStepsTemplates_ProcessTemplates(stepIds)
      processTemplatesForProcessTemplatesToProcessStep <- getProcessTemplateToProcessStepId(stepIds)
      responsible <- raciProcessTemplateDTO.getResponsibleProcessTemplates(processTemplateId) // get all responsibles for this process template
      accountable <- raciProcessTemplateDTO.getAccountableProcessTemplates(processTemplateId) // get all accountables for this process template
      consulted <- raciProcessTemplateDTO.getConsultedProcessTemplates(processTemplateId) // get all consulted for this process template
      informed <- raciProcessTemplateDTO.getInformedProcessTemplates(processTemplateId) // get all consulted for this process template
    } yield (allApprovedProcessTemplates, processTemplate, prerequisites, postConditions, processSteps, processStepsPrerequisites,
      processStepsPrerequisiteProcessTemplate, processTemplatesForStepPrerequisites, processStepsPostConditions, processStepPostConditionProcessTemplate, processTemplatesForStepPostConditions, derivedProcesses,
      processTemplatesForStepDerivedProcesses, processStepsTemplates_ProcessTemplates, processTemplatesForProcessTemplatesToProcessStep, approvedProcessTemplate, trainedProcessTemplate, responsible, accountable, consulted, informed)

    process.flatMap({ case (allApprovedProcessTemplates, processTemplate, prerequisites, postConditions, processSteps, processStepsPrerequisites,
    processStepsPrerequisiteProcessTemplate, processTemplatesForStepPrerequisites, processStepsPostConditions, processStepPostConditionProcessTemplate, processTemplatesForStepPostConditions, derivedProcesses,
    processTemplatesForStepDerivedProcesses, processStepsTemplates_ProcessTemplates, processTemplatesForProcessTemplatesToProcessStep, approvedProcessTemplate, trainedProcessTemplate, responsible, accountable, consulted, informed) =>

      Future.sequence {
        processSteps.map {
          step =>
            val prerequisiteFuture = processStepPrerequisitesDTO.getProcessStepPrerequisiteProcessTemplateIds(step.id.get)

            prerequisiteFuture.map(prereqTemplates => {

              processTemplateDTO.getProessTemplatesForStepPreqrequsites(prereqTemplates).map(pres => {
                  println("test", pres) // they are printed
                  step.stepPrerequisites ++Some(pres)
                  println("test2", step)
                 step
                })

            })
        }
      }.map {
        stepTemplates =>
          Ok(Json.obj(
            "allApprovedProcessTemplates" -> allApprovedProcessTemplates,
            "processTemplate" -> processTemplate,
            "prerequisites" -> prerequisites,
            "postConditions" -> postConditions,
            "approvedProcessTemplate" -> approvedProcessTemplate,
            "trainedProcessTemplate" -> trainedProcessTemplate,
            // Step prerequisites
            "processStepsPrerequisites" -> processStepsPrerequisites,
            "processStepsPrerequisiteProcessTemplate" -> processStepsPrerequisiteProcessTemplate,
            "processTemplatesForStepPrerequisites" -> processTemplatesForStepPrerequisites,
            // Step post conditions
            "processStepsPostConditions" -> processStepsPostConditions,
            "processStepPostConditionProcessTemplate" -> processStepPostConditionProcessTemplate,
            "processTemplatesForStepPostConditions" -> processTemplatesForStepPostConditions,
            // Derived processes
            "derivedProcesses" -> derivedProcesses,
            "processTemplatesForStepDerivedProcesses" -> processTemplatesForStepDerivedProcesses,
            // Process to process step
            "processStepsTemplates_ProcessTemplates" -> processStepsTemplates_ProcessTemplates,
            "processTemplatesForProcessTemplatesToProcessStep" -> processTemplatesForProcessTemplatesToProcessStep,
            "steps" -> "stepTemplates",
            "responsible" -> responsible,
            "accountable" -> accountable,
            "consulted" -> consulted,
            "informed" -> informed
          ))
      }
    })
  }

def getEditProcessTemplateData（processTemplateId:Int）=Action.async{
//获取此过程的所有步骤模板
val stepId:Future[Seq[Int]]=processTemplateDTO.GetProcessStepTemplateId（processTemplateId）
val进程=用于{
allApprovedProcessTemplates ProcessTemplates ForProcessTemplatesToProcessStep，
“步骤”->“步骤模板”，
“负责任”->负责任，
“负责任”->负责任，
“咨询”->咨询，
“知情”->知情
))
}
})
}

---

Future.sequence

将

Seq[Future[ProcessStepTemplatesModel]

转换为

Future[Seq[ProcessStepTemplatesModel]

。因此，如果您只需要

Seq[ProcessStepTemplatesModel]

就可以等到未来

Await.result({
  Future.sequence {
    processSteps.map ...
  }
}, 1 minute)

但是，在你的情况下，阻塞是否是一个好主意，只有你才能知道

---

例如，这里有一个控制器，它具有

列表[Future[Int]

并应用

Future.sequence

打印整数：

/app/controllers/HomeController.scala

/app/views/index.scala.html

这里

我看不出您是如何使用

步骤的值的。如果返回原始
步骤
。有任何副作用吗？
工作解决方案是：

Future.sequence {
        processSteps.map {
          step =>
            val prerequisiteFuture = processStepPrerequisitesDTO.getProcessStepPrerequisiteProcessTemplateIds(step.id.get)
            prerequisiteFuture.map(prereqTemplates => {
              processTemplateDTO.getProessTemplatesForStepPreqrequsites(prereqTemplates).map(pres => {
                  println("test", pres) // they are printed
                  step.stepPrerequisites = Some(pres)
                  println("test2", step)
                 step
                })
            })
        }
      }.flatMap {
        stepTemplates => {

          Future.sequence(stepTemplates).map(test =>

            Ok(Json.obj( [....]

你的代码怎么了？你说的去除内在未来是什么意思？使用future.traverse将为您提供一个
未来[Seq[ProcessStepTemplatesModel]]
，这不是您想要的吗？什么类型的
processTemplateDTO.GetProessTemplatesForStepPreqRequisites（prereqTemplates）
？最后我需要的是一个
Seq[ProcessStepTemplatesModel]
这个
processTemplateDTO.GetProessTemplatesForStepPreqRequisites（pr‌​eRequestTemplates）
返回一个
未来[Seq[ProcessTemplatesModel]]
任何像“删除未来”、“提取未来”这样的问题都没有意义。请注意，人们不太可能帮助你，因为你似乎问了很多问题，每一个问题都跟在前一个问题后面。这表明——至少对我来说——你自己没有做太多的研究和实验。我知道我会问很多问题，以防我有很多问题；）。。。有没有一个不用等待的解决方案？您是否知道您的问题是如何从
Future[X]
获取
X
？答案取决于您下一步对
X
所做的操作。类似的问题是如何从
选项[X]
或
列表[X]
获取
X
{res@Felix好吧，这不是全部代码。不清楚这个方法在哪里，如何调用，以及里面的东西是什么类型。它看起来像来自某个控制器的代码。它呈现了一些页面吗？这个控制器现在做什么，你希望它做什么？现在它生成一些json，你希望它生成其他json吗？是的这是一个控制器方法。它应该只在最后返回一个json。它是做什么的。但不是整个json。因为上面提到的问题。你需要哪种类型？
@(nums: List[Int])

@main("Welcome to Play") {
  <h1>Welcome to Play!</h1>
    <ul>
    @for(num <- nums) {
        <li>@num</li>
    }
    </ul>
}

  def index() =
    Action.async {
      Future.sequence {
        List(1, 2).map(num =>
          Future{
            Thread.sleep(5000)
            10
          }.map(n =>
            num + n
          )
        )
      }.map {
        nums =>
          Ok(views.html.index(nums))
      }
    }

             step.stepPrerequisites ++Some(pres)
             step

Future.sequence {
        processSteps.map {
          step =>
            val prerequisiteFuture = processStepPrerequisitesDTO.getProcessStepPrerequisiteProcessTemplateIds(step.id.get)
            prerequisiteFuture.map(prereqTemplates => {
              processTemplateDTO.getProessTemplatesForStepPreqrequsites(prereqTemplates).map(pres => {
                  println("test", pres) // they are printed
                  step.stepPrerequisites = Some(pres)
                  println("test2", step)
                 step
                })
            })
        }
      }.flatMap {
        stepTemplates => {

          Future.sequence(stepTemplates).map(test =>

            Ok(Json.obj( [....]