Flink 窗口

Flink 窗口

相关博客：

Flink_Window

一、Window

1.1 概述

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

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

比如：假设按照时间段划分桶，接收到的数据马上能判断放到哪个桶，且多个桶的数据能并行被处理。（迟到的数据也可判断是原本属于哪个桶的）

1.2 Window 类型

window有两大类型：

• 时间窗口（Time Window）
  • 滚动时间窗口
  • 滑动事件窗口
  • 会话窗口
• 计数窗口（Count Window）
  • 滚动计数窗口
  • 滑动计数窗口

TimeWindow：按照时间生成Window。

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

---

滚动窗口（Tumbling Windows）

滚动时间窗口，按照固定的窗口长度对数据进行切分的。

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

滑动窗口（Sliding Windows）

可以按照固定的长度向后滑动固定的距离。

滑动窗口由固定窗口长度和滑动间隔组成。

可以有重叠，是否重叠和滑动距离有关系。

滑动窗口是滚动窗口的更广义的一种形式，滚动窗口可以看做是滑动窗口的一种特殊情况，窗口大小和滑动间隔相等。

会话窗口（Session Windows）

由一系列事件组合一个指定事件长度的timeout间隙组成，也就是一段时间没有接受到新的数据就会产生新的窗口。

会话窗口的特点是：时间无对齐。

二、Window API

2.1 概述

Flink中使用窗口分配器，window()方法，来定义一个窗口，然后可以基于这个窗口去做一些聚合或者其他处理操作。

需要注意的是，**window()方法必须分组之后才能使用，也就是在KeyBy之后。**

Flink除了window方法可以设置窗口，还提供了简单的timeWindow()和countWindow()方法，用于定义时间窗口和计数窗口。

DataStream<Tuple2<String,Double>> minTempPerWindowStream = 
  datastream
  .map(new MyMapper())
  .keyBy(data -> data.f0)     // 分组
  .timeWindow(Time.seconds(15))  // 定义15s的滚动窗口
  .minBy(1);

窗口分配器（Window Assigner）

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

WindowAssigner负责将每一条数据分发到正确的Window中。

Flink提供了通用的WindowAssigner

• 滚动窗口（tumbling window）
• 滑动窗口（sliding window）
• 会话窗口（session window）
• 全局窗口（global window）

创建不同类型的窗口

• 滚动时间窗口
  • timeWindow(Time.seconds(15))
• 滑动时间窗口
  • timeWindow(Time.seconds(15), Time.seconds(5))
• 会话窗口
  • window(EventTimeSessionWindow.withGap(Time.minutes(10)))
• 滚动计数窗口
  • countWindow(10)
• 滑动计数窗口
  • countWindow(10, 2)

DataStream的windowAll()类似分区的global操作，这个操作是non-parallel的(并行度强行为1)，所有的数据都会被传递到同一个算子operator上，官方建议如果非必要就不要用这个API

2.2 TimeWindow

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

滚动时间窗口

Flink默认的时间窗口根据**ProcessingTime（当前时间）**进行窗口的划分，将Flink获取到的数据根据进入Flink的时间划分到不同的窗口中。

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

DataStream<Tuple2<String, Double>> minTempPerWindowStream = dataStream 
  .map(new MapFunction<SensorReading, Tuple2<String, Double>>() { 
    @Override 
    public Tuple2<String, Double> map(SensorReading value) throws Exception {
      return new Tuple2<>(value.getId(), value.getTemperature()); 
    } 
  }) 
  .keyBy(data -> data.f0) 
  .timeWindow( Time.seconds(15) ) 
  .minBy(1);

滑动时间窗口

滑动窗口的滚动窗口，只是在传参数时需要传入两个参数，一个是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");

2.3 CountWindow

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

注意：CountWindow的window_size指的是相同key的元素个数，不是输入的所有元素的总数。

滚动计数窗口

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

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

滑动计数窗口

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

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

2.4 window function

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

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

增量聚合函数

每条数据到来就进行计算，保持一个简单的状态。（来一条处理一条，但是不输出，到窗口临界位置才输出）

典型的增量聚合函数有ReduceFunction, AggregateFunction。

全窗口函数

先把窗口所有数据收集起来，等到计算的时候会遍历所有数据。（来一个放一个，窗口临界位置才遍历且计算、输出）

ProcessWindowFunction，WindowFunction

这两个有什么区别，全窗口函数可以看作触发器是定时的，达到一定时间/一定数量时，执行函数。增量聚合函数可以看作有一个累计的过程，达到窗口临界位置时，输出累计结果。

2.5 其他可选 API

相关博客：

Flink-Window概述 | Window类型 | TimeWindow、CountWindow、SessionWindow、WindowFunction

• .trigger() ——触发器

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

• .evitor() ——移除器

  定义移除某些数据的逻辑

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

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

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

2.6 测试代码

相关博客：

Flink之Window的使用（2）：时间窗口

测试滚动计算窗口的增量聚合函数

package com.root.window;

import com.root.SensorReading;
import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

/**
 * @author Kewei
 * @Date 2022/3/6 12:24
 */

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

        DataStreamSource<String> inputStream = env.socketTextStream("localhost", 7777);

        SingleOutputStreamOperator<SensorReading> dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });
        
        // 先分组后定制滑动计数窗口，对每个窗口进行增量聚合，求出平均值
        SingleOutputStreamOperator<Double> resultStream = dataStream.keyBy("id")
                .countWindow(10, 2)
                .aggregate(new MyAvgFun());

        resultStream.print();

        env.execute();
    }
    
    // 创建一个聚合类实现AggregateFunction<input, output>接口

    /**
     * 需要实现四个函数：
     * createAccumulator ： 初始化累加器
     * add              ： 同分区累加数据
     * merge            ： 不同分区累计器聚合
     * getResult        ： 返回累加器结果，可以做一些运算
     */
    public static class MyAvgFun implements AggregateFunction<SensorReading, Tuple2<Double, Integer>, Double>{
        @Override
        public Tuple2<Double, Integer> createAccumulator() {
            return new Tuple2<>(0.0, 0);
        }

        @Override
        public Tuple2<Double, Integer> add(SensorReading value, Tuple2<Double, Integer> acc) {
            return new Tuple2<>(acc.f0 + value.getTemperature(),acc.f1+1);
        }

        @Override
        public Double getResult(Tuple2<Double, Integer> acc) {
            return acc.f0/acc.f1;
        }

        @Override
        public Tuple2<Double, Integer> merge(Tuple2<Double, Integer> acc1, Tuple2<Double, Integer> acc2) {
            return new Tuple2<>(acc1.f0+acc2.f0,acc1.f1+acc2.f1);
        }
    }
}

其他可选API代码片段

// 3. 其他可选API
OutputTag<SensorReading> outputTag = new OutputTag<SensorReading>("late") {
};

SingleOutputStreamOperator<SensorReading> sumStream = dataStream.keyBy("id")
  .timeWindow(Time.seconds(15))
  //                .trigger() // 触发器，一般不使用 
  //                .evictor() // 移除器，一般不使用
  .allowedLateness(Time.minutes(1)) // 允许1分钟内的迟到数据<=比如数据产生时间在窗口范围内，但是要处理的时候已经超过窗口时间了
  .sideOutputLateData(outputTag) // 侧输出流，迟到超过1分钟的数据，收集于此
  .sum("temperature"); // 侧输出流 对 温度信息 求和。

// 之后可以再用别的程序，把侧输出流的信息和前面窗口的信息聚合。（可以把侧输出流理解为用来批处理来补救处理超时数据）