Flink-窗口WindowAPI学习与实践

Bertha 。 2022-09-09 10:53 190阅读 0赞

# Flink 中的 Window #

## Window ##

streaming 流式计算是一种被设计用于处理无限数据集的数据处理引擎,而无限数据集是指一种不断增长的本质上无限的数据集,而 **window 是一种切割 无限数据为有 限块进行处理 的手段**。

Window 是无限数据流处理的核心, Window 将一个无限的 stream 拆分成有限大小的”buckets”桶,我们可以在这些桶上做计算操作。

将无限的数据流转换成有界的桶进行处理。

### Window 类型 ###

Window 可以分成两类:

➢ CountWindow:按照指定的数据条数生成一个 Window,与时间无关，计数窗口。

➢ TimeWindow:按照时间生成 Window，时间窗口。

对于 TimeWindow,可以根据窗口实现原理的不同分成三类:滚动窗口( TumblingWindow)、滑动窗口(Sliding Window)和会话窗口(Session Window)。

对于CountWindow分为滚动窗口和滑动窗口。

**1、滚动窗口(Tumbling Windows)**

将数据依据固定的窗口长度对数据进行切片。

**特点 :时间对齐, 窗口长度 固定,没有重 叠。**

滚动窗口分配器将每个元素分配到一个指定窗口大小的窗口中,滚动窗口有一个固定的大小,并且不会出现重叠。例如:如果你指定了一个 5 分钟大小的滚动窗口,窗口的创建如下图所示:

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6a2U56ybTG92ZQ_size_20_color_FFFFFF_t_70_g_se_x_16]

适用场景:适合做 BI 统计等(做每个时间段的聚合计算)。

**2、滑动窗口(Sliding Windows)**

滑动窗口是固定窗口的更广义的一种形式,滑动窗口由固定的窗口长度和滑动间隔组成。

**特点 :时间对齐, 窗口长度 固定, 可以有 重叠。**

滑动窗口分配器将元素分配到固定长度的窗口中,与滚动窗口类似,窗口的大小由窗口大小参数来配置,另一个窗口滑动参数控制滑动窗口开始的频率。因此,滑动窗口如果滑动参数小于窗口大小的话,窗口是可以重叠的,在这种情况下元素会被分配到多个窗口中。

例如,你有 10 分钟的窗口和 5 分钟的滑动,那么每个窗口中 5 分钟的窗口里包含着上个 10 分钟产生的数据,如下图所示:

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6a2U56ybTG92ZQ_size_20_color_FFFFFF_t_70_g_se_x_16 1]

适用场景:对最近一个时间段内的统计(求某接口最近 5min 的失败率来决定是否要报警)。

**3、会话窗口(Session Windows)**

由一系列事件组合一个指定时间长度的 timeout 间隙组成,类似于 web 应用的session,也就是一段时间没有接收到新数据就会生成新的窗口。

**特点 :时间无对齐 。**

session 窗口分配器通过 session 活动来对元素进行分组,session 窗口跟滚动窗口和滑动窗口相比,不会有重叠和固定的开始时间和结束时间的情况,相反,当它在一个固定的时间周期内不再收到元素,即非活动间隔产生,那个这个窗口就会关闭。一个 session 窗口通过一个 session 间隔来配置,这个 session 间隔定义了非活跃周期的长度,当这个非活跃周期产生,那么当前的 session 将关闭并且后续的元素将被分配到新的 session 窗口中去。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6a2U56ybTG92ZQ_size_17_color_FFFFFF_t_70_g_se_x_16]

## Window API ##

窗口分配器 —— window() 方法

➢ 可以用 .window() 来定义一个窗口,然后基于这个 window 去做一些聚合或者其它处理操作。注意 window () 方法必须在 keyBy 之后才能用。

➢ Flink 提供了更加简单的 .timeWindow 和 .countWindow 方法,用于定义时间窗口和计数窗口。

window() 方法接收的输入参数是一个 WindowAssigner

WindowAssigner 负责将每条输入的数据分发到正确的 window 中

Flink 提供了通用的 WindowAssigner

➢ 滚动窗口(tumbling window)

➢ 滑动窗口(sliding window)

➢ 会话窗口(session window)

➢ 全局窗口(global window)

创建不同类型的窗口：

**时间窗口**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6a2U56ybTG92ZQ_size_20_color_FFFFFF_t_70_g_se_x_16 2]

**计数窗口**  
![在这里插入图片描述][b1f1a80b068949db98c1a3ff50f3b304.png]

**窗口函数(window function)**

window function 定义了要对窗口中收集的数据做的计算操作，可以分为两类

➢ **增量聚合函数(incremental aggregation functions)**

每条数据到来就进行计算,保持一个简单的状态；

ReduceFunction, AggregateFunction

➢ **全窗口函数(full window functions)**

先把窗口所有数据收集起来,等到计算的时候会遍历所有数据；ProcessWindowFunction, WindowFunction

### TimeWindow ###

TimeWindow 是将指定时间范围内的所有数据组成一个 window,一次对一个window 里面的所有数据进行计算。

**滚动窗口**

Flink 默认的**时间窗口根据 Processing Time 进行 窗口的划分**,将 Flink 获取到的数据根据进入 Flink 的时间划分到不同的窗口中。

时间间隔可以通过 Time.milliseconds(x),Time.seconds(x),Time.minutes(x)等其中的一个来指定。

**滑动窗口(SlidingEventTimeWindows)**

滑动窗口和滚动窗口的函数名是完全一致的,只是在传参数时需要传入两个参数,一个是 window\_size,一个是 sliding\_size。

下面代码中的 sliding\_size 设置为了 5s,也就是说,每 5s 就计算输出结果一次,  
每一次计算的 window 范围是 15s 内的所有元素。

DataStream<SensorReading> minTempPerWindowStream = dataStream
        .keyBy(SensorReading::getId)
        .timeWindow( Time.seconds(15), Time.seconds(5) )
        .minBy("temperature");

时间间隔可以通过 Time.milliseconds(x),Time.seconds(x),Time.minutes(x)等其中的一个来指定。

时间窗口基本测试

public static void main(String[] args) throws Exception { 
    
        // 创建执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    
        // 从Socket读取
        DataStream<String> inputStream = env.socketTextStream("localhost", 4444);
    
    
        DataStream<SensorReading> dataStream = inputStream.map(line -> { 
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });
    
        // 开窗测试
        // 增量聚合函数
        dataStream.keyBy("id")
            // .countWindow(10, 2); // 滑动计数窗口
            // .timeWindow(Time.seconds(15)); // 滚动时间窗口
            // .window(EventTimeSessionWindows.withGap(Time.minutes(1))); // 会话窗口
            .window(TumblingProcessingTimeWindows.of(Time.seconds(15)))
            .aggregate(new AggregateFunction<SensorReading, Integer, Integer>() { 
                @Override
                public Integer createAccumulator() { 
                    return 0;
                }
    
                @Override
                public Integer add(SensorReading sensorReading, Integer integer) { 
                    return integer + 1;
                }
    
                @Override
                public Integer getResult(Integer integer) { 
                    return integer;
                }
    
                @Override
                public Integer merge(Integer integer, Integer acc1) { 
                    return integer + acc1;
                }
            }).print("window");
    
        // 全窗口函数
        dataStream.keyBy("id")
            .timeWindow(Time.seconds(10))
            .apply(new WindowFunction<SensorReading, Tuple3<String, Long, Integer>, Tuple, TimeWindow>() { 
                @Override
                public void apply(Tuple tuple, TimeWindow timeWindow, Iterable<SensorReading> iterable, Collector<Tuple3<String, Long, Integer>> out) throws Exception { 
    
                    String id = tuple.getField(0);
                    Long windowEnd = timeWindow.getEnd();
                    Integer count = IteratorUtils.toList(iterable.iterator()).size();
    
                    out.collect(new Tuple3<String, Long, Integer>(id ,windowEnd, count));
                }
            }).print("window");
        // 执行
        env.execute();
    }
    
    lxj@lxj:~$ nc -lk 4444
    sensor_1,1547718199,35.8
    sensor_6,1547718201,15.4
    sensor_7,1547718202,6.7
    sensor_10,1547718205,38.1
    sensor_1,1547710000,36.8
    sensor_1,1547719999,34.8
    sensor_1,1547715555,37.8
    sensor_10,1547718205,38.1
    
    window:4> (sensor_1,1630316590000,4)
    window:3> (sensor_10,1630316590000,2)
    window:5> (sensor_7,1630316590000,1)
    window:4> (sensor_6,1630316590000,1)
    window:3> 2
    window:4> 1
    window:5> 1
    window:4> 4

### CountWindow ###

CountWindow 根据窗口中相同 key 元素的数量来触发执行,执行时只计算元素数量达到窗口大小的 key 对应的结果。

注意:CountWindow 的 window\_size 指的是相同 Key 的元素的个数,不是输入的所有元素的总数。

**滚动窗口**

默认的 CountWindow 是一个滚动窗口,只需要指定窗口大小即可,当元素数量达到窗口大小时,就会触发窗口的执行。

DataStream<SensorReading> minTempPerWindowStream = dataStream
        .keyBy(SensorReading::getId)
        .countWindow( 5 )
        .minBy("temperature");

**滑动窗口**

滑动窗口和滚动窗口的函数名是完全一致的,只是在传参数时需要传入两个参数,一个是 window\_size,一个是 sliding\_size。

下面代码中的 sliding\_size 设置为了 2,也就是说,每收到两个相同 key 的数据就计算一次,每一次计算的 window 范围是 10 个元素。

DataStream<SensorReading> minTempPerWindowStream = dataStream
        .keyBy(SensorReading::getId)
        .countWindow( 10, 2 )
        .minBy("temperature");

### 其它可选 API ###

.trigger() —— 触发器，定义 window 什么时候关闭,触发计算并输出结果

.evitor() —— 移除器，定义移除某些数据的逻辑

.allowedLateness() —— 允许处理迟到的数据

.sideOutputLateData() — — 将迟到的数据放入侧输出流

.getSideOutput() —— 获取侧输出流

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6a2U56ybTG92ZQ_size_20_color_FFFFFF_t_70_g_se_x_16 3]

OutputTag<SensorReading> outputTag = new OutputTag<SensorReading>("late") { 
    };
    
    SingleOutputStreamOperator<SensorReading> sumStream = dataStream.keyBy("id")
        .timeWindow(Time.seconds(15))
        // .trigger()
        // .evictor()
        .allowedLateness(Time.minutes(1)) // 在事件时间语义下才有效
        .sideOutputLateData(outputTag)
        .sum("temperature");
    sumStream.getSideOutput(outputTag).print("late");

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6a2U56ybTG92ZQ_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/b0f595f2c26b4817874bf841c0198e82.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6a2U56ybTG92ZQ_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/291a67f599934704b225f782af02421a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6a2U56ybTG92ZQ_size_17_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/27d16bed600b4e298a766dd069b5841a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6a2U56ybTG92ZQ_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220829/29c98ca4642848fbad9d27c2b4db5448.png
[b1f1a80b068949db98c1a3ff50f3b304.png]: /images/20220829/683a53cc1c8d4fddbe09ba46a4297725.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6a2U56ybTG92ZQ_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220829/e7f4cf95da7a4c2f9bb064392efd21ee.png