1

I'd like to reduce the boilerplate needed to bind these akka actors.

At current, my code looks like this:

bind(classOf[ActorRef]).
  annotatedWith(Names.named("mines")).
  toProvider(new TypeLiteral[ActorProvider[MyActor]]() {}).
  asEagerSingleton()

I'd like it too look like:

bindActor[MyActor].withName("mines")

I've tried to subclass AbstractModule to squeeze this concept in to no avail.

Pertinent code:

class ActorProvider[T <: Actor] @Inject() ( val key:Key[T], val injector:Injector, val system: ActorSystem ) extends Provider[ActorRef] {
  def get = {
    system.actorOf(Props(injector.getInstance(key)))
  }
}
Scoobie
  • 1,097
  • 2
  • 12
  • 22

2 Answers2

1

Check out https://github.com/codingwell/scala-guice/. Here is a sample based on it. It allows for 

bindActor[MyActor].withName("mines")

Keep in mind you are binding a non-generic ActorRef and not Actor itself. This will create a binding for @Named("foo") ActorRef. You should never work with Actor directly.

You cannot get Key in the provider. Provider doesn't take any contextual injections like you tried with the Key or e.g. Injection Point. What you can do is create a different instance of the provider for each actor binding and inject it with ActorSystem afterwards. Alternatively you could change the API to include the actor system instance aswell.

trait AkkaModule extends AbstractModule {
  // should be:
  // this: AbstractModule =>
  // see http://lampsvn.epfl.ch/trac/scala/ticket/3564
  import ScalaModule._

  private def binderAccess = super.binder // shouldn't need super

  def bindActor[T <: Actor](implicit m: Manifest[T]) = new ActorBindingBuilder {
    //Hack, no easy way to exclude the bind method that gets added to classes inheriting ScalaModule
    //So we experamentally figured out how many calls up is the source, so we use that
    //Commit 52c2e92f8f6131e4a9ea473f58be3e32cd172ce6 has better class exclusion
    val mybinder = binderAccess.withSource((new Throwable).getStackTrace()(3))
    val self = (mybinder bind classOf[ActorRef]).asInstanceOf[AnnotatedBindingBuilder[ActorRef]]
  }

}

object AkkaModule {

  class ActorProvider(val name: String) extends Provider[ActorRef] {
    @Inject var system: ActorSystem = _
    def get = {
      system.actorFor(system.name + "/user/" + name)
    }
  }

  trait ActorBindingBuilder {
    val mybinder: Binder
    val self: AnnotatedBindingBuilder[ActorRef]

    def withName(name: String) = {
      val provider = new ActorProvider(name)
      self.annotatedWith(Names.named(name)).toProvider(provider)
      mybinder.requestInjection(provider)
    }
  }
}
Alen Vrečko
  • 886
  • 10
  • 13
0

Something like this that leverages scala's type Manifest might work http://www.scala-lang.org/api/current/scala/reflect/Manifest.html where Foo is analogous to ActorRef and Bla is analogous to MyActor:

scala> import com.google.inject
import com.google.inject

scala> val binder:inject.Binder = null
binder: com.google.inject.Binder = null

scala> class Foo {}
defined class Foo

scala> class Bla extends Foo {}
defined class Bla

scala> def bind[T <: Foo:Manifest] = binder.bind( classOf[Foo] ).toProvider( new
 inject.TypeLiteral[inject.Provider[T]](){} ).asEagerSingleton
bind: [T <: Foo](implicit evidence$1: Manifest[T])Unit

Maybe combine that with implicit conversion to convert a Binder to a MyBinder: http://daily-scala.blogspot.com/2009/08/implicit-methods.html

class MyBinder {
    def bindActor[T <: ActorRef:Manifest]( nameToBind:String ):Unit = ...
}


object MyBinder {
    implicit def binderToMyBinder( ...
}

Good luck!

Reuben
  • 155
  • 3