Akka Siblings 递归 ActorRef 要求

Question

请允许我抽象一下我经常面对演员的问题，以及解决这个问题的常见设计模式。假设我有以下演员层次结构：

── user
    └── ServiceActor
        ├── TicketManager
        │   ├── WorkerA
        │   ├── WorkerB
        │   └── WorkerC
        └── UserManager
            ├── WorkerA
            ├── WorkerB
            └── WorkerC

第一级之外的层次结构，即工单和用户管理器并不重要。我要求 TicketManager 向 UserManager 发送消息，反之亦然。 （请注意，这些只是我使用的示例名称，并不代表任何实际问题）

以下哪个最合适？

选项1：

TicketManager 构造函数将 UserManager 作为构造函数参数。 UserManager 构造函数将 TicketManager 作为构造函数参数。 但是，两者都不能相互递归调用，所以这可能无论如何都不可能。

选项 2：

UserManager 通过 actorSelection 引用 TicketManager 作为 actorSelection("../TicketManager") 等要求，或者仅在启动时引用一次并保留它。

选项 3：

在任何给定时间点，UserManager/TicketManager 都会向其父级 (ServiceActor) 请求对其他兄弟姐妹的引用，并在父级持有该引用时适当地回复 ActorRef。

选项 4：

这种情况不应该是这样吗？我不应该考虑兄弟姐妹互相交谈，因为它以某种方式使设计“复杂化”吗？应该有一个更像树的层次结构吗？如果是这种情况，有什么常见的设计模式可以帮助避免这种情况？

我希望我已经明确了要求，如果需要，请允许我进一步澄清？

Answer 1

如果依赖关系变得复杂，选项 4 可能是最好的方法，但是对于两个参与者，您可以简单地使用消息来初始化它们：参与者被设计为保持可变状态，所以如果你改变它就可以了。

所以我想说负责创建 TickerManager 和 ActorManager 的父演员可以执行以下操作

case class InitializeTicketManager(userManager:ActorRef)

case class InitializeUserManager(ticketManager:ActorRef)
val userManager = context.actorOf(...)
val ticketManager = context.actorOf(...)
userManager ! InitializeUserManager(ticketManager)
ticketManager ! InitializeTicketManager(userManager)

Answer 2

如果您使用多个 ActorSystem，您正在寻找的是某种 ServiceDiscovery。这些也会有所帮助（Cluster Routing、Cluster Sharding、ClusterRouterGroup）。

你的更简单，你只有一个 ActorSystem。我会使用带有惰性 val 和按名称调用的选项 1，即

package sumnulu

import akka.actor.{Actor, ActorLogging, ActorRef, Props}

/**
  * Created by sumnulu
  */
class RootActor extends Actor with ActorLogging {
  lazy val serviceA: ActorRef = context.actorOf(ServiceA.props(serviceB))
  lazy val serviceB: ActorRef = context.actorOf(ServiceB.props(serviceA))

  override def preStart() = {
    log info "Root Actor Ready"
    serviceA ! "test"
  }

  override def receive = Actor.ignoringBehavior
}

class ServiceA(serviceB: ActorRef) extends Actor {
  println("serviceA constructor")
  serviceB ! "Hi"


  override def receive: Receive = {
    case x => println(s"self:$self from:$sender msg:$x")
  }
}


class ServiceB(serviceA: ActorRef) extends Actor {
  println("serviceB constructor")
  serviceA ! "Hi"

  override def receive: Receive = {
    case x => println(s"self:$self from:$sender msg:$x")
  }

}

//call-by-name important is i.e `=>` 
object ServiceA {
  def props(serviceB: => ActorRef) = Props(new ServiceA(serviceB))
}

//call-by-name important is i.e `=>` 
object ServiceB {
  def props(serviceA: => ActorRef) = Props(new ServiceB(serviceA))
}

object RootActor {
  def props = Props[RootActor]
}

---

[info] [INFO] [02/18/2017 17:49:52.485] [Main-akka.actor.default-dispatcher-4] [akka://Main/user/app] Root Actor Ready
[info] serviceA constructor
[info] serviceB constructor
[info] self:Actor[akka://Main/user/app/$a#1420483478] from:Actor[akka://Main/user/app#274353135] msg:test
[info] self:Actor[akka://Main/user/app/$b#1573183992] from:Actor[akka://Main/user/app/$a#1420483478] msg:Hi
[info] self:Actor[akka://Main/user/app/$a#1420483478] from:Actor[akka://Main/user/app/$b#1573183992] msg:Hi