Flink基于watermarker和event time的window函数

最新推荐文章于 2023-01-13 00:03:34 发布
最新推荐文章于 2023-01-13 00:03:34 发布
阅读量564 收藏 1
点赞数 1
文章标签： flink window watermarker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42045791/article/details/93743249
版权

前言

近些年来Flink大有取代sparkstreaming的趋势，windows作为实时数据分析的核心函数，Flink加了watermarker水印的时间窗口函数在解决实时延时、乱序等问题上相对于sparkstreaming则完全胜出。
下面的示例介绍了flink是如何应用eventtime的watermarker从而实现我们的需求。

一、需求
flink接收kafka每5s传来的一条数据，实时不断的传入形成实时数据流，求下一条数据与上一条数据的差值。

数据：

time,1538359822000,data,T002.B026;1.000000;T001.A087;1.000000;T018.B026;1.00000;T002.B039;T002.B088;T002.B100
time,1538359827000,data,T002.B026;4.000000;T001.A087;4.000000;T018.B026;2.00000;T002.B039;T002.B088;T002.B100
time,1538359832000,data,T002.B026;6.000000;T001.A087;6.000000;T018.B026;5.00000;T002.B039;T002.B088;T002.B100
time,1538359837000,data,T002.B026;9.000000;T001.A087;9.000000;T018.B026;3.00000;T002.B039;T002.B088;T002.B100
time,1538359842000,data,T002.B026;11.000000;T001.A087;11.000000;T018.B026;9.00000;T002.B039;T002.B088;T002.B100
time,1538359847000,data,T002.B026;15.000000;T001.A087;15.000000;T018.B026;11.00000;T002.B039;T002.B088;T002.B100
time,1538359852000,data,T002.B026;20.000000;T001.A087;26.000000;T018.B026;20.00000;T002.B039;T002.B088;T002.B100
time,1538359857000,data,T002.B026;27.000000;T001.A087;27.000000;T018.B026;22.00000;T002.B039;T002.B088;T002.B100
time,1538359862000,data,T002.B026;29.000000;T001.A087;29.000000;T018.B026;26.00000;T002.B039;T002.B088;T002.B100

二、实现过程及详细步骤***

1、数据解析成窗口函数所需要的tuple3格式（全部代码都在main函数中）。

        int port = 9000;
        //获取运行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        //设置使用eventtime，默认是使用processtime
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

        //设置并行度为1,默认并行度是当前机器的cpu数量
        env.setParallelism(1);

        //连接socket获取输入的数据
        DataStream<String> text = env.socketTextStream("localhost", port, "\n");

        DataStream<Tuple3<String, String, HashMap<String, Object>>> data = text.map(new MapFunction<String, Tuple3<String, String, HashMap<String, Object>>>() {
            @Override
            public Tuple3<String, String, HashMap<String, Object>> map(String string) throws Exception {
                //构建map
                HashMap<String, Object> map = new HashMap<>();
                HashMap<String, Object> map2 = new HashMap<>();
                String[] split = string.split(",");
                map.put(split[0], split[1]);
                String[] split1 = split[3].split(";");
                map2.put(split1[0], split1[1] + "_" + split1[6]);
                map2.put(split1[2], split1[3] + "_" + split1[7]);
                map2.put(split1[4], split1[5] + "_" + split1[8]);
                map.put(split[2], map2);

                //map转tuple3
                Tuple3<String, String, HashMap<String, Object>> tuple3 = new Tuple3<>();
                for (String k : map.keySet()) {
                    if (k.equals("time")) {
                        String o = map.get(k).toString();
                        tuple3.setField(o, 1);
                    } else if (k.equals("data")) {
                        HashMap map3 = (HashMap) map.get(k);

                        tuple3.setField(map3, 2);
                        tuple3.setField("1", 0);

                    }
                }
                // System.out.println("tuple3:"+tuple3);
                return tuple3;
            }
        });

2、利用watermarker，解决延迟、乱序等问题，这里设置的最大允许的乱序时间是10s。

 
        DataStream<Tuple3<String, String, HashMap<String, Object>>> waterMarkStream = data.assignTimestampsAndWatermarks(new AssignerWithPeriodicWatermarks<Tuple3<String, String, HashMap<String, Object>>>() {
            //默认时间戳
            Long currentMaxTimestamp = 0L;
            //最大允许的乱序时间是10s
            Long maxOutOfOrderness = 10000L;

            //没100ms获取一次Watermark
            @Nullable
            @Override
            public Watermark getCurrentWatermark() {
                return new Watermark(currentMaxTimestamp - maxOutOfOrderness);
            }

            //提取时间戳timestamp
            @Override
            public long extractTimestamp(Tuple3<String, String, HashMap<String, Object>> element, long previousElementTimestamp) {
                //从数据中获取时间戳
                long timestamp = Long.parseLong(element.f1);
                currentMaxTimestamp = Math.max(timestamp, currentMaxTimestamp);
                return timestamp;
            }
        });

3、经过水印处理后的数据，才能进入时间窗口函数，window函数大致分为四种：ReduceFunction，AggregateFunction，FoldFunction，ProcessWindowFunction，该示例中应用的窗口函数为ReduceFunction，即进入窗口的函数可以进行聚合操作。需要注意的是，该函数的输入和输出是保持一致的。

    DataStream<Tuple3<String, String, HashMap<String, Object>>> amountAllStream = waterMarkStream 
            //进行以Tuple3的f0进行分组
            .keyBy(0)
            .window(SlidingEventTimeWindows.of(Time.seconds(10), Time.seconds(5)))
            .reduce(new ReduceFunction<Tuple3<String, String, HashMap<String, Object>>>() {
                @Override
                //Tuple3中Map<String, Object>的数据格式：
                //{T002.B026=1.000000_T002.B039, T001.A087=1.000000_T002.B088,T001.A087=1.000000_T002.B100}
                public Tuple3<String, String, HashMap<String, Object>> reduce(Tuple3<String, String, HashMap<String, Object>> t1, Tuple3<String, String, HashMap<String, Object>> t2) throws Exception {
                    Tuple3<String, String, HashMap<String, Object>> tu1 = new Tuple3<>();
                    //遍历t1
                    //Tuple3中t1第一条数据的map
                    HashMap<String, Object> map1 = t1.f2;
                    //Tuple3中t1第二条数据的map
                    HashMap<String, Object> map2 = t2.f2;
                    HashMap<String, Object> map3 = new HashMap<>();
                    //判断两条数据哪个时间戳是较小的
                    long min = Long.parseLong(t1.f1) > Long.parseLong(t2.f1) ? Long.parseLong(t2.f1) : Long.parseLong(t1.f1);
                    //如果第一条时间戳较小
                    if (Long.parseLong(t1.f1) == min) {
                        for (String k1 : map1.keySet()) {
                            //t2示值-t1示值=量值
                            //map1，map2：{T002.B026=1.000000_T002.B039, T001.A087=1.000000_T002.B088,T001.A087=1.000000_T002.B100}
                            Double i = Double.parseDouble(map2.get(k1).toString().split("_")[0]) -
                                    Double.parseDouble(map1.get(k1).toString().split("_")[0]);

                            // 把全部量值封装到map3中  {T007.B055=2.0}
                            //这里map2.get(k1)中的map2 是map1 map2都行 因为是相同的指标
                            map3.put(map2.get(k1).toString().split("_")[1], i);
                        }
                    }

                    //如果第二条时间戳较小
                    else if (Long.parseLong(t2.f1) == min) {
                        for (String k1 : map1.keySet()) {
                            //t1示值-t2示值=量值
                            Double i = Double.parseDouble(map1.get(k1).toString().split("_")[0]) -
                                    Double.parseDouble(map2.get(k1).toString().split("_")[0]);
                            //这里map2.get(k1)中的map2 是map1 map2都行 因为是相同的指标
                            map3.put(map2.get(k1).toString().split("_")[1], i);
                        }
                    }
                    String minn = String.valueOf(min);
                    //Tuple3< "data",minnTime,Map<String, Object>> 把量值赋给前一时间戳
                    tu1.setFields(t1.f0, minn, map3);
                    return tu1;

                }
            });

        //得到经过异常处理的量值

        DataStream<HashMap<String, Object>> amountExStream = amountAllStream.map(new MapFunction<Tuple3<String, String, HashMap<String, Object>>, HashMap<String, Object>>() {
            @Override
            public HashMap<String, Object> map(Tuple3<String, String, HashMap<String, Object>> tuple3) throws Exception {
                //得到全部量值
                HashMap<String, Object> map = tuple3.f2;
                HashMap<String, Object> excMap = new HashMap<>();
                HashMap<String, Object> excMap1 = new HashMap<>();

                for (String k1 : map.keySet()) {
                    //如果数据中不包含"_" ，就进行判断
                    if (!map.get(k1).toString().contains("_")) {
                        //非空判断
                        if (map.get(k1) != null && !("").equals(map.get(k1))) {
                            double i = Double.parseDouble((map.get(k1)).toString());
                            //如果小于0，把量值置0
                            if (i < 0) {
                                //YC为0  即把异常量值置零
                                excMap1.put(k1, 0);
                            } else {
                                excMap1.put(k1, i);
                            }
                        }
                    }
                }
                //把数据重新放入一个map中，还原到基础map格式
                //第一个是空的 判断如果为非空map
                if (excMap1.size() > 0) {
                    excMap.put("data", excMap1);
                    excMap.put("time", tuple3.f1);
                }
                //  {data={T002.B039=3.0, T002.B100=1.0, T002.B088=3.0}, time=1538359822000}
                return excMap;
            }
        });
        amountExStream.print();


env.execute();

最大允许乱序时间maxOutOfOrderness 设置为10s，窗口长度为10s，即最终延迟时间为20s，需等待第5条数据输入后第一条结果才会输出。当时间输入为1538359842000的时候，第一条数据的时间戳为1538359822000。

结果为：

{data={T002.B039=3.0, T002.B100=1.0, T002.B088=3.0}, time=1538359822000}
{data={T002.B039=2.0, T002.B100=3.0, T002.B088=2.0}, time=1538359827000}
{data={T002.B039=3.0, T002.B100=1.0, T002.B088=3.0}, time=1538359832000}
{data={T002.B039=2.0, T002.B100=3.0, T002.B088=2.0}, time=1538359837000}

三、注意

  • 利用eventtime来界定窗口的大小，sources中就必须带有时间戳；
  • 使用水印后面跟的必须是时间窗口；
  • 该maxOutOfOrderness为10s，可以尝试进行10s的乱序数据插入，验证watermarker的正确性。
一路走下去、
关注
FLINK 基于1.15.2的Java开发-Watermark是怎么解决延迟数据唯一正确的生产级解决方案-目前市面上的例子都有问题
lifetragedy的专栏
10-27 1251
flink的watermark目前在网上的博客的例子、说明其实没有一个是对的。很多连watermark的使用公式都错了，而这个错一直没有得到纠正。同时写的晦涩难懂，因此本人为了弥补这一块国内的空白以及apache官网这一块知识的不全便以一个生产实际例子贯穿了整个flink中最难懂的watermark知识，以供大家真正具备高级实时计算能力的学习所用
Flink之窗口函数以及watermark详解
weixin_49165958的博客
01-05 789
1 Time与Window 1.1 Flink中涉及的时间 - **Event Time**：是事件创建的时间。它通常由事件中的时间戳描述，例如采集的日志数据中，每⼀条⽇志都会记录⾃己的生成时间，Flink通过时间戳分配器访问事件时间戳。- **Ingestion Time**：是数据进入Flink的时间。- **Processing Time**：是每⼀个执行基于时间操作的算子的本地系统时间，与机器相关，默认的时间属性就是Processing Time。 ## 1.2 Window 1.2.1 Win
Flink---WaterMark机制
04stone37
12-20 969
背景  使用Event time时间模型时，由于网络或传输等原因，事件被Flink处理的顺序不一定是事件产生的顺序（乱序），可能会存在两方面影响： 当前窗口不知道何时停止，开始计算结果； 影响窗口计算结果的准确性，见示例； WaterMark机制  WaterMark本质上是一个带有时间戳的特殊event，当Flink中的运算符接收到水印时，它明白（假设）它不会看到比该时间戳更早的消息。  ...
Flink WaterMark
热门推荐
小杨的技术博客
03-27 2万+
文章目录背景概念window划分示例提取watermarkAssignerWithPeriodicWatermarksAssignerWithPunctuatedWatermarks使用设置数据流时间特征代码代码详解试验第一次第二次第三次第四次第五次第六次结论总结Flink如何处理乱序？Flink何时触发window？Flink应该如何设置最大乱序时间？参考 背景 实时计算中，数据时间比较敏感。...
flink watermark介绍
weixin_30781631的博客
10-09 132
转发请注明原创地址 http://www.cnblogs.com/dongxiao-yang/p/7610412.html 一 概念 watermark是flink为了处理eventTime窗口计算提出的一种机制,本质上也是一种时间戳，由flink souce或者自定义的watermark生成器按照需求定期或者按条件生成一种系统event，与普通数据流event一样流转到对应的下游...
Flink之WaterMarker详解
ChengYanan的博客
05-19 1362
前言 对于流计算来说，最核心的概念就是无穷数据集，而用来处理无穷数据集的计算就可以称为流计算。面对无穷数据集，有多种多样的处理方式，但是大致上可以分为四类： 1、时间无关：最基础的场景就是Filter，我们只关心我们想要的数据，这跟数据源是否是无穷的、失序都没有关系了。 2、近似算法：比如近似Top-N、流K-means聚类等。他们都以无穷数据为输入，并计算出差不多你想要的结果。 3、窗口：而窗口...
FlinkWindow和水印
小小鱼
04-18 175
文章目录Flink Window API1、TimeWindow1.1、滚动窗口1.2、滑动窗口（SlidingEventTimeWindows）2、CountWindow2.1、滚动窗口2.2、滑动窗口3、window function4、其它可选API5、窗口起始点的确认时间语义与 Wartermark1、Flink中的时间语义2、EventTime 的引入3、Watermark基本概念4、Watermark 的引入4.1、乱序数据的水印引入4.2、Assigner with periodic wate
Flink的Time故事 :EventTime/IngestTime/ProcessingTime
qq_34009542的博客
12-10 591
1. Time三兄弟 1.1 DataStream支持的三种time DataStream有大量基于time的operator，windows操作只是其中一种。 Flink支持三种time: 1.EventTime 2.IngestTime 3.ProcessingTime 1.2三个时间的比较 EventTime 1.事件生成时的时间，在进入Flink之前就已经存在，可以从event的字段中抽取。 2.必须指定watermarks（水位线）的生成方式。 3.优势：确定性.
Apache Flink（七）：Flink Window
qq_38310603的博客
11-20 186
Flink Window 窗口计算 窗口计算是流计算的核心，通过使用窗口对无限的流数据划分成固定大小的 buckets，然后基于落入同一个bucket（窗口）中的元素执行计算。Flink将窗口计算分为两大类: 基于keyed stream窗口计算，使用的窗口分配器为window 基于non-keyed stream窗口计算，使用的窗口分配器为windowAll Window Assigners...
【Flink】时间语义和水位线的概念和使用
weixin_43923463的博客
11-28 853
当Flink接收到数据时，会按照一定的规则去生成Watermark，这条Watermark就等于当前所有到达数据中的maxEventTime - 最大延迟时长 -1ms，也就是说，Watermark是基于数据携带的时间戳生成的，一旦Watermark比当前未触发的窗口的停止时间要晚，那么就会触发相应窗口的执行。的-4001ms的水位线，其不能够跳过这个算子向前传送。它通常由事件中的时间戳描述，例如采集的日志数据中，每一条日志都会记录自己的生成时间，Flink通过时间戳分配器访问事件时间戳。
WaterMarker
06-09
很好用的 水印文字 很好用的 水印文字 很好用的 水印文字 很好用的 水印文字 很好用的 水印文字 很好用的 水印文字
flink的watermarker理解
jia_yp的博客
04-02 1588
watermark是用于处理乱序事件的，而正确的处理乱序事件，通常用watermark机制结合window来实现。 我们知道，流处理从事件产生，到流经source，再到operator，中间是有一个过程和时间的。虽然大部分情况下，流到operator的数据都是按照事件产生的时间顺序来的，但是也不排除由于网络、背压等原因，导致乱序的产生（out-of-order或者说late element）。 但是对于late element，我们又不能无限期的等下去，必须要有个机制来保证一个特定的时间后，必须触发wi
flink核心之watermarker
神技圈子的博客
06-27 539
讲师介绍： 张涛，现任阿里巴巴集团的技术专家，2012工作即入职大厂，有着丰富的大型分布式系统研发经验，尤其擅长分布式原理与数据结构，并有着多年带团队经验。在多个大厂就职且担任面试官，能从行业领域给出职业生涯建议以及意见。 背景介绍： 现在的社会，人们产生越来越多的数据，而数据对每个人人都产生了巨大的影响。比如你去银行贷款，那么必然银行要对你做信用评估，会涉及到大数据画像等数据分析。比如美团外卖，则需要分析足够多的数据，给买卖各方做推荐引导，并同时结合大量的订单数据给骑手做配送陆续引导。 所有的
Flink的WaterMarker理解
最新发布
lihuazaizheli的博客
01-13 230
Flink的Water Marker的理解
Flink--WaterMark原理和实现
感谢你的关注~~~~ღ( ´･ᴗ･` )
09-17 602
一、WaterMark作用 在使用 EventTime 处理 Stream 数据的时候会遇到数据乱序的问题，流处理从 Event(事 件)产生，流经 Source，再到 Operator，这中间需要一定的时间。虽然大部分情况下，传输到 Operator 的数据都是按照事件产生的时间顺序来的，但是也不排除由于网络延迟等原因而导致乱序的产生，特别是使用 Kafka 的时候，多个分区之间的数据无法保证有序。因此， 在进行 Window 计算的时候，不能无限期地等下去，必须要有个机制来保证在特定的时间后， 必须触
Flink | EventTime 和Watermark
风中云彩的博客
08-10 446
​ 通常情况下，由于网络原因或系统等外部因素，事件数据往往不能及时传输到Flink系统中，导致数据乱序到达或延迟到达，因此需要一种机制能够控制数据处理的过程和进度。水平线（watermarks）机制，它能够衡量数据处理进度，保证事件数据到达Flink系统，或者在乱序和延迟时，也能够像预期一样计算出正确并且连续的结果。Flink会将用读取进去系统的最新事件时间减去固定的时间间隔作为w...
Flink Window机制与watermark水位线
忄凝^的博客
09-06 1061
这里目录标题1.简介2、Flink 搭建3、Flink 运行架构4、程序与数据流（DataFlow）5、Flink 流处理API6、Window 窗口机制6.1、策略6.2、类型6.3、Windows API6.3.1. 滚动窗口(Tumbling Window)6.3.2. 滑动窗口(Sliding Window)6.3.3. 会话窗口（session windown）6.3.4. 全局窗口(Global Windows)6.4、 window窗口聚合函数6.4.1. 增量聚合函数6.4.2. 全量窗口函
Flink: Window And WaterMark
难得糊涂
10-12 600
序言 在使用flink的时候,我们在整合Kafka作为Source的时候需要设置watermarket.否则就不能持续行的去消费.举一反三,watermarket在其它技术整合的时候也许要进行设置.cuiyaonan2000@163.com. window:是Flink将流数据或者批量数据根据时间(开始时间,结束时间)划分的多个段叫做bucket.(批量数据对于flink是特殊的流式数据,至于为什么将数据流划分成段可以自己百度) watermark:中文译名是水位线,它的存在是为了解决flink将数据
Flink之Watermark实践
sxiaobei的博客
07-21 6351
我们知道实时计算中，数据时间比较敏感，有eventTime和processTime区分，一般来说eventTime是从原始的消息中提取过来的，processTime是Flink自己提供的，Flink中一个亮点就是可以基于eventTime计算，这个功能很有用，因为实时数据可能会经过比较长的链路，多少会有延时，并且有很大的不确定性，对于一些需要精确体现事件变化趋势的场景中，单纯使用processTi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值