Flink 内容分享(二十五)：Flink的时间类型和WaterMark机制

最新推荐文章于 2024-04-26 14:36:50 发布
最新推荐文章于 2024-04-26 14:36:50 发布
阅读量861 收藏 22
点赞数 24
分类专栏： Flink 内容分享 大数据（Hadoop）内容分享 文章标签： flink java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45038038/article/details/135315835
版权

目录

1.1 需求背景

1.2 Process Time Window（有序）

1.3 Process Time Window（无序）

1.4 使用Event Time处理无序

1.5 使用【WaterMark】机制解决无序

1.6 WaterMark机制

1.6.3 小需求

1.6.5 WaterMark+Window 处理乱序事件

1.6.6 迟到太多的事件

1.7 多并行度下的WaterMark

1.1 需求背景

需求描述：每隔5秒，计算近10秒单词出现的次数。

1.1.1 TimeWindow实现

/**
 * 每隔5秒统计最近10秒的单词出现的次数
 */
public class TimeWindowWordCount {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStreamSource<String> dataStream = env.socketTextStream("bigdata02", 1234);
        dataStream.flatMap(new FlatMapFunction<String, Tuple2<String,Integer>>() {
            @Override
            public void flatMap(String line,
                                Collector<Tuple2<String, Integer>> out) throws Exception {
                String[] fields = line.split(",");
                for(String word:fields){
                    out.collect(Tuple2.of(word,1));
                }

            }
        }).keyBy(0).timeWindow(Time.seconds(10),Time.seconds(5))
                .sum(1)
                .print().setParallelism(1);

        env.execute("TimeWindowWordCount");

    }
}

1.1.2 ProcessWindowFunction

/**
 * 每隔5秒统计最近10秒的单词出现的次数
 */
public class TimeWindowWordCount {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStreamSource<String> dataStream = env.socketTextStream("bigdata02", 1234);
        dataStream.flatMap(new FlatMapFunction<String, Tuple2<String,Integer>>() {
            @Override
            public void flatMap(String line,
                                Collector<Tuple2<String, Integer>> out) throws Exception {
                String[] fields = line.split(",");
                for(String word:fields){
                    out.collect(Tuple2.of(word,1));
                }
                
            }
        }).keyBy(0).timeWindow(Time.seconds(10),Time.seconds(5))
                .process(new MySumProcessWindowFunction()) //foreach key,value -> sum -> key,value
                .print().setParallelism(1);

        env.execute("word count..");
    }

    /**
     * IN, OUT, KEY, W extends Window
     */
    public  static class MySumProcessWindowFunction extends
            ProcessWindowFunction<Tuple2<String,Integer>,Tuple2<String,Integer>
                    ,Tuple,TimeWindow>{
        FastDateFormat dataformat=FastDateFormat.getInstance("HH:mm:ss");
        @Override
        public void process(Tuple key, Context context,
                            Iterable<Tuple2<String, Integer>> elements,
                            Collector<Tuple2<String, Integer>> out) throws Exception {

            System.out.println("当前系统时间："+dataformat.format(System.currentTimeMillis()));
            System.out.println("窗口处理时间："+dataformat.format(context.currentProcessingTime()));
            System.out.println("窗口开始时间："+dataformat.format(context.window().getStart()));


            int sum=0;
            for (Tuple2<String,Integer> ele:elements){
                sum += 1;
            }
            out.collect(Tuple2.of(key.getField(0),sum));

            System.out.println("窗口结束时间："+dataformat.format(context.window().getEnd()));

            System.out.println("=====================================================");
        }
    }


根据每隔5秒执行近10秒的数据，Flink划分的窗口

[00:00:00, 00:00:05) [00:00:05, 00:00:10)
[00:00:10, 00:00:15) [00:00:15, 00:00:20)
[00:00:20, 00:00:25) [00:00:25, 00:00:30) 
[00:00:30, 00:00:35) [00:00:35, 00:00:40) 
[00:00:40, 00:00:45) [00:00:45, 00:00:50) 
[00:00:50, 00:00:55) [00:00:55, 00:01:00) 
[00:01:00, 00:01:05)  ...
1.1.3 Time的种类

针对stream数据中的时间，可以分为以下三种：
Event Time：事件产生的时间，它通常由事件中的时间戳描述。
Ingestion time：事件（日志，数据，消息）进入Flink的时间(不考虑)
Processing Time：事件被处理时当前系统的时间
默认情况下，我们使用的是Processing Time


案例演示： 原始日志如下

2020-04-11 10:00:01,134 INFO executor.Executor: Finished task in state 0.0

这条数据进入Flink的时间是2020-04-11 20:00:00,102

到达window处理的时间为2020-04-11 20:00:01,100

  • 2020-04-11 10:00:01,134 是Event time
  • 2020-04-11 20:00:00,102 是Ingestion time
  • 2020-04-11 20:00:01,100 是Processing time
    思考：

如果我们想要统计每分钟内接口调用失败的错误日志个数，使用哪个时间才有意义？

1.2 Process Time Window（有序）

需求：每隔5秒计算近10秒的单词出现的次数
自定义source，模拟：第 13 秒的时候连续发送 2 个事件，第 16 秒的时候再发送 1 个事件

/**
 * 需求：每隔5秒计算最近10秒的单词次数
 */
public class WindowWordCountBySource {
    public static void main(String[] args) throws  Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStreamSource<String> dataStream = env.addSource(new TestSource());
        dataStream.flatMap(new FlatMapFunction<String, Tuple2<String,Integer>>() {
            @Override
            public void flatMap(String line,
                                Collector<Tuple2<String, Integer>> out) throws Exception {
                String[] fields = line.split(",");
                for (String word:fields){
                    out.collect(Tuple2.of(word,1));
                }
            }
        })
                .keyBy(0)
                .timeWindow(Time.seconds(10),Time.seconds(5))
                .process(new SumProcessFunction()).print().setParallelism(1);


        env.execute("WindowWordCountAndTime");

    }

    public static class TestSource implements
            SourceFunction<String>{
        FastDateFormat dateformat =  FastDateFormat.getInstance("HH:mm:ss");
        @Override
        public void run(SourceContext<String> cxt) throws Exception {

            String currTime = String.valueOf(System.currentTimeMillis());

            System.out.println(currTime);

            //这个操作是我为了保证是 10s的倍数。
            //我们执行的时间是10的倍数
            //10 20 30 40 50
            while(Integer.valueOf(currTime.substring(currTime.length() - 4)) > 100){
                currTime=String.valueOf(System.currentTimeMillis());
                continue;
            }

            System.out.println("开始发送事件的时间："+dateformat.format(System.currentTimeMillis()));
            TimeUnit.SECONDS.sleep(3);
            cxt.collect("hadoop");
            cxt.collect("hadoop");

            TimeUnit.SECONDS.sleep(3);
            cxt.collect("hadoop");

            TimeUnit.SECONDS.sleep(300000);

        }

        @Override
        public void cancel() {

        }
    }

    /**
     * IN
     * OUT
     * KEY
     * W extends Window
     *
     */
    public static class  SumProcessFunction
            extends ProcessWindowFunction<Tuple2<String,Integer>,Tuple2<String,Integer>,Tuple,TimeWindow>{

        FastDateFormat dataformat=FastDateFormat.getInstance("HH:mm:ss");
        @Override
        public void process(Tuple tuple, Context context,
                            Iterable<Tuple2<String, Integer>> allElements,
                            Collector<Tuple2<String, Integer>> out) {

            int count=0;
           for (Tuple2<String,Integer> e:allElements){
               count++;
           }
            out.collect(Tuple2.of(tuple.getField(0),count));

        }
    }
}

1.3 Process Time Window（无序）

自定义source，模拟：第 13 秒的时候连续发送 2 个事件，但是有一个事件确实在第13秒的发送出去 了，另外一个事件因为某种原因在19秒的时候才发送出去，第 16 秒的时候再发送 1 个事件

/**
 * 需求：每隔5秒计算最近10秒的单词次数
 * 乱序
 */
public class WindowWordCountBySource2 {
    public static void main(String[] args) throws  Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStreamSource<String> dataStream = env.addSource(new TestSource());
        dataStream.flatMap(new FlatMapFunction<String, Tuple2<String,Integer>>() {
            @Override
            public void flatMap(String line,
                                Collector<Tuple2<String, Integer>> out) throws Exception {
                String[] fields = line.split(",");
                for (String word:fields){
                    out.collect(Tuple2.of(word,1));
                }
            }
        })
                .keyBy(0)
                .timeWindow(Time.seconds(10),Time.seconds(5))
                .process(new SumProcessFunction()).print().setParallelism(1);


        env.execute("WindowWordCountAndTime");

    }

    public static class TestSource implements
            SourceFunction<String>{
        FastDateFormat dateformat =  FastDateFormat.getInstance("HH:mm:ss");
        @Override
        public void run(SourceContext<String> cxt) throws Exception {
            String currTime = String.valueOf(System.currentTimeMillis());
            while(Integer.valueOf(currTime.substring(currTime.length() - 4)) > 100){
                currTime=String.valueOf(System.currentTimeMillis());
                continue;
            }
            System.out.println("开始发送事件的时间："+dateformat.format(System.currentTimeMillis()));

            //13
            TimeUnit.SECONDS.sleep(3);
            //实际上我们的数据是在13秒的时候生成的，只是19的时候被发送出去。
            String event="hadoop";

            cxt.collect(event);
         // cxt.collect(event);

            //16
            TimeUnit.SECONDS.sleep(3);
            cxt.collect("hadoop");
            //19
            TimeUnit.SECONDS.sleep(3);
            cxt.collect(event);

            TimeUnit.SECONDS.sleep(300990);

        }

        @Override
        public void cancel() {

        }
    }

    /**
     * IN
     * OUT
     * KEY
     * W extends Window
     *
     */
    public static class  SumProcessFunction
            extends ProcessWindowFunction<Tuple2<String,Integer>,Tuple2<String,Integer>,Tuple,TimeWindow>{

        FastDateFormat dataformat=FastDateFormat.getInstance("HH:mm:ss");
        @Override
        public void process(Tuple tuple, Context context,
                            Iterable<Tuple2<String, Integer>> allElements,
                            Collector<Tuple2<String, Integer>> out) {

            int count=0;
           for (Tuple2<String,Integer> e:allElements){
               count++;
           }
            out.collect(Tuple2.of(tuple.getField(0),count));

        }
    }
}

1.4 使用Event Time处理无序

使用Event Time处理

/**
 * 需求：每隔5秒计算最近10秒的单词次数
 */
public class WindowWordCountByEventTime {
    public static void main(String[] args) throws  Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        //步骤一：设置时间类型，默认的是Processtime
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

        DataStreamSource<String> dataStream = env.addSource(new TestSource());
        dataStream.map(new MapFunction<String, Tuple2<String,Long>>() {
            @Override
            public Tuple2<String, Long> map(String line) throws Exception {
                String[] fields = line.split(",");
                    //key/value
                return new Tuple2<>(fields[0],Long.valueOf(fields[1]));
            }
            //作用：指定时间字段
        }).assignTimestampsAndWatermarks(new EventTimeExtractor())
                .keyBy(0)
                .timeWindow(Time.seconds(10),Time.seconds(5))
                .process(new SumProcessFunction()).print().setParallelism(1);


        env.execute("WindowWordCountAndTime");

    }

    public static class TestSource implements
            SourceFunction<String>{
        FastDateFormat dateformat =  FastDateFormat.getInstance("HH:mm:ss");
        @Override
        public void run(SourceContext<String> cxt) throws Exception {
            String currTime = String.valueOf(System.currentTimeMillis());
            while(Integer.valueOf(currTime.substring(currTime.length() - 4)) > 100){
                currTime=String.valueOf(System.currentTimeMillis());
                continue;
            }
            System.out.println("开始发送事件的时间："+dateformat.format(System.currentTimeMillis()));
            TimeUnit.SECONDS.sleep(3);
            //13
            String event="hadoop,"+System.currentTimeMillis();//时间

            cxt.collect(event);
           // cxt.collect(event);

            TimeUnit.SECONDS.sleep(3);//16
            cxt.collect("hadoop,"+System.currentTimeMillis());

            TimeUnit.SECONDS.sleep(3);
            //19
            cxt.collect(event);

            TimeUnit.SECONDS.sleep(3000);
            
        }

        @Override
        public void cancel() {

        }
    }


    private static class EventTimeExtractor
            implements AssignerWithPeriodicWatermarks<Tuple2<String,Long>>{
        @Nullable
        @Override
        public Watermark getCurrentWatermark() {
            return new Watermark(System.currentTimeMillis());
        }

        //指定时间
        @Override
        public long extractTimestamp(Tuple2<String, Long> element, long l) {
            return element.f1;
        }
    }

    /**
     * IN
     * OUT
     * KEY
     * W extends Window
     *
     */
    public static class  SumProcessFunction
            extends ProcessWindowFunction<Tuple2<String,Long>,Tuple2<String,Integer>,Tuple,TimeWindow>{

        FastDateFormat dataformat=FastDateFormat.getInstance("HH:mm:ss");
        @Override
        public void process(Tuple tuple, Context context,
                            Iterable<Tuple2<String, Long>> allElements,
                            Collector<Tuple2<String, Integer>> out) {

            int count=0;
           for (Tuple2<String,Long> e:allElements){
               count++;
           }
            out.collect(Tuple2.of(tuple.getField(0),count));

        }
    }
}

现在我们第三个window的结果已经计算准确了，但是我们还是没有彻底的解决问题。接下来就需要我 们使用WaterMark机制来解决了。

1.5 使用【WaterMark】机制解决无序

/**
 * 需求：每隔5秒计算最近10秒的单词次数
 *
 * 引入watermark解决问题
 */
public class WindowWordCountByWaterMark {
    public static void main(String[] args) throws  Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        //步骤一：设置时间类型，默认的是Processtime
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

        DataStreamSource<String> dataStream = env.addSource(new TestSource());
        dataStream.map(new MapFunction<String, Tuple2<String,Long>>() {
            @Override
            public Tuple2<String, Long> map(String line) throws Exception {
                String[] fields = line.split(",");
                return new Tuple2<>(fields[0],Long.valueOf(fields[1]));
            }
        }).assignTimestampsAndWatermarks(new EventTimeExtractor())
                .keyBy(0)
                .timeWindow(Time.seconds(10),Time.seconds(5))
                .process(new SumProcessFunction()).print().setParallelism(1);


        env.execute("WindowWordCountAndTime");

    }

    public static class TestSource implements
            SourceFunction<String>{
        FastDateFormat dateformat =  FastDateFormat.getInstance("HH:mm:ss");
        @Override
        public void run(SourceContext<String> cxt) throws Exception {
            String currTime = String.valueOf(System.currentTimeMillis());
            while(Integer.valueOf(currTime.substring(currTime.length() - 4)) > 100){
                currTime=String.valueOf(System.currentTimeMillis());
                continue;
            }
            System.out.println("开始发送事件的时间："+dateformat.format(System.currentTimeMillis()));
            TimeUnit.SECONDS.sleep(3);
            String event="hadoop,"+System.currentTimeMillis();
            cxt.collect(event);

            TimeUnit.SECONDS.sleep(3);
            cxt.collect("hadoop,"+System.currentTimeMillis());

            TimeUnit.SECONDS.sleep(3);
            cxt.collect(event);
            TimeUnit.SECONDS.sleep(3000);
            
        }

        @Override
        public void cancel() {

        }
    }


    private static class EventTimeExtractor implements AssignerWithPeriodicWatermarks<Tuple2<String,Long>>{
        //设置 5s的延迟（乱序）
        @Nullable
        @Override
        public Watermark getCurrentWatermark() {
            //System.out.println("water mark:......"+System.currentTimeMillis());
            return new Watermark(System.currentTimeMillis() - 5000);
        }

        @Override
        public long extractTimestamp(Tuple2<String, Long> element, long l) {
            return element.f1;
        }
    }

    /**
     * IN
     * OUT
     * KEY
     * W extends Window
     *
     */
    public static class  SumProcessFunction
            extends ProcessWindowFunction<Tuple2<String,Long>,Tuple2<String,Integer>,Tuple,TimeWindow>{

        FastDateFormat dataformat=FastDateFormat.getInstance("HH:mm:ss");
        @Override
        public void process(Tuple tuple, Context context,
                            Iterable<Tuple2<String, Long>> allElements,
                            Collector<Tuple2<String, Integer>> out) {

            int count=0;
           for (Tuple2<String,Long> e:allElements){
               count++;
           }
            out.collect(Tuple2.of(tuple.getField(0),count));

        }
    }
}

1.6 WaterMark机制

1.6.2 WaterMark的定义

我们知道，流处理从事件产生，到流经source，再到operator，中间是有一个过程和时间的。虽然大部 分情况下，流到operator的数据都是按照事件产生的时间顺序来的，但是也不排除由于网络延迟等原 因，导致乱序的产生，特别是使用kafka的话，多个分区的数据无法保证有序。所以在进行window计算 的时候，我们又不能无限期的等下去，必须要有个机制来保证一个特定的时间后，必须触发window去 进行计算了。这个特别的机制，就是watermark，watermark是用于处理乱序事件的。watermark可以 翻译为水位线

有序的流的watermarks

无序的流的watermarks

多并行度流的watermarks

1.6.3 小需求

得到并打印每隔 3 秒钟统计前 3 秒内的相同的 key 的所有的事件
允许最大乱序时间4s

/**
 * 需求：3秒一个窗口，把相同 key合并起来
 *
 * hadoop,1461756862000
 * hadoop,1461756866000
 * hadoop,1461756872000
 * hadoop,1461756873000
 * hadoop,1461756874000
 * hadoop,1461756876000
 * hadoop,1461756877000
 *
 *
 * window + watermark  观察窗口是如何被触发？
 *
 * 可以解决乱序问题
 *
 *
 */
public class WindowWordCountByWaterMark2 {
    public static void main(String[] args) throws  Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //步骤一：设置时间类型
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

        //checkpoint

        DataStreamSource<String> dataStream = env.socketTextStream("bigdata02", 1234);
        dataStream.map(new MapFunction<String, Tuple2<String,Long>>() {
            @Override
            public Tuple2<String, Long> map(String line) throws Exception {
                String[] fields = line.split(",");
                return new Tuple2<>(fields[0],Long.valueOf(fields[1]));
            }
            //步骤二：获取数据里面的event Time
        }).assignTimestampsAndWatermarks(new EventTimeExtractor() )
                .keyBy(0)
                .timeWindow(Time.seconds(3))
                .process(new SumProcessWindowFunction())
                .print().setParallelism(1);

        env.execute("WindowWordCountByWaterMark2");

    }

    /**
     * IN, OUT, KEY, W
     * IN：输入的数据类型
     * OUT：输出的数据类型
     * Key：key的数据类型（在Flink里面，String用Tuple表示）
     * W：Window的数据类型
     */
    public static class SumProcessWindowFunction extends
            ProcessWindowFunction<Tuple2<String,Long>,String,Tuple,TimeWindow> {
        FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss");
        /**
         * 当一个window触发计算的时候会调用这个方法
         * @param tuple key
         * @param context operator的上下文
         * @param elements 指定window的所有元素
         * @param out 用户输出
         */
        @Override
        public void process(Tuple tuple, Context context,
                            Iterable<Tuple2<String, Long>> elements,
                            Collector<String> out) {
            System.out.println("处理时间：" + dateFormat.format(context.currentProcessingTime()));
            System.out.println("window start time : " + dateFormat.format(context.window().getStart()));

            List<String> list = new ArrayList<>();
            for (Tuple2<String, Long> ele : elements) {
                list.add(ele.toString() + "|" + dateFormat.format(ele.f1));
            }
            out.collect(list.toString());
            System.out.println("window end time  : " + dateFormat.format(context.window().getEnd()));

        }
    }

    private static class EventTimeExtractor
            implements AssignerWithPeriodicWatermarks<Tuple2<String, Long>> {
        FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss");
        //3s 计算时间最大的一个值。
        private long currentMaxEventTime=0L;
        private long maxOufOfOrderness=10000;//最大乱序时间

        //30
        @Nullable
        @Override
        public Watermark getCurrentWatermark() {
            //watermark的计算的逻辑
            //如何计算出来一个窗口里面的watermark
            return new Watermark(currentMaxEventTime - maxOufOfOrderness);
        }

        @Override
        public long extractTimestamp(Tuple2<String, Long> element, long timeStamp) {
            Long currentElementTime = element.f1;


            currentMaxEventTime = Math.max(currentMaxEventTime,currentElementTime);
//
            System.out.println("event = " + element
                    + "|" + dateFormat.format(element.f1) // Event Time
                    + "|" + dateFormat.format(currentMaxEventTime)  // Max Event Time
                    + "|" + dateFormat.format(getCurrentWatermark().getTimestamp())); // Current Watermark

            return currentElementTime;
        }
    }
}



[00:00:00, 00:00:03) [00:00:03, 00:00:06)
[00:00:06, 00:00:12) [00:00:12, 00:00:15)
[00:00:15, 00:00:18) [00:00:18, 00:00:21) 
[00:00:21, 00:00:24) [00:00:24, 00:00:27) 
[00:00:27, 00:00:30) [00:00:30, 00:00:33) 
[00:00:33, 00:00:36) [00:00:36, 00:00:39) 
[00:00:42, 00:00:45)  ...
KeyEvent TimecurrentMaxTimestamepcurrentWatermarkwindow start timewindow end time
00000119:34:2219:34:2219:34:12
00000119:34:2619:34:2619:34:16
00000119:34:3219:34:3219:34:22
00000119:34:3319:34:3319:34:23
00000119:34:3419:34:3419:34:24[19:34:2119:34:24)
00000119:34:3619:34:3619:34:26
00000119:34:3719:34:3719:34:27[19:34:2419:34:27)

总结：window触发的时间

  • 1. watermark 时间 >= window_end_time
  • 2. 在 [window_start_time, window_end_time) 区间中有数据存在，注意是左闭右开的区间，而且是 以 event time 来计算的

1.6.5 WaterMark+Window 处理乱序事件

/**
 * 需求：3秒一个窗口，进行单词计数
 *
 * 迟到太多的数据：默认就丢弃了
 *
 * 000001,1461756879000
 * 000001,1461756871000
 * 000001,1461756883000
 */
public class WindowWordCountByWaterMark3 {
    public static void main(String[] args) throws  Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //步骤一：设置时间类型
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

        DataStreamSource<String> dataStream = env.socketTextStream("bigdata02", 1234);
        dataStream.map(new MapFunction<String, Tuple2<String,Long>>() {
            @Override
            public Tuple2<String, Long> map(String line) throws Exception {
                String[] fields = line.split(",");
                return new Tuple2<>(fields[0],Long.valueOf(fields[1]));
            }
            //步骤二：获取数据里面的event Time
        }).assignTimestampsAndWatermarks(new EventTimeExtractor())
                .keyBy(0)
                .timeWindow(Time.seconds(3))
               // .allowedLateness(Time.seconds(2)) // 允许事件迟到 2 秒
                .process(new SumProcessWindowFunction())
                .print().setParallelism(1);

        env.execute("WindowWordCountByWaterMark3");

    }

    /**
     * IN, OUT, KEY, W
     * IN：输入的数据类型
     * OUT：输出的数据类型
     * Key：key的数据类型（在Flink里面，String用Tuple表示）
     * W：Window的数据类型
     */
    public static class SumProcessWindowFunction extends
            ProcessWindowFunction<Tuple2<String,Long>,String,Tuple,TimeWindow> {
        FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss");
        /**
         * 当一个window触发计算的时候会调用这个方法
         * @param tuple key
         * @param context operator的上下文
         * @param elements 指定window的所有元素
         * @param out 用户输出
         */
        @Override
        public void process(Tuple tuple, Context context, Iterable<Tuple2<String, Long>> elements,
                            Collector<String> out) {
            System.out.println("处理时间：" + dateFormat.format(context.currentProcessingTime()));
            System.out.println("window start time : " + dateFormat.format(context.window().getStart()));

            List<String> list = new ArrayList<>();
            for (Tuple2<String, Long> ele : elements) {
                list.add(ele.toString() + "|" + dateFormat.format(ele.f1));
            }
            out.collect(list.toString());
            System.out.println("window end time  : " + dateFormat.format(context.window().getEnd()));

        }
    }

    private static class EventTimeExtractor
            implements AssignerWithPeriodicWatermarks<Tuple2<String, Long>> {
        FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss");
        private long currentMaxEventTime=0L;
        private long maxOufOfOrderness=10000;//最大乱序时间
        @Nullable
        @Override
        public Watermark getCurrentWatermark() {
            return new Watermark(currentMaxEventTime - maxOufOfOrderness);
        }

        @Override
        public long extractTimestamp(Tuple2<String, Long> element, long timeStamp) {
            Long currentElementTime = element.f1;
            currentMaxEventTime = Math.max(currentMaxEventTime,currentElementTime);

            System.out.println("event = " + element
                    + "|" + dateFormat.format(element.f1) // Event Time
                    + "|" + dateFormat.format(currentMaxEventTime)  // Max Event Time
                    + "|" + dateFormat.format(getCurrentWatermark().getTimestamp())); // Current Watermark

            return currentElementTime;
        }
    }
}

KeyEvent TimecurrentMaxTimestamepcurrentWatermarkwindow start timewindow end time
00000119:34:3919:34:3919:34:29
00000119:34:3119:34:3919:34:29
00000119:34:4319:34:4319:34:33[19:34:3019:34:33)

1.6.6 迟到太多的事件


1. 丢弃，这个是默认的处理方式
2. allowedLateness 指定允许数据延迟的时间(我们一般不选择)
3. sideOutputLateData 收集迟到的数据(修正实时的数据)

丢弃

重启程序，做测试。

输入数据：

000001,1461756870000 
000001,1461756883000 
000001,1461756870000 
000001,1461756871000 
000001,1461756872000

KeyEvent TimecurrentMaxTimestamepcurrentWatermarkwindow start timewindow end time
00000119:34:3019:34:3019:34:20
00000119:34:4319:34:4319:34:33[19:34:3019:34:33)
00000119:34:3019:34:4319:34:33[19:34:3019:34:33)
00000119:34:3119:34:4319:34:33[19:34:3019:34:33)
00000119:34:3219:34:4319:34:33[19:34:3019:34:33)

发现迟到太多数据就会被丢弃

指定允许再次迟到的时间

).assignTimestampsAndWatermarks(new EventTimeExtractor() )
               .keyBy(0)
                .timeWindow(Time.seconds(3)) 
               .allowedLateness(Time.seconds(2)) // 允许事件迟到 2 秒
                .process(new SumProcessWindowFunction())
                .print().setParallelism(1);

输入数据

000001,1461756870000 
000001,1461756883000

000001,1461756870000 
000001,1461756871000 
000001,1461756872000
000001,1461756884000

000001,1461756870000 
000001,1461756871000 
000001,1461756872000
000001,1461756885000

000001,1461756870000 
000001,1461756870000 
000001,1461756872000
  • 1. 当我们设置允许迟到 2 秒的事件，第一次 window 触发的条件是 watermark >= window_end_time
  • 2. 第二次(或者多次)触发的条件是 watermark < window_end_time + allowedLateness

收集迟到的数据

/**
 * 需求：3秒一个窗口，进行单词计数
 *
 * 指定延迟时间
 * 收集延迟数据
 */
public class WindowWordCountByWaterMark4 {
    public static void main(String[] args) throws  Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //步骤一：设置时间类型
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        //设置waterMark产生的周期为1s
        env.getConfig().setAutoWatermarkInterval(1000);

        DataStreamSource<String> dataStream = env.socketTextStream("bigdata02", 1234);

        //步骤一：声明这样的一个数据结构
        OutputTag<Tuple2<String, Long>> outputTag = new OutputTag<Tuple2<String, Long>>("late-date"){};

        SingleOutputStreamOperator<String> result = dataStream.map(new MapFunction<String, Tuple2<String, Long>>() {
            @Override
            public Tuple2<String, Long> map(String line) throws Exception {
                String[] fields = line.split(",");
                return new Tuple2<>(fields[0], Long.valueOf(fields[1]));
            }
            //步骤二：获取数据里面的event Time
        }).assignTimestampsAndWatermarks(new EventTimeExtractor())
                .keyBy(0)
                .timeWindow(Time.seconds(3))
             //   .allowedLateness(Time.seconds(2)) // 允许事件迟到 2 秒
                .sideOutputLateData(outputTag) //保留迟到太多的数据
                .process(new SumProcessWindowFunction());
        //打印结果数据
        result.print();


        /**
         *
         * 处理延迟的数据：
         * 1. 准备另外一个延迟的topic（Kafka，磁盘，数据库）
         *
         * 不会有太多，如果没有太多，其实结果影响不大。
         *
         *
         * 实时的任务，大多数的情况就是为了看这个趋势而已。
         *
         *
         */
        result.getSideOutput(outputTag).map(new MapFunction<Tuple2<String,Long>, String>() {
            @Override
            public String map(Tuple2<String, Long> stringLongTuple2) throws Exception {
                return "迟到数据："+stringLongTuple2.toString();
            }
        }).print();

        env.execute("WindowWordCountByWaterMark3");

    }

    /**
     * IN, OUT, KEY, W
     * IN：输入的数据类型
     * OUT：输出的数据类型
     * Key：key的数据类型（在Flink里面，String用Tuple表示）
     * W：Window的数据类型
     */
    public static class SumProcessWindowFunction extends
            ProcessWindowFunction<Tuple2<String,Long>,String,Tuple,TimeWindow> {
        FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss");
        /**
         * 当一个window触发计算的时候会调用这个方法
         * @param tuple key
         * @param context operator的上下文
         * @param elements 指定window的所有元素
         * @param out 用户输出
         */
        @Override
        public void process(Tuple tuple, Context context, Iterable<Tuple2<String, Long>> elements,
                            Collector<String> out) {
            System.out.println("处理时间：" + dateFormat.format(context.currentProcessingTime()));
            System.out.println("window start time : " + dateFormat.format(context.window().getStart()));

            List<String> list = new ArrayList<>();
            for (Tuple2<String, Long> ele : elements) {
                list.add(ele.toString() + "|" + dateFormat.format(ele.f1));
            }
            out.collect(list.toString());
            System.out.println("window end time  : " + dateFormat.format(context.window().getEnd()));

        }
    }

    private static class EventTimeExtractor
            implements AssignerWithPeriodicWatermarks<Tuple2<String, Long>> {
        FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss");
        private long currentMaxEventTime=0L;
        private long maxOufOfOrderness=10000;//最大乱序时间
        @Nullable
        @Override
        public Watermark getCurrentWatermark() {
            return new Watermark(currentMaxEventTime - maxOufOfOrderness);
        }

        @Override
        public long extractTimestamp(Tuple2<String, Long> element, long timeStamp) {
            Long currentElementTime = element.f1;
            currentMaxEventTime = Math.max(currentMaxEventTime,currentElementTime);

            System.out.println("event = " + element
                    + "|" + dateFormat.format(element.f1) // Event Time
                    + "|" + dateFormat.format(currentMaxEventTime)  // Max Event Time
                    + "|" + dateFormat.format(getCurrentWatermark().getTimestamp())); // Current Watermark

            return currentElementTime;
        }
    }
}

1.7 多并行度下的WaterMark


一个window可能会接受到多个waterMark，我们以小的为准。

/**
 * 需求：3秒一个窗口，进行单词计数
 *
 * 多并行度下多watermark
 *
 * 000001,1461756870000
 * 000001,1461756883000
 * 000001,1461756888000
 *
 */
public class WindowWordCountByWaterMark5 {
    public static void main(String[] args) throws  Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //步骤一：设置时间类型
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

        env.setParallelism(2);

        DataStreamSource<String> dataStream = env.socketTextStream("bigdata02", 1234);


        OutputTag<Tuple2<String, Long>> outputTag = new OutputTag<Tuple2<String, Long>>("late-date"){};

        SingleOutputStreamOperator<String> result = dataStream.map(new MapFunction<String, Tuple2<String, Long>>() {
            @Override
            public Tuple2<String, Long> map(String line) throws Exception {
                String[] fields = line.split(",");
                return new Tuple2<>(fields[0], Long.valueOf(fields[1]));
            }
            //步骤二：获取数据里面的event Time
        }).assignTimestampsAndWatermarks(new EventTimeExtractor())
                .keyBy(0)
                .timeWindow(Time.seconds(3))
//                .allowedLateness(Time.seconds(2)) // 允许事件迟到 2 秒
                .sideOutputLateData(outputTag) //保留迟到太多的数据
                .process(new SumProcessWindowFunction());
        //打印结果数据
        result.print();



        result.getSideOutput(outputTag).map(new MapFunction<Tuple2<String,Long>, String>() {
            @Override
            public String map(Tuple2<String, Long> stringLongTuple2) throws Exception {
                return "迟到数据："+stringLongTuple2.toString();
            }
        }).print();

        env.execute("WindowWordCountByWaterMark3");

    }

    /**
     * IN, OUT, KEY, W
     * IN：输入的数据类型
     * OUT：输出的数据类型
     * Key：key的数据类型（在Flink里面，String用Tuple表示）
     * W：Window的数据类型
     */
    public static class SumProcessWindowFunction extends
            ProcessWindowFunction<Tuple2<String,Long>,String,Tuple,TimeWindow> {
        FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss");
        /**
         * 当一个window触发计算的时候会调用这个方法
         * @param tuple key
         * @param context operator的上下文
         * @param elements 指定window的所有元素
         * @param out 用户输出
         */
        @Override
        public void process(Tuple tuple, Context context, Iterable<Tuple2<String, Long>> elements,
                            Collector<String> out) {
            System.out.println("处理时间：" + dateFormat.format(context.currentProcessingTime()));
            System.out.println("window start time : " + dateFormat.format(context.window().getStart()));

            List<String> list = new ArrayList<>();
            for (Tuple2<String, Long> ele : elements) {
                list.add(ele.toString() + "|" + dateFormat.format(ele.f1));
            }
            out.collect(list.toString());
            System.out.println("window end time  : " + dateFormat.format(context.window().getEnd()));

        }
    }

    private static class EventTimeExtractor
            implements AssignerWithPeriodicWatermarks<Tuple2<String, Long>> {
        FastDateFormat dateFormat = FastDateFormat.getInstance("HH:mm:ss");
        private long currentMaxEventTime=0L;
        private long maxOufOfOrderness=10000;//最大乱序时间
        @Nullable
        @Override
        public Watermark getCurrentWatermark() {
            return new Watermark(currentMaxEventTime - maxOufOfOrderness);
        }

        @Override
        public long extractTimestamp(Tuple2<String, Long> element, long timeStamp) {
            Long currentElementTime = element.f1;
            currentMaxEventTime = Math.max(currentMaxEventTime,currentElementTime);

            long id = Thread.currentThread().getId();

            System.out.println("当前线程id="+id+" event = " + element
                    + "|" + dateFormat.format(element.f1) // Event Time
                    + "|" + dateFormat.format(currentMaxEventTime)  // Max Event Time
                    + "|" + dateFormat.format(getCurrentWatermark().getTimestamp())); // Current Watermark

            return currentElementTime;
        }
    }
}

  • ID为58的线程有两个WaterMark：20,38
    那么38这个会替代20，所以ID为58的线程的WaterMark是38

  • 然后ID为57的线程的WaterMark是33，而ID为58是WaterMark是38，会在里面求一个小的值作为 waterMark，就是33，这个时候会触发Window为30-33的窗口，那这个窗口里面就有 (000001,1461756870000)这条数据。

之乎者也·
关注
  • 24
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
flink cdc 2.0.2 针对mysql Date类型数据的解决思路
qq_31866793的博客
11-10 9119
1，实践了flinkcdc的小伙伴肯定会遇到时间字段的问题，以mysql作为数据源为案例 我们读取的数据为Date类型 实际打印写入doris之后发现是： 2，在社区里询问通过issues了解到 Flink-CDC 在同步字段为timestamp类型的数据时，初始化数据和增量数据时区不一致 · Issue #317 · ververica/flink-cdc-connectors · GitHub 从这里我找到了自己想要的信息： 3，我们找到RowDataDebe...
【Flink篇07】Flink之时间语义和WaterMark1
08-04
在Flink的流处理框架中，时间语义是至关重要的概念，主要分为三种类型：Event Time、Ingestion Time和Processing Time。理解这些时间语义对于正确处理实时数据流至关重要。 1. Event Time：事件时间是事件实际发生...
写给大忙人的Flink的Data Types
shengjk1的博客
03-16 1320
一.Flink 中 Data Type 组成 基本数据类型：java 的 8 中基本数据类型加上它们各自的包装类型，在加上 void , String, Date,BigDecimal, BigInteger. 基本数据类型的数据和 Object 类型的数组 复合类型 Flink Java Tuples scala case classes Row POJOs: 如果要被 Flink...
5、Flink事件时间之Watermark详解
最新发布
猫猫爱吃小鱼粮
04-26 1744
Flink事件时间之Watermark详解
【flink 床头书系列】data Types 数据类型词典
wang2leee的博客
10-15 350
Flink SQL提供了丰富的本地数据类型供用户使用。
Flink支持的数据类型
互联网知识分享
08-02 853
支持多种不同的数据类型，包括基本数据类型、复合数据类型、集合类型和特殊数据类型。上述代码首先创建了一个执行环境，然后从给定的元素创建了一个数据流。时，可以通过指定数据类型来实现类型安全，并在处理过程中进行相关的转换和操作。最后，将处理后的结果打印出来，并执行任务。是一个流处理和批量处理框架，支持多种不同的数据类型。中的一个特殊类，用于定义不可变的数据结构。）：有序的集合，可以包含重复的元素。）：键值对的集合，每个键对应一个值。）：由相同类型的元素组成的有序集合。）：无序的集合，不包含重复的元素。
Flink之Flink程序开发过程与Flink常见数据类型
积跬步，至千里。
10-13 988
DataStream API是Flink中最主要的API之一，它支持高级的流处理操作，例如窗口计算、状态管理、流分区等，并且在处理大规模数据时表现出色。
flink多并行数据源下的waterMark触发机制1.pdf
01-22
然而，在处理多并行数据源时，Flink 需要一种机制来触发 watermark，以便正确地处理事件时间。这篇文章将深入探讨 Flink 多并行数据源下的 WaterMark 触发机制。 在 Flink 中，WaterMark 是一种特殊的 timestamp，...
Flink SQL大数据项目实战（基于Flink1.14.3版本）
09-15
分享课程——《Flink SQL大数据项目实战》，2022新课，基于Flink1.14.3版本。提供视频配套的源码和文档下载！ Flink SQL大数据项目实战课程以FlinkSQL流批一体技术为主线，全面讲解Flink Table编程、SQL编程、Time...
大数据开发｜Flink中的窗口分类和生命周期
11-06
在处理窗口时，Flink 还提供了丰富的触发器（Triggers）和窗口生命周期管理机制，如 early firing（提前触发）、late firing（延迟触发）以及水印（Watermark）机制，这些都用于处理乱序事件和确保数据完整性。...
大数据技术之Flink教程
04-02
- **Time Semantics & Watermark**：Flink的时间语义确保正确处理乱序事件，Watermark机制用来处理延迟事件，保证处理时间与事件时间的一致性。 **ProcessFunction API（底层API）** ProcessFunction允许用户...
FLinkCDC读取MySQl中的日期问题
YPeiQi的博客
04-20 1816
在通过FlinkCDC读取MySQL的BinLog日志的时候，发现读取到日期类型的数据和数据库中存储的相差八小时。flink版本：1.15.1，MySQLCDC版本：2.3.0如下图。自定义时间转换配置。
Flink的时间类型和watermark机制
默硕的博客
04-09 345
Watermark是一个对Event Time的标识，内容方面Watermark是个时间戳，一个带有时间戳X的Watermark到达，相当于告诉Flink系统，Processing Time并不能保证确定性，它容易受到Event到达系统的速度（例如来自消息队列）以及数据在Flink系统内部处理的先后顺序的影响，首先如果这种事情出现的概率非常小，不影响所要求的准确度，除了把违反watermark机制的数据丢弃，也有不丢弃的处理方法，比如通过一些机制来更新之前统计的结果，这种方式会有一定的性能开销。
【Android IPC】序列化
dev晴天的博客
03-31 313
要点 serializable、parcelable接口可以完成对象序列化过程。 1、 当我们需要通过intent和Binder传输数据的时候，就需要使用serializable，或者parcelable。 2、我们需要把对象持久化到设备上，或者通过网络传输给其他客户端这时候也需要serializable来完成对象持久化。 一 、Serializable接口 1、简介： Serializab...
Flink1.10入门：时间机制简介
陆继森的技术专栏
04-12 447
微信公众号：大数据开发运维架构 关注可了解更多大数据相关的资讯。问题或建议，请公众号留言; 如果您觉得“大数据开发运维架构”对你有帮助，欢迎转发朋友圈 一、概述 上篇文章介绍了Window窗口机制的相关知识，这里我们介绍下Flink的另外一个核心概念“Event Time机制”，本篇文章只介绍相关概念不讲实战，实战会结合Window窗口机制一起讲解。 二、Flink中的三...
Flink -- 事件时间 & Watermark
加油
11-06 534
上图表示的是以Flink的流程图，图中总共有两个并行度，每一个Task上面都带着任务的时间，在Flink中，会将任务的时间向后传递，当途中上游map（1）将任务时间传递给下游window（1）时，下面的上游map（2）也会任务时间传递给下游window（1）（上游的任务是并行的），此时下游window（1）就会产生两个任务时间，此时就会选择时间最小的时间的作为水位线。在使用事件时间的时候需要注意的是打入数据的数据时间是需要按照时间的顺序打入，否则数据就会丢失（也可以不按照顺序打入，后面有解决办法）
Flink的时间类型和窗口概述，助你进阶Flink，畅游大数据时代
m0_60666921的博客
04-01 859
其它面试题（springboot、mybatis、并发、java中高级面试总结等）中…(img-MvAaC4Dz-1711903754980)]既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
Flink基础知识 ---事件时间与处理时间
happyfreeangel的博客
11-11 2839
事件时间与处理时间要谈论无限数据处理，需要清楚地了解所涉及的时间域。在任何数据处理系统中，通常有两个我们关心的时间域：事件时间这是事件实际发生的时间。 处理时间这是在系统中观察事件的时间。 并非所有的用例都关心事件时间（如果你的事情没有，那么万岁！你的生活会更容易），但很多人都这么做。示例包括表征用户随时间的行为，大多数计费应用程序以及许多类型的异常检测，仅举几例。 在理想的世界中，事件时间和处理...
Flink时间窗口详解：从ProcessingTime到EventTime与Watermark
总结起来，这份《Flink Time深度解析》文档为Flink用户提供了宝贵的知识，涵盖了从基础概念到高级技术的全面讲解，适合对实时流处理和时间窗口处理感兴趣的开发者深入学习和实践。收藏此文档将有助于提升在Flink项目...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

之乎者也·

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值