I'm trying to figure out if my usage of passing Akka ActorRef
around to other actors is not an anti-pattern.
I've a few actors in my system. Some are long lived (restClientRouter
,publisher
) and some die after that they have done the work (geoActor
). The short-lived actors need to send messages to the long-lived actors and therefore need their ActorRef
s.
//router for a bunch of other actors val restClientRouter = createRouter(context.system) //publishers messages to an output message queue val publisher: ActorRef = context.actorOf(Props(new PublisherActor(host, channel)), name = "pub-actor") //this actor send a message to the restClientRouter and then sends the response //to the publisher val geoActor = context.actorOf(Props(new GeoInferenceActor(restClientRouter, publisher)), name = "geo-inference-actor")
As you can see I'm passing the ActorRefs (restClientRouter
and publisher
) to the constructor of GeoInferenceActor
. Is this okay or not? Is there a better way of doing this ?
There are a couple of good ways to "introduce" actor refs to actor instances that need them.
1) Create the actor with the refs it needs as constructor args (which is what you are doing)
2) Pass in the needed refs with a message after the instance is created
Your solution is perfectly acceptable, and even suggested by Roland Kuhn, the Tech Lead for Akka, in this post:
Akka actor lookup or dependency injection
It is perfectly valid, as stated in the Akka API documentation:
ActorRefs can be freely shared among actors by message passing.
In your case, you are passing them to the constructors, which is absolutely fine and the way it is supposed to be.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With