第九章 Flink高阶之迟到无序数据处理代码实战

已于 2023-03-20 22:04:15 修改
阅读量370 收藏 1
点赞数
分类专栏： # Flink专题 文章标签： flink hbase big data
于 2021-11-18 10:18:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27924553/article/details/121394712
版权

1、WaterMark机制

  • Watermark机制：由某个算子操作生成，在整个程序中随event数据流转
Watermaker = 当前计算窗⼝最⼤的事件时间 - 允许乱序延迟的时间
  • 触发计算时机：
1、:Watermaker >= Window EndTime窗⼝结束时间
2、:当前计算窗⼝最⼤的事件时间 - 允许乱序延迟的时间 >=Window EndTime窗⼝结束时间

（1）需求

需求:分组统计不同视频的成交价,数据有乱序延迟,允许3秒延迟

（2）代码实战：watermark+window机制

package com.lihaiwei.text1.app;

import com.lihaiwei.text1.util.TimeUtil;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.datastream.DataStream;
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.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 javax.print.DocFlavor;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;

public class flink08watermark {
    public static void main(String[] args) throws Exception {
        // 1、构建流环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        // 2、从socket中读取数据
        DataStream<String> DS = env.socketTextStream("192.168.6.104",8088);

        // 3、将输入数据(java,2022-11-11 09-10-10,12)转为tuple3类型
        SingleOutputStreamOperator<Tuple3<String, String, Integer>> flatmapDS = DS.flatMap(new FlatMapFunction<String, Tuple3<String, String, Integer>>() {
            @Override
            public void flatMap(String value, Collector<Tuple3<String, String, Integer>> out) throws Exception {
                // 3.1、将字符串切割为数组
                String[] arr = value.split(",");
                // 3.2、使用收集器收集到tuple中
                out.collect(Tuple3.of(arr[0],arr[2],Integer.parseInt(arr[2])));
            }
        });
        // 4、指定特定列为eventtime,进行watermark生成
        SingleOutputStreamOperator<Tuple3<String, String, Integer>> watermarkDS = flatmapDS.assignTimestampsAndWatermarks(WatermarkStrategy
                // 4.1、指定允许最大延迟乱序时间
                .<Tuple3<String, String, Integer>>forBoundedOutOfOrderness(Duration.ofSeconds(3))
                // 4.2、指定water的时间语义及时间时间列
                .withTimestampAssigner((event, timestamp) -> TimeUtil.strToDate(event.f1).getTime()));
        // 5、分组开窗统计
        SingleOutputStreamOperator<String> sumDS = watermarkDS.keyBy(new KeySelector<Tuple3<String, String, Integer>, String>() {
            @Override
            public String getKey(Tuple3<String, String, Integer> value) throws Exception {
                return value.f0;
            }
        })
                // 开窗
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                // 聚合
                .apply(new WindowFunction<Tuple3<String, String, Integer>, String, String, TimeWindow>() {
                    @Override
                    public void apply(String key, TimeWindow window, Iterable<Tuple3<String, String, Integer>> input, Collector<String> out) throws Exception {
                        // 准备list,存放窗口的事件时间
                        List<String> timeList = new ArrayList<>();
                        int total = 0;
                        //遍历数据集,
                        for(Tuple3<String,String,Integer> order:input){
                            timeList.add(order.f1);
                            total = total + order.f2;
                        }
                        String outStr = String.format("分组key:%s,聚合值:%s,窗⼝开始结束:[%s~%s),窗⼝所有事件时 间:%s", key,total,TimeUtil.format(window.getStart()),TimeUtil.format(window.getEnd()), timeList);
                        out.collect(outStr);
                    }
                });
        // 6、打印输出
        sumDS.print();

        // 7、命名Job并提交
        env.execute("watermark job");
    }
}

（3）代码调试过程

  • 开启sokect
nc -lk 9999
  • 窗口一
// 窗口一[12:00,12:10)
java,2022-11-11 23:12:07,10  // NO
java,2022-11-11 23:12:11,10  // NO,在另一个窗口
java,2022-11-11 23:12:08,10  // NO
mysql,2022-11-11 23:12:13,10 //YES,在另一个窗口
  • 窗口二
// 窗口二[12:10,12:20)
java,2022-11-11 23:12:13,10  // NO
java,2022-11-11 23:12:17,10  // NO
java,2022-11-11 23:12:09,10  // NO,数据丢弃
java,2022-11-11 23:12:20,10  // NO,数据在第三个窗口
java,2022-11-11 23:12:22,10  // NO,数据在第三个窗口
java,2022-11-11 23:12:23,10  // YES,数据在第三个窗口
  • 运行结果

在这里插入图片描述

2、allowLateness机制 - 二次兜底

  • 应用场景：超过了watermark的等待，然后配置allowedLateness 再延⻓时间，然后到了后更新之前的窗⼝数据；
DataStream.window("窗口时间")
    	  .allowedLateness("允许时间")
          .apply("全窗口聚合")

（1）代码实战

package com.lihaiwei.text1.app;

import com.lihaiwei.text1.util.TimeUtil;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.datastream.DataStream;
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.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 javax.print.DocFlavor;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;

public class flink08watermark {
    public static void main(String[] args) throws Exception {
        // 1、构建流环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        // 2、从socket中读取数据
        DataStream<String> DS = env.socketTextStream("192.168.6.104",9999);

        // 3、将输入数据(java,2022-11-11 09-10-10,12)转为tuple3类型
        SingleOutputStreamOperator<Tuple3<String, String, Integer>> flatmapDS = DS.flatMap(new FlatMapFunction<String, Tuple3<String, String, Integer>>() {
            @Override
            public void flatMap(String value, Collector<Tuple3<String, String, Integer>> out) throws Exception {
                // 3.1、将字符串切割为数组
                String[] arr = value.split(",");
                // 3.2、使用收集器收集到tuple中
                out.collect(Tuple3.of(arr[0],arr[1],Integer.parseInt(arr[2])));
            }
        });
        // 4、指定特定列为eventtime,进行watermark生成
        SingleOutputStreamOperator<Tuple3<String, String, Integer>> watermarkDS = flatmapDS.assignTimestampsAndWatermarks(WatermarkStrategy
                // 4.1、指定允许最大延迟乱序时间
                .<Tuple3<String, String, Integer>>forBoundedOutOfOrderness(Duration.ofSeconds(3))
                // 4.2、指定water的时间语义及时间时间列
                .withTimestampAssigner((event, timestamp) -> TimeUtil.strToDate(event.f1).getTime()));
        // 5、分组开窗统计
        SingleOutputStreamOperator<String> sumDS = watermarkDS.keyBy(new KeySelector<Tuple3<String, String, Integer>, String>() {
            @Override
            public String getKey(Tuple3<String, String, Integer> value) throws Exception {
                return value.f0;
            }
        })
                // 开窗
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                // 允许一分钟延迟
                .allowedLateness(Time.minutes(1))
                // 聚合
                .apply(new WindowFunction<Tuple3<String, String, Integer>, String, String, TimeWindow>() {
                    @Override
                    public void apply(String key, TimeWindow window, Iterable<Tuple3<String, String, Integer>> input, Collector<String> out) throws Exception {
                        // 准备list,存放窗口的事件时间
                        List<String> timeList = new ArrayList<>();
                        int total = 0;
                        //遍历数据集,
                        for(Tuple3<String,String,Integer> order:input){
                            timeList.add(order.f1);
                            total = total + order.f2;
                        }
                        String outStr = String.format("分组key:%s,聚合值:%s,窗⼝开始结束:[%s~%s),窗⼝所有事件时 间:%s", key,total,TimeUtil.format(window.getStart()),TimeUtil.format(window.getEnd()), timeList);
                        out.collect(outStr);
                    }
                });
        // 6、打印输出
        sumDS.print();

        // 7、命名Job并提交
        env.execute("watermark job");
    }
}

（2）调试结果

  • 窗口一
// 窗口一[12:00,12:10)
java,2022-11-11 23:12:07,10  // NO
java,2022-11-11 23:12:11,10  // NO,在另一个窗口
java,2022-11-11 23:12:08,10  // NO
mysql,2022-11-11 23:12:13,10 //YES,在另一个窗口
  • 窗口二
// 窗口二[12:10,12:20)
java,2022-11-11 23:12:13,10  // NO
java,2022-11-11 23:12:17,10  // NO
java,2022-11-11 23:12:09,10  // YES,触发窗口一更新计算
java,2022-11-11 23:12:20,10  // NO,数据在第三个窗口
java,2022-11-11 23:12:22,10  // NO,数据在第三个窗口
java,2022-11-11 23:12:23,10  // YES,数据在第三个窗口
  • 运行结果

在这里插入图片描述

3、sideOutPut机制 - 最后兜底

  • 应用场景：超过了watermark的等待，到了后更新之前的窗⼝数据数据超过了allowedLateness 后，⽤侧输出流 SideOutput
// 1、new旁路输出对象



DataStream.window("窗口时间")
    	  .allowedLateness("允许时间")
    	  .sideOutputLateData("旁路输出对象")
          .apply("全窗口聚合")

（1）代码实战

package com.lihaiwei.text1.app;

import com.lihaiwei.text1.util.TimeUtil;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.datastream.DataStream;
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.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 javax.print.DocFlavor;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;

public class flink08watermark {
    public static void main(String[] args) throws Exception {
        // 1、构建流环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        // 2、从socket中读取数据
        DataStream<String> DS = env.socketTextStream("192.168.6.104",8888);

        // 3、将输入数据(java,2022-11-11 09-10-10,12)转为tuple3类型
        SingleOutputStreamOperator<Tuple3<String, String, Integer>> flatmapDS = DS.flatMap(new FlatMapFunction<String, Tuple3<String, String, Integer>>() {
            @Override
            public void flatMap(String value, Collector<Tuple3<String, String, Integer>> out) throws Exception {
                // 3.1、将字符串切割为数组
                String[] arr = value.split(",");
                // 3.2、使用收集器收集到tuple中
                out.collect(Tuple3.of(arr[0],arr[1],Integer.parseInt(arr[2])));
            }
        });
        // 4.1、指定特定列为eventtime,进行watermark生成
        SingleOutputStreamOperator<Tuple3<String, String, Integer>> watermarkDS = flatmapDS.assignTimestampsAndWatermarks(WatermarkStrategy
                // 4.1、指定允许最大延迟乱序时间
                .<Tuple3<String, String, Integer>>forBoundedOutOfOrderness(Duration.ofSeconds(3))
                // 4.2、指定water的时间语义及时间时间列
                .withTimestampAssigner((event, timestamp) -> TimeUtil.strToDate(event.f1).getTime()));
        // 4.2、旁路输出对象
        OutputTag<Tuple3<String,String,Integer>> latedata = new OutputTag<Tuple3<String, String, Integer>>("latedate");

        // 5、分组开窗统计
        SingleOutputStreamOperator<String> sumDS = watermarkDS.keyBy(new KeySelector<Tuple3<String, String, Integer>, String>() {
            @Override
            public String getKey(Tuple3<String, String, Integer> value) throws Exception {
                return value.f0;
            }
        })
                // 开窗
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                // 允许一分钟延迟
                .allowedLateness(Time.minutes(1))
                // 旁路输出
                .sideOutputLateData(latedata)
                // 聚合
                .apply(new WindowFunction<Tuple3<String, String, Integer>, String, String, TimeWindow>() {
                    @Override
                    public void apply(String key, TimeWindow window, Iterable<Tuple3<String, String, Integer>> input, Collector<String> out) throws Exception {
                        // 准备list,存放窗口的事件时间
                        List<String> timeList = new ArrayList<>();
                        int total = 0;
                        //遍历数据集,
                        for(Tuple3<String,String,Integer> order:input){
                            timeList.add(order.f1);
                            total = total + order.f2;
                        }
                        String outStr = String.format("分组key:%s,聚合值:%s,窗⼝开始结束:[%s~%s),窗⼝所有事件时 间:%s", key,total,TimeUtil.format(window.getStart()),TimeUtil.format(window.getEnd()), timeList);
                        out.collect(outStr);
                    }
                });
        // 6.1、打印输出
        sumDS.print();
        // 6.2、输出旁路对象
        sumDS.getSideOutput(latedata).print();

        // 7、命名Job并提交
        env.execute("watermark job");
    }
}

（2）调试结果

  • 窗口一
// 窗口一[12:00,12:10)
java,2022-11-11 23:12:07,10  // NO
java,2022-11-11 23:12:11,10  // NO,在另一个窗口
java,2022-11-11 23:12:08,10  // NO
mysql,2022-11-11 23:12:13,10 //YES,在另一个窗口
  • 窗口二
// 窗口二[12:10,12:20)
java,2022-11-11 23:12:17,10  // NO
java,2022-11-11 23:12:09,10  // YES,触发窗口一更新计算
java,2022-11-11 23:12:20,10  // NO,数据在第三个窗口
java,2022-11-11 23:12:22,10  // NO,数据在第三个窗口
java,2022-11-11 23:12:23,10  // YES,数据在第三个窗口
  • 窗口三
// 窗口二[12:20,12:30)
java,2022-11-11 23:13:20,10  // YES,数据在第四个窗口
java,2022-11-11 23:12:01,10  // NO,数据在旁路输出
  • 运行结果

在这里插入图片描述

4、多层保证措施归纳

  • flink采用watermark、allowedLateness()、sideOutoutLateDate()三个机制保证获取数据
4.1、原理

①watermark：防⽌数据出现延迟乱序，允许等待⼀会 再触发窗⼝计算，将其输出；

②allowLateness：将窗⼝关闭时间再延迟⼀段时间，这期间迟到数据会通过allowLateness主动更新watermark输出的局部数据从而将其修复；

③sideOutPut：超过allowLateness后，窗⼝已 经彻底关闭了，就会把数据放到侧输出；

4.2、应用场景

  • watermark及时输出数据

  • allowLateness 做短期的更新迟到数据

  • sideOutPut做兜底更新保证数据准确性

4.3、Flink机制相关

（1）第一层 - DataStream

  • 从DataStream数据流⾥指定范围获取数据；

（2）第二层 - Watermark

  • 是防⽌数据出现乱序延迟，允许窗口等待延迟数据达到，再触发计算；

（3）第三层 - allowLateness

  • 会让窗⼝关闭时间再延迟⼀段时间, 如 果还有数据达到，会局部修复数据并主动更新窗⼝的数据输出；

（4）第四层 - sideOutPut

  • 在窗⼝已经彻底关闭后，所有过期延迟数据放到侧输出流，可以单独获取， 存储到某个地⽅再批量更新之前的聚合的数据；
随缘清风殇
关注
专栏目录
Flink 如何现实新的流处理应用第一部分:事件时间与无序处理
SmartSi
01-15 198
流数据处理正处于蓬勃发展中，可以提供更实时的数据以实现更好的数据洞察，同时从数据中进行分析的流程更加简化。在现实世界中数据生产是一个连续不断的过程(例如，Web服务器日志，移动应用程序中的用户活跃，数据库事务或者传感器读取的数据)。正如其他人所指出的，到目前为止，大部分数据架构都是建立在数据是有限的、静态的这样的基本假设之上。为了缩减连续数据生产和旧"批处理"系统局限性之间的这一根本差距，引入了复杂而脆弱(fragile)的端到端管道。现代流处理技术通过以现实世界事件产生的形式对数据进行建模和处理，从而减轻
【Flink】迟到数据的处理
qq_43744420的博客
08-11 1876
【Flink】迟到数据的处理
Flink 数据分析批处理java代码和scala代码
XGkerwin1的博客
05-29 314
数据流分析批处理
flink最佳实战
qq_44962429的博客
01-10 628
最佳实践 此页面包含Flink程序员有关如何解决常见问题的最佳实践的集合。 解析命令行参数并在Flink应用程序中传递它们 将您的配置值放入 ParameterTool 在Flink程序中使用参数 命名大型TupleX类型 使用Logback代替Log4j 在IDE中/从Java应用程序中运行Flink时使用Logback 在群集上运行Flink时使用Logback 解析命令行参数...
Flink实战（三）
weixin_42529806的博客
03-02 1142
文章目录Flink编程模型Flink分层架构Flink核心组件Flink分层架构Flink DataFlowFlink DataFlow基本套路 Flink编程模型 Flink分层架构 Flink核心组件 核心组件 Flink分层架构 Stateful Stream Processing 位于最底层，是core API的底层实现 Processing Function 利用低阶，构建...
Flink 流处理和批处理测试小代码
weixin_40817778的博客
07-30 264
批处理： import org.apache.flink.api.common.functions.FlatMapFunction; import org.apache.flink.api.java.DataSet; import org.apache.flink.api.java.ExecutionEnvironment; import org.apache.flink.api.java.operators.DataSource; import org.apache.flink.api.java.tu
《Flink大数据分析实战》随书示例代码
最新发布
07-04
《Flink大数据分析实战》随书示例代码涵盖了Flink在大数据处理领域的核心技术和实践应用。这本书通过实际的代码示例，旨在帮助读者深入理解Flink的架构、API使用以及在数据分析中的各种策略。以下是对这些示例代码的...
Flink-构建下一代大数据处理引擎
10-13
总的来说，Apache Flink作为下一代大数据处理引擎，以其强大的实时处理能力、数据多样性和高可用性，正逐渐成为业界首选的解决方案。无论是大型企业如阿里巴巴，还是快速增长的创业公司如滴滴，乃至内容丰富的社区...
JAVA大数据流处理Flink代码.zip
02-03
这个名为 "JAVA大数据流处理Flink代码.zip" 的压缩包很可能包含了一系列用 Java 编写的 Flink 示例代码，用于演示如何在实际项目中应用 Flink 技术。Flink 的核心特性包括事件时间处理、窗口机制、状态管理和容错...
Flink批处理WordCount代码实现
qq_59336423的博客
06-22 310
1.在Idea工程根目录下新建一个 input 文件夹，并在下面创建文本文件 words.txt2.在 words.txt 中输入一些文字，例如： 3.在 com.atguigu.chapter02 包下新建 Java 类 BatchWordCount，在静态 main 方法中编 写测试代码。我们进行单词频次统计的基本思路是：先逐行读入文件数据，然后将每一行文字拆分成单 词；接着按照单词分组，统计每组数据的个数，就是对应单词的频次。...
Flink代码阅读之代码架构
define_us的专栏
02-08 288
flink-core 基础的内部数据定义 一些函数（function） The base interface for all user-defined functions. This interface is empty in order to allow extending interfaces to be SAM (single abstract method) interfaces that can be implemented via Java 8 lambdas. org.apache.flink
基于 Watermark 处理延迟数据
Poor - Because you have no ambition
10-22 1015
watermark 在用于基于时间的状态聚合操作时, 该时间可以基于窗口, 也可以基于 event-time本身.window输出模式必须是append或update. 在输出模式是complete的时候(必须有聚合), 要求每次输出所有的聚合结果. 我们使用 watermark 的目的是丢弃一些过时聚合数据, 所以complete模式使用wartermark无效也无意义.在输出模式是append。
Flink之数据乱序处理
datacreating的博客
03-14 2641
理想情况下，数据都是严格有序的，但现实中的数据往往都存在乱序的情况。
记 - Flink SQL Upsert Kafka Sink 数据乱序排查与解决思路【业务数据任意修改】
a123147abc的博客
07-18 2768
Flink SQL Upsert Kafka Sink 数据乱序
Flink(window time watermark)
我的祖传代码
04-01 1320
https://ci.apache.org/projects/flink/flink-docs-release-1.7/dev/stream/operators/windows.html 1 Time与Window 1.1 Flink中涉及的时间 Event Time：是事件创建的时间。它通常由事件中的时间戳描述，例如采集的日志数据中，每⼀条⽇志都会记录⾃己的生成时间，Flink通过时间...
Flink 最锋利的武器：Flink SQL 入门和实战
热门推荐
微信搜：import_bigdata，大数据领域硬核原创作者
06-21 8万+
一、Flink SQL 背景Flink SQL 是 Flink 实时计算为简化计算模型，降低用户使用实时计算门槛而设计的一套符合标准 SQL 语义的开发语言。自 2015...
不懂watermark？来吧～
大数据星球-浪尖
01-18 1107
经常有球友或者微信群友反馈自己搞不明白watermark怎么回事儿，所以今天浪尖准备发文详细说明一下。首先，拿基于窗口的计算来说吧，窗口的大小 size和滑动间隔 sli...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

随缘清风殇

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

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

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

打赏作者

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

抵扣说明：

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

余额充值