playframework scala Seq[Future[Model]] 删除未来

Question

我有以下问题，

我有一个 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
          ))
      }
    })
  }

Answer 1

Future.sequence 将 Seq[Future[ProcessStepTemplatesModel]] 转换为 Future[Seq[ProcessStepTemplatesModel]]。所以如果你只需要Seq[ProcessStepTemplatesModel]你可以等到未来到来

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

但是在你的情况下阻塞是否是个好主意只有你自己知道。

例如，这里有一个具有 List[Future[Int]] 并应用 Future.sequence 打印整数的控制器：

/app/controllers/HomeController.scala

package controllers

import javax.inject._

import play.api._
import play.api.mvc._

import scala.concurrent.Future

import scala.concurrent.ExecutionContext.Implicits.global

@Singleton
class HomeController @Inject()(cc: ControllerComponents) extends AbstractController(cc) {

  def index() =
    Action.async {
      Future.sequence {
        List(Future(1), Future(2))
      }.map { nums =>
          Ok(views.html.index(nums))
      }
    }
}

/app/views/index.scala.html

@(nums: List[Int])

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

好的，这个和你的更相似，打印出 11, 12:

  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

我看不出你怎么用step.stepPrerequisites ++Some(pres)的值，你return原来的step。有没有副作用？

Answer 2

工作解决方案是：

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( [....]

playframework scala Seq[Future[Model]] 删除未来

playframework scala Seq[Future[Model]] removing the Future

scala

playframework

playframework-2.0