【Flink】Window API

Window的概念

窗口

• 一般真实的流都是无界的，怎样处理无界的数据？

• 可以把无限的数据流进行切分，得到有限的数据集进行处理 —— 也就是得到有界流

• 窗口（window）就是将无限流切割为有限流的一种方式，它会将流数据分发到有限大小的桶（bucket）中进行分析

---

窗口的分类

• 滚动窗口（Tumbling Windows）
  

• 将数据依据固定的窗口长度对数据进行切分

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

---

• 滑动窗口（Sliding Windows）
  

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

• 窗口长度固定，可以有重叠

• 滑动窗口可以看作是一个特殊的滚动窗口（滑动间隔等于大小的）

---

• 会话窗口（Session Windows）
  

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

• 特点：时间无对齐

跳转顶部

---

Window API

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

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

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

        dataStream.keyBy("id")
                .timeWindow(Time.seconds(15))
                .min("temp");

---

窗口分配器（window assigner）

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

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

• Flink 提供了通用的 WindowAssigner

  滚动窗口（tumbling window）

  滑动窗口（sliding window）

  会话窗口（session window）

  全局窗口（global window）

• 如何创建各个窗口？

• 滚动时间窗口（tumbling time window）
  

• 滑动时间窗口（sliding time window）
  

• 会话窗口（session window）
  

• 滚动计数窗口（tumbling count window）
  

• 滑动计数窗口（sliding count window）
  

---

窗口函数（window function）

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

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

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

  ReduceFunction, AggregateFunction

• 全窗口函数（full window functions）

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

  ProcessWindowFunction，WindowFunction

• 自定义AggregateFunction

        SingleOutputStreamOperator<Integer> aggregate = dataStream
                .keyBy("id")
                .timeWindow(Time.seconds(15))
                /**
                 * 三个参数分别是输入、累加器和输出
                 */
                .aggregate(new AggregateFunction<SenSorReading, Integer, Integer>() {
                    @Override
                    public Integer createAccumulator() {
                        return 0;
                    }

                    /**\
                     * 在什么时候启用累加，如何累加
                     * @param senSorReading
                     * @param integer
                     * @return
                     */
                    @Override
                    public Integer add(SenSorReading senSorReading, Integer integer) {
                        return integer + 1;
                    }

                    @Override
                    public Integer getResult(Integer integer) {
                        return integer;
                    }

                    /**
                     * 合并多个分区的数据
                     * @param integer
                     * @param acc1
                     * @return
                     */
                    @Override
                    public Integer merge(Integer integer, Integer acc1) {
                        return integer + acc1;
                    }
                });

• 自定义WindowFunction

        SingleOutputStreamOperator<Integer> apply = dataStream
                .keyBy("id")
                .timeWindow(Time.seconds(15))
                /**
                 * 四个参数：输入、输出、输入的key，和窗口
                 */
                .apply(new WindowFunction<SenSorReading, Integer, Tuple, TimeWindow>() {
                    @Override
                    public void apply(Tuple tuple, TimeWindow timeWindow, Iterable<SenSorReading> iterable, Collector<Integer> collector) throws Exception {
                        Integer count = IteratorUtils.toList(iterable.iterator()).size();
                        collector.collect(count);
                    }
                });

---

其它可选 API

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

• evictor() —— 移除器：定义移除某些数据的逻辑

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

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

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

• 练习

        OutputTag<SenSorReading> late = new OutputTag<>("late");
        dataStream
                .keyBy("id")
                .timeWindow(Time.seconds(15))
                .allowedLateness(Time.minutes(1))//允许超市一分钟
                .sideOutputLateData(late);//超时的数据单独分成与i个流

跳转顶部

---