13.Time/WatermarkerWatermaker水印机制/水位线机制Watermaker案例演示

Posted 2022-12-09 涂作权的博客

本文来自：Flink1.12-2021黑马程序员贺岁视频 的学习笔记

13.Time/Watermarker
13.1.时间分类
13.2.EventTime的重要性和Watermaker的引入
13.3.Watermaker详解
13.3.1.Watermaker水印机制/水位线机制
13.3.1.1.什么是Watermaker ?
13.3.1.2.如何计算Watermaker?
13.3.1.3.Watermarker有什么用？
13.3.1.4.Watermaker如何触发窗口计算的？
13.4.Watermaker案例演示
13.5.代码演示-验证版-了解
13.6.代码演示-侧道输出解决数据丢失-掌握（Allowed Lateness案例）
13.6.1.需求和API

13.Time/Watermarker

13.1.时间分类

Time分类
在Flink的流式处理中，会涉及到时间的不同概念，如下图所示：
事件时间EventTime: 事件真真正正发生产生的时间。
摄入时间IngestionTime: 事件到达Flink的时间
处理时间ProcessingTime: 事件真正被处理/计算的时间

问题：上面的三个时间，我们更关注哪一个？

13.2.EventTime的重要性和Watermaker的引入

示例2：

13.3.Watermaker详解

1.Watermaker本质是时间戳。
2.Watermaker = 当前进来的数据最大的事件时间 - 最大允许的数据延迟时间或乱序时间。
3.Watermaker可以通过改变窗口触发计算时机来解决一定程度上的数据乱序或延迟达到的问题。
4.Watermaker >= 窗口结束时间时触发窗口计算。
5.当前的最大的事件时间 - 最大允许的数据延迟时间或乱序时间>= 窗口结束时间时触发窗口计算。
6.当前的最大的事件时间 >= 窗口结束时间 +最大允许的数据延迟时间或乱序时间时触发窗口计算。

13.3.1.Watermaker水印机制/水位线机制

13.3.1.1.什么是Watermaker ?

Watermaker就是给数据再额外的加的一个时间列，也就是Watermaker是个时间戳。

13.3.1.2.如何计算Watermaker?

Watermaker = 数据的事件时间 - 最大允许的延迟时间或乱序时间。

注意：后面通过源码会发现，准确来说：
Watermaker = 当前窗口的最大的事件时间 - 最大允许的延迟时间或乱序时间。
这样可以保证Watermaker水位线会一直上升(变大),不会下下降。

13.3.1.3.Watermarker有什么用？

之前的窗口都是按照系统时间来触发计算的，如:[10:00:00 ~ 10:00:10)的窗口，一旦系统时间到了10:00:10就会触发计算，那么可能会导致延迟到达的数据丢失。

那么现在有了Watermaker,窗口就可以按照Watermaker来触发计算。
也就是说Watermaker是用来触发窗口计算的!

13.3.1.4.Watermaker如何触发窗口计算的？

1.窗口中有数据 2.Watermaker >= 窗口的结束时间。
Watermaker = 当前窗口的最大的事件时间 - 最大允许的延迟时间或乱序时间。
也就是说只要不断有数据来，就可以保证Watermaker水位线是会一直上升/变大的，不会下降/减小的。所以最终一定是会触发窗口计算的。

注意：
上面的触发公式进行如下变形：
Watermaker >= 窗口的结束时间。
Watermaker = 当前窗口的最大的事件时间 - 最大允许的延迟时间或乱序时间。
当前窗口的最大的事件时间 - 最大允许的延迟时间或乱序时间 >= 窗口的结束时间。
当前窗口的最大的事件时间 >= 窗口的结束时间 + 最大允许的延迟时间或乱序时间。

13.4.Watermaker案例演示

https://ci.apache.org/projects/flink/flink-docs-release-1.12/dev/event_timestamps_watermarks.html

package day3.demo4;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.calcite.linq4j.Ord;
import org.apache.flink.api.common.RuntimeExecutionMode;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
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.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

import java.time.Duration;
import java.util.Random;
import java.util.UUID;

/**
 * Desc 演示基于事件时间的窗口计算+Watermaker解决一定程度上的数据乱序/延迟到达的问题
 *
 * @author tuzuoquan
 * @date 2022/5/5 9:49
 */
public class WatermakerDemo01 

    public static void main(String[] args) throws Exception 
        //TODO 0.env
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);

        //TODO 1.source
        DataStreamSource<Order> orderDS = env.addSource(new SourceFunction<Order>() 
            private boolean flag = true;

            @Override
            public void run(SourceContext<Order> ctx) throws Exception 
                Random random = new Random();
                while (flag) 
                    String orderId = UUID.randomUUID().toString();
                    int userId = random.nextInt(2);
                    int money = random.nextInt(101);
                    //随机模拟延迟
                    long eventTime = System.currentTimeMillis() - random.nextInt(5) * 1000;
                    ctx.collect(new Order(orderId, userId, money, eventTime));
                    Thread.sleep(1000);
                
            

            @Override
            public void cancel() 
                flag = false;
            
        );

        //TODO 2.transformation
        //老版本API
        /*DataStream<Order> watermakerDS = orderDS.assignTimestampsAndWatermarks(
                new BoundedOutOfOrdernessTimestampExtractor<Order>(Time.seconds(3)) //最大允许的延迟时间或乱序时间
                    @Override
                    public long extractTimestamp(Order element) 
                        return element.eventTime;
                        //指定事件时间是哪一列,Flink底层会自动计算:
                        //Watermaker = 当前最大的事件时间 - 最大允许的延迟时间或乱序时间
                    
        );*/
        //注意:下面的代码使用的是Flink1.12中新的API
        //每隔5s计算最近5s的数据求每个用户的订单总金额,要求:基于事件时间进行窗口计算+Watermaker
        //env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);//在新版本中默认就是EventTime
        //设置Watermaker = 当前最大的事件时间 - 最大允许的延迟时间或乱序时间
        SingleOutputStreamOperator<Order> orderDSWithWatermark = orderDS.assignTimestampsAndWatermarks(
                WatermarkStrategy.<Order>forBoundedOutOfOrderness(Duration.ofSeconds(3))//指定maxOutOfOrderness最大无序度/最大允许的延迟时间/乱序时间
                        .withTimestampAssigner((order, timestamp) -> order.getEventTime())//指定事件时间列
        );

        SingleOutputStreamOperator<Order> result = orderDSWithWatermark.keyBy(Order::getUserId)
                .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                .sum("money");

        //TODO 3.sink
        result.print();

        //TODO 4.execute
        env.execute();
    

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Order 
        private String orderId;
        private Integer userId;
        private Integer money;
        private Long eventTime;
    


6> WatermakerDemo01.Order(orderId=0140f77b-e5a2-4849-8a95-5c4ef0a42191, userId=0, money=121, eventTime=1651766908579)
6> WatermakerDemo01.Order(orderId=94d637a9-d621-4f24-b192-3687c80a49c4, userId=1, money=99, eventTime=1651766908598)
6> WatermakerDemo01.Order(orderId=105873f2-e676-46e5-9c08-7dec812a4b38, userId=1, money=318, eventTime=1651766911618)
6> WatermakerDemo01.Order(orderId=05997f89-5065-4646-bbc9-27b797a93c5b, userId=0, money=79, eventTime=1651766911644)
6> WatermakerDemo01.Order(orderId=66bf589f-9e3e-43ff-8f40-441b75399300, userId=0, money=9, eventTime=1651766917699)
6> WatermakerDemo01.Order(orderId=feb8d902-660c-41ee-b721-a0bb1d063367, userId=1, money=236, eventTime=1651766916693)

13.5.代码演示-验证版-了解

通过源码和下面的代码可以验证
总结：
1.Watermaker本质是时间戳
2.Watermaker = 当前窗口的最大的事件时间 - 最大允许的数据延迟时间或乱序时间。
3.Watermaker可以通过改变窗口触发计算时机来解决一定程度上的数据乱序或延迟达到的问题。
4.Watermaker >= 窗口结束时间时触发窗口计算
5.当前窗口的最大的事件时间 - 最大允许的数据延迟时间或乱序时间 >= 窗口结束时间时触发窗口计算。
6.当前窗口的最大的事件时间 >= 窗口结束时间时触发窗口计算 + 最大允许的数据延迟时间或乱序时间。

package day3.demo5;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.time.FastDateFormat;
import org.apache.flink.api.common.eventtime.*;
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.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
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 java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.UUID;

/**
 * Desc
 * 模拟实时订单数据,格式为: (订单ID，用户ID，订单金额，时间戳/事件时间)
 * 要求每隔5s,计算5秒内(基于时间的滚动窗口)，每个用户的订单总金额
 * 并添加Watermaker来解决一定程度上的数据延迟和数据乱序问题。
 *
 * @author tuzuoquan
 * @date 2022/5/6 0:22
 */
public class WatermakerDemo02_Check 

    public static void main(String[] args) throws Exception 
        FastDateFormat df = FastDateFormat.getInstance("HH:mm:ss");

        //TODO 1.env
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        //TODO 2.Source
        //模拟实时订单数据(数据有延迟和乱序)
        DataStreamSource<Order> orderDS = env.addSource(new SourceFunction<Order>() 
            private boolean flag = true;
            @Override
            public void run(SourceContext<Order> ctx) throws Exception 
                Random random = new Random();
                while (flag) 
                    String orderId = UUID.randomUUID().toString();
                    int userId = random.nextInt(3);
                    int money = random.nextInt(100);
                    //模拟数据延迟和乱序!
                    long eventTime = System.currentTimeMillis() - random.nextInt(5) * 1000;
                    System.out.println("发送的数据为: "+userId + " : " + df.format(eventTime));
                    ctx.collect(new Order(orderId, userId, money, eventTime));
                    //TimeUnit.SECONDS.sleep(1);
                    Thread.sleep(1000);
                
            

            @Override
            public void cancel() 
                flag = false;
            
        );

        //TODO 3.Transformation
        /*DataStream<Order> watermakerDS = orderDS
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy.<Order>forBoundedOutOfOrderness(Duration.ofSeconds(3))
                                .withTimestampAssigner((event, timestamp) -> event.getEventTime())
                );*/

        //开发中直接使用上面的即可
        //学习测试时可以自己实现
        DataStream<Order> watermakerDS = orderDS
                .assignTimestampsAndWatermarks(
                        new WatermarkStrategy<Order>() 
                            @Override
                            public WatermarkGenerator<Order> createWatermarkGenerator(WatermarkGeneratorSupplier.Context context) 
                                return new WatermarkGenerator<Order>() 
                                    private int userId = 0;
                                    private long eventTime = 0L;
                                    private final long outOfOrdernessMillis = 3000;
                                    private long maxTimestamp = Long.MIN_VALUE + outOfOrdernessMillis + 1;

                                    @Override
                                    public void onEvent(Order event, long eventTimestamp, WatermarkOutput output) 
                                        userId = event.userId;
                                        eventTime = event.eventTime;
                                        maxTimestamp = Math.max(maxTimestamp, eventTimestamp);
                                    

                                    @Override
                                    public void onPeriodicEmit(WatermarkOutput output) 
                                        //Watermaker = 当前最大事件时间 - 最大允许的延迟时间或乱序时间
                                        Watermark watermark = new Watermark(maxTimestamp - outOfOrdernessMillis - 1);
                                        System.out.println("key:" + userId + ",系统时间:" + df.format(System.currentTimeMillis()) + ",事件时间:" + df.format(eventTime) + ",水印时间:" + df.format(watermark.getTimestamp()));
                                        output.emitWatermark(watermark);
                                    
                                ;
                            
                        .withTimestampAssigner((order, timestamp) -> order.getEventTime())
                );


        //代码走到这里,就已经被添加上Watermaker了!接下来就可以进行窗口计算了
        //要求每隔5s,计算5秒内(基于时间的滚动窗口)，每个用户的订单总金额
        /* DataStream<Order> result = watermakerDS
                 .keyBy(Order::getUserId)
                //.timeWindow(Time.seconds(5), Time.seconds(5))
                .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                .sum("money");*/

        //开发中使用上面的代码进行业务计算即可
        //学习测试时可以使用下面的代码对数据进行更详细的输出,如输出窗口触发时各个窗口中的数据的事件时间,Watermaker时间
        SingleOutputStreamOperator<String> result = watermakerDS
                .keyBy(Order::getUserId)
                .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                //把apply中的函数应用在窗口中的数据上
                //WindowFunction<IN, OUT, KEY, W extends Window>
                .apply(new WindowFunction<Order, String, Integer, TimeWindow>() 
                    @Override
                    public void apply(Integer key, TimeWindow window, Iterable<Order> orders, Collector<String> out) throws Exception 
                        //用来存放当前窗口的数据的格式化后的事件时间
                        List<String> list = new ArrayList<>();
                        for (Order order : orders) 
                            Long eventTime = order.eventTime;
                            String formatEventTime = df.format(eventTime);
                            list.add(formatEventTime);
                        
                        String start = df.format(window.getStart());
                        String end = df.format(window.getEnd());
                        //现在就已经获取到了当前窗口的开始和结束时间,以及属于该窗口的所有数据的事件时间,把这些拼接并返回
                        String outStr = String.format