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.

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:

class MyChildActor @Inject() (db: Database, @Assisted id: String) extends Actor {
  ...
}

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

trait MyChildActorFactory {
  def apply(id: String): Actor
}

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

class MyModule extends AbstractModule with PekkoGuiceSupport {
  def configure = {
    bindActorFactory[MyChildActor, MyChildActorFactory]
  }
}

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

class MyActor @Inject() (myChildActorFactory: MyChildActorFactory) extends Actor with InjectedActorSupport {

  def receive {
    case CreateChildActor(id) =>
      val child: ActorRef = injectedChild(myChildActorFactory(id), id)
      sender() ! child
  }
}

Bind a typed actor.

Binds Behavior[T] and ActorRef[T] for the given message type T to the given ActorModule and actor name, so that it can be injected into other components. Use this variant of bindTypedActor when using the "functional programming" style of defining your actor's behavior and it needs to be injected with dependencies in dependency scope (such as Configuration).

The binding of the Behavior happens by installing the given ActorModule into this Guice Module. Make sure to add the Provides annotation on the Behavior-returning method to bind (by convention this is the apply method).

Note that, while the name is used when spawning the actor in the ActorSystem, it is NOT used as a name qualifier for the binding. This is so that you don't need to use Named to qualify all injections of typed actors. Use the underlying API to create multiple, name-annotated bindings.

Bind a typed actor.

Binds Behavior[T] and ActorRef[T] for the given message type T to the given Behavior value and actor name, so that it can be injected into other components. Use this variant of bindTypedActor when using the "functional programming" style of defining your actor's behavior and it doesn't depend on anything in dependency scope.

Note that, while the name is used when spawning the actor in the ActorSystem, it is NOT used as a name qualifier for the binding. This is so that you don't need to use Named to qualify all injections of typed actors. Use the underlying API to create multiple, name-annotated bindings.