Flink - 基于时间窗口的操作 - （Flink - 窗口原理）

于 2023-03-06 00:40:16 发布
阅读量476 收藏 1
点赞数 1
分类专栏： flink 文章标签： flink 前端 html
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44760145/article/details/129353436
版权

文章目录

Flink - 基于时间窗口的操作 -（Flink - 窗口原理）

在这里插入图片描述

窗口的一些概念和窗口处理流程

窗口

窗口分为全局窗口（GlobalWindow）和时间窗口（TimeWindow）

窗口分配器、触发器与驱逐器

Window Assigner：用来决定某个元素被分配到哪个/哪些窗口中去
Trigger：触发器。决定了一个窗口何时能够被计算或清除，每个窗口都会拥有一个自己的 Trigger

Trigger 的返回值 TriggerResult

CONTINUE 不做任何事情
FIRE 触发 window
PURGE 清空整个 window 的元素并销毁窗口
FIRE_AND_PURGE 触发窗口，然后销毁窗口

Evictor

Evictor 可以译为"驱逐者"
在Trigger触发之后，在窗口被处理之前，Evictor（如果有Evictor的话）会用来剔除窗口中不需要的元素，相当于一个filter

元素进入窗口的处理流程

1、每条进入窗口的元素都会交由 WindowAssigner 处理，WindowAssigner 会决定元素被放到那个或哪些窗口 一个元素可以放入多个窗口
2、window 本身就是一个 ID 标识 并不存储窗口中的元素 内部可能存储一些元数据 如 TimeWindow 中有开始和结束时间，窗口中的元素实际存储在 Key/Value State 中，key 为 Window，value 为元素集合（或聚合值）
3、每个 window 都有一个 Trigger 用来决定窗口何时被触发或清除
4、Trigger被调用：

  • 有元素加入当前窗口
  • 之前注册的定时器到期了

5、Trigger的返回结果 TriggerResult：

  • continue 不做任何操作
  • fire 处理窗口数据：计算窗口并保留窗口原样，也就是说窗口中的数据仍保留不变，下次 Trigger fire 的时候再次参与计算
  • purge 移除窗口和窗口中的数据：一个窗口可以被重复计算多次直到它被 purge 了 在 purge 之前，窗口会一直占用着内存
  • fire + purge 触发并清除窗口

6、当 Trigger Fire 了，窗口中的元素集合就会交给 Evictor（如果指定了的话）

  • Evictor: 遍历窗口中的元素列表
  • 移除最先进入窗口的多少个元素
  • 剩余的元素交由指定的函数进行窗口的计算

如果没有 Evictor 窗口中的所有元素会一起交给指定的函数进行计算

计算函数收到窗口的元素(可能经过了 Evictor 的过滤),计算出窗口结果并发送给下游

Flink - 窗口原理

在这里插入图片描述

.windowAll(org.apache.flink.streaming.api.windowing.assigners.GlobalWindows.create())
.countWindow(5,2)
.countWindow(5)
.window(ProcessingTimeSessionWindows.withGap(Time.seconds(5)))
.window(EventTimeSessionWindows.withGap(Time.seconds(5L)))
.window(TumblingProcessingTimeWindows.of(Time.seconds(5L)))
.window(TumblingEventTimeWindows.of(Time.seconds(5L)))
.window(SlidingProcessingTimeWindows.of(Time.seconds(5L),Time.seconds(2L)))
.window(SlidingEventTimeWindows.of(Time.seconds(5L), Time.seconds(2L)))


public class Win {

    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);

        DataStreamSource<String> streamSource = env
                .socketTextStream("hadoop102", 9099);

        SingleOutputStreamOperator<Tuple2<String, Long>> flatMapStream = streamSource
                .flatMap(
                        new FlatMapFunction<String, Tuple2<String, Long>>() {
                            @Override
                            public void flatMap(String value, Collector<Tuple2<String, Long>> out) throws Exception {
                                String[] elems = value.split(" ");
                                out.collect(Tuple2.of(elems[0], Long.parseLong(elems[1]) * 1000));
                            }
                        }
                );

        SingleOutputStreamOperator<Tuple2<String, Long>> withWatermarkStream = flatMapStream
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple2<String, Long>>forBoundedOutOfOrderness(Duration.ofSeconds(0L))
                                .withTimestampAssigner(
                                        new SerializableTimestampAssigner<Tuple2<String, Long>>() {
                                            @Override
                                            public long extractTimestamp(Tuple2<String, Long> element, long recordTimestamp) {
                                                return element.f1;
                                            }
                                        }
                                )
                );

        KeyedStream<Tuple2<String, Long>, String> keyedStream = withWatermarkStream
                .keyBy(
                        new KeySelector<Tuple2<String, Long>, String>() {
                            @Override
                            public String getKey(Tuple2<String, Long> value) throws Exception {
                                return value.f0;
                            }
                        }
                );

//        withWatermarkStream
//                .windowAll(org.apache.flink.streaming.api.windowing.assigners.GlobalWindows.create());

        WindowedStream<Tuple2<String, Long>, String, TimeWindow> winStream = keyedStream
                .countWindow(5, 2)
//                .countWindow(5)
//                .window(ProcessingTimeSessionWindows.withGap(Time.seconds(5)))
//                .window(EventTimeSessionWindows.withGap(Time.seconds(5L)))
//                .window(TumblingProcessingTimeWindows.of(Time.seconds(5L)))
//                .window(TumblingEventTimeWindows.of(Time.seconds(5L)))
//                .window(SlidingProcessingTimeWindows.of(Time.seconds(5L),Time.seconds(2L)))
//                .window(SlidingEventTimeWindows.of(Time.seconds(5L), Time.seconds(2L)));

        SingleOutputStreamOperator<String> countWinStream = winStream
                .process(
                        new ProcessWindowFunction<Tuple2<String, Long>, String, String, TimeWindow>() {
                            @Override
                            public void process(String key, Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {

                                Timestamp winStart = new Timestamp(context.window().getStart());
                                Timestamp winEnd = new Timestamp(context.window().getEnd());

                                long count = elements.spliterator().getExactSizeIfKnown();

                                out.collect("key = " + key + ", win [ " + winStart + " - " + winEnd + " ), 窗口有 " + count + " 条元素");

                            }
                        }
                );

        countWinStream
                .print();


        env.execute();


    }

}

SlidingEventTimeWindows

nc -lk 9099
a 1
a 2
a 3

程序启动初始化窗口分配器
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
根据窗口分配器创建 WindowedStream
在这里插入图片描述
在这里插入图片描述
位窗口分配器创建默认的触发器
在这里插入图片描述
窗口中第一条元素到来交由 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement 方法处理

分配窗口
在这里插入图片描述
进入 org.apache.flink.streaming.api.windowing.assigners.SlidingEventTimeWindows#assignWindows 方法为元素分配窗口
在这里插入图片描述
最终元素会被分配到 [-2000,3000) 与 [0,5000) 的窗口
在这里插入图片描述
在这里插入图片描述
元素分配到指定窗口后返回元素所属的窗口，回到 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement 方法
在这里插入图片描述
判断窗口分配器是否是 session 类型的窗口，如果是遍历所有窗口，判断是否需要 merge 窗口，我们此处是滚动事件窗口，因此跳过进入 else 分支
在这里插入图片描述
进入 else 分支
1、元素事件时间小于窗口的数据丢弃
在这里插入图片描述
在这里插入图片描述
2、为窗口创建一个 State (所有窗口共享，在 WindowOperator 初始化时创建)，并将元素数存入，每个窗口的元素通过当前窗口的 Namespace 区分
在这里插入图片描述
3、获取窗口的 TriggerResult，每一条元素都有进入org.apache.flink.streaming.api.windowing.triggers.EventTimeTrigger#onElement方法获取 TriggerResult
在这里插入图片描述
4、判断窗口是否触发，如果是，触发窗口计算
在这里插入图片描述
5、判断是否清空窗口
在这里插入图片描述
6、注册触发窗口的定时器
在这里插入图片描述
在这里插入图片描述
7、判断元素是否要输出到侧输出流（所有类型的窗口分配器都会执行该步骤）
在这里插入图片描述
在这里插入图片描述
输入 a 3 触发窗口 watermark = 3 - 1 ms = 29999 ms，定时器触发 ，timer 原理时将详细描述触发过程
在这里插入图片描述
获取 TriggerResult
在这里插入图片描述
在这里插入图片描述
org.apache.flink.streaming.api.windowing.triggers.EventTimeTrigger#onElement
在这里插入图片描述

EventTimeSessionWindows

第一条元素 (a,1) 到来

初始化 EventTimeSessionWindows org.apache.flink.streaming.api.windowing.assigners.EventTimeSessionWindows
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
创建 WindowedStream org.apache.flink.streaming.api.datastream.WindowedStream
在这里插入图片描述
在这里插入图片描述
默认触发器 org.apache.flink.streaming.api.windowing.assigners.EventTimeSessionWindows#getDefaultTrigger
在这里插入图片描述
输入第一条元素 (a,1)
为元素分配窗口 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement
在这里插入图片描述
org.apache.flink.streaming.api.windowing.assigners.EventTimeSessionWindows#assignWindows
在这里插入图片描述
回到 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement 方法
在这里插入图片描述
在这里插入图片描述
创建 MergingWindowSet
在这里插入图片描述
在这里插入图片描述
org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#MergingWindowSet
在这里插入图片描述
将当前元素的窗口和之前的窗口进行 merge
在这里插入图片描述
合并窗口 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow
在这里插入图片描述
TimeWindow 合并窗口操作 org.apache.flink.streaming.api.windowing.windows.TimeWindow#mergeWindows，mergeWindows 方法是专门为 session 合并窗口而定义的方法，同时配备有 mergeTrigger、mergeTimer 等方法
1、将所有窗口存入一个集合
在这里插入图片描述
2、对集合中的窗口按窗口开始时间排序
在这里插入图片描述
3、创建一个集合用于保存所有 merge 后的窗口，创建一个 元组保存正在 merge 的窗口
在这里插入图片描述
4、遍历所有窗口判断是否合并
在这里插入图片描述
在这里插入图片描述
合并完后回到 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow 方法
在这里插入图片描述
返回 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement 方法
在这里插入图片描述
在这里插入图片描述

第二条元素 (a,2) 到来

为 (a,2) 元素分配窗口org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement
在这里插入图片描述
获取 MergingWindowSet org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#MergingWindowSet
在这里插入图片描述
在这里插入图片描述
通过 MergingWindowSet 合并窗口
在这里插入图片描述
org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow
1、创建一个空集合，并将 MergingWindowSet 状态中的旧窗口信息和当前元素的新窗口信息添加到集合中
在这里插入图片描述
2、通过TimeWindow mergeWindows 方法合并窗口
在这里插入图片描述
3、org.apache.flink.streaming.api.windowing.windows.TimeWindow#mergeWindowsmerge 窗口
将所有窗口存入一个 List 集合
在这里插入图片描述
按窗口起始时间升序排序
在这里插入图片描述
创建一个空的集合和二元组用于存储合并后的结果和正在 merge 的窗口
在这里插入图片描述
合并窗口操作
在这里插入图片描述
遍历第一个窗口 [1000,6000)
初始化二元组，f0：（当前排序中）起始时间最小的窗口，f1：被合并的窗口集合
在这里插入图片描述
遍历第二个窗口 [2000,7000)
在这里插入图片描述
由于第一步已经创建好了 currentMerge 因此走第二个分支，判断是否需要合并窗口
在这里插入图片描述
判断两个窗口是否相交
在这里插入图片描述
在这里插入图片描述
通过 cover 方法合并，合并方式就是创建一个新的窗口，新窗口的开始时间为两个窗口最小的时间，结束时间同理，然后返回新的窗口
在这里插入图片描述
在这里插入图片描述
将窗口放入被合并的窗口集合中
在这里插入图片描述
更新合并窗口的集合中
在这里插入图片描述
回调 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow 方法中的 MergingWindowAssigner.MergeCallback 具体实现，将合并后的数据保存到 map 中
在这里插入图片描述
返回 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow 方法
执行其他 merge 操作，主要 merge 定时器和状态
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
返回 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement 方法中执行具体的 MergeFunction 实现
合并触发器 org.apache.flink.streaming.api.windowing.triggers.EventTimeTrigger#onMerge
在这里插入图片描述
在这里插入图片描述
清空被合并窗口的触发器上下文信息和定时器
在这里插入图片描述
在这里插入图片描述
merge namespace 和 state
在这里插入图片描述
在这里插入图片描述
最后再次返回 org.apache.flink.streaming.runtime.operators.windowing.WindowOperator#processElement 方法
处理迟到元素
在这里插入图片描述
获取 mapping 中被合并的窗口，这一步需要结合 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow方法中
在这里插入图片描述
在这里插入图片描述
将当前元素添加到 state 中
在这里插入图片描述
获取触发器
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
更新状态 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#persist
在这里插入图片描述
在这里插入图片描述
侧输出流处理
在这里插入图片描述

第三条元素 (a,9) 到来

分配窗口 [9000,14000)
在这里插入图片描述
初始 MergingWindowSet
在这里插入图片描述
合并窗口 org.apache.flink.streaming.runtime.operators.windowing.MergingWindowSet#addWindow
在这里插入图片描述
在这里插入图片描述
执行合并操作 org.apache.flink.streaming.api.windowing.windows.TimeWindow#mergeWindows
在这里插入图片描述
定时器触发窗口

countWindow

public class Win {

    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);

        DataStreamSource<String> streamSource = env
                .socketTextStream("hadoop102", 9099);

        SingleOutputStreamOperator<Tuple2<String, Long>> flatMapStream = streamSource
                .flatMap(
                        new FlatMapFunction<String, Tuple2<String, Long>>() {
                            @Override
                            public void flatMap(String value, Collector<Tuple2<String, Long>> out) throws Exception {
                                String[] elems = value.split(" ");
                                out.collect(Tuple2.of(elems[0], Long.parseLong(elems[1]) * 1000));
                            }
                        }
                );

        SingleOutputStreamOperator<Tuple2<String, Long>> withWatermarkStream = flatMapStream
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple2<String, Long>>forBoundedOutOfOrderness(Duration.ofSeconds(0L))
                                .withTimestampAssigner(
                                        new SerializableTimestampAssigner<Tuple2<String, Long>>() {
                                            @Override
                                            public long extractTimestamp(Tuple2<String, Long> element, long recordTimestamp) {
                                                return element.f1;
                                            }
                                        }
                                )
                );

        KeyedStream<Tuple2<String, Long>, String> keyedStream = withWatermarkStream
                .keyBy(
                        new KeySelector<Tuple2<String, Long>, String>() {
                            @Override
                            public String getKey(Tuple2<String, Long> value) throws Exception {
                                return value.f0;
                            }
                        }
                );

//        withWatermarkStream
//                .windowAll(org.apache.flink.streaming.api.windowing.assigners.GlobalWindows.create());
//
//        WindowedStream<Tuple2<String, Long>, String, TimeWindow> winStream = keyedStream
                .countWindow(5, 2)
                .countWindow(5)
                .window(ProcessingTimeSessionWindows.withGap(Time.seconds(5)))
//                .window(EventTimeSessionWindows.withGap(Time.seconds(5L)));
                .window(TumblingProcessingTimeWindows.of(Time.seconds(5L)))
                .window(TumblingEventTimeWindows.of(Time.seconds(5L)))
                .window(SlidingProcessingTimeWindows.of(Time.seconds(5L),Time.seconds(2L)))
                .window(SlidingEventTimeWindows.of(Time.seconds(5L), Time.seconds(2L)));
//
//        SingleOutputStreamOperator<String> countWinStream = winStream
//                .process(
//                        new ProcessWindowFunction<Tuple2<String, Long>, String, String, TimeWindow>() {
//                            @Override
//                            public void process(String key, Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {
//
//                                Timestamp winStart = new Timestamp(context.window().getStart());
//                                Timestamp winEnd = new Timestamp(context.window().getEnd());
//
//                                long count = elements.spliterator().getExactSizeIfKnown();
//
//                                out.collect("key = " + key + ", win [ " + winStart + " - " + winEnd + " ), 窗口有 " + count + " 条元素，当前的 watermark = " + context.currentWatermark());
//
//                            }
//                        }
//                );
//
//        countWinStream
//                .print();


        WindowedStream<Tuple2<String, Long>, String, GlobalWindow> winStream = keyedStream
                .countWindow(5, 2);

        winStream
                .process(
                        new ProcessWindowFunction<Tuple2<String, Long>, String, String, GlobalWindow>() {
                            @Override
                            public void process(String key, Context context, Iterable<Tuple2<String, Long>> elements, Collector<String> out) throws Exception {
                                out.collect("key = " + key + ", 窗口有 " + elements.spliterator().getExactSizeIfKnown() + " 条元素 ");
                            }
                        }
                )
                .print();


        env.execute();


    }

}

初始化 WindowedStream
在这里插入图片描述
在这里插入图片描述
初始化全局窗口分配器
在这里插入图片描述
初始化 WindowedStream org.apache.flink.streaming.api.datastream.WindowedStream#WindowedStream
在这里插入图片描述
初始化 CountEvictor
在这里插入图片描述
给窗口添加 evictor org.apache.flink.streaming.api.datastream.WindowedStream#evictor
在这里插入图片描述
初始化 CountTrigger
在这里插入图片描述
为窗口添加 trigger org.apache.flink.streaming.api.datastream.WindowedStream#trigger
在这里插入图片描述
第一条元素来了，分配窗口 org.apache.flink.streaming.runtime.operators.windowing.EvictingWindowOperator#processElement
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
获取触发器 org.apache.flink.streaming.api.windowing.triggers.CountTrigger#onElement
在这里插入图片描述
在这里插入图片描述
第二条元素到来
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

驱逐窗口中的元素 org.apache.flink.streaming.runtime.operators.windowing.EvictingWindowOperator#emitWindowContents
在这里插入图片描述
org.apache.flink.streaming.api.windowing.evictors.CountEvictor#evictBefore
在这里插入图片描述
org.apache.flink.streaming.api.windowing.evictors.CountEvictor#evict
在这里插入图片描述
执行 process 方法
在这里插入图片描述
第六条元素到来
驱逐窗口中的元素 org.apache.flink.streaming.runtime.operators.windowing.EvictingWindowOperator#emitWindowContents
在这里插入图片描述
org.apache.flink.streaming.runtime.operators.windowing.EvictingWindowOperator.EvictorContext#evictBefore
在这里插入图片描述
org.apache.flink.streaming.api.windowing.evictors.CountEvictor#evictBefore
在这里插入图片描述
org.apache.flink.streaming.api.windowing.evictors.CountEvictor#evict
在这里插入图片描述
在这里插入图片描述

wenvlove
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Flink之滑动窗口（SlidingEventTimeWindows）
01-07
def main(args: Array[String]): Unit = { // 环境 val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime) env.setParallelism(1) val dstream: DataStream[String] = env.socketTextStream(hadoop1,7777)
Flink_窗口_Window
959
03-28 1306
文章目录1.窗口概述2.窗口分类2.1 时间窗口2.2 计数窗口3.细分3.1 滚动窗口3.2 滑动窗口3.3 会话窗口3.4 全局窗口4.窗口Api4.1 按键分区窗口4.2 非按键分区4.3 代码中窗口Api的调用5.窗口分配器 Window Assigners5.1 时间窗口5.2 计数窗口5.3 全局窗口6.窗口函数6.1 增量函数6.2 全量函数7.TopN 实例 1.窗口概述 Flink 是一种流式计算引擎，主要是来处理无界数据流的，数据源源不断、无穷无尽。想要更加方便高效地处理无界流，一种方式
FlinkTime与Window以及Event Time计算规则详解
syyyyyyyyyyyyyyh的博客
09-25 632
在Flink的流式处理中，会涉及到时间的不同概念、 Event Time：是事件创建的时间。它通常由事件中的时间戳描述，例如采集的日志数据中，每一条日志都会记录自己的生成时间，Flink通过时间戳分配器访问的事件时间戳 Ingestion Time：是数据进入Flink的时间。 Processing Time：是每一个执行基于时间操作的算子的本地系统时间，与机器相关，默认的时间属性就是Processing Time。 例如，一条日志进入Flink的时间为2017-11-12 10:00:00...
Flink中Time&Window
数据工匠记
01-04 4437
Time 更多代码案例可参考：https://github.com/perkinls/flink-local-train Fink支持的Time类型 Flink在流式传输程序中支持不同的时间概念。 处理时间（Processing time） 处理时间是指正在执行相应操作的机器的系统时间。当流式程序按处理时间运行时，所有基于时间的操作（如时间窗口）都将使用运行相应操作员的计算机的系统时钟。每小时处理...
Flink基础系列32-Table API和Flink SQL之时间窗口
04-26
Flink基础系列32-Table API和Flink SQL之时间窗口，大数据，flink 时间窗口
flink-cep-perf:测试带窗口pattern性能
04-30
#Pattern 性能测试 ...需要注意的是，设定事件次数的阈值 * 事件发送间隔时间需要小于等于窗口时间，否则pattern不会触发。 pattern代码 Pattern<JSONObject> pattern = Pattern.<JSONObject>begin(
flink-java-interview:Flink面试练习
05-12
Flink面试 前任。 1个 该练习的目的是： 在WalkMeEventSourceFunction中生成随机WalkMeEvents。 在10秒钟的（Tumbling）窗口中编写汇总事件的代码。 每10秒打印一次最近10秒内每个用户的事件总数。 脚步 实现...
项目6-Flink-Action综合练习1
08-08
}}编码步骤:envsourcetransformation3.1定义大小为一天的窗口,第二个参数表示中国使用的UTC+08:00时区比UTC时间早.keyBy
flink-local-train:flink入门到项目实践
05-06
文章会对Flink中基本API如：DataSet、DataStream、Table、Sql和常用特性如：Time&Window、窗口函数、Watermark、触发器、分布式缓存、异步IO、侧输出、广播和高级应用如：ProcessFunction、状态管理等知识点进行整理...
Flink之Window与窗口开始时间
heroking
02-15 6100
一、滚动窗口（TumblingEventTimeWindows） // 引入滚动窗口 val streamWindow = stream.window(TumblingEventTimeWindows.of(Time.seconds(10))) 二、滑动窗口（SlidingEventTimeWindows） // 引入滑动窗口，窗口10s，没5s滑动一次 val streamWindow = s...
flink在EvnetTime 在 window 中的使用
song_quan_的博客
11-08 116
1 滚动窗口（TumblingEventTimeWindows）（Scala 版） 结果是按照 Event Time 的时间窗口计算得出的，而无关系统的时间（包括输入 的快慢） 2 滑动窗口（SlidingEventTimeWindows） 3 会话窗口（EventTimeSessionWindows） 相邻两次数据的 EventTime 的时间差超过指定的时间间隔就会触发执行。如果 加入 Watermark， 会在符合窗口触发的情况下进行延迟。到达...
Flink 时间流处理
chanyue123的博客
03-29 2825
讲解flink中时间的分类，以及时间在水位线、窗口计算中的应用
Flink窗口全解析：三种时间窗口、窗口处理函数使用及案例
czl689的专栏
03-14 3056
我们经常需要在一个时间窗口维度上对数据进行聚合，窗口是流处理应用中经常需要解决的问题。Flink的窗口算子为我们提供了方便易用的API，我们可以将数据流切分成一个个窗口，对窗口内的数据进行处理。本文将介绍如何在Flink上进行窗口的计算。 一个Flink窗口应用的大致骨架结构如下所示： // Keyed Window stream .keyBy(...) <- 按照一个Key进行分组 .window(...) &
Flink的触发器Trigger介绍和使用
sghuu的博客
12-25 7533
触发器定义了window何时会被求值以及何时发送求值结果。触发器可以到了特定的时间触发也可以碰到特定的事件触发。例如：观察到事件数量符合一定条件或者观察到了特定的事件。 默认的触发器将会在两种情况下触发 处理时间：机器时间到达处理时间 事件时间：水位线超过了窗口的结束时间 触发器可以访问流的时间属性以及定时器，还可以对state状态编程。所以触发器和process function一样强大。例如我...
Flink 解析（七）：时间窗口
Stray_Lambs的博客
01-17 2566
时间概念 由于Flink框架中实时流处理事件中，时间在计算中起到很大的作用。例如进行时间序列分析、基于特定时间段(窗口)进行聚合或者是重要情况下的事件处理。Flink的DataStream支持三种time：EventTime、IngestTime和ProcessingTime，并且有大量的基于time的operator。 这三种时间进行比较： EventTime 事件生成的时间，在进入Flink之间就已经存在，可以从event的字段中抽取 必须指定watermarks的生成方式 优势..
【Flink】【第六章 Window】
weixin_43589563的博客
01-14 855
Window概述 Streaming流式计算是一种被设计用于处理无限数据集的数据处理引擎，而无限数据集是指一种不断增长的本质上无限的数据集，而window是一种切割无限数据为有限块进行处理的手段。 Window是无限数据流处理的核心，Window将一个无限的stream拆分成有限大小的”buckets”桶，我们可以在这些桶上做计算操作。 flink中的window可以理解为水桶，数据理解为水流，水流源源不断，对于DataStream来说是来一个数据处理一条，有了桶之后，将数据装进桶中再处理，在窗口关闭的时候
Flink Window Triggers 触发器 和 EVICTORS 清理器
shenjianyu_rex的博客
09-07 948
前言 触发器定义了window何时会被求值以及何时发送求值结果。触发器可以到了特定的时间触发也可以碰到特定的事件触发。例如：观察到事件数量符合一定条件或者观察到了特定的事件。 清理器是一个可选的组件，可以被注入到ProcessWindowFunction之前或者之后调用。evictor可以清除掉window中收集的元素。由于evictor需要迭代所有的元素，所以evictor只能使用在没有增量聚合函数作为参数的情况下。 如果对window 的概念或者window的分配器不熟悉的话，可以看下前面的文章Flin
Flink-跟着问题读源码：近24小时或者近XX小时这种SlidingEventTimeWindows相关的问题
三石
08-21 917
问题描述 这周接到一个新需求，近24小时的用户行为标签偏好跑分，实现的算法逻辑非常复杂，需要对用户的各类行为分别统计并求出比例，再配合各种时间衰减因子、反作弊数据等等。下面针对这次的开发总结下自己的心得，主要是flink window和state方面。 join维表之前预先聚合，否则CP失败 近24小时的window可以拆分为5分钟维度 onTimer watermark的多次申明 timestamp必须是毫秒否则数据无法输出，也不报错，并且过滤脏数据， Java中对数的使用，防止负数 ...
flink-jav-1.14.4api 中文版
最新发布
01-16
它包括了Flink的各种概念和概述，如流处理、窗口操作、状态管理、数据源和数据接收器等。 使用Flink-Java-1.14.4 API中文版，开发人员可以快速了解Flink框架的架构和工作原理，学习如何使用Flink编写流处理和批处理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值