flink重温笔记(九):Flink 高级 API 开发——flink 四大基石之WaterMark(Time为核心)

Flink学习笔记

前言:今天是学习 flink 的第 9 天啦!学习了 flink 四大基石之 Time的应用---> Watermark(水印,也称水位线),主要是解决数据由于网络延迟问题,出现数据乱序或者迟到数据现象,重点学习了水位线策略机制原理和应用,以及企业级的应用场景,结合自己实验猜想和代码实践,总结了很多自己的理解和想法,希望和大家多多交流!
Tips:转码之路,溯洄从之,道阻且长!希望自己继续努力,学有所成,让华丽的分割线,成为闪耀明天的起跑线!


文章目录

  • Flink学习笔记
    • [三、Flink 高级 API 开发](#三、Flink 高级 API 开发)
      • [2. WaterMark](#2. WaterMark)
        • [2.1 为什么需要 WaterMark](#2.1 为什么需要 WaterMark)
        • [2.2 多并行度与 WaterMark](#2.2 多并行度与 WaterMark)
        • [2.3 KeyBy 分流与 WaterMark](#2.3 KeyBy 分流与 WaterMark)
        • [2.4 水印的生成策略](#2.4 水印的生成策略)
          • [2.4.1 内置水印生成策略](#2.4.1 内置水印生成策略)
            • [(1) 固定延迟生成水印](#(1) 固定延迟生成水印)
            • [(2) 单调递增生成水印](#(2) 单调递增生成水印)
          • [2.4.2 自定义水印生成策略](#2.4.2 自定义水印生成策略)
            • [(1) ==周期性 watermark 策略==](#(1) ==周期性 watermark 策略==)
            • [(2) ==间歇性 watermark 策略==](#(2) ==间歇性 watermark 策略==)
        • [2.5 在非数据源之后使用水印 [重点]](#2.5 在非数据源之后使用水印 [重点])
          • [2.5.1 WaterMark 的四种使用情况](#2.5.1 WaterMark 的四种使用情况)
            • [(1) 本来有序的 Stream中的 Watermark](#(1) 本来有序的 Stream中的 Watermark)
            • [(2) 乱序事件中的Watermark](#(2) 乱序事件中的Watermark)
            • [(3) 并行数据流中的Watermark](#(3) 并行数据流中的Watermark)
            • [(4) 自定义 Watermark](#(4) 自定义 Watermark)
        • [2.6 在数据源之后使用水印 (Kafka) [重点]](#2.6 在数据源之后使用水印 (Kafka) [重点])
          • [2.6.1 kafka 向指定分区写入数据](#2.6.1 kafka 向指定分区写入数据)
          • [2.6.2 水印机制消费 kafak 数据](#2.6.2 水印机制消费 kafak 数据)
        • [2.7 Flink 对严重迟到数据的处理](#2.7 Flink 对严重迟到数据的处理)

2. WaterMark

2.1 为什么需要 WaterMark

当 flink 以 EventTime 模式处理流数据时,它会根据数据里的时间戳来处理基于时间的算子。但是由于网络、分布式等原因,会导致数据乱序的情况。

结论:

  • 只要使用 event time,就必须使用 watermark,在上游指定,比如:source、map算子后。

  • Watermark 的核心本质可以理解成一个延迟触发机制。

  • 因为前面提到,数据时间 >= 窗口结束时间,触发计算,这里想要延迟触发计算,所以水印时间一般比数据事件时间少几秒

  • 水印时间 = 事件时间 - 设置的水印长度

  • 水印的功能:在不影响按照事件时间判断数据属于哪个窗口的前提下,延迟某个窗口的关闭时间,让其等待一会儿延迟数据

举例:

窗口5秒,延迟(水印)3秒,按照事件时间计算

来一条数据事件时间3, 落入窗口0-5.水印时间0
来一条数据事件时间7, 落入窗口5-10,水印时间4
来一条数据事件时间4,落入窗口0-5,水印时间1
来一条数据事件时间8,落入窗口5-10,水印时间5

2.2 多并行度与 WaterMark
  • 如果并行度是 n,那么watermark 就有 n 个
  • 触发条件以线程中最小的 watermark 为准

2.3 KeyBy 分流与 WaterMark
  • 一个程序中有多少个水印和并行度有关,和 keyby 无关

举例:

shell 复制代码
比如有单词hadoop spark
按照keyby,会分成hadoop组 和spark组
但是这两个组是共用1个水印的
hadoop来的数据满足了触发条件,会将spark组的数据也触发

2.4 水印的生成策略
2.4.1 内置水印生成策略
(1) 固定延迟生成水印

简介:设置最大延迟时间

例子:

java 复制代码
DataStream dataStream = ...... ;
dataStream.assignTimestampsAndWatermarks(WatermarkStrategy.forBoundedOutOfOrderness(Duration.ofSeconds(3)));
(2) 单调递增生成水印

简介:当前时间戳就可以充当 watermark,因为后续到达数据的时间戳不会比当前的小(网络延迟)。

例子:

java 复制代码
DataStream dataStream = ...... ;
dataStream.assignTimestampsAndWatermarks(WatermarkStrategy.forMonotonousTimestamps());
2.4.2 自定义水印生成策略
(1) 周期性 watermark 策略
  • 升序watermark:单调递增生成水印
  • 乱序watermark:固定延迟生成水印

都是基于周期性生成,默认的周期是 200ms ,一般不去改,保持在 ms 级别 onPeriodicEmit()

(2) 间歇性 watermark 策略
  • 每一个事件时间都会产生一个watermark

2.5 在非数据源之后使用水印 [重点]
2.5.1 WaterMark 的四种使用情况
(1) 本来有序的 Stream中的 Watermark

例子:以 java bean 的数据输入作为有序事件时间

java 复制代码
package cn.itcast.day09.WaterMark;

/**
 * @author lql
 * @time 2024-03-01 21:11:00
 * @description TODO
 */

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.datastream.WindowedStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.AscendingTimestampExtractor;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;

/**
 * 使用单调递增水印,解决数据有序的场景(大多数情况都是乱序的数据,因此该场景比较少见)
 * 需求:从socket接受数据,进行转换操作,然后应用窗口每隔5秒生成一个窗口,使用水印时间触发窗口计算
 *
 * 使用水印的前提:
 * 1:数据必须要携带事件时间
 * 2:指定事件时间作为数据处理的时间
 * 3:指定并行度为1
 * 4:使用之前版本的api的时候,需要增加时间类型的代码
 *
 * 测试数据:
 * sensor_1,1547718199,35       -》2019-01-17 17:43:19
 * sensor_6,1547718201,15       -》2019-01-17 17:43:21
 * sensor_6,1547718205,15       -》2019-01-17 17:43:25
 * sensor_6,1547718210,15       -》2019-01-17 17:43:30
 *
 * todo 如果窗口销毁以后,有延迟数据的到达会被丢弃,无法再次触发窗口的计算了
 */
public class MonotonousWaterMark {
    public static void main(String[] args) throws Exception {
        //todo 1)创建flink流处理的运行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        //设置 Flink 程序中流数据时间语义为 EventTime。
        // 在处理数据时 Flink 程序会按照数据事件发生的时间进行处理,而不是按照数据到达 Flink 程序的时间进行处理。
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

        //todo 2) 接入数据源
        SingleOutputStreamOperator<WaterSensor> lines = env.socketTextStream("node1", 9999)
                .map(new MapFunction<String, WaterSensor>() {
                    @Override
                    public WaterSensor map(String value) throws Exception {
                        String[] data = value.split(",");
                        return new WaterSensor(data[0], Long.valueOf(data[1]), Integer.parseInt(data[2]));
                    }
                });

        //todo 3)添加水印处理
        //flink1.12之前版本的api编写(单调递增水印本质上还是周期性水印)
        SingleOutputStreamOperator<WaterSensor> waterMarkStream = lines.assignTimestampsAndWatermarks(new AscendingTimestampExtractor<WaterSensor>() {
            @Override
            public long extractAscendingTimestamp(WaterSensor element) {
                // 因为我们在转换时间戳,需要毫秒级别!
                return element.getTs()*1000L;
            }
        });

        waterMarkStream.print("数据>>>");

        //todo 4)应用窗口操作,设置窗口长度为5秒
        WindowedStream<WaterSensor, String, TimeWindow> sensorWS = waterMarkStream.keyBy(sensor -> sensor.getId()).window(TumblingEventTimeWindows.of(Time.seconds(5)));

        //todo 5)定义窗口函数
        SingleOutputStreamOperator<String> result = sensorWS.process(new ProcessWindowFunction<WaterSensor, String, String, TimeWindow>() {
            @Override
            public void process(String s, Context context, Iterable<WaterSensor> elements, Collector<String> out) throws Exception {
                out.collect("key" + s + "\n" +
                        "数据为" + elements + "\n" +
                        "数据条数为" + elements.spliterator().estimateSize() + "\n" +
                        "窗口时间为" + context.window().getStart() + "->" + context.window().getEnd());
            }
        });

        //todo 6)输出测试
        result.print();

        //todo 启动运行
        env.execute();
    }

    /**
     * 水位传感器,用来接受水位数据
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    private static class WaterSensor {
        private String id;  //传感器id
        private long ts;    //时间
        private Integer vc; //水位
    }
}

注意:flink 1.12 版本之后的有序流添加周期水印

java 复制代码
//注意:下面的代码使用的是Flink1.12中新的API
SingleOutputStreamOperator<WaterSensor> sensorDS = lines
	//TODO 有序流中的watermark
	.assignTimestampsAndWatermarks(
    //指定watermark生成(单调递增)
	WatermarkStrategy.<WaterSensor>forMonotonousTimestamps()
    .withTimestampAssigner(new SerializableTimestampAssigner<WaterSensor>() {
        @Override
        public long extractTimestamp(WaterSensor element, long recordTimestamp) {
            //指定如何从数据提取时间戳
            return element.getTs() * 1000L;
}));

结果:

java 复制代码
情况一:一种类别输入
sensor_6,1547718201,15       -》2019-01-17 17:43:21
sensor_6,1547718205,15       -》2019-01-17 17:43:25
sensor_6,1547718210,15       -》2019-01-17 17:43:30

输出:
数据>>>> MonotonousWaterMark.WaterSensor(id=sensor_6, ts=1547718201, vc=15)
数据>>>> MonotonousWaterMark.WaterSensor(id=sensor_6, ts=1547718205, vc=15)
keysensor_6
数据为[MonotonousWaterMark.WaterSensor(id=sensor_6, ts=1547718201, vc=15)]
数据条数为1
(2019-01-17 17:43:20 - > 2019-01-17 17:43:25)

数据>>>> MonotonousWaterMark.WaterSensor(id=sensor_6, ts=1547718210, vc=15)
keysensor_6
数据为[MonotonousWaterMark.WaterSensor(id=sensor_6, ts=1547718205, vc=15)]
数据条数为1
窗口时间为1547718205000->1547718210000
(2019-01-17 17:43:25 - > 2019-01-17 17:43:30)
java 复制代码
情况二:两种类别输入
sensor_1,1547718199,35       -》2019-01-17 17:43:19
sensor_6,1547718201,15       -》2019-01-17 17:43:21
sensor_6,1547718205,15       -》2019-01-17 17:43:25
sensor_6,1547718210,15       -》2019-01-17 17:43:30

输出:
数据>>>> MonotonousWaterMark.WaterSensor(id=sensor_1, ts=1547718199, vc=35)
数据>>>> MonotonousWaterMark.WaterSensor(id=sensor_6, ts=1547718201, vc=15)
数据>>>> MonotonousWaterMark.WaterSensor(id=sensor_6, ts=1547718205, vc=15)
keysensor_1
数据为[MonotonousWaterMark.WaterSensor(id=sensor_1, ts=1547718199, vc=35)]
数据条数为1
窗口时间为1547718195000->1547718200000
(2019-01-17 17:43:15 - > 2019-01-17 17:43:20)
    
keysensor_6
数据为[MonotonousWaterMark.WaterSensor(id=sensor_6, ts=1547718201, vc=15)]
数据条数为1
窗口时间为1547718200000->1547718205000
(2019-01-17 17:43:20 - > 2019-01-17 17:43:25)

数据>>>> MonotonousWaterMark.WaterSensor(id=sensor_6, ts=1547718210, vc=15)
keysensor_6
数据为[MonotonousWaterMark.WaterSensor(id=sensor_6, ts=1547718205, vc=15)]
数据条数为1
窗口时间为1547718205000->1547718210000
(2019-01-17 17:43:25 - > 2019-01-17 17:43:30)

总结:

  • 1- 体现窗口左闭右开思想(即右端时间重合的数据不参与计算)
  • 2- 有序数据的水印窗口标准开始时间 :时间戳(秒级)// 窗口长度 * 窗口长度 * 1000 (这里的整除可以去掉余数)
java 复制代码
// 如果是秒级,而不是时间戳:
1)start = timestamp - (timestamp - offset + windowSize) % windowSize; ​

事件时间 - (事件时间 - 0 + 窗口大小)%窗口大小 ​​​​​​​​​

时间戳按照窗口长度 取整数倍(以1970年1月1日0点为起点 => 伦敦时间) ​

2)end = start + size ​​​​​​​​ 开始时间 + 窗口长度

3)左闭右开: 属于本窗口的最大时间戳 = end -1ms , 所以时间为 end这条数据,不属于本窗口,所以是开区间
  • 3- 有序数据的水印窗口标准结束时间 :标准开始时间 + 窗口长度

  • 4- 此时水位线的变化和事件时间保持一致(因为是有序时间,就不需设置延迟,那么 t 就是 0。

    ​ watermark = maxtime - 0 = maxtime)

  • 5- 环境并行度设置为 1,方便观察现象

  • 6- flink 1.12 之前版本,需要指定事件时间,env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

  • 7- 转换时间戳时需要毫秒级别

  • 8- window().getStart() 获取窗口标准开始时间,window().getEnd()获取窗口标准结束时间

  • 9- spliterator().estimateSize() 获取窗口内数据条数

  • 10- api版本区别:

    • flink1.12之前:调用 assignTimestampAndwatermarks,new 一个 AscendingTimestampExtractor,重写方法获取时间戳
    • flink1.12之后:调用 assignTimestampAndWatermarks,有序流回调本质周期水印策略
      • WatermarkStrategy.forMonotonousTimestamps.withTimestampAssigner
      • new 一个序列化 SerializableTimestampAssigner,重写方法获取时间戳
  • 11- 应用场景:周期水印解决数据有序场景


(2) 乱序事件中的Watermark

例子:以 java bean 的数据输入作为乱序事件时间

java 复制代码
package cn.itcast.day09.WaterMark;

/**
 * @author lql
 * @time 2024-03-02 15:20:38
 * @description TODO:
 */

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.datastream.WindowedStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;

/**
 * 使用固定延迟水印,解决数据乱序的场景(大多数情况都是乱序的数据,使用比较多)
 * 需求:从socket接受数据,进行转换操作,然后应用窗口每隔5秒生成一个窗口,使用水印时间触发窗口计算
 *
 * 使用水印的前提:
 * 1:数据必须要携带事件时间
 * 2:指定事件时间作为数据处理的时间
 * 3:指定并行度为1
 * 4:使用之前版本的api的时候,需要增加时间类型的代码
 *
 * 测试数据:
 * sensor_1,1547718199,35       -》2019-01-17 17:43:19
 * sensor_6,1547718201,15       -》2019-01-17 17:43:21
 * sensor_6,1547718205,15       -》2019-01-17 17:43:25
 * sensor_6,1547718210,15       -》2019-01-17 17:43:30
 *
 * todo 固定延迟触发,根据事件时间-最大乱序时间-1得到水印,根据水印时间作为触发窗口的条件
 * 触发窗口计算的两个条件:
 * 1:时间达到窗口的endtime
 * 2:窗口中存在数据
 */
public class OutOfOrdernessWaterMark {
    public static void main(String[] args) throws Exception {
        // todo 1) 设置流处理环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

        // todo 2) 数据源
        SingleOutputStreamOperator<WaterSensor> lines = env.socketTextStream("node1", 9999).map(new MapFunction<String, WaterSensor>() {
            @Override
            public WaterSensor map(String value) throws Exception {
                String[] data = value.split(",");
                return new WaterSensor(data[0], Long.valueOf(data[1]), Integer.parseInt(data[2]));
            }
        });

        // todo 3) 设置水印
        //flink1.12之前版本的api编写
        SingleOutputStreamOperator<WaterSensor> waterMarkStream = lines.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<WaterSensor>(Time.seconds(3)) {
            @Override
            public long extractTimestamp(WaterSensor element) {
                return element.getTs() * 1000L;
            }
        });

        waterMarkStream.print("数据>>>");
        //todo 4)应用窗口操作
        WindowedStream<WaterSensor, String, TimeWindow> sensorWS = waterMarkStream.keyBy(t -> t.getId()).window(TumblingEventTimeWindows.of(Time.seconds(5)));

        //todo 5) 自定义窗口
        SingleOutputStreamOperator<String> result = sensorWS.process(new ProcessWindowFunction<WaterSensor, String, String, TimeWindow>() {
            @Override
            public void process(String s, Context context, Iterable<WaterSensor> elements, Collector<String> collector) throws Exception {
                collector.collect("key: " + s + "\n" +
                 "数据为: " + elements + "\n" +
                 "条数为:" + elements.spliterator().estimateSize() + "\n" +
                 "时间窗口为:" + context.window().getStart() + "->" + context.window().getEnd() + "\n");
            }
        });

        //todo 6) 打印操作
        result.print();

        //todo 7) 启动程序
        env.execute();
    }

    /**
     * 水位传感器,用来接受水位数据
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    private static class WaterSensor {
        private String id;  //传感器id
        private long ts;    //时间
        private Integer vc; //水位
    }
}

注意:flink 1.12 版本之后的无序流添加固定延迟水印

java 复制代码
SingleOutputStreamOperator<WaterSensor> waterMarkStream = lines
	.assignTimestampsAndWatermarks(
    // 固定延迟水印,是 Duration 类型
		WatermarkStrategy<WaterSensor>forBoundedOutOfOrderness(Duration.ofSeconds(3))
			.withTimestampAssigner(
				new SerializableTimestampAssigner<WaterSensor>() {
					@Override
						public long extractTimestamp(WaterSensor waterSensor, long l) {
							return waterSensor.getTs() * 1000L;
            				}}));

结果:

java 复制代码
情况一:一种类别输入
sensor_6,1547718201,15       -》2019-01-17 17:43:21
sensor_6,1547718205,15       -》2019-01-17 17:43:25
sensor_6,1547718210,15       -》2019-01-17 17:43:30

输出:
数据>>>> OutOfOrdernessWaterMark.WaterSensor(id=sensor_6, ts=1547718201, vc=15)
数据>>>> OutOfOrdernessWaterMark.WaterSensor(id=sensor_6, ts=1547718205, vc=15)
数据>>>> OutOfOrdernessWaterMark.WaterSensor(id=sensor_6, ts=1547718210, vc=15)
key: sensor_6
数据为: [OutOfOrdernessWaterMark.WaterSensor(id=sensor_6, ts=1547718201, vc=15)]
条数为:1
时间窗口为:1547718200000->1547718205000
(2019-01-17 17:43:20 -> 2019-01-17 17:43:25)

总结:

  • 1- 如果是有 key 类别的差异,触发窗口计算往往在 key 变化时,而不需要两个一样的 key 作为对照

  • 2- 因为设置了延迟,在触发窗口范围的时候,事件时间 - 延迟时间 = 水印时间

    • (例子中打印了 3 条数据,即第 3 条数据触发计算,第3条数据的水印时间的秒级:30 - 3 = 27 >= 窗口的 endTime)
    • 窗口触发两个条件,一是水印时间达到窗口 endTime,二是窗口内有数据
  • 3- api版本区别:

    • flink1.12之前:调用 assignTimestampAndWatermarks,new 一个 BoundedOutofOrdernessTimestampExtractor

      注意设置 延迟时间,重写方法获取事件时间

    • flink1.12之后:调用 assignTimestampAndWatermarks,有序流回调固定延迟水印策略

      • WatermarkStrategy.forBoundedOutOfOrderness(Duration 类型延迟时间).withTimestampAssigner
      • new 一个序列化 SerializableTimestampAssigner,重写方法获取时间戳
  • 4- 应用场景:固定延迟水印解决数据乱序场景


(3) 并行数据流中的Watermark

对齐机制会取所有 Channel 中最小的 Watermark,即:

每个并行度中必须都有数据,且都满足触发窗口条件,才会有对齐机制

例子:将并行度设置为2,带有线程号

java 复制代码
package cn.itcast.day09.WaterMark;

/**
 * @author lql
 * @time 2024-03-02 19:27:53
 * @description TODO:多并行度下的水印操作演示
 */

import org.apache.flink.api.common.eventtime.*;
import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.windowing.WindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;
import org.stringtemplate.v4.ST;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Iterator;

/**
 * 测试数据:
 * 并行度设置为2测试:
 * hadoop,1626934802000 ->2021-07-22 14:20:02
 * hadoop,1626934805000 ->2021-07-22 14:20:05
 * hadoop,1626934806000 ->2021-07-22 14:20:06
 */
public class Watermark_Parallelism {
    //定义打印数据的日期格式
    final private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    public static void main(String[] args) throws Exception {
        // todo 1) 流式环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(2);

        // todo 2) 数据源
        SingleOutputStreamOperator<Tuple2<String, Long>> tupleDataStream = env.socketTextStream("node1", 9999).map(new MapFunction<String, Tuple2<String, Long>>() {
            @Override
            public Tuple2<String, Long> map(String line) throws Exception {
                try {
                    String[] array = line.split(",");
                    return Tuple2.of(array[0], Long.parseLong(array[1]));
                } catch (NumberFormatException e) {
                    System.out.println("输入的数据格式不正确:" + line);
                    return Tuple2.of("null", 0L);
                }
            }
        }).filter(new FilterFunction<Tuple2<String, Long>>() {
            @Override
            public boolean filter(Tuple2<String, Long> tuple) throws Exception {
                if (!tuple.f0.equals("null") && tuple.f1 != 0L) {
                    return true;
                }
                return false;
            }
        });

        // todo 3) 水印操作
        SingleOutputStreamOperator<Tuple2<String, Long>> waterMarkDataStream = tupleDataStream.assignTimestampsAndWatermarks(
                //TODO 自定义watermark生成器
                WatermarkStrategy.forGenerator(new WatermarkGeneratorSupplier<Tuple2<String, Long>>() {
                    @Override
                    public WatermarkGenerator<Tuple2<String, Long>> createWatermarkGenerator(Context context) {
                        return new MyWatermarkGenerator<>();
                    }
                }).withTimestampAssigner(new SerializableTimestampAssigner<Tuple2<String, Long>>() {
                    @Override
                    public long extractTimestamp(Tuple2<String, Long> element, long recordTimestamp) {
                        // 获取数据中的 eventTime
                        Long timestamp = element.f1;

                        // 定义字符串并打印
                        System.out.println("键值:" + element.f0 + ",线程号:" + Thread.currentThread().getId() + "," +
                                "事件时间:【" + sdf.format(timestamp) + "】");
                        return timestamp;
                    }
                })
        );

        // todo 4) 分流和窗口
        SingleOutputStreamOperator<String> result = waterMarkDataStream
                .keyBy(0)
                .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                .apply(new WindowFunction<Tuple2<String, Long>, String, Tuple, TimeWindow>() {
                    @Override
                    public void apply(Tuple tuple, TimeWindow window, Iterable<Tuple2<String, Long>> input, Collector<String> out) throws Exception {
                        //定义该窗口所有时间字段的集合对象
                        ArrayList<Long> timeArr = new ArrayList<>();
                        // 首先获取了输入数据流(input)的迭代器
                        Iterator<Tuple2<String, Long>> iterator = input.iterator();
                        while (iterator.hasNext()) {
                            Tuple2<String, Long> tuple2 = iterator.next();
                            timeArr.add(tuple2.f1);
                        }
                        //对保存到集合列表的时间进行排序
                        Collections.sort(timeArr);
                        //打印输出该窗口触发的所有数据
                        String outputData = "" +
                                "\n 键值:【" + tuple + "】" +
                                "\n     触发窗口数据的个数:【" + timeArr.size() + "】" +
                                "\n     触发窗口的数据:" + sdf.format(new Date(timeArr.get(timeArr.size() - 1))) +
                                "\n     窗口计算的开始时间和结束时间:" + sdf.format(new Date(window.getStart())) + "----->" +
                                sdf.format(new Date(window.getEnd()));
                        out.collect(outputData);
                    }
                });

        //TODO 6)打印测试
        result.printToErr("触发窗口计算结果>>>");

        //TODO 7)启动作业
        env.execute();
    }

    public static class MyWatermarkGenerator<T> implements WatermarkGenerator<T>{
        //定义变量,存储当前窗口中最大的时间戳
        private long maxTimestamp = -1L;
        /**
         * 每条数据都会调用该方法
         * @param event
         * @param eventTimestamp
         * @param output
         */
        @Override
        public void onEvent(T event, long eventTimestamp, WatermarkOutput output) {
            //System.out.println("on Event...");
            maxTimestamp = Math.max(maxTimestamp, eventTimestamp);
        }

        /***
         * 周期性的执行,默认是200ms调用一次
         * @param output
         */
        @Override
        public void onPeriodicEmit(WatermarkOutput output) {
            //System.out.println("on Periodic..."+System.currentTimeMillis());
            //发射watermark
            output.emitWatermark(new Watermark(maxTimestamp -1L));
        }
    }
}

结果:

java 复制代码
输入:
 * hadoop,1626934802000 ->2021-07-22 14:20:02
 * hadoop,1626934805000 ->2021-07-22 14:20:05
 * hadoop,1626934806000 ->2021-07-22 14:20:06
 
输出:
键值:hadoop,线程号:68,事件时间:【2021-07-22 14:20:02.000】
键值:hadoop,线程号:69,事件时间:【2021-07-22 14:20:05.000】
键值:hadoop,线程号:68,事件时间:【2021-07-22 14:20:06.000】
触发窗口计算结果>>>:2> 
键值:【(hadoop)】
     触发窗口数据的个数:【1】
     触发窗口的数据:2021-07-22 14:20:02.000
     窗口计算的开始时间和结束时间:2021-07-22 14:20:00.000----->2021-07-22 14:20:05.000

总结:

  • 1- 获取线程号:Thread.currentThread().getId()
  • 2- 自定义日期格式:new SimpleDateFormat()
  • 3- 看到 input 是 Iterate 类型,需要调用 iterator()方法转化为迭代对象,运用 while 循环结合 hashNext()边迭代边加入列表
  • 4- Collections.sort(列表),可以对列表进行排序

(4) 自定义 Watermark

A. 周期性水印

java 复制代码
package cn.itcast.day09.WaterMark;

/**
 * @author lql
 * @time 2024-03-02 17:07:17
 * @description TODO
 */

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.flink.api.common.eventtime.*;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.datastream.WindowedStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;

/**
 * 自定义周期性水印,内置水印:固定延迟水印和单调递增水印都是基于周期性水印开发的,默认是200ms生成一次watermark
 */
public class WaterMark_Periodic {
    public static void main(String[] args) throws Exception {
        // todo 1) 设置流处理环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        // todo 2) 数据源
        SingleOutputStreamOperator<WaterSensor> lines = env.socketTextStream("node1", 9999).map(new MapFunction<String, WaterSensor>() {
            @Override
            public WaterSensor map(String value) throws Exception {
                String[] data = value.split(",");
                return new WaterSensor(data[0], Long.valueOf(data[1]), Integer.parseInt(data[2]));
            }
        });

        // todo 3) 设置水印操作
        SingleOutputStreamOperator<WaterSensor> sensorDS  = lines.assignTimestampsAndWatermarks(WatermarkStrategy.forGenerator(
                new WatermarkGeneratorSupplier<WaterSensor>() {
                    @Override
                    public WatermarkGenerator<WaterSensor> createWatermarkGenerator(Context context) {
                        return new MyWatermarkGenerator<>();
                    }
                }).withTimestampAssigner(new SerializableTimestampAssigner<WaterSensor>() {
            @Override
            public long extractTimestamp(WaterSensor waterSensor, long l) {
                return waterSensor.getTs() * 1000L;
            }
        }));

        // todo 4) 分组
        KeyedStream<WaterSensor, String> sensorKS  = sensorDS.keyBy(t -> t.getId());

        // todo 5) 开窗
        WindowedStream<WaterSensor, String, TimeWindow> sensorWS  = sensorKS.window(TumblingEventTimeWindows.of(Time.seconds(10)));

        // todo 6) 自定义窗口
        SingleOutputStreamOperator<String> result = sensorWS.process(new ProcessWindowFunction<WaterSensor, String, String, TimeWindow>() {
            @Override
            public void process(String s, Context context, Iterable<WaterSensor> iterable, Collector<String> out) throws Exception {
                out.collect("key: " + s + "\n" +
                 "数据为: " + iterable + "\n" +
                 "条数为:" + iterable.spliterator().estimateSize() + "\n" +
                 "时间窗口为:" + context.window().getStart() + "->" + context.window().getEnd() + "\n");
            }
        });

        // todo 7) 打印和启动
        result.print();
        env.execute();
    }

    /**
     * 水位传感器,用来接受水位数据
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    private static class WaterSensor {
        private String id;  //传感器id
        private long ts;    //时间
        private Integer vc; //水位
    }


    private static class MyWatermarkGenerator<T> implements WatermarkGenerator<T> {
        private long maxTimestamp = -1L;

        /**
         * 每条数据执行一次
         * @param event
         * @param eventTimestamp
         * @param watermarkOutput
         */
        @Override
        public void onEvent(T event, long eventTimestamp, WatermarkOutput watermarkOutput) {
            System.out.println("onEvent......");
            maxTimestamp = Math.max(eventTimestamp, maxTimestamp);
        }

        /**
         * 周期性执行一次
         * @param watermarkOutput
         */
        @Override
        public void onPeriodicEmit(WatermarkOutput watermarkOutput) {
            System.out.println("onPeriodicEmit......"+ +System.currentTimeMillis());
            // 发生水印
            watermarkOutput.emitWatermark(new Watermark(maxTimestamp));
        }
    }
}

结果:

java 复制代码
onPeriodicEmit......1709376044007
onPeriodicEmit......1709376044214
onPeriodicEmit......1709376044415
onPeriodicEmit......1709376044631
onPeriodicEmit......1709376044834

总结:

  • 1- 自定义水印:WatermarkStrategy.forGenerator(new WatermarkGeneratorSupplier)
    • 重写方法,返回新的 Class<>()
    • 继承 WatermarkGenerator ,重写两个方法,一个每条数据执行一次,一个周期执行一次(默认是200ms)
  • 2- 更改执行周期:env.getConfig().setAutoWatermarkInterval(2000)
  • 3- 调用易出错:forGenerate 有 withTimestampAssigner 方法

B. 间歇性水印:

  • 在上述自定义周期性水印方法的 onEvent 中实现 onPeriodicEmit 中的生成水印代码即可实现
java 复制代码
watermarkOutput.emitWatermark(new Watermark(maxTimestamp));
2.6 在数据源之后使用水印 (Kafka) [重点]
2.6.1 kafka 向指定分区写入数据
java 复制代码
package cn.itcast.day09.watermark.kafka;


import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.internals.Topic;

import java.util.Properties;

/**
 * kafka生产者工具类,模拟数据的生成,将数据写入到指定的分区中
 *
 * 第一个分区写入:1000,hadoop、7000,hadoop-》没有触发窗口计算
 * 第二个分区写入:7000,flink              -》触发了窗口计算
 */
public class KafkaMock {
    private final KafkaProducer<String, String> producer;
    public final static String TOPIC = "test3";

    private KafkaMock(){
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "node01:9092");
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        props.put(ProducerConfig.RETRIES_CONFIG, 0);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        producer = new KafkaProducer<String, String>(props);
    }
    public void producer(){
        long timestamp = 1000;
        String value = "hadoop";
        String key = String.valueOf(value);
        String data = String.format("%s,%s", timestamp, value);
        producer.send(new ProducerRecord<String, String>(TOPIC, 1, key, data));
        producer.close();
    }
    public static void main(String[] args) {
        new KafkaMock().producer();
    }
}
2.6.2 水印机制消费 kafak 数据
java 复制代码
package cn.itcast.day09.watermark.kafka;

import org.apache.flink.api.common.eventtime.TimestampAssigner;
import org.apache.flink.api.common.eventtime.TimestampAssignerSupplier;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumerBase;
import org.apache.flink.util.Collector;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import scala.collection.convert.Wrappers;

import java.time.Duration;
import java.util.Iterator;
import java.util.Properties;
import java.util.concurrent.TimeUnit;

/**
 * 使用水印消费kafka里面的数据
 */
public class WatermarkTest {
    public static void main(String[] args) throws Exception {
        //todo 1)初始化flink流处理环境
        Configuration configuration = new Configuration();
        configuration.setInteger("rest.port", 8081);//设置webui的端口号
        StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(configuration);

        env.setParallelism(2);
        env.enableCheckpointing(5000);
        //todo 2)接入数据源
        //指定topic的名称
        String topicName = "test3";
        //实例化kafkaConsumer对象
        Properties props = new Properties();
        props.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "node01:9092");
        props.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "test001");
        props.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "latest");
        props.setProperty(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
        props.setProperty(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "2000");
        props.setProperty("flink.partition-discovery.interval-millis", "5000");//开启一个后台线程每隔5s检测一次kafka的分区情况

        FlinkKafkaConsumer<String> kafkaSource = new FlinkKafkaConsumer<String>(topicName, new SimpleStringSchema(), props);
        kafkaSource.setCommitOffsetsOnCheckpoints(true);//todo 在开启checkpoint以后,offset的递交会随着checkpoint的成功而递交,从而实现一致性语义,默认就是true

        DataStreamSource<String> kafkaDS = env.addSource(kafkaSource);

        //在数据源上添加水印
        SingleOutputStreamOperator<String> watermarkStream = kafkaDS.assignTimestampsAndWatermarks(
                WatermarkStrategy.<String>forBoundedOutOfOrderness(Duration.ofSeconds(2))
                        .withTimestampAssigner(new TimestampAssignerSupplier<String>() {
                            @Override
                            public TimestampAssigner<String> createTimestampAssigner(Context context) {
                                return new TimestampAssigner<String>() {
                                    @Override
                                    public long extractTimestamp(String element, long recordTimestamp) {
                                        return Long.parseLong(element.split(",")[0]);
                                    }
                                };
                            }
                        }).withIdleness(Duration.ofSeconds(60))
        );

        //todo 3)单词计数操作
        SingleOutputStreamOperator<Tuple2<String, Long>> wordAndOne = watermarkStream.map(new MapFunction<String, Tuple2<String, Long>>() {
            @Override
            public Tuple2<String, Long> map(String value) throws Exception {
                return new Tuple2<String, Long>(value.split(",")[1], 1L);
            }
        });
        //todo 4)单词分组操作
        wordAndOne.keyBy(x-> x.f0).window(TumblingEventTimeWindows.of(Time.of(5, TimeUnit.SECONDS))).process(
                new ProcessWindowFunction<Tuple2<String, Long>, String, String, TimeWindow>() {
                    @Override
                    public void process(String s, Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {
                        long sum = 0L;
                        Iterator<Tuple2<String, Long>> iterator = elements.iterator();
                        while (iterator.hasNext()){
                            Tuple2<String, Long> tuple2 = iterator.next();
                            System.out.println(tuple2.f0);
                            sum += tuple2.f1;
                        }
                        out.collect(s + ","+sum);
                    }
                }
        ).print();

        env.execute();

        //todo 6)启动作业
        env.execute();
    }
}

结果1:没加 withIdleness

java 复制代码
输入:
 * 第一个分区写入:1000,hadoop、7000,hadoop-》没有触发窗口计算
 * 第二个分区写入:7000,flink              -》触发了窗口计算

结果2:加上 withIdleness

java 复制代码
输入:
 * 第一个分区写入:1000,hadoop、7000,hadoop-》30s 后触发窗口计算

结论:

  • 1- 当某一个分区的触发机制达到的时候,其他的分区触发机制迟迟未触发的时候,无法触发机制
  • 2- withIdleness(Duration.ofSeconds(30)),允许 30s 等待其他分区触发计算,如果还没有触发,直接计算该分区
  • 3- 工作中一般设置 1 - 10分钟
  • 4- kafka 数据源添加水印,withTimestampAssigner 需要 new 一个 TimestampAssignerSupplier (第一次出现)

例子:延迟数据处理机制设计

java 复制代码
package cn.itcast.day09.WaterMark;

/**
 * @author lql
 * @time 2024-03-03 13:11:44
 * @description TODO
 */

import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.typeinfo.TypeHint;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.datastream.WindowedStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.windowing.WindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;

import java.time.Duration;

/**
 * flink默认情况下会将迟到的数据丢弃,但是对于绝大多数的业务中是不允许删除迟到数据的,因此可以使用flink的延迟数据处理机制进行数据的获取并处理
 */
public class LatenessDataDemo {
    public static void main(String[] args) throws Exception {
        // 设置环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 数据源
        DataStreamSource<String> lines = env.socketTextStream("node1", 9999);

        SingleOutputStreamOperator<Tuple2<String, Long>> wordAndOne = lines.map(new MapFunction<String, Tuple2<String, Long>>() {
            @Override
            public Tuple2<String, Long> map(String value) throws Exception {
                String[] data = value.split(",");
                return new Tuple2<String, Long>(data[0], Long.parseLong(data[1]));
            }
        });

        // 水印操作 -> 水印3秒
        SingleOutputStreamOperator<Tuple2<String, Long>> watermarkStream = wordAndOne.assignTimestampsAndWatermarks(
                WatermarkStrategy.<Tuple2<String, Long>>forBoundedOutOfOrderness(Duration.ofSeconds(3))
                        .withTimestampAssigner(new SerializableTimestampAssigner<Tuple2<String, Long>>() {
                            @Override
                            public long extractTimestamp(Tuple2<String, Long> element, long recordTimestamp) {
                                // 报错地方:因为我们的数据源已经是毫秒级别了,就不需要转换 *1000L哦!
                                return element.f1;
                            }
                        })
        );

        // 窗口操作 -> 5秒窗口
        // todo 1. 设置允许延迟的时间是通过allowedLateness(lateness: Time)设置
        WindowedStream<Tuple2<String, Long>, String, TimeWindow> windowStream = watermarkStream
                .keyBy(t -> t.f0)
                .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                .allowedLateness(Time.seconds(2));

        // todo 2.初始化延迟到达的数据对象
        OutputTag<Tuple2<String,Long>> outputTag = new OutputTag<>(
                "side output",
                TypeInformation.of(new TypeHint<Tuple2<String, Long>>() {})
        );

        // todo 3.保存延迟到达的数据
        WindowedStream<Tuple2<String, Long>, String, TimeWindow> sideOutputLateData = windowStream.sideOutputLateData(outputTag);

        // 数据聚合
        SingleOutputStreamOperator<Tuple2<String, Long>> result = sideOutputLateData.apply(new WindowFunction<Tuple2<String, Long>, Tuple2<String, Long>, String, TimeWindow>() {
            @Override
            public void apply(String s, TimeWindow window, Iterable<Tuple2<String, Long>> input, Collector<Tuple2<String, Long>> out) throws Exception {
                String key = null;
                Long counter = 0L;
                for (Tuple2<String, Long> element : input) {
                    key = element.f0;
                    counter += 1;
                }
                out.collect(Tuple2.of(key, counter));
            }
        });
        result.print("正常到达的数据>>>");

        // todo 4.获取延迟到达的数据
        DataStream<Tuple2<String, Long>> sideOutput = result.getSideOutput(outputTag);

        sideOutput.printToErr("延迟到达的数据>>>");
        env.execute();
    }
}

结果:

java 复制代码
 /*
 * 每5s一个窗口,水印:3s,延迟等待:2s
 * 测试数据:
 * hadoop,1626936202000  -> 2021-07-22 14:43:22 第一个窗口的数据
 * hadoop,1626936207000  -> 2021-07-22 14:43:27 因为设置了水印,所以不会触发窗口计算
 * hadoop,1626936202000  -> 2021-07-22 14:43:22 第一个窗口的数据
 * hadoop,1626936203000  -> 2021-07-22 14:43:23 第一个窗口的数据
 * hadoop,1626936208000  -> 2021-07-22 14:43:28 触发了窗口计算(hadoop,3),水印时间满足窗口endtime
 *
 * ====================事件时间 28 秒 -> 水印时间 25 秒 刚好临界 endtime =======================
 * ===============延迟 2s 等待机制:延迟到事件时间 30s 即 水印时间 27s 关闭第一个窗口===============
 *
 * 第一个窗口时间 2021-07-22 14:43:20 -> 2021-07-22 14:43:25
 *
 * hadoop,1626936202000  -> 2021-07-22 14:43:22 已经触发过计算的窗口再次有新数据到达,(hadoop,4)(数据重复计算)
 * hadoop,1626936203000  -> 2021-07-22 14:43:23 已经触发过计算的窗口再次有新数据到达,(hadoop,5)
 * hadoop,1626936209000  -> 2021-07-22 14:43:29 虽然 水印时间达到endtime,但是窗口里面没有新数据,不触发计算
 * hadoop,1626936202000  -> 2020-07-22 14:43:22 已经触发过计算的窗口再次有新数据到达,(hadoop,6)
 * hadoop,1626936210000  -> 2021-07-22 14:43:30 满足了窗口销毁的条件,开始专注于第二个新窗口
 *
 * 第二个窗口时间 2021-07-22 14:43:25 -> 2021-07-22 14:43:30
 * 
 * ====================事件时间 33 秒 -> 水印时间 30 秒 刚好临界 endtime ====================================
 *  * ===============延迟 2s 等待机制:延迟到事件时间 35s 即 水印时间 32s 关闭第二个窗口===============
 *
 * hadoop,1626936202000  -> 2021-07-22 14:43:22 打印迟到数据,(hadoop,1626936202000)
 * hadoop,1626936215000  -> 2021-07-22 14:43:35 达到水印时间触发窗口计算:(hadoop,3),之前27,28,29秒的数据
 */

总结:

  • 1- 设计允许迟到数据时间:

    在水印策略后面加上:allowedLateness(Times.seconds())

  • 2- 初始化迟到的数据对象:

    new OutputTag<>(id名字,TypeInformation.of(new TypeHint<迟到数据类型>(){ }))

  • 3- 保存延迟到达迟到数据:

    窗口流.sideOutputLateData(初始化对象)

  • 4- 获取延迟到达迟到数据:

    结果流.getSideOutput(初始化对象)

  • 5- 测输出流是之前 Window Function API 中的重要算子

    OutputTag(注意复习!)

思考:

  • allowedLateness(Times.seconds) 设计允许迟到时间和

    withIdleness(Duration.ofSeconds(30)) 设计允许等待触发时间有什么不同呢?

回答:

  • (1) 从概念上看,allowedLateness 是延迟窗口关闭,不影响触发时间,而 withIdleness 等待分区一段时间,等不到就触发
  • (2) 从应用来看,allowedLateness 适用于车联网入隧道一段时间没上报数据等待数据,而 withIdleness 适用于分区木桶原理等待数据,等不到数据就单独分区触发计算。

相关推荐
2401_883041081 小时前
新锐品牌电商代运营公司都有哪些?
大数据·人工智能
青云交1 小时前
大数据新视界 -- 大数据大厂之 Impala 性能优化:融合机器学习的未来之路(上 (2-1))(11/30)
大数据·计算资源·应用案例·数据交互·impala 性能优化·机器学习融合·行业拓展
Nu11PointerException1 小时前
JAVA笔记 | ResponseBodyEmitter等异步流式接口快速学习
笔记·学习
亦枫Leonlew2 小时前
三维测量与建模笔记 - 3.3 张正友标定法
笔记·相机标定·三维重建·张正友标定法
考试宝3 小时前
国家宠物美容师职业技能等级评价(高级)理论考试题
经验分享·笔记·职场和发展·学习方法·业界资讯·宠物
Json_181790144804 小时前
An In-depth Look into the 1688 Product Details Data API Interface
大数据·json
黑叶白树4 小时前
简单的签到程序 python笔记
笔记·python
幸运超级加倍~5 小时前
软件设计师-上午题-15 计算机网络(5分)
笔记·计算机网络
Qspace丨轻空间6 小时前
气膜场馆:推动体育文化旅游创新发展的关键力量—轻空间
大数据·人工智能·安全·生活·娱乐
芊寻(嵌入式)6 小时前
C转C++学习笔记--基础知识摘录总结
开发语言·c++·笔记·学习