7、如何使用Flink中的窗口（Window算子）

最新推荐文章于 2024-05-21 09:52:18 发布
最新推荐文章于 2024-05-21 09:52:18 发布
阅读量903 收藏 4
点赞数 1
分类专栏： # Flink API 使用技巧 文章标签： flink 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42845827/article/details/131541254
版权

目录

1、如何理解 Flink中的窗口（window）

2、Flink中窗口的类型

2.1 根据上游DataStream类型分类

2.2 根据驱动类型分类

2.3 根据进入到窗口数据的分发规则分类

3、怎样使用 Flink中的 Window算子

4、怎样使用 Flink中的 Window Assigners

4.1、基于处理时间的滑动窗口

4.2、基于处理时间的滚动窗口

4.3、基于处理时间的会话窗口

4.4、基于事件时间的滑动窗口

4.5、基于事件时间的滚动窗口

4.6、基于事件时间的会话窗口

4.7、计数窗口

5、怎样使用 Flink中的 Window Funcation

5.1、ReduceFunction

5.2、AggregateFunction

5.3、ProcessWindowFunction

5.4、增量聚合的 ProcessWindowFunction

6、Flink中的 Window的生命周期

6.1、触发器 - Triggers

6.2、移除器 - Evictors

7、对迟到数据的处理

7.1、生成水位线时，设置最大乱序时间

7.2、设置窗口延迟关闭 - allowedLateness

7.3、使用侧输出流获取迟到的数据 - sideOutputLateData

1、如何理解 Flink中的窗口（window）

        Flink中的窗口好像一个桶，可以根据不同的时间语义，将无界流中的数据分配到指定的桶中去，再通过 水位线或者处理时间 触发对桶中的数据进行计算

        其目的就是为了将无限的数据 根据指定的规则进行切分成有限的数据进行计算

2、Flink中窗口的类型

2.1 根据上游DataStream类型分类

按键分区窗口(Keyed Windows) ：

         基于KeyedStream做窗口操作，窗口计算会在多个并行子任务上同时执行，相同的key的数据会进入到同一个窗口中去。

非按键分区-Non-Keyed Windows ：

        基于DataStream做窗口操作，流上的数据会进入同一窗口中，只能有一个Task处理(不推荐这种方式)

2.2 根据驱动类型分类

时间窗口(Time Window)：

        通过指定的时间语义的时间点来定义窗口的开始和结束，流中的数据被分配到哪个窗口中，也由数据上的时间标识来决定，当接收到带有结束时间标识的数据时，将触发窗口计算，并销毁窗口

计数窗口(Count Window):

       窗口的大小由数据个数来限制，当窗口内接收的数据个数到达窗口大小时，将触发窗口计算，并销毁窗口

 2.3 根据进入到窗口数据的分发规则分类

滚动窗口（Tumbling Windows）：

        滚动窗口的大小是固定的，且各自范围之间不重叠。 比如说，如果你指定了滚动窗口的大小为 5 分钟，那么每 5 分钟就会有一个窗口被计算，且一个新的窗口被创建（如下图所示）

滑动窗口（Sliding Windows）：

        滑动窗口的 assigner 分发元素到指定大小的窗口，窗口大小通过 window size 参数设置。 滑动窗口需要一个额外的滑动距离（window slide）参数来控制生成新窗口的频率。 因此，如果 slide 小于窗口大小，滑动窗口可以允许窗口重叠。这种情况下，一个元素可能会被分发到多个窗口。

比如说，你设置了大小为 10 分钟，滑动距离 5 分钟的窗口，你会在每 5 分钟得到一个新的窗口， 里面包含之前 10 分钟到达的数据（如下图所示）

会话窗口（Session Windows）： 

         与滚动窗口和滑动窗口不同，会话窗口不会相互重叠，且没有固定的开始或结束时间。 会话窗口在一段时间没有收到数据之后会关闭，即在一段不活跃的间隔之后。 会话窗口的 assigner 可以设置固定的会话间隔（session gap）或 用 session gap extractor 函数来动态地定义多长时间算作不活跃。 当超出了不活跃的时间段，当前的会话就会关闭，并且将接下来的数据分发到新的会话窗口。

全局窗口（Global Windows）： 

全局窗口的 assigner 将拥有相同 key 的所有数据分发到一个全局窗口。 这样的窗口模式仅在你指定了自定义的 trigger 时有用。 否则，计算不会发生，因为全局窗口没有天然的终点去触发其中积累的数据。

3、怎样使用 Flink中的 Window算子

Keyed Windows API :

stream
       .keyBy(...)               <-  仅 keyed 窗口需要
       .window(...)              <-  必填项："assigner" 	 指定窗口类型
      [.trigger(...)]            <-  可选项："trigger"  	 指定触发器
      [.evictor(...)]            <-  可选项："evictor"  	 指定移除器
      [.allowedLateness(...)]    <-  可选项："lateness" 	 指定窗口延迟关闭时间 
      [.sideOutputLateData(...)] <-  可选项："output tag" 
       .reduce/aggregate/apply() <-  必填项："function"   指定窗口聚合函数
      [.getSideOutput(...)]      <-  可选项："output tag" 指定侧输出流(用来接收迟到数据)

Non-Keyed Windows API :

stream
       .windowAll(...)           <-  必填项："assigner" 	 指定窗口类型
      [.trigger(...)]            <-  可选项："trigger"  	 指定触发器
      [.evictor(...)]            <-  可选项："evictor"  	 指定移除器
      [.allowedLateness(...)]    <-  可选项："lateness" 	 指定窗口延迟关闭时间 
      [.sideOutputLateData(...)] <-  可选项："output tag" 指定侧输出流(用来接收迟到数据)
       .reduce/aggregate/apply() <-  必填项："function"   指定窗口聚合函数
      [.getSideOutput(...)]      <-  可选项："output tag"

4、怎样使用 Flink中的 Window Assigners

功能说明：

        通过stream.window(WindowAssigner) 来指定 窗口的类型

4.1、基于处理时间的滑动窗口

使用场景：

        每隔x秒统计近y秒内的数据(y>x)

代码示例：

/*
 * TODO 基于处理时间的滑动窗口
 *     每2秒计算最近10秒内的数据
 * */
public class SlidingProcessingTimeWindow {
    public static void main(String[] args) throws Exception {
        // 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(3);

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        // TODO Window：KeyedStream → WindowedStream
        Window(env);

        // TODO WindowAll：DataStream → AllWindowedStream
        //WindowAll(env);

        // 3.触发程序执行
        env.execute();
    }

    // TODO Keyed Windows
    private static void Window(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .keyBy(value -> value.f0)
                // 滑动窗口，窗口长度10s，滑动步长2s
                .window(SlidingProcessingTimeWindows.of(Time.seconds(10), Time.seconds(2)))
                .process(new ShowProcessWindowFunction())
                .print()
        ;
    }

    // TODO Non-Keyed Windows
    private static void WindowAll(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                // 滑动窗口，窗口长度5s，滑动步长2s
                .windowAll(SlidingProcessingTimeWindows.of(Time.seconds(5), Time.seconds(2)))
                .process(new ShowProcessAllWindowFunction())
                .print()
        ;
    }
}

4.2、基于处理时间的滚动窗口

使用场景：

        计算固定时间段内的数据

代码示例：

/*
 * TODO 基于处理时间的滚动窗口
 *   计算每小时内的用户访问数
 * */
public class TumblingProcessingTimeWindow {
    public static void main(String[] args) throws Exception {
        // 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(3);

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        // TODO Window：KeyedStream → WindowedStream
        //Window(env);

        // TODO WindowAll：DataStream → AllWindowedStream
        WindowAll(env);

        // 3.触发程序执行
        env.execute();
    }

    // TODO Keyed Windows
    private static void Window(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .keyBy(value -> value.f0)
                // 滚动窗口，窗口长度5s
                .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
                .process(new ShowProcessWindowFunction())
                .print()
        ;
    }

    // TODO Non-Keyed Windows
    private static void WindowAll(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                // 滚动窗口，窗口长度5s
                .windowAll(TumblingProcessingTimeWindows.of(Time.seconds(5)))
                .process(new ShowProcessAllWindowFunction())
                .print()
        ;
    }
}

4.3、基于处理时间的会话窗口

使用场景：

        计算指定时间间隔内的数据

代码示例：

/*
 * TODO 基于处理时间的会话窗口
 *    相邻两个元素的处理时间间隔 大于指定会话周期 触发窗口计算
 * */
public class ProcessingTimeSessionWindow {
    public static void main(String[] args) throws Exception {
        // 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(3);

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        // TODO Window：KeyedStream → WindowedStream
        //Window(env);

        // TODO WindowAll：DataStream → AllWindowedStream
        WindowAll(env);

        // 3.触发程序执行
        env.execute();
    }

    // TODO Keyed Windows
    private static void Window(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .keyBy(value -> value.f0)
                // 会话窗口，超时间隔5s
                .window(ProcessingTimeSessionWindows.withGap(Time.seconds(5)))
                .process(new ShowProcessWindowFunction())
                .print()
        ;
    }

    // TODO Non-Keyed Windows
    private static void WindowAll(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                // 会话窗口，超时间隔5s
                .windowAll(ProcessingTimeSessionWindows.withGap(Time.seconds(5)))
                .process(new ShowProcessAllWindowFunction())
                .print()
        ;
    }
}

4.4、基于事件时间的滑动窗口

代码示例：

/*
 * TODO 基于事件时间的滑动窗口
 *   每2秒计算一次最近10秒内的数据
 * */
public class SlidingEventTimeWindow {
    public static void main(String[] args) throws Exception {
        // 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(3);

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        // TODO Window：KeyedStream → WindowedStream
        Window(env);

        // TODO WindowAll：DataStream → AllWindowedStream
        //WindowAll(env);

        // 3.触发程序执行
        env.execute();
    }

    // TODO Keyed Windows
    private static void Window(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple2<String, Long>>forMonotonousTimestamps()
                                .withTimestampAssigner((element, recordTimestamp) -> element.f1)
                )
                .keyBy(value -> value.f0)
                // 滚动窗口，窗口长度10s，滑动步长2s
                .window(SlidingEventTimeWindows.of(Time.seconds(5), Time.seconds(1)))
                .process(new ShowProcessWindowFunction())
                .print()
        ;
    }

    // TODO Non-Keyed Windows
    private static void WindowAll(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                //.<Tuple2<String, Long>>forMonotonousTimestamps()
                                .<Tuple2<String, Long>>forGenerator(new PeriodWatermarkStrategy())
                                .withTimestampAssigner(
                                        (Tuple2<String, Long> element, long recordTimestamp) -> {
                                            //System.out.println("Step1：extractTimestamp-从事件数据中提取时间戳");
                                            return element.f1;
                                        }
                                )
                        //.withIdleness(Duration.ofSeconds(5))  //空闲等待5s
                )
                .keyBy(value -> value.f0)
                // 滑动窗口，窗口长度10s，滑动步长2s
                .windowAll(SlidingEventTimeWindows.of(Time.seconds(5), Time.seconds(2)))
                .process(new ShowProcessAllWindowFunction())
                .print()
        ;
    }

}

4.5、基于事件时间的滚动窗口

代码示例：

/*
 * TODO 基于事件时间的滚动窗口
 *   计算每个窗口周期内的数据（计算每小时内的用户访问数）
 * */
public class TumblingEventTimeWindow {
    public static void main(String[] args) throws Exception {
        // 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(3);

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        // TODO Window：KeyedStream → WindowedStream
        //Window(env);

        // TODO WindowAll：DataStream → AllWindowedStream
        WindowAll(env);

        // 3.触发程序执行
        env.execute();
    }

    // TODO Keyed Windows
    private static void Window(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple2<String, Long>>forMonotonousTimestamps()
                                .withTimestampAssigner((element, recordTimestamp) -> element.f1)
                )
                .keyBy(value -> value.f0)
                // 滚动窗口，窗口长度5s
                .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                .process(new ShowProcessWindowFunction())
                .print()
        ;
    }

    // TODO Non-Keyed Windows
    private static void WindowAll(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple2<String, Long>>forMonotonousTimestamps()
                                .withTimestampAssigner((element, recordTimestamp) -> element.f1)
                )
                .keyBy(value -> value.f0)
                // 滚动窗口，窗口长度5s
                .windowAll(TumblingEventTimeWindows.of(Time.seconds(5)))
                .process(new ShowProcessAllWindowFunction())
                .print()
        ;
    }
}

4.6、基于事件时间的会话窗口

代码示例：

/*
 * TODO 基于会话时间的会话窗口
 *    相邻两个元素的处理时间间隔 大于指定会话周期 触发窗口计算
 * */
public class EventTimeSessionWindow {
    public static void main(String[] args) throws Exception {
        // 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        // TODO Window：KeyedStream → WindowedStream
        // Window(env);

        // TODO WindowAll：DataStream → AllWindowedStream
        WindowAll(env);

        // 3.触发程序执行
        env.execute();
    }

    // TODO Keyed Windows
    private static void Window(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple2<String, Long>>forMonotonousTimestamps()
                                .withTimestampAssigner((element, recordTimestamp) -> element.f1)
                )
                .keyBy(value -> value.f0)
                // 会话窗口，超时间隔5s
                .window(EventTimeSessionWindows.withGap(Time.seconds(5)))
                .process(new ShowProcessWindowFunction())
                .print()
        ;
    }

    // TODO Non-Keyed Windows
    private static void WindowAll(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple2<String, Long>>forMonotonousTimestamps()
                                .withTimestampAssigner((element, recordTimestamp) -> element.f1)
                )
                // 会话窗口，超时间隔5s
                .windowAll(EventTimeSessionWindows.withGap(Time.seconds(5)))
                .process(new ShowProcessAllWindowFunction())
                .print()
        ;
    }
}

4.7、计数窗口

代码示例：

// TODO 计数窗口
public class countWindow {
    public static void main(String[] args) throws Exception {
        // 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(3);

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        // TODO Window：KeyedStream → WindowedStream
        // Window(env);

        // TODO countWindowAll：DataStream → AllWindowedStream
         countWindowAll(env);

        // 3.触发程序执行
        env.execute();
    }

    // TODO Keyed Windows
    private static void Window(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .keyBy(value -> value.f0)
                // TODO 滚动窗口，窗口长度=5个元素
                //.countWindow(5)
                // TODO 滑动窗口，窗口长度=5个元素，滑动步长=2个元素 (每当进入两个数据，就统计下窗口内最五个数据)
                .countWindow(5,2)
                .process(
                        new ProcessWindowFunction<Tuple2<String, Long>, String, String, GlobalWindow>() {
                            @Override
                            public void process(String s, ProcessWindowFunction<Tuple2<String, Long>, String, String, GlobalWindow>.Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {
                                // 当前水位线
                                long watermark = context.currentWatermark();
                                // 当前处理时间
                                long processingTime = context.currentProcessingTime();
                                // 窗口开始时间

                                // 窗口结束时间

                                // 计算窗口内数据数量
                                long count = elements.spliterator().estimateSize();

                                String record = "key=" + s
                                        + " 包含" + count + "条数据===>" + elements.toString()
                                        + " 当前Watermark：" + watermark
                                        + " 当前processingTime：" + processingTime;

                                out.collect(record);
                            }
                        }
                )
                .print()
        ;
    }

    // TODO Non-Keyed Windows
    private static void countWindowAll(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                // TODO 滚动窗口，窗口长度=5个元素
                .countWindowAll(5)
                // TODO 滑动窗口，窗口长度=5个元素，滑动步长=2个元素 (每当进入两个数据，就统计下窗口内最近的五个数据)
                //.countWindowAll(5,2)
                .process(
                        new ProcessAllWindowFunction<Tuple2<String, Long>, String, GlobalWindow>() {
                            @Override
                            public void process(ProcessAllWindowFunction<Tuple2<String, Long>, String, GlobalWindow>.Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {
                                // 当前水位线

                                // 当前处理时间

                                // 窗口开始时间

                                // 窗口结束时间

                                // 计算窗口内数据数量
                                long count = elements.spliterator().estimateSize();

                                String record = "窗口包含" + count + "条数据===>" + elements.toString();

                                out.collect(record);
                            }
                        }
                )
                .print()
        ;
    }

}

5、怎样使用 Flink中的 Window Funcation

窗口函数的作用：

        窗口函数定义了当窗口触发后，对窗口内数据的计算逻辑

窗口函数的分类：

5.1、ReduceFunction

函数功能：

        将两条数据合并成一条数据，输入和输出的数据类型必须相同

代码示例：

/*
 * TODO 增量聚合函数：ReduceFunction
 *  特点：
 *      1.增量聚合：进入窗口一条数据，就会被计算一次(调用reduce方法)，但是不会立刻输出(只会更新状态)
 *      2.第一条数据进入窗口后，不会调用 reduce 方法
 *      3.数据类型不能改变：输入数据类型 = 输出数据类型 = `中间累加器数据类型`
 *      4.窗口触发计算时，才会输出窗口的计算结果
 * */
public class ReduceFunctions {
    public static void main(String[] args) throws Exception {
        // 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(3);

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .keyBy(value -> value.f0)
                // TODO 指定窗口类型：滚动计数窗口，窗口长度=5个元素
                .countWindow(5)
                // TODO 对窗口内的元素求和
                .reduce(
                        new ReduceFunction<Tuple2<String, Long>>() {

                            /**
                             * @param value1 参与聚合的第一个值，也就是累加器的值
                             * @param value2 参与聚合的第二个值，也就是新进入窗口的时间数据
                             * @return
                             * @throws Exception
                             */
                            @Override
                            public Tuple2<String, Long> reduce(Tuple2<String, Long> value1, Tuple2<String, Long> value2) throws Exception {
                                System.out.println("触发计算：" + value1 + " ，" + value2);
                                long sum = value1.f1 + value2.f1;
                                return new Tuple2<>(value1.f0, sum);
                            }
                        }
                )
                .print()
        ;

        // 3.触发程序执行
        env.execute();
    }

}

5.2、AggregateFunction

函数功能：

        将两条数据合并成一条数据，输入和输出的数据类型可以不同

代码示例：

/*
 * TODO 增量聚合函数：AggregateFunction
 *  特点：
 *      1.增量聚合：进入窗口一条数据，就会被计算一次(调用add方法)，但是不会立刻输出(只会更累加器的状态)
 *      2.窗口内的第一条数据进入后，会创建窗口，创建累加器并初始化
 *      3.窗口触发计算时，才会输出窗口的计算结果(调用getResult方法)
 *      4.数据类型可以不同：输入数据类型、输出数据类型、累加器数据类型
 *  泛型参数：
 *      AggregateFunction<IN, ACC, OUT>
 *      @IN    ：  输入数据类型
 *      @ACC   ：  累加器数据类型
 *      @OUT   ：  输出数据类型
 *
 * */
public class AggregateFunctions {
    public static void main(String[] args) throws Exception {
        // 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(3);

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .keyBy(value -> value.f0)
                // TODO 指定窗口类型：滚动计数窗口，窗口长度=5个元素
                .countWindow(5)
                // TODO 对窗口内的元素求和
                .aggregate(
                        new AggregateFunction<Tuple2<String, Long>, Integer, String>() {
                            /**
                             * 创建累加器，并对累加器做初始化操作
                             * @return
                             */
                            @Override
                            public Integer createAccumulator() {
                                System.out.println("创建累加器");
                                return 0;
                            }

                            /**
                             * 事件数据与累加器的Merge逻辑，用来更新累加器状态
                             * 进入一条数据，调用一次
                             * @param value       The value to add
                             * @param accumulator The accumulator to add the value to
                             * @return
                             */
                            @Override
                            public Integer add(Tuple2<String, Long> value, Integer accumulator) {
                                System.out.println("调用add方法，value=" + value + " 当前累加器：" + accumulator);
                                return accumulator + 1;
                            }

                            /**
                             * 获取累加器的状态值，窗口触发时调用
                             * @param accumulator The accumulator of the aggregation
                             * @return
                             */
                            @Override
                            public String getResult(Integer accumulator) {
                                System.out.println("调用getResult 方法");
                                return accumulator.toString();
                            }

                            /**
                             * 合并窗口逻辑(只有sessionWindow才会用的)
                             * @param a An accumulator to merge
                             * @param b Another accumulator to merge
                             * @return
                             */
                            @Override
                            public Integer merge(Integer a, Integer b) {
                                System.out.println("调用merge方法");
                                return null;
                            }
                        }
                )
                .print()
        ;

        // 3.触发程序执行
        env.execute();
    }

}

5.3、ProcessWindowFunction

函数功能：

        将窗口内所有的数据缓存到Iterable，在窗口触发后对所有数据进行计算

代码示例：

/*
 * TODO 全窗口函数：ProcessWindowFunction
 *  特点：
 *      1.窗口触发时才会调用一次process方法，对窗口内的数据统一计算
 *  泛型参数说明：
 *      ProcessWindowFunction<IN, OUT, KEY, W extends Window>
 *      @IN     ：  输入数据类型
 *      @OUT    ：  输出数据类型
 *      @KEY    ：  key的数据类型
 *      @W      ：  window类型(时间窗口、计数窗口)
 *  上下文对象说明：
 *      时间信息：currentProcessingTime()、currentWatermark()
 *      状态信息：windowState()、globalState()
 *      侧输出流：
 *      窗口信息：window()
 *  重点说明：
 *      由于WindowFunction会存储窗口内的所有数据，当窗口内数量特别大时，慎用
 *  思考：
 *      1.什么时候需要使用全窗口函数呢？
 *          计算平均数、计算中位数
 * */
public class ProcessWindowFunctions {
    public static void main(String[] args) throws Exception {
        // 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(3);

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        // TODO 基于处理时间的 滚动时间窗口，窗口长度10秒
        timewindow(env);

        // TODO 计数窗口
        //countwindow(env);

        // 3.触发程序执行
        env.execute();
    }

    private static void timewindow(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .keyBy(value -> value.f0)
                // TODO 指定窗口类型：基于处理时间的 滚动时间窗口，窗口长度5秒
                .window(TumblingProcessingTimeWindows.of(Time.seconds(10)))
                // TODO 对窗口内的元素求和
                .process(
                        new ProcessWindowFunction<Tuple2<String, Long>, String, String, TimeWindow>() {

                            /**
                             * @param s        窗口中所属的key
                             * @param context  上下文对象
                             * @param elements 窗口中存储的数据
                             * @param out      采集器，用来向下游发送数据
                             * @throws Exception
                             */
                            @Override
                            public void process(String s, ProcessWindowFunction<Tuple2<String, Long>, String, String, TimeWindow>.Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {
                                // 通过窗口对象，获取窗口的范围信息
                                long startTs = context.window().getStart();
                                long endTs = context.window().getEnd();
                                String windowStart = DateFormatUtils.format(startTs, "yyyy-MM-dd HH:mm:ss.SSS");
                                String windowEnd = DateFormatUtils.format(endTs, "yyyy-MM-dd HH:mm:ss.SSS");

                                long count = elements.spliterator().estimateSize();

                                // 当前处理数据
                                long currentProcessingTime = context.currentProcessingTime();
                                String currentProcessingTimeS = DateFormatUtils.format(endTs, "yyyy-MM-dd HH:mm:ss.SSS");

                                // 当前水位线
                                long currentWatermark = context.currentWatermark();

                                out.collect("key=" + s + "，的窗口[" + windowStart + "," + windowEnd + ") 包含" + count + "条数据 ===> " + elements.toString() + " 当前处理时间：" + currentProcessingTimeS);

                            }
                        }
                )
                .print()
        ;

    }

    private static void countwindow(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .keyBy(value -> value.f0)
                // TODO 指定窗口类型：计数窗口，窗口长度为5
                .countWindow(5)
                // TODO 对窗口内的元素求和
                .process(
                        new ProcessWindowFunction<Tuple2<String, Long>, String, String, GlobalWindow>() {


                            /**
                             * @param s        窗口中所属的key
                             * @param context  上下文对象
                             * @param elements 窗口中存储的数据
                             * @param out      采集器，用来向下游发送数据
                             * @throws Exception
                             */
                            @Override
                            public void process(String s, ProcessWindowFunction<Tuple2<String, Long>, String, String, GlobalWindow>.Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {
                                // 通过窗口对象，获取窗口的范围信息

                                long count = elements.spliterator().estimateSize();

                                // 当前处理数据
                                long currentProcessingTime = context.currentProcessingTime();
                                String currentProcessingTimeS = DateFormatUtils.format(currentProcessingTime, "yyyy-MM-dd HH:mm:ss.SSS");

                                // 当前水位线
                                long currentWatermark = context.currentWatermark();

                                out.collect("key=" + s + "，的窗口 包含" + count + "条数据 ===> " + elements.toString() + " 当前处理时间：" + currentProcessingTimeS);

                            }
                        }
                )
                .print()
        ;

    }
}

5.4、增量聚合的 ProcessWindowFunction

函数功能：

        既可以使用 ReduceFunction 或 AggregateFunction 增量聚合功能

        又可以使用 ProcessWindowFunction 中的元数据信息(窗口信息、水位线信息)

代码示例：

/*
 * TODO 全窗口函数：ProcessWindowFunction
 *  特点：
 *      1.窗口触发时才会调用一次process方法，对窗口内的数据统一计算
 *  泛型参数说明：
 *      ProcessWindowFunction<IN, OUT, KEY, W extends Window>
 *      @IN     ：  输入数据类型
 *      @OUT    ：  输出数据类型
 *      @KEY    ：  key的数据类型
 *      @W      ：  window类型(时间窗口、计数窗口)
 *  上下文对象说明：
 *      时间信息：currentProcessingTime()、currentWatermark()
 *      状态信息：windowState()、globalState()
 *      侧输出流：
 *      窗口信息：window()
 *  重点说明：
 *      由于WindowFunction会存储窗口内的所有数据，当窗口内数量特别大时，慎用
 *  思考：
 *      1.什么时候需要使用全窗口函数呢？
 *      计算平均数、计算中位数
 * */
public class ReduceAggredateProcessWindowFunctions {
    public static void main(String[] args) throws Exception {
        // 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(3);

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        // TODO 基于处理时间的 滚动时间窗口，窗口长度10秒
        // TODO 使用 ReduceFunction + ProcessWindowFunction 增量聚合
        //reduceAndProcessWindowFunction(env);

        // TODO 使用 AggregateFunction + ProcessWindowFunction 增量聚合
        aggreateAndProcessWindowFunction(env);

        // 3.触发程序执行
        env.execute();
    }

    private static void reduceAndProcessWindowFunction(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .keyBy(value -> value.f0)
                // TODO 指定窗口类型：基于处理时间的 滚动时间窗口，窗口长度5秒
                .window(TumblingProcessingTimeWindows.of(Time.seconds(10)))
                // TODO 获取窗口中的最小元素和窗口的开始时间、结束时间
                .reduce(
                        new ReduceFunction<Tuple2<String, Long>>() {

                            /**
                             * @param value1 参与聚合的第一个值，也就是累加器的值
                             * @param value2 参与聚合的第二个值，也就是新进入窗口的时间数据
                             * @return
                             * @throws Exception
                             */
                            @Override
                            public Tuple2<String, Long> reduce(Tuple2<String, Long> value1, Tuple2<String, Long> value2) throws Exception {
                                System.out.println("触发计算：" + value1 + " ，" + value2);
                                long min = Math.min(value1.f1, value2.f1);

                                return new Tuple2<>(value1.f0, min);
                            }
                        }
                        , new ProcessWindowFunction<Tuple2<String, Long>, String, String, TimeWindow>() {

                            /**
                             * @param s        窗口中所属的key
                             * @param context  上下文对象
                             * @param elements 窗口中存储的数据
                             * @param out      采集器，用来向下游发送数据
                             * @throws Exception
                             */
                            @Override
                            public void process(String s, ProcessWindowFunction<Tuple2<String, Long>, String, String, TimeWindow>.Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {
                                // 通过窗口对象，获取窗口的范围信息
                                long startTs = context.window().getStart();
                                long endTs = context.window().getEnd();
                                String windowStart = DateFormatUtils.format(startTs, "yyyy-MM-dd HH:mm:ss.SSS");
                                String windowEnd = DateFormatUtils.format(endTs, "yyyy-MM-dd HH:mm:ss.SSS");

                                long count = elements.spliterator().estimateSize();

                                // 当前处理数据
                                long currentProcessingTime = context.currentProcessingTime();
                                String currentProcessingTimeS = DateFormatUtils.format(endTs, "yyyy-MM-dd HH:mm:ss.SSS");

                                // 当前水位线
                                long currentWatermark = context.currentWatermark();

                                out.collect("key=" + s + "，的窗口[" + windowStart + "," + windowEnd + ") 包含" + count + "条数据 ===> " + elements.toString() + " 当前处理时间：" + currentProcessingTimeS);

                            }
                        }
                )
                .print()
        ;

    }

    private static void aggreateAndProcessWindowFunction(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .keyBy(value -> value.f0)
                // TODO 指定窗口类型：基于处理时间的 滚动时间窗口，窗口长度5秒
                .window(TumblingProcessingTimeWindows.of(Time.seconds(10)))
                // TODO 计算窗口内数据平均值并与窗口对应的key一同输出
                .aggregate(
                        new AggregateFunction<Tuple2<String, Long>, Tuple2<Long, Long>, Double>() {

                            /**
                             * @return
                             */
                            @Override
                            public Tuple2<Long, Long> createAccumulator() {
                                return new Tuple2<Long, Long>(0L, 0L);
                            }

                            /**
                             * @param value       The value to add
                             * @param accumulator The accumulator to add the value to
                             * @return
                             */
                            @Override
                            public Tuple2<Long, Long> add(Tuple2<String, Long> value, Tuple2<Long, Long> accumulator) {
                                return new Tuple2<Long, Long>(accumulator.f0 + value.f1, accumulator.f1 + 1L);
                            }

                            /**
                             * @param accumulator The accumulator of the aggregation
                             * @return
                             */
                            @Override
                            public Double getResult(Tuple2<Long, Long> accumulator) {
                                return (double) (accumulator.f0 * 1.0000 / accumulator.f1);
                            }

                            /**
                             * @param a An accumulator to merge
                             * @param b Another accumulator to merge
                             * @return
                             */
                            @Override
                            public Tuple2<Long, Long> merge(Tuple2<Long, Long> a, Tuple2<Long, Long> b) {
                                return null;
                            }
                        }
                        ,new ProcessWindowFunction<Double,String,String,TimeWindow>(){
                            /**
                             * @param s        The key for which this window is evaluated.
                             * @param context  The context in which the window is being evaluated.
                             * @param elements The elements in the window being evaluated.
                             * @param out      A collector for emitting elements.
                             * @throws Exception
                             */
                            @Override
                            public void process(String s, ProcessWindowFunction<Double, String, String, TimeWindow>.Context context, Iterable<Double> elements, Collector<String> out) throws Exception {
                                // 通过窗口对象，获取窗口的范围信息
                                long startTs = context.window().getStart();
                                long endTs = context.window().getEnd();
                                String windowStart = DateFormatUtils.format(startTs, "yyyy-MM-dd HH:mm:ss.SSS");
                                String windowEnd = DateFormatUtils.format(endTs, "yyyy-MM-dd HH:mm:ss.SSS");

                                long count = elements.spliterator().estimateSize();

                                // 当前处理数据
                                long currentProcessingTime = context.currentProcessingTime();
                                String currentProcessingTimeS = DateFormatUtils.format(endTs, "yyyy-MM-dd HH:mm:ss.SSS");

                                // 当前水位线
                                long currentWatermark = context.currentWatermark();

                                out.collect("key=" + s + "，的窗口[" + windowStart + "," + windowEnd + ") 包含" + count + "条数据 ===> " + elements.toString() + " 当前处理时间：" + currentProcessingTimeS);
                            }
                        }
                )
                .print()
        ;

    }
}

6、Flink中的 Window的生命周期

窗口什么时候创建？

        当窗口所属的第一条数据到达时，窗口会被创建

窗口什么时候删除？

        当 水位线 或者 processing time 超过窗口的结束时间戳 + allowedLateness时，窗口会被删除

窗口什么时候被触发计算？

        当定义的触发器触发时， window function 会处理窗口内的数据

        默认触发器：

                当 水位线 或者 processing time 超过窗口的结束时间戳时，窗口会被计算

6.1、触发器 - Triggers

触发器的作用：

        Trigger 决定了一个窗口（由 window assigner 定义）何时可以被 window function 处理

内置 Trigger：

自定义 Triggers：

Trigger 接口：

    // 每个元素被加入窗口时调用
    @Override
    public TriggerResult onElement(Tuple2<String, Long> element, long timestamp, GlobalWindow window, TriggerContext ctx) 

    // 在注册的 event-time timer 触发时调用
    @Override
    public TriggerResult onProcessingTime(long time, GlobalWindow window, TriggerContext ctx)

    // 在注册的 processing-time timer 触发时调用
    @Override
    public TriggerResult onEventTime(long time, GlobalWindow window, TriggerContext ctx) 

    // 对应窗口被移除时所需的逻辑
    @Override
    public void clear(GlobalWindow window, TriggerContext ctx) 

    TriggerResult:
        CONTINUE: 什么也不做
        FIRE: 触发计算
        PURGE: 清空窗口内的元素
        FIRE_AND_PURGE: 触发计算，计算结束后清空窗口内的元素

代码示例：

// TODO 自定义触发器
public class Triggers {
    public static void main(String[] args) throws Exception {
        // 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(3);

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        // TODO Window：KeyedStream → WindowedStream
        // countWindow(env);

        // TODO countWindowAll：DataStream → AllWindowedStream
        timeWindow(env);

        // 3.触发程序执行
        env.execute();
    }

    // TODO 基于 计数窗口 的触发器
    private static void countWindow(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .keyBy(value -> value.f0)
                // TODO 滚动窗口，窗口长度=5个元素
                //.countWindow(5)
                // TODO 滑动窗口，窗口长度=5个元素，滑动步长=2个元素 (每当进入两个数据，就统计下窗口内最五个数据)
                .countWindow(5, 2)
                .trigger(
                        new Trigger<Tuple2<String, Long>, GlobalWindow>() {
                            @Override
                            public TriggerResult onElement(Tuple2<String, Long> element, long timestamp, GlobalWindow window, TriggerContext ctx) throws Exception {
                                System.out.println("调用onElement方法");
                                if (element.f1 == 999) {
                                    return TriggerResult.FIRE;
                                } else {
                                    return TriggerResult.CONTINUE;
                                }
                            }

                            @Override
                            public TriggerResult onProcessingTime(long time, GlobalWindow window, TriggerContext ctx) throws Exception {
                                System.out.println("调用onProcessingTime方法");
                                return null;
                            }

                            @Override
                            public TriggerResult onEventTime(long time, GlobalWindow window, TriggerContext ctx) throws Exception {
                                System.out.println("调用onEventTime方法");
                                return null;
                            }

                            @Override
                            public void clear(GlobalWindow window, TriggerContext ctx) throws Exception {
                                System.out.println("调用clear方法");
                            }
                        }
                )
                .process(
                        new ProcessWindowFunction<Tuple2<String, Long>, String, String, GlobalWindow>() {
                            @Override
                            public void process(String s, ProcessWindowFunction<Tuple2<String, Long>, String, String, GlobalWindow>.Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {
                                // 当前水位线
                                long watermark = context.currentWatermark();
                                // 当前处理时间
                                long processingTime = context.currentProcessingTime();
                                // 窗口开始时间

                                // 窗口结束时间

                                // 计算窗口内数据数量
                                long count = elements.spliterator().estimateSize();

                                String record = "key=" + s
                                        + " 包含" + count + "条数据===>" + elements.toString()
                                        + " 当前Watermark：" + watermark
                                        + " 当前processingTime：" + processingTime;

                                out.collect(record);
                            }
                        }
                )
                .print()
        ;
    }

    // TODO 基于 处理时间窗口 的触发器
    private static void timeWindow(StreamExecutionEnvironment env) {
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .keyBy(value -> value.f0)
                // 滚动窗口，窗口长度5s
                .window(TumblingProcessingTimeWindows.of(Time.seconds(10)))
                .trigger(
                        new Trigger<Tuple2<String, Long>, TimeWindow>() {

                            @Override
                            public TriggerResult onElement(Tuple2<String, Long> element, long timestamp, TimeWindow window, TriggerContext ctx) throws Exception {
                                System.out.println("调用onElement方法");
                                return TriggerResult.CONTINUE;
                            }

                            @Override
                            public TriggerResult onProcessingTime(long time, TimeWindow window, TriggerContext ctx) throws Exception {
                                System.out.println("调用onProcessingTime方法");
                                return TriggerResult.FIRE;
                            }

                            @Override
                            public TriggerResult onEventTime(long time, TimeWindow window, TriggerContext ctx) throws Exception {
                                System.out.println("调用onEventTime方法");
                                return TriggerResult.CONTINUE;
                            }
                            
                            @Override
                            public void clear(TimeWindow window, TriggerContext ctx) throws Exception {
                                System.out.println("调用clear方法");
                            }
                        }
                )
                .process(new ShowProcessWindowFunction())
                .print()
        ;
    }
}

6.2、移除器 - Evictors

移除器的作用：

        Evictor 可以在 trigger 触发后、调用窗口函数之前或之后从窗口中删除元素

内置 Evictors ：

        CountEvictor(元素个数) ：一旦窗口中的元素超过这个数量，多余的元素会从窗口缓存的开头移除

        DeltaEvictor ：接收 DeltaFunction 和 threshold 参数，计算最后一个元素与窗口缓存中所有元素的差值， 并移除差值大于或等于 threshold 的元素

        TimeEvictor ：接收 interval 参数，以毫秒表示。 它会找到窗口中元素的最大 timestamp max_ts 并移除比 max_ts - interval 小的所有元素

代码示例：

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

        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .keyBy(value -> value.f0)
                // TODO 滚动窗口，窗口长度=5个元素
                .countWindow(5)
                .evictor(CountEvictor.of(2L))
                .process(
                        new ProcessWindowFunction<Tuple2<String, Long>, String, String, GlobalWindow>() {
                            @Override
                            public void process(String s, ProcessWindowFunction<Tuple2<String, Long>, String, String, GlobalWindow>.Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {
                                // 当前水位线
                                long watermark = context.currentWatermark();
                                // 当前处理时间
                                long processingTime = context.currentProcessingTime();
                                // 窗口开始时间

                                // 窗口结束时间

                                // 计算窗口内数据数量
                                long count = elements.spliterator().estimateSize();

                                String record = "key=" + s
                                        + " 包含" + count + "条数据===>" + elements.toString()
                                        + " 当前Watermark：" + watermark
                                        + " 当前processingTime：" + processingTime;

                                out.collect(record);
                            }
                        }
                )
                .print()
        ;

        // 3.触发程序执行
        env.execute();
    }
}

7、对迟到数据的处理

        在使用 event-time 窗口时，数据可能会迟到，默认情况下，watermark 一旦越过窗口结束的 timestamp，迟到的数据就会被直接丢弃，Flink中提供多种多处理迟到数据的策略。

7.1、生成水位线时，设置最大乱序时间

        在生成 watermark 时，设置一个可容忍的最大乱序时间，保证窗口计算被延迟执行，保证更多的迟到的数据能够进入窗口

        注意：迟到的数据超过了设置的最大乱序时间，将会被丢弃

WatermarkStrategy
                .<Tuple2<String, Long>>forBoundedOutOfOrderness(Duration.ofSeconds(1)) // 设置最大乱序时间为1s
                .withTimestampAssigner((element,recordTimestamp) -> element.f1);

7.2、设置窗口延迟关闭 - allowedLateness

可以通过 window.allowedLateness 来设置窗口延迟关闭的时间

allowedLateness 默认为0

        表示 当watermark 或 processing time 超过 窗口结束的timestamp时，触发计算 并销毁窗口

allowedLateness 大于0时

        表示  当watermark 或 processing time 超过 窗口结束的timestamp时，会触发计算 但是并不会销毁窗口
        而是当 窗口结束的timestamp + allowedLateness 的数据到来后，才会销毁窗口
        并且 每次接收到迟到的数据后 都会触发窗口计算

代码示例：

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

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple2<String, Long>>forMonotonousTimestamps()
                                .withTimestampAssigner((element, recordTimestamp) -> element.f1)
                )
                .keyBy(value -> value.f0)
                // 滚动窗口，窗口长度5s
                .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                // 窗口延迟10s关闭
                .allowedLateness(Time.seconds(10))
                .process(new ShowProcessWindowFunction())
                .print()
        ;

        // 3.触发程序执行
        env.execute();
    }
}

运行结果：

7.3、使用侧输出流获取迟到的数据 - sideOutputLateData

在 Flink中可以使用 侧输出流-OutputTag 来获取窗口中迟到的数据

代码示例：

// TODO 使用侧流接收迟到的数据
public class UseSideOutputReceiveLatedata {
    public static void main(String[] args) throws Exception {
        // 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 声明 OutputTag 对象,用来接收迟到的数据
        OutputTag<Tuple2<String, Long>> outputTag = new OutputTag<Tuple2<String, Long>>("side-output"){};

        // 2.将socket作为数据源（开启socket端口: nc -lk 9999）
        SingleOutputStreamOperator<String> processDataStream = env
                .socketTextStream("localhost", 9999)
                .map(new MapFunction<String, Tuple2<String, Long>>() {
                         @Override
                         public Tuple2 map(String value) throws Exception {
                             return new Tuple2(value.split(",")[0], Long.parseLong(value.split(",")[1]));
                         }
                     }
                )
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple2<String, Long>>forMonotonousTimestamps()
                                .withTimestampAssigner((element, recordTimestamp) -> element.f1)
                )
                .keyBy(value -> value.f0)
                // 滚动窗口，窗口长度5s
                .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                .sideOutputLateData(outputTag)
                .process(new ShowProcessWindowFunction());

        // 输出主流
        processDataStream.print("主流输出");

        // 从主流获取侧输出流，打印迟到的数据
        processDataStream.getSideOutput(outputTag).printToErr("关窗后的迟到数据");

        // 3.触发程序执行
        env.execute();
    }
}

运行结果：

 

广阔天地大有可为
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flink之窗口聚合算子
AnameJL的博客
10-12 1170
Flink窗口聚合算子
Flink动态开窗——根据缓存的规则信息动态设置窗口size
二两窝子面的博客
11-21 346
Flink数据关联缓存的外部规则信息动态设置窗口size做动态开窗计算
37、Flink 的窗口函数（Window Functions）详解
最新发布
猫猫爱吃小鱼粮
05-21 815
Flink 的窗口函数（Window Functions）详解
【API篇】八、Flink窗口函数
llg___的博客
10-24 496
上一节的窗口分配器，指明了窗口类型，知道了数据属于哪个窗口并收集。而窗口函数，则是定义如何对这些数据做计算操作。 运行，输入数据，查看控制台：上面使用ReduceFunction的限制是，输入数据的类型、聚合中间状态的类型、输出结果的类型必须一致，AggregateFunction则没有这个限制。AggregateFunction接口有四个方法： 运行，输入数据，查看控制台：全窗口函数，即数据来了不计算，存起来，窗口触发的时候，计算并输出计算结果Flink全窗口函数有两种，第一种为apply方法下的： 传入
Flink 中的窗口
m0_63475429的博客
10-15 1918
更加高效的做法是，把无界流进行切分，每一段数据分别进行聚合，结果只输出一次。这 就相当于将无界流的聚合转化为了有界数据集的聚合，这就是所谓的“窗口”（Window）聚合 操作。在实际应用中，我们往往更关心一段 时间内数据的统计结果，比如在过去的 1 分钟内有多少用户点击了网页。在这种情况下，我们 就可以定义一个窗口，收集最近一分钟内的所有用户点击数据，然后进行聚合统计，最终输出 一个结果就可以了。在流处理中，我们往往需要面对的是连续 不断、无休无止的无界流，不可能等到所有所有数据都到齐了才开始处理。
Flink窗口全解析：三种时间窗口、窗口处理函数使用及案例
czl689的专栏
03-14 3090
我们经常需要在一个时间窗口维度上对数据进行聚合，窗口是流处理应用中经常需要解决的问题。Flink的窗口算子为我们提供了方便易用的API，我们可以将数据流切分成一个个窗口，对窗口内的数据进行处理。本文将介绍如何在Flink上进行窗口的计算。 一个Flink窗口应用的大致骨架结构如下所示： // Keyed Window stream .keyBy(...) <- 按照一个Key进行分组 .window(...) &
Flink 窗口函数（Window Functions）全窗口函数
weixin_45417821的博客
04-17 2826
文章目录1）窗口函数（WindowFunction）2）处理窗口函数（ProcessWindowFunction） 窗口操作中的另一大类就是全窗口函数。与增量聚合函数不同，全窗口函数需要先收集窗口中的数据，并在内部缓存起来，等到窗口要输出结果的时候再取出数据进行计算。 很明显，这就是典型的批处理思路了— —先攒数据，等一批都到齐了再正式启动处理流程。这样做毫无疑问是低效的：因为窗口全部的计算任务都积压在了要输出结果的那一瞬间，而在之前收集数据的漫长过程中却无所事事。这就好比平时不用功，到考试之前通宵抱佛脚，
Flink中Global Windows 全局窗口
TB_CYX的博客
02-06 291
全局窗口介绍
Flink之滑动窗口（SlidingEventTimeWindows）
01-07
def main(args: Array[String]): Unit = { // 环境 val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime...
Flink 中文文档资料.zip
01-17
flink Flink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料...
flink中文教程.zip
03-02
flink中文教程： 目录： 概念 教程 例子 应用开发 部署与运营 调试和监控 IDE开发 内幕
Flink window API.pptx
02-03
Flink的窗口API是处理无界数据流的关键工具，它允许开发者将无限的数据流分割成有限的数据集，以便进行有效的分析和处理。在大数据和实时分析的场景中，如电商用户行为分析、实时热门商品统计、实时流量统计、市场...
大数据开发｜Flink中的窗口分类和生命周期
11-06
在我们日常使用flink这个框架的过程中，我们会经常使用到窗口，让我们通过下面这篇文章，快速回顾总结一下吧。 Flink 是一种流式计算引擎，主要是来处理无界数据流的，数据源源不断、无穷无尽。想要更加方便高效地...
Flink学习（3）——Window（窗口机制）API
江左煤郎的博客
06-10 853
1.Window的概念 2.Window的类型 3.
实时Flink大数据分析平台的数据流时间窗口操作
禅与计算机程序设计艺术
01-21 888
1.背景介绍 在大数据时代，实时分析和处理数据变得越来越重要。Apache Flink是一个流处理框架，它可以处理大规模的实时数据流，并提供高性能和低延迟的数据处理能力。在Flink中，时间窗口是一种有用的数据处理方法，可以帮助我们对数据流进行聚合和分析。本文将深入探讨Flink大数据分析平台的数据流时间窗口操作，包括背景介绍、核心概念、算法原理、最佳实践、应用场景、工具推荐等。 1. 背景介...
Flink窗口API、窗口分配器和窗口函数
roi666的博客
01-19 1476
需要先对DataStream调用.keyBy()进行按键分区，然后再调用.window()定义窗口。
Flink 窗口 Window 介绍
SmartSi
08-27 158
对于刚刚接触流处理的人来说，这种思维方式的转变以及新的专业术语可能会让他们感到非常困惑。但是，Apache Flink 作为一个为生产环境而生的流处理器，具有易于使用并且表达能力很强的 API 来定义高级流分析程序。Flink 的 API 在数据流上有非常灵活的窗口定义，使其能在其他开源流处理器中脱颖而出。 在这篇文章中，我们主要讨论用于流处理的窗口的概念，介绍 Flink 的内置窗口，并说明其对自定义窗口语义的支持。......
5、Flink中的Window
yunweijie_cn的博客
03-10 3111
Flink中的Window一、Window1.Window概述2.Window类型2.1滚动窗口（Tumbling Windows）2.2滑动窗口（Sliding Windows）2.3会话窗口（Session Windows）二、Window API1.TimeWindow2.CountWindow3.Window Fcuntion3.1 增量聚合函数3.2全窗口聚合函数3.3 计数窗口实例4.其他可选API 一、Window 1.Window概述     &nbs
Flink 窗口算子知识点扫盲
胖虎儿的博客
05-19 6731
什么是窗口？为什么需要窗口？有哪些窗口?如何使用窗口？
flink中所有算子的详细解释
04-06
Apache Flink是一个流处理引擎，提供了多个算子用于流式数据处理。以下是Flink中常用算子的详细解释： 1. Map算子：将输入流中的每个元素映射为一个新元素。 2. Filter算子：根据指定条件过滤输入流中的元素，只输出满足条件的元素。 3. FlatMap算子：将输入流中的每个元素映射为多个新元素。 4. KeyBy算子：将输入流中的元素按照指定的key进行分组，输出分组后的流。 5. Reduce算子：对输入流中的元素进行累加操作，输出累加后的结果。 6. Aggregations算子：对输入流中的元素进行聚合操作，输出聚合后的结果。 7. Window算子：将输入流中的元素按照时间窗口或者计数窗口进行分组，输出分组后的流。 8. Join算子：将两个输入流中的元素进行关联操作，输出关联后的结果。 9. Union算子：将多个输入流进行合并操作，输出合并后的结果。 10. CoMap算子：将两个输入流中的元素进行关联操作，并将结果映射为新的元素输出。 11. CoFlatMap算子：将两个输入流中的元素进行关联操作，并将结果映射为多个新元素输出。 12. Iterate算子：对输入流中的元素进行迭代操作，直到满足指定条件后输出结果。 13. Split算子：将输入流中的元素按照指定条件进行拆分操作，输出拆分后的结果。 14. Select算子：从拆分后的结果中选择指定的流输出。 以上是Flink中常用的算子，可以根据具体需求选择适合的算子进行数据处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值