0
Ich möchte einen potenziell sehr großen Zustand aus einem Strom von Ereignissen projizieren. Dies ist, wie ich dies in einer imperativen Art und Weise implementieren könnte:Apache Flink - Implementieren eines Stream-Prozessors mit möglicherweise sehr großen Zustand
class ImperativeFooProcessor {
val state: mutable.Map[UUID, BarState] = mutable.HashMap.empty[UUID, BarState]
def handle(event: InputEvent) = {
event match {
case FooAdded(fooId, barId) => {
// retrieve relevant state and do some work on it
val barState = state(barId)
// let the world know about what may have happened
publish(BarOccured(fooId, barId))
// or maybe rather
publish(BazOccured(fooId, barId))
}
case FooRemoved(fooId, barId) => {
// retrieve relevant state and do some work on it
val barState = state(barId)
// let the world know about what may have happened
publish(BarOccured(fooId, barId))
// or maybe rather
publish(BazOccured(fooId, barId))
}
}
}
private def publish(event: OutputEvent): Unit = {
// push event to downstream sink
}
}
Im schlimmsten Fall wird die Größe der BarState wird mit der Anzahl der Zeiten wachsen seine von FooAdded
Die Anzahl der eindeutigen BarID ist erwähnt worden ist sehr klein relativ zur Gesamtzahl der Ereignisse für jede barId.
Wie würde ich beginnen, diese Verarbeitungsstruktur in Flink darzustellen?
Wie arbeite ich mit der Tatsache, dass jeder BarState potenziell sehr groß werden kann?