scala - 无法在[[scala.concurrent.Future]]上获取`pipeTo`方法

正如akka的文档所解释的那样，您应该可以通过以下方式在[[scala.concurrent.Future]]上获得pipeTo方法：

import akka.pattern.pipe
val future = ...
future pipeTo sender()

不幸的是，我无法做到这一点，我在IDE中收到“无法解析符号pipeTo”错误。

解决方法是，我必须以这种方式使用语法

pipe(future) pipeTo sender()

但这仍然困扰着我不知道为什么（我在scala BTW中还很陌生）。非常感谢帮助您理解这个难题。

斯卡拉2.12.2
阿卡2.5.3

最佳答案

您需要在范围内有一个implicit ExecutionContext，这是一个示例：

import akka.actor.{Actor, ActorSystem, Props}
import akka.pattern.pipe

import scala.concurrent.Future

// Get the implicit ExecutionContext from this import
import scala.concurrent.ExecutionContext.Implicits.global

object Hello extends App {

  // Creating a simple actor
  class MyActor extends Actor {
    override def receive: Receive = {
      case x => println(s"Received message: ${x.toString}")
    }
  }

  // Create actor system
  val system = ActorSystem("example")
  val ref = system.actorOf(Props[MyActor], "actor")

  // Create the future to pipe
  val future: Future[Int] = Future(100)

  // Test
  future pipeTo ref
}

安慰：

sbt run
[info] <stuff here>
[info] Running example.Hello
Received message: 100

之所以必须这样做，是因为pipeTo是PipeableFuture上的实例函数，并且常规的Future必须“增强”为PipeableFuture。这是PipeableFuture的构造函数，请注意implicit executionContext: ExecutionContext参数：

final class PipeableFuture[T](val future: Future[T])(implicit executionContext: ExecutionContext)

完整的类在这里，您可以在其中看到pipeTo函数：

final class PipeableFuture[T](val future: Future[T])(implicit executionContext: ExecutionContext) {
  def pipeTo(recipient: ActorRef)(implicit sender: ActorRef = Actor.noSender): Future[T] = {
    future andThen {
      case Success(r) ⇒ recipient ! r
      case Failure(f) ⇒ recipient ! Status.Failure(f)
    }
  }
  def pipeToSelection(recipient: ActorSelection)(implicit sender: ActorRef = Actor.noSender): Future[T] = {
    future andThen {
      case Success(r) ⇒ recipient ! r
      case Failure(f) ⇒ recipient ! Status.Failure(f)
    }
  }
  def to(recipient: ActorRef): PipeableFuture[T] = to(recipient, Actor.noSender)
  def to(recipient: ActorRef, sender: ActorRef): PipeableFuture[T] = {
    pipeTo(recipient)(sender)
    this
  }
  def to(recipient: ActorSelection): PipeableFuture[T] = to(recipient, Actor.noSender)
  def to(recipient: ActorSelection, sender: ActorRef): PipeableFuture[T] = {
    pipeToSelection(recipient)(sender)
    this
  }
}

由于pipe(future)不是Future上的实例函数，因此可以在您的示例中使用。