在同一个Action.asyncScala Play调用2个期货

Question

我是一个Scala新手:(也就是说，我反对Play framework Action.async和Future calls。

我想在同一个动作中调用2个Futures，并等待它们都计算出来，然后将结果发送到我的视图中。

以下是代码：

    def showPageWithTags(category: String) = Action.async {
        val page = PageDAO.findOne(Json.obj("category" -> category)).map {
          case Some(page) => {
            page.content = page.content.byteArrayToString
          }
        }
        val futureTags = ArticleDAO.listTags
        Ok(views.html.web.pages.show(page, futureTags))
   }

通过该定义的功能：

def findOne(id: String): Future[Option[PageModel]]

def listTags: Future[List[String]] 

我得到这个错误：

[error]  found   : Some[A]
[error]  required: models.PageModel
[error]         case Some(page) => {
[error]              ^
.../...
[error]  found   : None.type
[error]  required: models.PageModel
[error]         case None => {
[error]              ^
.../...
[error]  found   : Option[Nothing]
[error]  required: scala.concurrent.Future[play.api.mvc.Result]
[error]       optionPage.map {
[error]                      ^
.../...
[error]  found   : scala.concurrent.Future[Unit]
[error]  required: models.PageModel
[error]         Ok(views.html.web.pages.show(optionPage, futureTags))
[error]                                      ^
.../...
[error]  found   : scala.concurrent.Future[List[String]]
[error]  required: List[String]
[error]         Ok(views.html.web.pages.show(optionPage, futureTags))
[error]                                                  ^

我试着用map、for/yield、foreach来处理期权和期货，但总有一个错误仍然存在。

然而，在我添加“标记”功能之前，未来的一个调用运行良好:

  def showPage(category: String) = Action.async {
    PageDAO.findOne(Json.obj("category" -> category)).map {
      case Some(page) => {
        page.content = page.content.byteArrayToString
        Ok(views.html.web.pages.show(page))
      }
      case None => {
        NotFound
      }
    }
  }

如何在同一个操作中调用2个Futures并等待它们都计算通过Ok（）将它们传递给我的页面浏览量？

非常感谢任何澄清！

Answer 1

可以这样试试。

def showPageWithTags(category: String) = Action.async {

   for{
       pOpt <- PageDAO.findOne(Json.obj("category" -> category))
      futureTags <- ArticleDAO.listTags
      } yield{
          pOpt match {
           case Some(x)=> Ok(views.html.web.pages.show(x.content.byteArrayToString, futureTags))
           case _=> NotFound
                     }              
            }         
}

Answer 2

您可以使用< code>Future的< code>flatMap方法。

faceMap方法采用一个函数，该函数将值映射到一个新的未来g，然后返回一个在g完成后完成的未来。

(来自http://docs.scala-lang.org/overviews/core/futures.html)

因此，不妨尝试：

def showPage(category: String) = Action.async {
  ArticleDAO.listTags.flatMap { tags =>
    PageDAO.findOne(Json.obj("category" -> category)).map {
      case Some(page) => {
        page.content = page.content.byteArrayToString
        Ok(views.html.web.pages.show(page, tags))
      }
      case None => {
        NotFound
      }
    }
  }

Answer 3

您需要映射和平面映射未来的以异步访问它们的结果<代码>操作。异步需要一个未来的[结果]，因此您必须将未来的映射到该结果。这里有一个简单的方法：

def showPageWithTags(category: String) = Action.async {
    val page = PageDAO.findOne(Json.obj("category" -> category)).map {
      case Some(page) => {
        page.content.byteArrayToString
      }
    }
    val futureTags = ArticleDAO.listTags

    page.flatMap { page =>
        futureTags.map { tags =>
            Ok(views.html.web.pages.show(page, tags))
        }
    }
}

或者您可以使用for理解来清理它，它是平面地图/map的语法糖。

def showPageWithTags(category: String) = Action.async {
    for {
        pageOpt <- PageDAO.findOne(Json.obj("category" -> category))
            .map(_.map(_.content.byteArrayToString))
        tags <- ArticleDAO.listTags
    } yield {
        pageOpt.map { page =>
            Ok(views.html.web.pages.show(page, tags))
        } getOrElse {
            NotFound
        }
    }
}

我还擅自简化了您在< code>findOne结果上的< code >地图。