Question

我正在使用Akka Stream实现节流，而且它几乎正常工作。它几乎正常工作，因为我想每次都发送一个消息列表而不是一个消息。我不确定Akka的Actors是否允许在调用actor之前累积消息。

我知道以下示例很简单，但在实际情况下，我会收到来自RabbitMQ的大量消息，我想在几秒钟后调用actor以避免过高的速率 - 收到消息后，我和＃39; ll调用webservice。

这是我做的：

import akka.NotUsed
import akka.actor.{Actor, ActorRef, ActorSystem, Props}
import akka.stream.{ActorMaterializer, OverflowStrategy, ThrottleMode}
import akka.stream.scaladsl.{Sink, Source}

import scala.concurrent.duration._

object AkkaStream {
  def main(args:Array[String]): Unit = {
    val system = ActorSystem("HelloSystem")
    val actor = system.actorOf(Props[ToughActor])
    implicit val materializer = ActorMaterializer.create(system)
    val throttler: ActorRef =
      Source.actorRef(bufferSize = 1000, OverflowStrategy.dropNew)
        .throttle(2, 5.second, 2, ThrottleMode.Shaping)
        .to(Sink.actorRef(actor, NotUsed))
        .run()

    throttler ! CoolThing("message 1")
    throttler ! CoolThing("message 2")
    throttler ! CoolThing("message 3")
    throttler ! CoolThing("message 4")
    throttler ! CoolThing("message 5")
  }
}

class ToughActor extends Actor {
  def receive = {
    case x => println(x.getClass)
  }
}

case class CoolThing(name: String)

在我的示例中，我希望在receive函数上收到最多2个对象的集合，而不是receive被调用两次。

如果我发送了2条消息（例如：CoolThing("message 1")和CoolThing("message 2")），是否可以在演员{{1}}上收到？

Answer 1

我认为你想要一个分组功能而不是节流。或者也许是一个接一个。

例如，

 Source.actorRef(bufferSize = 1000, OverflowStrategy.dropNew)
    .groupedWithin(2, 2.seconds)
    .to(Sink.actorRef(actor, NotUsed))
    .run()

了解更多http://doc.akka.io/japi/akka/2.4.2/akka/stream/scaladsl/FlowOps.html#groupedWithin-int-scala.concurrent.duration.FiniteDuration-

在Akka上调用Actor之前累积消息

1 个答案: