Verschil tussen doorsturen en vertellen in akka-acteurs

Wat is een verschil tussen vertellen en doorsturen, voor het geval ik hetzelfde bericht stuur:

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

en

case msg: Message =>
  otherActor forward msg

Antwoord 1, autoriteit 100%

De sender()zal aan de ontvangende kant anders zijn.

Bericht wordt verzonden met tell(ook bekend als !):

Averteltbericht Maan B.
Bverteltdat bericht aan C.
Cdenkt dat de sender()van bericht MBis.

Bericht wordt verzonden met doorsturen:

Averteltbericht Maan B.
Bstuurt dat bericht doornaar C.
Cdenkt dat de sender()van bericht MAis.

Het is de moeite waard om erop te wijzen dat je hetzelfde kunt bereiken als forwardwanneer je de afzender van een bericht expliciet instelt met tell, maar dit is niet typisch Akka-stijl:

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

Raadpleeg voor meer informatie de docs over forward.

Antwoord 2, autoriteit 14%

Tell stelt de afzender in als de acteur die het bericht verstuurt.

Doorsturen behoudt de oorspronkelijke afzender van het bericht.

Antwoord 3

target.tell(bericht, getSelf());
uiteindelijke Object resultaat = “”;
target.forward(resultaat, getContext());

Hier,
getself() is de zelfreferentie van de acteur.
getcontext() is de supervisor-referentie.

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