Die `pipeTo'-Methode kann nicht auf [[scala.concurrent.Future]]

Question

erreicht werden. Wie das Dokument von akka erklärt, sollten Sie die Methode pipeTo auf [[scala.concurrent.Future]] auf diese Weise erhalten können :

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

Leider kann ich das nicht tun, ich bin immer ein Fehler in meinem IDE „nicht Symbol pipeTo lösen kann“.

Als Abhilfe können hatte ich die Syntax auf diese Weise

pipe(future) pipeTo sender() 

Aber es mich noch benutzen stören, warum (ich bin ganz newby in scala BTW), um nicht herausgefunden. Vielen Dank, um dieses Puzzle zu verstehen.

scala 2.12.2 akka 2.5.3

Answer 1

Sie benötigen ein implicit ExecutionContext in ihrem Umfang haben, hier ein Beispiel:

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 
} 

Console:

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

---

Der Grund dafür ist, dass pipeTo eine Instanzfunktion ist n auf einem PipeableFuture, und Ihr regulärer Future muss zu einem PipeableFuture "erweitert" werden. Hier ist der Konstruktor für PipeableFuture, beachten Sie den implicit executionContext: ExecutionContext Parameter:

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

Die vollständige Klasse ist hier, wo Sie die pipeTo Funktion sehen:

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 
    } 
} 

Da pipe(future) war keine Instanz Funktion auf Zukunft In deinem Beispiel funktioniert es.