playframework Scala return 没有未来

Question

有没有办法只 return Seq[ProcessStepPrerequisitesModel]

而不是未来？

我的函数如下所示：

  def blubb (stepId: Int): Future[Seq[ProcessStepPrerequisitesModel]] ={

      val combinedFuture = for {
        v1 <- processStepPrerequisitesDTO.getProcessStepPrerequisitesByProcessTemplateId(stepId)
        v2 <- processStepPrerequisitesDTO.getProcessStepsPrerequisiteProcessTemplate(stepId)
      } yield (v1,v2)

      val test = combinedFuture.map({ case(v1,v2) => {
        v1.map(v => {
          v2.map(k => {
            if (v.id.get == k.id) v.processTemplate_id = k.processtemplate
            v
          })
        })
        v1
      }})

      test.map(t => {
        println(t)
        t
      })
  }

提前致谢！

更新：

整个方法：

 def getEditProcessTemplateData(processTemplateId: Int, clientId: Int): Action[AnyContent] = Action.async {
    //Get all steps of this process templates
    val process = for {
      stepIds <- processTemplateDTO.getProcessStepTemplateIds(processTemplateId)
      allApprovedProcessTemplates <- processTemplateDTO.getApprovedProcessTemplates(clientId) //Get all approved process templates
      processTemplate <- processTemplateDTO.getProcessTemplate(processTemplateId, clientId) // Get the Process Template
      prerequisites <- getProcessTemplateForEdit(processPrerequisitesDTO.getProcessPrerequisiteProcessTemplateIdsByProcessTemplateId(processTemplateId), clientId)
      postConditions <- getProcessTemplateForEdit(processPostConditionsDTO.getProcessPostConditionProcessTemplateIdsByProcessTemplateId(processTemplateId), clientId)
      approvedProcessTemplate <- processTemplateDTO.getProcessTemplate(processTemplate.get.approveprocess, clientId)
      trainedProcessTemplate <- processTemplateDTO.getProcessTemplate(processTemplate.get.trainingsprocess, clientId)
      processSteps <- processTemplateDTO.getProcessStepTemplates(processTemplateId)
      // Responsibles
      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 (stepIds, allApprovedProcessTemplates, processTemplate, prerequisites, postConditions, processSteps, approvedProcessTemplate, trainedProcessTemplate, responsible, accountable, consulted, informed)

    process.flatMap({ case (stepIds, allApprovedProcessTemplates, processTemplate, prerequisites, postConditions, processSteps, approvedProcessTemplate, trainedProcessTemplate, responsible, accountable, consulted, informed) =>

      Future.sequence {
        processSteps.map {
          step =>
            val prerequisiteFuture = processStepPrerequisitesDTO.getProcessStepPrerequisiteProcessTemplateIds(step.id.get)
            prerequisiteFuture.map(prereqTemplates => {
              processTemplateDTO.getProcessTemplates(prereqTemplates).map(pres => {
                step.stepPrerequisites = Some(pres)
//                step.prerequisites = blubb(step.id.get)
                step
              })
            })

            // Fetches the StepPostCondition Process Templates
            val postConditionsFuture = processStepPostConditionDTO.getProcessStepPostConditionProcessTemplateIds(step.id.get)
            postConditionsFuture.map(postConsTemplates => {
              processTemplateDTO.getProcessTemplates(postConsTemplates).map(pos => {
                step.stepPostconditions = Some(pos)
                step
              })
            })

            // Fetches all Derived ProcessesTemplates for a Process Step Template
            val derivedProcessesFuture = processTemplateDTO.getDerivedProcessesByProcessStep(step.id.get)
            derivedProcessesFuture.map(derived => {
              processTemplateDTO.getProcessTemplates(derived).map(derive => {
                step.stepDerivedProcesses = Some(derive)
                step
              })
            })

            // Fetches all Responsibles for ProcessStep Templates
            val responsibleStepFuture = raciProcessStepTemplateDTO.getResponsibleProcessTemplates(step.id.get)
            responsibleStepFuture.map(responsibles => {
              step.stepResponsible = Some(responsibles)
              step
            })

            // Fetches all SubProcesses for a ProcessStepTemplate
            val subProcessesFuture = processTemplateDTO.getSubProcessesByProcessStep(step.id.get)
            subProcessesFuture.map(subProcesses => {
              processTemplateDTO.getProcessTemplates(subProcesses).map(sub => {
                step.stepSubProcesses = Some(sub)
                step
              })
            })
        }
      }.flatMap {
        stepTemplates => {
          Future.sequence(stepTemplates).map(processStepTemplates =>
            Ok(Json.obj(
              "allApprovedProcessTemplates" -> allApprovedProcessTemplates,
              "processTemplate" -> processTemplate,
              "prerequisites" -> prerequisites,
              "postConditions" -> postConditions,
              "approvedProcessTemplate" -> approvedProcessTemplate,
              "trainedProcessTemplate" -> trainedProcessTemplate,
              "steps" -> processStepTemplates,
              "responsible" -> responsible,
              "accountable" -> accountable,
              "consulted" -> consulted,
              "informed" -> informed,
              "stepIds" -> stepIds
            )))
        }
      }
    })
  }

Answer 1

见How do I wait for asynchronous tasks to complete in scala?

您可以使用 Await 等待未来，例如：

def blubb(stepId: Int): Future[Seq[ProcessStepPrerequisitesModel]] = {
  ...
}

def blockingBlubb(stepId: Int): Seq[ProcessStepPrerequisitesModel] = {
  Await.result(blubb(stepId), Duration.Inf);
}

这将 "block" 一个线程，这可能会在高并发环境中引起问题（但不会对性能不关键的代码造成任何伤害）。

Answer 2

尝试替换

prerequisiteFuture.map(prereqTemplates => {
  processTemplateDTO.getProcessTemplates(prereqTemplates).map(pres => {
    step.stepPrerequisites = Some(pres)
    //                step.prerequisites = blubb(step.id.get)
    step
  })
})

和

prerequisiteFuture.flatMap(prereqTemplates => {
  Future.sequence {
    processTemplateDTO.getProcessTemplates(prereqTemplates).map(pres => {
      step.stepPrerequisites = Some(pres)
      blubb(step.id.get).map(x => {
        step.prerequisites = x
        step
      })
    })
  }
})

playframework Scala return 没有未来

playframework Scala return without future

scala

future

playframework

playframework-2.0