将不同的工厂注入同一个角色

Question

我是Akka和Guice的新手，刚刚开始探索它。

我试图让一个父亲演员，从一种特定类型中产生儿童演员，更通用 - 所以它会产生许多不同类型的儿童演员。

目前 - 我向父亲演员注入了一种特定类型演员的工厂， 我不想给父亲演员增加更多的案例，我想用更优雅的方式解决这个问题。

所以现在我有 2 个儿童演员，我想将他们的工厂注入父亲演员，为此我想也许我应该创建两次父亲演员，每次注入不同类型的工厂。

我想要实现的是这样的代码 (这段代码不起作用，但这是这个想法(：

基础工厂特性：

trait BaseFactory {
apply(id: Int) : Actor
}

object FirstActor {
trait Factory extends BaseFactory
}
class FirstActor (@Assisted id: Int) extends Actor with InjectedActorSupport {
....
}

object SecondActor {
trait Factory extends BaseFactory
}
class SecondActor (@Assisted id: Int) extends Actor with InjectedActorSupport {
....
}

class Father @Inject()(factory: BaseFactory, name: String) extends Actor with InjectedActorSupport {
override def receive: Receive = {
case Command =>
...
val actor = context.child(id)
.getOrElse(injectedChild(factory(id), name, _.withMailbox("deque-mailbox")))
}
}

然后是模块： (这部分没有编译，因为我不能将工厂传递给道具作为特征定义而不是实例(

class Module extends AkkaGuiceSupport {
def configure(): Unit = {
bindActor[ExecutorsOffice]("FirstFather", Props(new Father(FirstActor.Factory)))
bindActor[ExecutorsOffice]("SecondFather", Props(new Father(SecondActor.Factory)))
bindActorFactory[FirstActor, FirstActor.Factory]
bindActorFactory[SecondActor, SecondActor.Factory]
}

我很高兴听到您的想法和解决方案(其他解决方案也很棒！

Answer 1

我不确定为什么你需要Guice注射。

type PropsCreator = String => Props
object ParentActor {
def props(childPropsCreator: PropsCreator) = Props(classOf[ParentActor], childPropsCreator)
}
class ParentActor(childPropsCreator: PropsCreator) extends Actor {
// yadda yadda yadda
def receive(): Receive = {
case x: Command =>
// yadda yadda yadda
val child = context.child(id)
.getOrElse(context.actorOf(childPropsCreator(id), id))
child.forward(x)
}
}
object DdvRenderProcessManager {
def props(id: String) = Props(classOf[DdvRenderProcessManager], id)
}
class DdvRenderProcessManager(id: String) extends Actor {
// definition omitted
}
object UpdateProcessManager {
def props(id: String) = Props(classOf[UpdateProcessManager], id)
}
class UpdateProcessManager(id: String) extends Actor {
// definition omitted
}

然后你会创建像这样的父母

val ddvRenderParent = system.actorOf(ParentActor.props(DdvRenderProcessManager.props _), "ddvRenderParent")
val updateParent = system.actorOf(ParentActor.props(UpdateProcessManager.props _), "updateParent")

例如，如果您愿意，则让所有DdvRenderProcessManager都具有特定的动态值：

object DdvRenderProcessManager {
// could also express as
//  def props(x: Int)(id: String): Props
// and curry, but this expression is clearer about intent
def propsFor(x: Int): String => Props = { (id: String) =>
Props(classOf[DdvRenderProcessManager], id, x)
}
}
class DdvRenderProcessManager(id: String, x: Int) extends Actor {
// definition omitted
}

然后

val ddvRenderParent = system.actorOf(ParentActor.props(DdvRenderProcessManager.propsFor(42)), "ddvRenderParent")

您甚至可以将动态值设为implicit，以允许非常接近编译时 DI 的内容。