大数据之Flink流处理Window

痛定思痛。 2022-09-14 02:36 202阅读 0赞

# 1、Window #

## 1.1 Window 概述 ##

streaming 流式计算是一种被设计用于处理无限数据集的数据处理引擎，而无限数据集是指一种不断增长的本质上无限的数据集，而 window 是一种切割无限数据为有限块进行处理的手段。  
Window 是无限数据流处理的核心， Window 将一个无限的 stream 拆分成有限大小的” buckets”桶，我们可以在这些桶上做计算操作。

## 1.2 Window 类型 ##

Window 可以分成两类：  
➢ CountWindow：按照指定的数据条数生成一个 Window，与时间无关。  
➢ TimeWindow：按照时间生成 Window。

对于 TimeWindow，可以根据窗口实现原理的不同分成三类：滚动窗口（ Tumbling Window）、滑动窗口（ Sliding Window）和会话窗口（ Session Window）。

1） 滚动窗口（Tumbling Windows）  
将数据依据固定的窗口长度对数据进行切片。

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

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

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp6b6Z6Iez5bCK_size_20_color_FFFFFF_t_70_g_se_x_16][]

适用场景：适合做 BI 统计等（做每个时间段的聚合计算）。

2） 滑动窗口（Sliding Windows）  
滑动窗口是固定窗口的更广义的一种形式，滑动窗口由固定的窗口长度和滑动间隔组成。

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

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

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

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp6b6Z6Iez5bCK_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_Q1NETiBA5aSp6b6Z6Iez5bCK_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

# 2、Window API  #

## 2.1 TimeWindow ##

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

1）滚动窗口  
Flink 默认的时间窗口根据 Processing Time 进行窗口的划分，将 Flink 获取到的数据根据进入 Flink 的时间划分到不同的窗口中。

package application.window;
    
    import application.entity.SensorReading;
    import org.apache.flink.api.common.functions.AggregateFunction;
    import org.apache.flink.api.common.functions.MapFunction;
    import org.apache.flink.streaming.api.datastream.DataStream;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
    import org.apache.flink.streaming.api.windowing.time.Time;
    
    /**
     * @author: wtl
     * @License: (C) Copyright 2021, wtl Corporation Limited.
     * @Contact: 1050100468@qq.com
     * @Date: 2021/10/1 5:53 上午
     * @Version: 1.0
     * @Description:
     */
    public class FlinkWindowTimeWindow {
    
        public static void main(String[] args) throws Exception{
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    
            DataStream<String> inputDataStream = env.socketTextStream("localhost", 7777);
    
            DataStream<SensorReading> mapDataStream = inputDataStream.map(new MapFunction<String, SensorReading>() {
                @Override
                public SensorReading map(String s) throws Exception {
                    String[] fields = s.split(",");
    
                    return new SensorReading(fields[0],Long.parseLong(fields[1]),Double.parseDouble(fields[2]));
                }
            });
    
            DataStream<Integer> aggregateDataStream = mapDataStream.keyBy(SensorReading::getSensorId)
                    .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;
                        }
                    });
    
            aggregateDataStream.print();
    
            env.execute();
        }
    }

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

2） 滑动窗口（SlidingEventTimeWindows）

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

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

DataStream<SensorReading> minByDataStream = mapDataStream.keyBy(SensorReading::getSensorId)
                    .window(TumblingProcessingTimeWindows.of(Time.seconds(15), Time.seconds(5)))
                    .minBy("value");

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

## 2.2 CountWindow ##

CountWindow 根据窗口中相同 key 元素的数量来触发执行，执行时只计算元素数量达到窗口大小的 key 对应的结果。  
注意： CountWindow 的 window\_size 指的是相同 Key 的元素的个数，不是输入的所有元素的总数。

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

DataStream<SensorReading> minByDataStream = mapDataStream.keyBy(SensorReading::getSensorId)
                    .countWindow(5)
                    .minBy("value");

2 滑动窗口  
滑动窗口和滚动窗口的函数名是完全一致的，只是在传参数时需要传入两个参数，一个是 window\_size，一个是 sliding\_size。  
下面代码中的 sliding\_size 设置为了 2，也就是说，每收到两个相同 key 的数据就计算一次，每一次计算的 window 范围是 10 个元素。

DataStream<SensorReading> minByDataStream = mapDataStream.keyBy(SensorReading::getSensorId)
                    .countWindow(5,2)
                    .minBy("value");

## 2.3 window function ##

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

*  增量聚合函数（ incremental aggregation functions）

每条数据到来就进行计算，保持一个简单的状态。典型的增量聚合函数有ReduceFunction, AggregateFunction。

*  全窗口函数（ full window functions）

先把窗口所有数据收集起来，等到计算的时候会遍历所有数据。ProcessWindowFunction 就是一个全窗口函数。

## 2.4 其它可选 API ##

*  .trigger() —— 触发器

定义 window 什么时候关闭，触发计算并输出结果

*   .evitor() —— 移除器

定义移除某些数据的逻辑

*  .allowedLateness() —— 允许处理迟到的数据
 *  .sideOutputLateData() —— 将迟到的数据放入侧输出流
 *  .getSideOutput() —— 获取侧输出流

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp6b6Z6Iez5bCK_size_20_color_FFFFFF_t_70_g_se_x_16 3][]

# 3、 时间语义与 Wartermark  #

## 3.1 Flink 中的时间语义 ##

在 Flink 的流式处理中，会涉及到时间的不同概念，如下图所示：  
![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp6b6Z6Iez5bCK_size_20_color_FFFFFF_t_70_g_se_x_16 4][]

**Event Time**：是事件创建的时间。它通常由事件中的时间戳描述，例如采集的日志数据中，每一条日志都会记录自己的生成时间， Flink 通过时间戳分配器访问事件时间戳。

**Ingestion Time**：是数据进入 Flink 的时间。

**Processing Time**：是每一个执行基于时间操作的算子的本地系统时间，与机器相关，默认的时间属性就是 Processing Time。

## 3.2 2 EventTime 的引入 ##

**1.12版本的flink，setStreamTimeCharacteristic 这个不需要设置，默认就是eventtime，所以你的data必须要使用assignTimestampsAndWatermarks提取出wm所需要的时间字段！！！**

# 4、Watermark #

## 4.1 基本概念 ##

我们知道，流处理从事件产生，到流经 source，再到 operator，中间是有一个过程和时间的，虽然大部分情况下，流到 operator 的数据都是按照事件产生的时间顺序来的，但是也不排除由于网络、分布式等原因，导致乱序的产生，所谓乱序，就是指 Flink 接收到的事件的先后顺序不是严格按照事件的 Event Time 顺序排列的。

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp6b6Z6Iez5bCK_size_20_color_FFFFFF_t_70_g_se_x_16 5][]

那么此时出现一个问题，一旦出现乱序，如果只根据 eventTime 决定 window 的运行，我们不能明确数据是否全部到位，但又不能无限期的等下去，此时必须要有个机制来保证一个特定的时间后，必须触发 window 去进行计算了，这个特别的机制，就是 Watermark。

*  Watermark 是一种衡量 Event Time 进展的机制。
 *  **Watermark 是用于处理乱序事件的，而正确的处理乱序事件**，通常用Watermark 机制结合 window 来实现。
 *  数据流中的 Watermark 用于表示 timestamp 小于 Watermark 的数据，都已经到达了，因此， window 的执行也是由 Watermark 触发的。
 *  Watermark 可以理解成一个延迟触发机制，我们可以设置 Watermark 的延时时长 t，每次系统会校验已经到达的数据中最大的 maxEventTime，然后认定 eventTime小于 maxEventTime - t 的所有数据都已经到达，如果有窗口的停止时间等于maxEventTime – t，那么这个窗口被触发执行。

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp6b6Z6Iez5bCK_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/c42d386bbd4a4bef8582cea19cc832eb.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp6b6Z6Iez5bCK_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/9830c906d80b4dccb7d1ebdcbe81e563.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp6b6Z6Iez5bCK_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/7208cdfee6fb4d40ba924cf626ffb3dd.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp6b6Z6Iez5bCK_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220828/e3d3776b95194f83b6fc0bbf5a676239.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp6b6Z6Iez5bCK_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220828/76dc6939bea44fb89c4f0d0f920bb7b4.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aSp6b6Z6Iez5bCK_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20220828/90323ccc8daf4a8cb7dae53c1d03a8a7.png