访问scala futures返回的值

我是scala futures的新手，我对scala futures的回报值有疑问

因此，scala未来的语法通常是

 def downloadPage(url: URL) = Future[List[Int]] {

 }

我想知道如何从调用此方法的其他方法访问

列表[Int]

换句话说,

val result = downloadPage("localhost") 

那么，将来如何才能获得

List[Int]

---

我尝试过使用map方法，但未能成功完成此操作。`

您需要等待将来完成，才能在给定的时间间隔内获得结果，下面是一些可行的方法：

  import scala.concurrent.duration._

  def downloadPage(url: URL) = Future[List[Int]] {
    List(1,2,3)
  }

  val result = downloadPage("localhost")

  val myListInt = result.result(10 seconds)

理想情况下，如果您使用的是

Future

，您不希望阻塞正在执行的线程，因此您可以将处理

Future

结果的逻辑移到

onComplete

方法中，如下所示：

  result.onComplete({
    case Success(listInt) => {
      //Do something with my list
    }
    case Failure(exception) => {
      //Do something with my error
    }
  })

---

您需要等待将来完成，才能在给定的时间范围内获得结果，以下是一些可行的方法：

  import scala.concurrent.duration._

  def downloadPage(url: URL) = Future[List[Int]] {
    List(1,2,3)
  }

  val result = downloadPage("localhost")

  val myListInt = result.result(10 seconds)

理想情况下，如果您使用的是

Future

，您不希望阻塞正在执行的线程，因此您可以将处理

Future

结果的逻辑移到

onComplete

方法中，如下所示：

  result.onComplete({
    case Success(listInt) => {
      //Do something with my list
    }
    case Failure(exception) => {
      //Do something with my error
    }
  })

成功案例（listInt）=>我想返回listInt，但我不知道如何返回

最佳实践是不返回值。相反，您只需将未来（或使用

map

、

flatMap

等转换的版本）传递给需要此值的每个人，他们可以添加自己的

onComplete

如果您确实需要返回它（例如，在实现遗留方法时），那么您唯一能做的就是阻止（例如，使用），并且您需要决定等待多长时间

成功案例（listInt）=>我想返回listInt，但我不知道如何返回

最佳实践是不返回值。相反，您只需将未来（或使用

map

、

flatMap

等转换的版本）传递给需要此值的每个人，他们可以添加自己的

onComplete

---

如果您真的需要返回它（例如，在实现遗留方法时），那么您唯一能做的就是阻止（例如，使用），并且您需要决定等待多长时间。

我希望您已经解决了这个问题，因为它是在2013年提出的，但也许我的回答可以帮助其他人：

如果您使用的是Play Framework，它支持异步操作（实际上所有操作在内部都是异步的）。创建异步操作的一种简单方法是使用

Action.async（）

。您需要为此函数提供一个

Future[Result]

现在，您可以使用Scala的map、flatMap或async/await，从

Future[List[Int]]

转换为

Future[Result]

。这里是Play框架文档中的一个示例

import play.api.libs.concurrent.Execution.Implicits.defaultContext

def index = Action.async {
  val futureInt = scala.concurrent.Future { intensiveComputation() }
  futureInt.map(i => Ok("Got result: " + i))
}

---

我希望你已经解决了这个问题，因为它是在2013年提出的，但也许我的回答可以帮助其他人：

如果您使用的是Play Framework，它支持异步操作（实际上所有操作在内部都是异步的）。创建异步操作的一种简单方法是使用

Action.async（）

。您需要为此函数提供一个

Future[Result]

现在，您可以使用Scala的map、flatMap或async/await，从

Future[List[Int]]

转换为

Future[Result]

。这里是Play框架文档中的一个示例

import play.api.libs.concurrent.Execution.Implicits.defaultContext

def index = Action.async {
  val futureInt = scala.concurrent.Future { intensiveComputation() }
  futureInt.map(i => Ok("Got result: " + i))
}

---

我所发现的思考未来的最好方式是，在某个时刻，一个盒子里会装着你想要的东西。未来的关键是永远不要打开盒子。试图强行打开盒子会导致阻塞和悲伤。相反，您将未来放在另一个更大的框中，通常使用映射方法

下面是一个包含字符串的Future的示例。当Future完成时，将调用Console.println：

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

object Main {

  def main(args:Array[String]) : Unit = {
    val stringFuture: Future[String] = Future.successful("hello world!")
    stringFuture.map {
      someString =>
        // if you use .foreach you avoid creating an extra Future, but we are proving
        // the concept here...
        Console.println(someString)
    }
  }
}

注意，在本例中，我们调用main方法，然后…finishing。字符串的未来由全局ExecutionContext提供，用于调用Console.println。这很好，因为当我们放弃控制某个字符串何时出现以及何时调用Console.println时，我们让系统自行管理。相反，看看当我们试图强行打开盒子时会发生什么：

val stringFuture: Future[String] = Future.successful("hello world!")
val someString = Future.await(stringFuture)

---

在这种情况下，我们必须等待——让一条线旋转它的拇指——直到我们得到一些字符串。我们已经打开了这个盒子，但我们不得不占用系统的资源来实现它。

我发现思考未来的最佳方式是在某个时候，一个盒子会包含你想要的东西。未来的关键是永远不要打开盒子。试图强行打开盒子会导致阻塞和悲伤。相反，您将未来放在另一个更大的框中，通常使用映射方法

下面是一个包含字符串的Future的示例。当Future完成时，将调用Console.println：

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

object Main {

  def main(args:Array[String]) : Unit = {
    val stringFuture: Future[String] = Future.successful("hello world!")
    stringFuture.map {
      someString =>
        // if you use .foreach you avoid creating an extra Future, but we are proving
        // the concept here...
        Console.println(someString)
    }
  }
}

注意，在本例中，我们调用main方法，然后…finishing。字符串的未来由全局ExecutionContext提供，用于调用Console.println。这很好，因为当我们放弃控制某个字符串何时出现以及何时调用Console.println时，我们让系统自行管理。相反，看看当我们试图强行打开盒子时会发生什么：

val stringFuture: Future[String] = Future.successful("hello world!")
val someString = Future.await(stringFuture)

---

在这种情况下，我们必须等待——让一条线旋转它的拇指——直到我们得到一些字符串。我们已经打开了这个盒子，但是我们必须占用系统的资源来实现它。

您可以这样做。如果

Await.result

方法中给出的等待时间小于执行

awaitable

所需的时间，则将出现

TimeoutException

，您需要处理错误（或任何其他错误）

---

你可以这样做。如果没有