Scala Akka数据流收集数据（源->；流->；流（收集）>；汇）

我对Scala和Akka完全陌生。我有一个简单的RunnableFlow：

Source -> Flow (do some transformation) -> Sink.runForeach

现在我想要这样的东西：

Source -> Flow1 (do some transformation) -> Flow2 (do some transformation) -> Sink.runForeach

但是Flow2应该等到Flow1中的100个元素可用，然后将这100个元素转换为一个新元素（需要Flow1中的所有100个元素），并将这个新元素提供给接收器

---

我做了一些研究，发现了一些问题，但我不明白如何在flow2中访问flow1中的所有100个元素，并对它们进行一些转换。有人能解释一下吗？或者最好贴一个简单的小例子？或者两者都有？

Akka定义的集合

如果您不介意使用akka确定的收集类型，那么您可以使用

grouped

功能：

//alternative stream formation
val stream = Source(1 to 100).via(Flow[Int].grouped(bufferSize))
                             .runWith(Sink foreach println)

用户定义的集合

如果要控制用于缓冲区的收集类型，例如

Seq

或

Array

：

type MyCollectionType[X] = Array[X]

def emptyMyCollection[X] : MyCollectionType[X] = Array.empty[X]

然后可以使用两个流执行此操作。第一个流执行

扫描

，以建立元素序列：

val bufferSize = 10

def appendToMyCollection[X](coll : MyCollectionType[X], i : X) : MyCollectionType[X] = 
  (if(coll.size < bufferSize) coll else emptyMyCollection[Int]) :+ i

val buffer : Flow[Int, MyCollectionType[Int], _] = 
  Flow[Int].scan[MyCollectionType[Int]](emptyMyCollection[Int]){
    (coll, i) => appendToMyCollection(coll, i)
  }

这两个流可以组合起来生成一个流，该流将生成所需的集合类型：

val stream = Source(1 to 100).via(buffer)
                             .via(goldiLocks)
                             .runWith(Sink foreach println)

Flow[Int]。分组（bufferSize）

更简单。

val stream = Source(1 to 100).via(buffer)
                             .via(goldiLocks)
                             .runWith(Sink foreach println)