Akka 带路由器的参与者构造函数参数

我正在尝试创建一个路由器，它将使用构造函数arg（一种变异方法）部署参与者

object LocalRouterArgEvalFrequency {
  def main(args: Array[String]) {
    val system = ActorSystem("TestSystem")
    var number = 0

    def getANumber: Int = {
      number += 1
      number
    }

    val router = system.actorOf(Props(classOf[Foo], getANumber)
                               .withRouter(RoundRobinRouter(5)), "RRRouter")
    (1 to 10).foreach(_ => router ! "What's Your Number?")
  }
}

class Foo(number: Int) extends Actor {
  println("I got instantiated")
  def receive: Actor.Receive = {
    case msg: String => println(s"My Number is $number")
  }
}

我希望看到这些方面的东西作为输出（我认为循环是我上次检查时所做的最好的努力，所以没有保证）：

相反，我看到的是：

I got instantiated
I got instantiated
I got instantiated
I got instantiated
I got instantiated
My Number is 1
My Number is 1
My Number is 1
My Number is 1
My Number is 1
My Number is 1
My Number is 1
My Number is 1
My Number is 1
My Number is 1

我认识到，从模式角度来看，注入这样的突变很可能不是一个好主意，但我在测试代码中有一个用例非常类似于这种类型的交互

---

有没有办法让道具每次在路由器部署时都进行评估？或者也许有一种不同的方式去做这件事，我没有看到…提前谢谢

需要记住的一件事是，构造函数arg值是使用当前方法捕获一次的。换句话说，

getANumber

实际上只调用一次，其结果（本例中为1）用作路由器创建的所有参与者的构造函数参数。如果你想让每个人都有一个唯一的号码，那么你可以尝试以下方法：

object LocalRouterArgEvalFrequency {
  def main(args: Array[String]) {
    val system = ActorSystem("TestSystem")
    var number = 0

    def getANumber: Int = {
      number += 1
      number
    }
    val routees = List.fill(5)(getANumber).map(i => system.actorOf(Props(classOf[Foo], i)))
    val router = system.actorOf(Props.empty.withRouter(RoundRobinRouter(routees = routees)), "RRRouter")
    (1 to 10).foreach(_ => router ! "What's Your Number?")
  }
}

class Foo(number: Int) extends Actor {
  println("I got instantiated: " + number)
  def receive: Actor.Receive = {
    case msg: String => println(s"My Number is $number")
  }
}

编辑

您也可以使用不同的

道具来创建路由器。请这样应用
：

val router = system.actorOf(Props(new Foo(getANumber)).withRouter(RoundRobinRouter(5)), "RRRouter")

这种方法可能更符合您的要求。
需要记住的一点是，构造函数arg值是使用当前方法捕获一次的。换句话说，
getANumber
实际上只调用一次，其结果（本例中为1）用作路由器创建的所有参与者的构造函数参数。如果你想让每个人都有一个唯一的号码，那么你可以尝试以下方法：

object LocalRouterArgEvalFrequency {
  def main(args: Array[String]) {
    val system = ActorSystem("TestSystem")
    var number = 0

    def getANumber: Int = {
      number += 1
      number
    }
    val routees = List.fill(5)(getANumber).map(i => system.actorOf(Props(classOf[Foo], i)))
    val router = system.actorOf(Props.empty.withRouter(RoundRobinRouter(routees = routees)), "RRRouter")
    (1 to 10).foreach(_ => router ! "What's Your Number?")
  }
}

class Foo(number: Int) extends Actor {
  println("I got instantiated: " + number)
  def receive: Actor.Receive = {
    case msg: String => println(s"My Number is $number")
  }
}

编辑

您也可以使用不同的
道具来创建路由器。请这样应用
：

val router = system.actorOf(Props(new Foo(getANumber)).withRouter(RoundRobinRouter(5)), "RRRouter")

这种方法可能更符合您的要求。
需要记住的一点是，构造函数arg值是使用当前方法捕获一次的。换句话说，
getANumber
实际上只调用一次，其结果（本例中为1）用作路由器创建的所有参与者的构造函数参数。如果你想让每个人都有一个唯一的号码，那么你可以尝试以下方法：

object LocalRouterArgEvalFrequency {
  def main(args: Array[String]) {
    val system = ActorSystem("TestSystem")
    var number = 0

    def getANumber: Int = {
      number += 1
      number
    }
    val routees = List.fill(5)(getANumber).map(i => system.actorOf(Props(classOf[Foo], i)))
    val router = system.actorOf(Props.empty.withRouter(RoundRobinRouter(routees = routees)), "RRRouter")
    (1 to 10).foreach(_ => router ! "What's Your Number?")
  }
}

class Foo(number: Int) extends Actor {
  println("I got instantiated: " + number)
  def receive: Actor.Receive = {
    case msg: String => println(s"My Number is $number")
  }
}

编辑

您也可以使用不同的
道具来创建路由器。请这样应用
：

val router = system.actorOf(Props(new Foo(getANumber)).withRouter(RoundRobinRouter(5)), "RRRouter")

这种方法可能更符合您的要求。
需要记住的一点是，构造函数arg值是使用当前方法捕获一次的。换句话说，
getANumber
实际上只调用一次，其结果（本例中为1）用作路由器创建的所有参与者的构造函数参数。如果你想让每个人都有一个唯一的号码，那么你可以尝试以下方法：

object LocalRouterArgEvalFrequency {
  def main(args: Array[String]) {
    val system = ActorSystem("TestSystem")
    var number = 0

    def getANumber: Int = {
      number += 1
      number
    }
    val routees = List.fill(5)(getANumber).map(i => system.actorOf(Props(classOf[Foo], i)))
    val router = system.actorOf(Props.empty.withRouter(RoundRobinRouter(routees = routees)), "RRRouter")
    (1 to 10).foreach(_ => router ! "What's Your Number?")
  }
}

class Foo(number: Int) extends Actor {
  println("I got instantiated: " + number)
  def receive: Actor.Receive = {
    case msg: String => println(s"My Number is $number")
  }
}

编辑

您也可以使用不同的
道具来创建路由器。请这样应用
：

val router = system.actorOf(Props(new Foo(getANumber)).withRouter(RoundRobinRouter(5)), "RRRouter")

这种方法可能更符合您的要求。
我就是这么想的。谢谢你的确认。有没有办法强迫路由器或道具每次重新评估？太好了！我感谢你们两位阐明第一点，然后缩小到我想要的具体答案。谢谢对于其他关注这一点的人，我想评论一下，不仅创造不断变异的参与者（就像我在上面所做的那样）可能是个坏主意，cmbaxter展示的方法（对我有效）也带来了一些问题。干杯（该死的我爱这个网站）@Ceryni，是的，你能做到并不意味着你应该做到。我相信还有更美味的选择。我就是这么想的。谢谢你的确认。有没有办法强迫路由器或道具每次重新评估？太好了！我感谢你们两位阐明第一点，然后缩小到我想要的具体答案。谢谢对于其他关注这一点的人，我想评论一下，不仅创造不断变异的参与者（就像我在上面所做的那样）可能是个坏主意，cmbaxter展示的方法（对我有效）也带来了一些问题。干杯（该死的我爱这个网站）@Ceryni，是的，你能做到并不意味着你应该做到。我相信还有更美味的选择。我就是这么想的。谢谢你的确认。有没有办法强迫路由器或道具每次重新评估？太好了！我感谢你们两位阐明第一点，然后缩小到我想要的具体答案。谢谢对于其他关注这一点的人，我想评论一下，不仅创造不断变异的参与者（就像我在上面所做的那样）可能是个坏主意，cmbaxter展示的方法（对我有效）也带来了一些问题。干杯（该死的我爱这个网站）@Ceryni，是的，你能做到并不意味着你应该做到。我相信还有更美味的选择。我就是这么想的。谢谢你的确认。有没有办法强迫路由器或道具每次重新评估？太好了！我感谢你们两位阐明第一点，然后缩小到我想要的具体答案。谢谢对于其他关注这一点的人，我想评论一下，不仅创造不断变异的参与者（就像我在上面所做的那样）可能是个坏主意，cmbaxter展示的方法（对我有效）也带来了一些问题。干杯（该死的我爱这个网站）@Ceryni，是的，你能做到并不意味着你应该做到。我相信还有更美味的选择。