Flink Window

客官°小女子只卖身不卖艺 2023-07-21 15:26 29阅读 0赞

## 1、Window概述 ##

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

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

## 2、Window类型 ##

Window可以分成两类：

*  CountWindow：按照指定的数据条数生成一个Window，与时间无关。
 *  TimeWindow：按照时间生成Window。

对于TimeWindow，可以根据窗口实现原理的不同分成三类：

*  滚动窗口（Tumbling Window）
 *  滑动窗口（Sliding Window）
 *  会话窗口（Session Window）

### 滚动窗口（Tumbling Windows） ###

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

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

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

![E5_9B_BE_E7_89_87-19.png][]

**代码片段**

1 val input: DataStream[T] = ...
     2 
     3 // tumbling event-time windows
     4 input
     5     .keyBy(<key selector>)
     6     .window(TumblingEventTimeWindows.of(Time.seconds(5)))
     7     .<windowed transformation>(<window function>)
     8 
     9 // tumbling processing-time windows
    10 input
    11     .keyBy(<key selector>)
    12     .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
    13     .<windowed transformation>(<window function>)
    14 
    15 // daily tumbling event-time windows offset by -8 hours.
    16 input
    17     .keyBy(<key selector>)
    18     .window(TumblingEventTimeWindows.of(Time.days(1), Time.hours(-8)))
    19     .<windowed transformation>(<window function>)

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

### 滑动窗口（Sliding Windows） ###

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

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

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

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

![E5_9B_BE_E7_89_87-20.png][]

**代码片段**

1 val input: DataStream[T] = ...
     2 
     3 // sliding event-time windows
     4 input
     5     .keyBy(<key selector>)
     6     .window(SlidingEventTimeWindows.of(Time.seconds(10), Time.seconds(5)))
     7     .<windowed transformation>(<window function>)
     8 
     9 // sliding processing-time windows
    10 input
    11     .keyBy(<key selector>)
    12     .window(SlidingProcessingTimeWindows.of(Time.seconds(10), Time.seconds(5)))
    13     .<windowed transformation>(<window function>)
    14 
    15 // sliding processing-time windows offset by -8 hours
    16 input
    17     .keyBy(<key selector>)
    18     .window(SlidingProcessingTimeWindows.of(Time.hours(12), Time.hours(1), Time.hours(-8)))
    19     .<windowed transformation>(<window function>)

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

### 会话窗口（Session Windows） ###

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

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

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

![E5_9B_BE_E7_89_87-21.png][]

代码

1 val input: DataStream[T] = ...
     2 
     3 // event-time session windows with static gap
     4 input
     5     .keyBy(<key selector>)
     6     .window(EventTimeSessionWindows.withGap(Time.minutes(10)))
     7     .<windowed transformation>(<window function>)
     8 
     9 // event-time session windows with dynamic gap
    10 input
    11     .keyBy(<key selector>)
    12     .window(EventTimeSessionWindows.withDynamicGap(new SessionWindowTimeGapExtractor[String] {
    13       override def extract(element: String): Long = {
    14         // determine and return session gap
    15       }
    16     }))
    17     .<windowed transformation>(<window function>)
    18 
    19 // processing-time session windows with static gap
    20 input
    21     .keyBy(<key selector>)
    22     .window(ProcessingTimeSessionWindows.withGap(Time.minutes(10)))
    23     .<windowed transformation>(<window function>)
    24 
    25 
    26 // processing-time session windows with dynamic gap
    27 input
    28     .keyBy(<key selector>)
    29     .window(DynamicProcessingTimeSessionWindows.withDynamicGap(new SessionWindowTimeGapExtractor[String] {
    30       override def extract(element: String): Long = {
    31         // determine and return session gap
    32       }
    33     }))
    34     .<windowed transformation>(<window function>)

## 3、WindowAPI ##

### 3.1 TimeWindow ###

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

1. **滚动窗口**

Flink默认的时间窗口根据Processing Time 进行窗口的划分，将Flink获取到的数据根据进入Flink的时间划分到不同的窗口中。然后就可以对窗口的数据进行聚合等操作

1 val dataDS: DataStream[String] = env.socketTextStream("hadoop01", 9999)
     2 
     3 val mapDS = dataDS.map(data=>{
     4     val datas = data.split(",")
     5     (datas(0),1)
     6 })
     7 
     8 val reduceDS: DataStream[(String, Int)] = mapDS.keyBy(_._1)
     9     .timeWindow(Time.seconds(5)).reduce(
    10     (t1, t2) => {
    11         (t1._1, t1._2 + t2._2)
    12     }
    13 )
    14 
    15 reduceDS.print()

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

**2.滑动窗口**

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

下面代码中的sliding\_size设置为了3s，也就是说，窗口每3s就计算一次，每一次计算的window范围是6s内的所有元素。

1 val dataDS: DataStream[String] = env.socketTextStream("hadoop01", 9999)
     2 
     3 val mapDS = dataDS.map(data=>{
     4     val datas = data.split(",")
     5     (datas(0),1)
     6 })
     7 
     8 val reduceDS: DataStream[(String, Int)] = mapDS.keyBy(_._1)
     9     .timeWindow(Time.seconds(6),Time.seconds(3)).reduce(
    10     (t1, t2) => {
    11         (t1._1, t1._2 + t2._2)
    12     }
    13 )
    14 
    15 reduceDS.print()

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

### 3.2 CountWindow ###

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

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

**1.滚动窗口**

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

1 val dataDS: DataStream[String] = env.socketTextStream("hadoop01", 9999)
     2 
     3 val mapDS = dataDS.map(data=>{
     4     val datas = data.split(",")
     5     (datas(0),1)
     6 })
     7 
     8 val reduceDS: DataStream[(String, Int)] = mapDS.keyBy(_._1)
     9     .countWindow(3).reduce(
    10     (t1, t2) => {
    11         (t1._1, t1._2 + t2._2)
    12     }
    13 )
    14 
    15 reduceDS.print()

**2.滑动窗口**

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

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

1 val dataDS: DataStream[String] = env.socketTextStream("hadoop01", 9999)
     2 
     3 val mapDS = dataDS.map(data=>{
     4     val datas = data.split(",")
     5     (datas(0),datas(2).toInt)
     6 })
     7 
     8 val reduceDS: DataStream[(String, Int)] = mapDS.keyBy(_._1)
     9     .countWindow(3,2).reduce(
    10     (t1, t2) => {
    11         (t1._1, t1._2 + t2._2)
    12     }
    13 )
    14 
    15 reduceDS.print()

### 3.3 Window function ###

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

*  增量聚合函数（incremental aggregation functions）
 *  全窗口函数（full window functions）

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

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

**ReduceFunction**

1 val dataDS: DataStream[String] =
     2  env.socketTextStream("linux1", 9999)
     3 
     4 val mapDS = dataDS.map(data=>{
     5     val datas = data.split(",")
     6     (datas(0),datas(2).toInt)
     7 })
     8 
     9 val reduceDS: DataStream[(String, Int)] = mapDS.keyBy(_._1)
    10     .timeWindow(Time.seconds(3)).reduce(
    11         new ReduceFunction[(String, Int)] {
    12             override def reduce(t: (String, Int), t1: (String, Int)): (String, Int) = {
    13                 (t._1, t._2 + t1._2)
    14             }
    15         }
    16     )
    17 
    18 reduceDS.print()
    19 val dataDS: DataStream[String] =
    20  env.socketTextStream("linux1", 9999)
    21 
    22 val mapDS = dataDS.map(data=>{
    23     val datas = data.split(",")
    24     (datas(0),datas(2).toInt)
    25 })
    26 
    27 val reduceDS: DataStream[(String, Int)] = mapDS.keyBy(_._1)
    28     .timeWindow(Time.seconds(3)).reduce(
    29         new ReduceFunction[(String, Int)] {
    30             override def reduce(t: (String, Int), t1: (String, Int)): (String, Int) = {
    31                 (t._1, t._2 + t1._2)
    32             }
    33         }
    34     )
    35 
    36 reduceDS.print()

**AggregateFunction**

1 val dataDS: DataStream[String] =
     2  env.socketTextStream("linux1", 9999)
     3 
     4 val mapDS = dataDS.map(data=>{
     5     val datas = data.split(",")
     6     (datas(0),datas(2).toInt)
     7 })
     8 
     9 val aggregateDS: DataStream[(String, Int)] = mapDS.keyBy(_._1)
    10     .countWindow(3).aggregate(
    11         // TODO 此处聚合函数类似于Spark中的累加器
    12         new AggregateFunction[(String, Int), (Int, Int), (String, Int)] {
    13             override def createAccumulator(): (Int, Int) = {
    14                 (0,0)
    15             }
    16 
    17             override def add(in: (String, Int), acc: (Int, Int)): (Int, Int) = {
    18                 (in._2 + acc._1, acc._2 + 1)
    19             }
    20 
    21             override def getResult(acc: (Int, Int)): (String, Int) = {
    22                 ("sensor", (acc._1 / acc._2))
    23             }
    24 
    25             override def merge(acc: (Int, Int), acc1: (Int, Int)): (Int, Int) = {
    26                 (acc._1 + acc1._1, acc._2 + acc1._2)
    27             }
    28         }
    29     )
    30 
    31 aggregateDS.print()

**全窗口函数（full window functions）**

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

1 val dataDS: DataStream[String] =
     2  env.socketTextStream("linux1", 9999)
     3 
     4 val mapDS = dataDS.map(data=>{
     5     val datas = data.split(",")
     6     (datas(0),datas(2).toInt)
     7 })
     8 
     9 val processDS: DataStream[String] = mapDS.keyBy(_._1)
    10     .countWindow(3)
    11     .process(new ProcessWindowFunction[(String, Int), String, String, GlobalWindow] {
    12         override def process(key: String, context: Context, elements: Iterable[(String, Int)], out: Collector[String]): Unit = {
    13             //println(elements.mkString(","))
    14             out.collect(elements.mkString(","))
    15         }
    16     })
    17 processDS.print()

### 3.4 其他API ###

*  .trigger() —— 触发器

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

*  .evitor() —— 移除器

定义移除某些数据的逻辑

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

![E5_9B_BE_E7_89_87-22.png][]

[E5_9B_BE_E7_89_87-19.png]: http://47.112.223.94/wp-content/uploads/2020/04/%E5%9B%BE%E7%89%87-19.png
[E5_9B_BE_E7_89_87-20.png]: http://47.112.223.94/wp-content/uploads/2020/04/%E5%9B%BE%E7%89%87-20.png
[E5_9B_BE_E7_89_87-21.png]: http://47.112.223.94/wp-content/uploads/2020/04/%E5%9B%BE%E7%89%87-21.png
[E5_9B_BE_E7_89_87-22.png]: http://47.112.223.94/wp-content/uploads/2020/04/%E5%9B%BE%E7%89%87-22.png