play.libs.akka

Interface AkkaGuiceSupport

public interface AkkaGuiceSupport

Support for binding actors with Guice. Mix this interface in with a Guice AbstractModule to get convenient support for binding actors. For example:

 public class MyModule extends AbstractModule implements AkkaGuiceSupport {
   protected void configure() {
     bindActor(MyActor.class, "myActor");
   }
 }
 

Then to use the above actor in your application, add a qualified injected dependency, like so:

 public class MyController extends Controller {
    @Inject @Named("myActor") ActorRef myActor;
   ...
 }
 

Method Summary

Modifier and Type	Method and Description
default <T extends akka.actor.Actor> void	bindActor(java.lang.Class<T> actorClass, java.lang.String name) Bind an actor.
default <T extends akka.actor.Actor> void	bindActor(java.lang.Class<T> actorClass, java.lang.String name, java.util.function.Function<akka.actor.Props,akka.actor.Props> props) Bind an actor.
default <T extends akka.actor.Actor> void	bindActorFactory(java.lang.Class<T> actorClass, java.lang.Class<?> factoryClass) Bind an actor factory.

Method Detail

bindActor

default <T extends akka.actor.Actor> void bindActor(java.lang.Class<T> actorClass,
                                                    java.lang.String name,
                                                    java.util.function.Function<akka.actor.Props,akka.actor.Props> props)

Bind an actor. This will cause the actor to be instantiated by Guice, allowing it to be dependency injected itself. It will bind the returned ActorRef for the actor will be bound, qualified with the passed in name, so that it can be injected into other components.

Parameters:

actorClass - The class that implements the actor.

name - The name of the actor.

props - A function to provide props for the actor. The props passed in will just describe how to create the actor, this function can be used to provide additional configuration such as router and dispatcher configuration.

bindActor

default <T extends akka.actor.Actor> void bindActor(java.lang.Class<T> actorClass,
                                                    java.lang.String name)

Bind an actor. This will cause the actor to be instantiated by Guice, allowing it to be dependency injected itself. It will bind the returned ActorRef for the actor will be bound, qualified with the passed in name, so that it can be injected into other components.

Parameters:

actorClass - The class that implements the actor.

name - The name of the actor.

bindActorFactory

default <T extends akka.actor.Actor> void bindActorFactory(java.lang.Class<T> actorClass,
                                                           java.lang.Class<?> factoryClass)

Bind an actor factory. This is useful for when you want to have child actors injected, and want to pass parameters into them, as well as have Guice provide some of the parameters. It is intended to be used with Guice's AssistedInject feature. Let's say you have an actor that looks like this:

 public class MyChildActor extends UntypedActor {
     final Database db;
     final String id;

      @Inject
     public MyChildActor(Database db,  @Assisted String id) {
         this.db = db;
         this.id = id;
     }
     ...
 }
 

So db should be injected, while id should be passed. Now, define an interface that takes the id, and returns the actor:

 public interface MyChildActorFactory {
   MyChildActor apply(String id);
 }
 

Now you can use this method to bind the child actor in your module:

 public class MyModule extends AbstractModule implements AkkaGuiceSupport {
   protected void configure() {
     bindActorFactory(MyChildActor.class, MyChildActorFactory.class);
   }
 }
 

Now, when you want an actor to instantiate this as a child actor, inject `MyChildActorFactory`:

 public class MyActor extends UntypedActor implements InjectedActorSupport {
   final MyChildActorFactory myChildActorFactory;

    @Inject
   public MyActor(MyChildActor myChildActorFactory) {
       this.myChildActorFactory = myChildActorFactory;
   }

   public onReceive(Object msg) {
     if (msg instanceof CreateChildActor) {
       ActorRef child = injectedChild(myChildActorFactory.apply(((CreateChildActor) msg).getId()));
       sender().send(child, self);
     }
   }
 }
 

Parameters:

actorClass - The class that implements the actor.

factoryClass - The factory interface for creating the actor.