在能够处理一些其他消息之前初始化一个actor

Question

我有一个演员可以创造另一个演员：

class MyActor1 extends Actor {
  val a2 = system actorOf Props(new MyActor(123))
}

第二个参与者必须在创建后自行初始化（引导），然后才能执行其他工作。

class MyActor2(a: Int) extends Actor {
  //initialized (bootstrapped) itself, potentially a long operation 
  //how?
  val initValue = // get from a server

  //handle incoming messages
  def receive = {
    case "job1" => // do some job but after it's initialized (bootstrapped) itself
  }
}

所以MyActor2 必须做的第一件事就是做一些初始化工作。这可能需要一些时间，因为它是对服务器的请求。只有在它成功完成后，它才必须能够处理通过receive 传入的消息。在此之前 - 它不能那样做。

当然，对服务器的请求必须是异步的（最好使用Future，而不是async、await 或其他高级别的东西，如AsyncHttpClient）。我知道如何使用 Future，不过这不是问题。

我如何确保这一点？

p.s.我的猜测是它必须先向自己发送消息。

Answer 1

你可以在初始化后使用become方法来改变actor的行为：

class MyActor2(a: Int) extends Actor {

  server ! GetInitializationData

  def initialize(d: InitializationData) = ???

  //handle incoming messages
  val initialized: Receive = {
    case "job1" => // do some job but after it's initialized (bootstrapped) itself
  }

  def receive = {
    case d @ InitializationData =>
      initialize(d)
      context become initialized
  }
}

请注意，此类参与者将在初始化之前丢弃所有消息。您必须手动保存这些消息，例如使用Stash：

class MyActor2(a: Int) extends Actor with Stash {

  ...

  def receive = {
    case d @ InitializationData =>
      initialize(d)
      unstashAll()
      context become initialized
    case _ => stash()
  }
}

如果您不想使用 var 进行初始化，您可以使用 InitializationData 创建初始化行为，如下所示：

class MyActor2(a: Int) extends Actor {

  server ! GetInitializationData

  //handle incoming messages
  def initialized(intValue: Int, strValue: String): Receive = {
    case "job1" => // use `intValue` and `strValue` here
  }

  def receive = {
    case InitializationData(intValue, strValue) =>
      context become initialized(intValue, strValue)
  }
}

Answer 2

我不知道建议的解决方案是否是个好主意。 发送初始化消息对我来说似乎很尴尬。Actor 有一个生命周期并提供了一些钩子。当您查看API 时，您会发现prestart 挂钩。

因此我提出以下建议：

• 创建 Actor 后，将运行其 preStart 挂钩，您可以在其中执行返回未来的服务器请求。
• 虽然未来尚未完成，但所有传入的消息都会被隐藏。
• 未来完成时，它使用 context.become 来使用您的真实/正常接收方法。
• 在成为之后，您可以解开所有内容。

这是代码的粗略草图（不好的解决方案，请参阅下面的真正解决方案）：

class MyActor2(a: Int) extends Actor with Stash{

  def preStart = {
    val future = // do your necessary server request (should return a future)
    future onSuccess {
      context.become(normalReceive)
      unstash()
    }
  }

  def receive = initialReceive

  def initialReceive = {
    case _ => stash()
  }

  def normalReceive = {
    // your normal Receive Logic
  }
}

更新：根据 Senias 的反馈改进了解决方案

class MyActor2(a: Int) extends Actor with Stash{

  def preStart = {
    val future = // do your necessary server request (should return a future)
    future onSuccess {
      self ! InitializationDone
    }
  }

  def receive = initialReceive

  def initialReceive = {
    case InitializationDone =>
      context.become(normalReceive)
      unstash()
    case _ => stash()
  }

  def normalReceive = {
    // your normal Receive Logic
  }

  case class InitializationDone
}