web-dev-qa-db-fra.com

Différence entre les acteurs avancés et les acteurs akka

Quelle est la différence entre tell et forward, au cas où j'enverrais le même message:

case msg: Message =>
  otherActor tell (msg,sender)

et

case msg: Message =>
  otherActor forward msg
scalaakkaactor
53
Michał Jurczuk

La sender() sera différente chez le destinataire.


Le message envoie en utilisant tell (également appelé !):

Adit message M à B. 
Bdit à ce message à C. 
C pense que la sender() du message M est B.


Le message envoie en utilisant forward:

Adit message M à B. 
Btransmet ce message à C.
C pense que la sender() du message M est A.



Il est intéressant de noter que vous pouvez obtenir le même résultat que forward lorsque vous définissez explicitement l'expéditeur d'un message à l'aide de tell, mais ce n'est pas typique du style Akka

// inside `B`, when received `msg` from `A`
C tell (msg, A) 
      == 
C forward msg



Pour plus d’informations, reportez-vous à la documentation relative à forward .

95
Konrad 'ktoso' Malawski

Tell définit l'expéditeur comme l'acteur envoyant le message.

Forward conserve l'expéditeur d'origine du message.

15
monkjack

target.tell (message, getSelf ()); final Object result = ""; target.forward (resultat, getContext ());

Ici, getself () est l'auto-référence de l'acteur . getcontext () est la référence du superviseur.

1
Suresh Kumar
import akka.actor.{Actor, ActorSystem, Props}
case object FromActor3
/**
  * forward method: Forwards the message and passes the original sender actor as the sender.
  */

object ActorForward extends App {

  class ActorExample extends Actor {
      def receive = {
       case message: String =>
        println(s"Message received from ${sender.path.name}, message = $message")
       val child = context.actorOf(Props[Actor2], "ChildActor")
       child ! message
      case FromActor3 => println("Response when forwarded by Actor2 to Actor3")
       }
  }

class Actor2 extends Actor {
    def receive = {
      case message: String =>
      println(s"Message received from ${sender.path.name}, message = $message")
    val child = context.actorOf(Props[Actor3], "ChildActor")
    println("forwarding...")
    child forward message
    case _ => println("Unknown message")
}
  }


class Actor3 extends Actor {
   def receive = {
    case message: String =>
    println(s"Message received from ${sender.path.name}, message = $message")
    sender ! FromActor3
   case _ => println("Unknown message")
}
  }


  val actorSystem = ActorSystem("ActorSystem")
  val actor = actorSystem.actorOf(Props[ActorExample], "RootActor")
  actor ! "Hello"
}
0
Aamir