Akka: Kommunikation außerhalb des Akteursystems?

Question

Ich habe folgende Treiber/Hauptklasse mein Akka Programm Einkapseln:

// Groovy pseudo-code 
class FizzBuzz { 
    ActorSystem actorSystem 

    static void main(String[] args) { 
     FizzBuzz d = new FizzBuzz() 
     d.run() 
    } 

    void run() { 
     Initialize initCmd = new Initialize() 
     MasterActor master = actorSystem.get(...) 

     // Tells the entire actor system to initialize itself and start doing stuff. 
     // ChickenCluckDetector is an actor managed/supervised by MasterActor. 
     master.tell(initCmd, ...) 
    } 

    // Called when a ChickenCluckDetector actor inside the actor system receives 
    // a 'Cluck' message. 
    void onChickenGoesCluck(Cluck cluck) { 
     // Do something 
    } 
} 

und die folgenden ChickenCluckDetector Schauspieler:

class ChickenCluckDetector extends UntypedActor { 
    @Override 
    void onReceive(Object message) { 
     if(message instanceof Cluck) { 
      Cluck cluck = message as Cluck 

      // Now, how to pass the message safely/properly to FizzBuzz#onCluck? 
     } 
    } 
} 

das Problem bei der Hand ist also, wie man sicher/richtig die Cluck Nachricht übergeben zu FizzBuzz#onCluck(Cluck), die lebt außerhalb das Aktorsystem? ich könnte bietet einen FizzBuzz Bezug auf ChickenCluckDetector wie so:

class ChickenCluckDetector extends UntypedActor { 
    FizzBuzz fizzBuzz 

    @Override 
    void onReceive(Object message) { 
     if(message instanceof Cluck) { 
      Cluck cluck = message as Cluck 

      fizzBuzz.onCluck(cluck) 
     } 
    } 
} 

Aber ich habe das Gefühl, das Akka Best Practices verletzt und konnte alle Art von Concurrency-basierten Problemen verursachen, besonders wenn es nur ein FizzBuzz (die es gibt) Nicht-Schauspieler/Fahrer und zehntausend ChickenCluckDetector Schauspieler. Ideen?

Answer 1

wenn es nur eine FizzBuzz (die gibt es) nicht-Schauspieler/Fahrer und zehntausend ChickenCluckDetector Schauspieler

Dann wäre es am besten für alle diese ChickenCluckDetectors einem gemeinsamen Elternteil zu erstellen. Dieser Elternteil könnte dann sicher den Bezug zu FizzBuzz halten, von allen seinen Kindern Gacks erhalten und die onCluck-Methode aufrufen.

Eine Möglichkeit, Nachrichten außerhalb von Schauspielern zu erhalten, ist die Frage. Und in Scala gibt es Schauspieler DSL (nur für die Vollständigkeit hinzugefügt). Aber ich glaube, dass du das in deinem Beispiel nicht brauchst.

public class ChickenCluckMaster extends UntypedActor { 

    private FizzBuzz fizzBuzz; 

    public ChickenCluckMaster(FizzBuzz fizzBuzz) { 
     this.fizzBuzz = fizzBuzz; 
    } 

    public void onReceive(Object message) throws Exception { 
     if (message instanceOf CreateDetector) { 
      getContext().actorOf(
       Props.create(ChickenCluckDetector.class, getSelf); // Create child 
     } else if (message instanceof Cluck) { 
      fizzBuzz.onCluck(cluck); 
     } else { 
      unhandled(message); 
     } 
    } 

} 

public class ChickenCluckDetector extends UntypedActor { 

    private ActorRef master; 

    public ChickenCluckDetector(ActorRef master) { 
     this.master = master; 
    } 

    public void onReceive(Object message) throws Exception { 
     if (message instanceof Cluck) { 
      Cluck cluck = (Cluck) message; 
      master.tell(cluck, getSelf); 
     } else { 
      unhandled(message); 
     } 
    } 

}