Flink学习笔记（5）——window

最新推荐文章于 2024-04-30 07:11:20 发布

颍天

最新推荐文章于 2024-04-30 07:11:20 发布

阅读量154

点赞数

分类专栏： flink 文章标签： flink 大数据

本文链接：https://blog.csdn.net/anyitian/article/details/117164322

版权

flink 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

本文详细介绍了Apache Flink中窗口操作的基本概念、类型及API使用，包括时间窗口和计数窗口，如滚动窗口、滑动窗口和会话窗口。窗口用于将无限的数据流切割成有界的片段进行处理。同时，文章讲解了增量聚合函数和全窗口函数的使用，以及window API的相关配置，如触发器、移除器和迟到数据处理。

摘要由CSDN通过智能技术生成

基本概念

一般真实的流都是无限的，怎么处理无界的数据？在实际生产中，需要把无限的数据流进行切分，得到有限的数据集进行处理。

窗口(window)就是将无限流切割为有界流的一种方式，它会将流数据分发到有限大小的桶中进行分析。
在这里插入图片描述

window类型

flink里提供了时间窗口(TimeWindow)和计数窗口(CountWindow)。

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

时间窗口（Time Window）
- 滚动时间窗口(Tumbling Windows)
- 滑动时间窗口(Sliding Windows)
- 会话窗口(Session Windows)
计数窗口(count window)
- 滚动计数窗口
- 滑动计数窗口

ps：滚动窗口和滑动窗口左闭右开，例如窗口长度设置为1个小时，9点整这条数据属于9点到10点的窗口

滚动窗口(Tumbling Windows)

在这里插入图片描述

根据固定的窗口长度对数据进行切分
时间对齐，窗口长度固定没有重叠每一个数据只会属于一个窗口

滑动窗口(Sliding Windows)

在这里插入图片描述

滑动窗口由固定的窗口长度和滑动间隔组成。滚动窗口就是滑动距离和窗口长度一致的滑动窗口。
窗口长度固定，可以有重叠，一条数据可以属于多个窗口

会话窗口(Session Windows)

在这里插入图片描述

由一系列时间组合一个指定时间长度的timeout间隙组成，也就是一段时间没有接收到新数据就会生成新的窗口，gap长度不定。
时间无对齐

window api

概述

我们可以用window()方法来定义一个窗口，然后基于这个window去做一些聚合或者其他处理操作。注意window()方法必须在keyby之后才能使用。

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

DataStream<Tuple2<String,Double>> minTempPerWindowStream = 
	  datastream
	  .map(new MyMapper())
	  .keyBy(data -> data.f0)
	  //timeWindow()在1.12已经过期了
	  .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
	  .minBy(1);

创建不同类型的窗口

滚动时间窗口（tumbling time window）

.window(TumblingProcessingTimeWindows.of(Time.seconds(5)))

滑动时间窗口（sliding time window）

.window(TumblingProcessingTimeWindows.of(Time.seconds(10),Time.seconds(5)))

会话窗口（session window）

.window(ProcessingTimeSessionWindows.withGap(Time.seconds(5)))

滚动计数窗口（tumbling count window）
```
.countWindow(10)
```
滑动计数窗口（sliding count window）
```
.countWindow(10,2)
```
DataStream的windowAll()类似分区的global操作，这个操作是non-parallel的(并行度强行为1)，所有的数据都会被传递到同一个算子operator上，官方建议如果非必要就不要用这个API。

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

window function

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

增量聚合函数（incremental aggregation functions）

每条数据到来就进行计算，保持一个简单的状态。（来一条处理一条，但是不输出，到窗口临界位置才输出）
典型的增量聚合函数有ReduceFunction, AggregateFunction。

package window;

import bean.SensorReading;
import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
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;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: yingtian
 * @Date: 2021/05/20/16:45
 * @Description: 时间窗口
 */
public class WindowTest1_TimeWindow {

    public static void main(String[] args) throws Exception{
        //获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        //从socket流中获取数据
        DataStreamSource<String> socketStream = env.socketTextStream("localhost", 7777);

        SingleOutputStreamOperator<SensorReading> mapStream = socketStream.map(line -> {
            String[] arr = line.split(",");
            return new SensorReading(arr[0], Long.valueOf(arr[1]), Double.valueOf(arr[2]));
        });

        //1. 增量聚合函数 (这里简单统计每个key组里传感器信息的总数)
        SingleOutputStreamOperator<Integer> resultStream = mapStream
                .keyBy(SensorReading::getId)
                .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;
                    }

                    //分区合并结果(TimeWindow一般用不到，SessionWindow可能需要考虑合并)
                    @Override
                    public Integer merge(Integer integer, Integer acc1) {
                        return integer + acc1;
                    }
                });
        resultStream.print("result");
        env.execute();
    }
}

全窗口函数（full window functions）

先把窗口所有数据收集起来，等到计算的时候会遍历所有数据。（来一个放一个，窗口临界位置才遍历且计算、输出）
ProcessWindowFunction，WindowFunction。
process和apply在功能上差不多，但是process可以拿的到上下文context。

// 2. 全窗口函数 （WindowFunction和ProcessWindowFunction，后者更全面）
    SingleOutputStreamOperator<Tuple3<String, Long, Integer>> resultStream2 = dataStream.keyBy(SensorReading::getId)
            .window(TumblingProcessingTimeWindows.of(Time.seconds(15)))
//                .process(new ProcessWindowFunction<SensorReading, Object, Tuple, TimeWindow>() {
//                })
                .apply(new WindowFunction<SensorReading, Tuple3<String, Long, Integer>, String, TimeWindow>() {
                    @Override
                    public void apply(String s, TimeWindow window, Iterable<SensorReading> input, Collector<Tuple3<String, Long, Integer>> out) throws Exception {
                        String id = s;
                        long windowEnd = window.getEnd();
                        int count = IteratorUtils.toList(input.iterator()).size();
                        out.collect(new Tuple3<>(id, windowEnd, count));
                    }
                });