Understanding Windowing in Apache Flink

Windowing is a fundamental concept in stream processing that allows you to group a continuous stream of events into finite chunks for processing. Apache Flink provides powerful windowing capabilities that support various window types and triggers for flexible, real-time data analysis.

Alt textSource: Apache Flink

Types of Windows in Flink

Tumbling Windows

Tumbling windows are fixed-size, non-overlapping windows. Each event belongs to exactly one window.

1
2
3
4
5
6
7
8
9
10

DataStream<Event> stream = ...; // your event stream
DataStream<WindowedEvent> windowedStream = stream
    .keyBy(event -> event.getKey())
    .window(TumblingEventTimeWindows.of(Time.seconds(10)))
    .apply(new WindowFunction<Event, WindowedEvent, Key, TimeWindow>() {
        @Override
        public void apply(Key key, TimeWindow window, Iterable<Event> input, Collector<WindowedEvent> out) {
            // Window processing logic
        }
    });

Sliding Windows

Sliding windows are also fixed-size but can overlap. Each event can belong to multiple windows depending on the slide interval.

1
2
3
4
5
6
7
8
9
10

DataStream<Event> stream = ...;
DataStream<WindowedEvent> windowedStream = stream
    .keyBy(event -> event.getKey())
    .window(SlidingEventTimeWindows.of(Time.seconds(10), Time.seconds(5)))
    .apply(new WindowFunction<Event, WindowedEvent, Key, TimeWindow>() {
        @Override
        public void apply(Key key, TimeWindow window, Iterable<Event> input, Collector<WindowedEvent> out) {
            // Window processing logic
        }
    });

Session Windows

Session windows group events that arrive close to each other, with a session gap defining the threshold for grouping.

1
2
3
4
5
6
7
8
9
10

DataStream<Event> stream = ...;
DataStream<WindowedEvent> windowedStream = stream
    .keyBy(event -> event.getKey())
    .window(ProcessingTimeSessionWindows.withGap(Time.minutes(5)))
    .apply(new WindowFunction<Event, WindowedEvent, Key, TimeWindow>() {
        @Override
        public void apply(Key key, TimeWindow window, Iterable<Event> input, Collector<WindowedEvent> out) {
            // Window processing logic
        }
    });

Global Windows

Global windows group all elements with the same key into a single window. These windows require custom triggers to define when to produce results.

1
2
3
4
5
6
7
8
9
10
11

DataStream<Event> stream = ...;
DataStream<WindowedEvent> windowedStream = stream
    .keyBy(event -> event.getKey())
    .window(GlobalWindows.create())
    .trigger(CountTrigger.of(100)) // Triggering every 100 events
    .apply(new WindowFunction<Event, WindowedEvent, Key, TimeWindow>() {
        @Override
        public void apply(Key key, TimeWindow window, Iterable<Event> input, Collector<WindowedEvent> out) {
            // Window processing logic
        }
    });

Assigning Timestamps and Generating Watermarks

For event-time windowing, it’s crucial to assign timestamps to events and generate watermarks.

1
2
3
4
5
6
7
8
9
10
11

DataStream<Event> stream = ...;
WatermarkStrategy<Event> watermarkStrategy = WatermarkStrategy
    .<Event>forBoundedOutOfOrderness(Duration.ofSeconds(5))
    .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
        @Override
        public long extractTimestamp(Event event, long recordTimestamp) {
            return event.getTimestamp();
        }
    });

DataStream<Event> timestampedStream = stream.assignTimestampsAndWatermarks(watermarkStrategy);

Example: Tumbling Window with Event Time

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;

public class TumblingWindowExample {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<Event> stream = env.addSource(new EventSource());

        WatermarkStrategy<Event> watermarkStrategy = WatermarkStrategy
            .<Event>forBoundedOutOfOrderness(Duration.ofSeconds(5))
            .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                @Override
                public long extractTimestamp(Event event, long recordTimestamp) {
                    return event.getTimestamp();
                }
            });

        DataStream<Event> timestampedStream = stream.assignTimestampsAndWatermarks(watermarkStrategy);

        timestampedStream
            .keyBy(event -> event.getKey())
            .window(TumblingEventTimeWindows.of(Time.seconds(10)))
            .apply(new WindowFunction<Event, WindowedEvent, String, TimeWindow>() {
                @Override
                public void apply(String key, TimeWindow window, Iterable<Event> input, Collector<WindowedEvent> out) {
                    // Window processing logic
                    out.collect(new WindowedEvent(key, window, input));
                }
            })
            .print();

        env.execute("Tumbling Window Example");
    }
}

Benefits of Windowing

Temporal Aggregation: Windows allow you to perform aggregations and computations over specific time intervals, essential for real-time analytics and monitoring.

Handling Out-of-Order Events: With proper windowing and watermarking, Flink can handle out-of-order events and ensure accurate results.

Scalability: Windowed operations can be distributed and parallelized, making it feasible to process large-scale data streams efficiently.

Flexibility: Flink’s windowing system is highly flexible, supporting various window types and custom triggers, catering to a wide range of use cases.

Conclusion

Windowing in Apache Flink is a versatile and powerful feature that enables the processing of continuous data streams in meaningful chunks. By utilizing different types of windows and configuring them appropriately, you can implement robust real-time data processing pipelines that handle time-based computations effectively.

For more detailed information, you can refer to the Apache Flink Documentation on Windowing and Understanding Event Time in Apache Flink

Comments