scala - Diferencia entre avanzar y contar en akka actores.

Question

Qué diferencia hay entre decir y reenviar, en caso de que envíe el mismo mensaje:

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

y

case msg: Message =>
  otherActor forward msg

Answer 1

target.tell (mensaje, getSelf ()); Resultado final del objeto = ""; target.forward (resultado, getContext ());

Aquí, getself () es la auto referencia del actor. getcontext () es la referencia del supervisor.

Answer 2

El sender() será diferente en el extremo receptor.

Los mensajes se envían usando tell (también conocido como ! ):

A dice el mensaje M a B
B le dice ese mensaje a C
C piensa que el sender() del mensaje M es B

El mensaje se envía usando reenviar :

A dice el mensaje M a B
B reenvía ese mensaje a C
C piensa que el sender() del mensaje M es A

Vale la pena señalar que puede lograr lo mismo que forward cuando se configura explícitamente el remitente de un mensaje usando tell , sin embargo, esto no es típico del estilo Akka:

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

Para obtener más información, consulte los documentos sobre adelante .

Answer 3

Tell establece el remitente como el actor que envía el mensaje.

Forward mantiene el remitente original del mensaje.

Answer 4

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