Flink Window 窗口【更新中】

已于 2024-07-28 21:47:02 修改
阅读量442 收藏 6
点赞数 5
文章标签： flink 大数据
于 2024-07-13 13:12:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xwcj3/article/details/140253323
版权

Flink Window 窗口

在Flink流式计算中，最重要的转换就是窗口转换Window，在DataStream转换图中，可以发现处处都可以对DataStream进行窗口Window计算。
在这里插入图片描述窗口（window）就是从 Streaming 到 Batch 的一个桥梁。窗口将无界流（unbounded data stream）划分很多有界流（bounded stream），对无界流进行计算。

在这里插入图片描述
在实际业务需求中，往往说窗口，指的就是基于时间Time窗口，比如最近1分钟内数据，指的就是1分钟时间内产生的数据，放在窗口中。

Flink Window 窗口的结构中，有两个必须的两个操作：

  • 第一、窗口分配器（Window Assigner）：将数据流中的元素分配到对应的窗口。
  • 第二、窗口函数（Window Function）：当满足窗口触发条件后，对窗口内的数据使用窗口处理函数（Window Function）进行处理，常用的有reduce、aggregate、process。
  • 其他的trigger、evictor则是窗口的触发和销毁过程中的附加选项，主要面向需要更多自定义的高级编程者，如果不设置则会使用默认的配置。
    在这里插入图片描述
  • 上图是窗口的生命周期示意图，假如设置的是一个10分钟的滚动窗口，第一个窗口的起始时间是0:00，结束时间是0:10，后面以此类推。
  • 当数据流中的元素流入后，窗口分配器会根据时间（Event Time或Processing Time）分配给相应的窗口。相应窗口满足了触发条件，比如已经到了窗口的结束时间，会触发相应的Window Function进行计算。

在Flink计算引擎中，支持窗口类型有很多种，几乎所有Streaming流式计算引擎需要实现窗口都支持。

在这里插入图片描述

  • 1）、时间窗口TimeWindow

    • 按照时间间隔划分出窗口，并对窗口中数据进行计，如每xx分钟统计，最近xx分钟的数据
    • 划分为：**滚动（Tumbling）窗口和滑动（Sliding）**窗口

  • 2）、计数窗口CountWindow

    • 按照数据条目数进行设置窗口，比如每10条数据统计一次
    • 划分为：**滚动（Tumbling）窗口和滑动（Sliding）**窗口
    • [此种方式窗口计算，在实际项目中使用不多，但是有些特殊业务需要，需要使用此场景。]
      在这里插入图片描述
package com.lyj.sx.flink.day05;

import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.AllWindowedStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.windows.GlobalWindow;

public class CountWindowAllDemo {
    public static void main(String[] args) throws Exception {
         StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());
         DataStreamSource<String> source = env.socketTextStream("192.168.25.62", 8889);
         SingleOutputStreamOperator<Integer> map = source.map(Integer::parseInt);
        //不keyBy，直接划分窗口
        //窗口内的数据达到5条，就生成一个窗口，然后对窗口内的数据进行计算
         AllWindowedStream<Integer, GlobalWindow> win = map.countWindowAll(5);
         SingleOutputStreamOperator<Integer> sum = win.sum(0);
         sum.print();
         env.execute("pxj");


    }
}

package com.lyj.sx.flink.day05;

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class CountWindowDemo {
    public static void main(String[] args)throws  Exception {
         StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());
         DataStreamSource<String> source = env.socketTextStream("192.168.25.62", 8889);
         SingleOutputStreamOperator<Tuple2<String, Integer>> map = source.map(new MapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String value) throws Exception {
                final String[] split = value.split(" ");
                return Tuple2.of(split[0], Integer.parseInt(split[1]));
            }
        });
         SingleOutputStreamOperator<Tuple2<String, Integer>> summed = map.keyBy(t -> t.f0).countWindow(5).sum(1);
         summed.print();
         env.execute("pxj");
    }
}

package com.lyj.sx.flink.day05;

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.datastream.WindowedStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;

import java.util.concurrent.TimeUnit;

/**
 * 滚动窗口：按照指定的时间进行滚动，滚动的时间和窗口的长度是一致的，窗口和窗口之间没有重叠
 *
 * 按照时间划分的窗口，跟窗口内数据的条数无关，可以按照EventTime划分窗口，也可以按照ProcessingTime划分窗口
 *
 * 窗口也分为keyedWindow和NonKeyedWindow(Window和WindowFunction对应的Task并行度为1)
 */
public class TumblingWindowAllDemo {
    public static void main(String[] args) throws  Exception {
         StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());
         DataStreamSource<String> source = env.socketTextStream("192.168.25.62", 8889);
         SingleOutputStreamOperator<Tuple2<String, Integer>> map = source.map(new MapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String value) throws Exception {
                String[] split = value.split(",");
                return Tuple2.of(split[0], Integer.parseInt(split[1]));
            }
        });
         WindowedStream<Tuple2<String, Integer>, String, TimeWindow> window = map.keyBy(t -> t.f0).window(TumblingProcessingTimeWindows.of(Time.of(10000, TimeUnit.MILLISECONDS)));
         SingleOutputStreamOperator<Tuple2<String, Integer>> summed = window.sum(1);
         summed.print();
         env.execute("pxj");
    }
}

package com.lyj.sx.flink.day05;

import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.assigners.ProcessingTimeSessionWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

public class SessionWindowAllDemo {
    public static void main(String[] args) throws Exception {
         StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());
         DataStreamSource<String> source = env.socketTextStream("192.168.25.62", 8888);
         SingleOutputStreamOperator<Integer> map = source.map(Integer::parseInt);
         SingleOutputStreamOperator<Integer> sum = map.windowAll(ProcessingTimeSessionWindows.withGap(Time.seconds(5))).sum(0);
         sum.print();
         env.execute("pxj");
    }
}

package com.lyj.sx.flink.day05;

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.assigners.ProcessingTimeSessionWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

/**
 * 先KeyBy再划分Sessionindow，即KeyedWindow，Window和WindowFunction对应的Task是可以多个并行的
 *
 * 按照系统时间和最后一条进入窗口的数据划分窗口
 *
 * 同一个分区同一个组内的数据，当系统时间减去进入到这个组内的最后一条数据的时间>指定的时间间隔，那么这个组单独触发
 */public class SessionWindowDemo {
    public static void main(String[] args) throws Exception {
         StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());
         DataStreamSource<String> source = env.socketTextStream("192.168.25.62", 8889);
         SingleOutputStreamOperator<Tuple2<String, Integer>> map = source.map(new MapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String value) throws Exception {
                String[] fields = value.split(",");
                return Tuple2.of(fields[0], Integer.parseInt(fields[1]));
            }
        });
         SingleOutputStreamOperator<Tuple2<String, Integer>> summed = map.keyBy(t -> t.f0).window(ProcessingTimeSessionWindows.withGap(Time.seconds(5))).sum(1);
         summed.print();
         env.execute("pxj");
    }
}

package com.lyj.sx.flink.day05;

import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.assigners.ProcessingTimeSessionWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

public class SessionWindowAllDemo {
    public static void main(String[] args) throws Exception {
         StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());
         DataStreamSource<String> source = env.socketTextStream("192.168.25.62", 8888);
         SingleOutputStreamOperator<Integer> map = source.map(Integer::parseInt);
         SingleOutputStreamOperator<Integer> sum = map.windowAll(ProcessingTimeSessionWindows.withGap(Time.seconds(5))).sum(0);
         sum.print();
         env.execute("pxj");
    }
}

作者：pxj_sx（潘陈沈）
日期：2024-07-28 21:46:30 更新

panxuej_shenx
关注
Flink SQL 窗口表值函数 Window TVF 实战
SmartSi
10-04 778
窗口 TVF 是 Flink 定义的多态表函数(缩写 PTF)。PTF 是 SQL 2016 标准的一部分，是一个特殊的表函数，可以将表作为参数。因为 PTF 在语义上像表一样使用，所以它们的调用发生在 SELECT 语句的 FROM 子句中。窗口 TVF 是传统 Grouped Window 函数的替代品。窗口 TVF 更符合 SQL 标准，也更强大，可以支持复杂的基于窗口的计算，例如 Window TopN, Window Join。但是，Grouped Window 函数只能支持窗口聚合。
Flink动态窗口(动态window参数)
物联网三分钟
09-28 2838
原文Stack Overflow上的大卫安德森的回答 Flink的窗口API不支持动态更改窗口大小。 需要自己用KeyedProcessFunction实现动态窗口参数 下面例子中的durationMsec就是窗口长度.我也是参照这个例子改的,把durationMsec通过传入元素的某个字段来请求获取.然后用Guava Cache缓存一定时间即可 public class PseudoWindow extends KeyedProcessFunction<String, KeyedDataPoint&
Flink之window窗口
m0_64115815的博客
09-07 509
flink相关内容
flink window 窗口
sasa527的专栏
03-10 1520
从 demo 到生产 - 手把手写出实战需求的 Flink窗口处理程序 - 大数据江湖 - 博客园
Flink窗口(Flink Window)
龙飞的博客
12-09 932
上一篇讲到Flink 中事件时间和水位线的概念，那它们有什么具体应用呢？当然是做基于时间的处理计算了。其中最常见的场景，就是窗口聚合计算。之前我们已经了解了 Flink 中基本的聚合操作。在流处理中，我们往往需要面对的是连续不断、无休无止的无界流，不可能等到所有所有数据都到齐了才开始处理。所以聚合计算其实只能针对当前已有的数据——之后再有数据到来，就需要继续叠加、再次输出结果。这样似乎很“实时”，但现实中大量数据一般会同时到来，需要并行处理，这样频繁地更新结果就会给系统带来很大负担了。
Flink的window(窗口)
jason_bone_的博客
02-19 2738
Flink的window(窗口) 1.Flink窗口的概念 窗口（window）就是将无限流切割为有限流的一种方式，它会将流数据分发到有限大小的桶（bucket）中进行分析 2.Flink的窗口分类 其实, 在用window前首先需要确认应该是在keyBy后的流上用, 还是在没有keyBy的流上使用. 2.1Non-Keyed Windows 在non-keyed stream上使用窗口,只能调用windowAll()方法,返回AllWindowedStream流.Flink会把所有数据放到同一个窗口中
Flink_窗口_Window
959
03-28 1352
文章目录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 是一种流式计算引擎，主要是来处理无界数据流的，数据源源不断、无穷无尽。想要更加方便高效地处理无界流，一种方式
Flink Window窗口机制和延迟处理
小财迷嘻嘻的博客
01-05 2261
java版本：Flink Window窗口机制 1、窗口 在流处理应用中，数据是连续不断的，因此我们不可能等到所有数据都到了才开始处理。 当然我们可以每来一个消息就处理一次，但是有时我们需要做一些聚合类的处理，例如：在过去的1分钟内有多少用户点击了我们的网页。 在这种情况下，我们必须定义一个窗口，用来收集最近一分钟内的数据，并对这个窗口内的数据进行计算。 窗口可以是基于时间驱动的（Time Window，例如：每30秒钟） 也可以是基于数据驱动的（Count Window，例如：每一百个
Flink window API.pptx
02-03
- `.evictor()`：定义清除窗口中某些数据的策略。 - `.allowedLateness()`：设置允许处理迟到数据的时间范围。 - `.sideOutputLateData()`：将迟到数据发送到侧输出流。 - `.getSideOutput()`：从侧输出流中获取数据...
Flink窗口——window
诸葛子房的博客
09-26 172
时间窗口(按时间进行统计) 个数窗口(按个数进行统计) 参考：https://blog.csdn.net/weixin_43291055/article/details/101421939 会话窗口 参考：https://blog.csdn.net/lmalds/article/details/51604501 ...
【Flink】窗口（Window）
最新发布
lxtx
11-19 881
窗口（Window）是处理无界流的关键所在。窗口可以将数据流装入大小有限的“桶”中，再对每个“桶”加以处理。本文的重心将放在 Flink 如何进行窗口操作以及开发者如何尽可能地利用 Flink 所提供的功能。我们将窗口理解为一个一个的水桶，数据流（stream）就像水流，每个数据都会分发到对应的桶中，当达到结束时间时，对每个桶中收集的数据进行计算处理Flink中窗口并不是静态准备好的，而是动态创建——当有落在这个窗口区间范围的数据达到时，才创建对应的窗口。
Flink笔记-window窗口
ooeeerrtt的博客
05-06 389
一、不分组窗口函数 public class WindowStream { public static void main(String[] args) throws Exception { StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); env.setParallelism(3); env.setStreamTimeCha
Flink——窗口（window）
m0_57126456的博客
11-18 1298
一：窗口（window）就是将无限流切割为有限流的一种方式，它会将流数据分发到有限大小的桶（bucket）中进行分析 window类型： 时间窗口（Time Window） ➢ 滚动时间窗口（Tumbling Windows）：将数据依据固定的窗口长度对数据进行切分时间对齐，窗口长度固定，没有重叠 ➢ 滑动时间窗口 (Sliding Windows)：滑动窗口是固定窗口的更广义的一种形式，滑动窗口由固定的窗口长度和滑动间隔组成。窗口长度固定，可以有重叠 ➢ 会话窗口（Session Win
flink-18 flink之windows窗口
a3125504x的博客
09-24 309
flink之windows窗口概念窗口的类型滚动窗口（tumbling windows）滑动窗口（sliding windows）会话窗口窗口（session windows）窗口应用示例窗口数据的集合统计增量聚合统计7.3.2 全量聚合统计 概念 把数据想象成一种流，窗口在流上滑动，显示指定时间段或指定个数的数据。 即windows是一种可以把无限无数据切割为有限数据块的手段 应用场景 对于流式处理，如果我们需要求取总和，平均值，或者最大值，最小值等，是做不到的，因为数据一直在源源不断的产生，即数据是没有
Flink之Windows
qq_41924766的博客
05-17 487
Flink Windows相关代码实现
Flink 基础学习之窗口 Window
Java极客技术
12-04 1130
01、前言前面讲了时间 Time 的概念和实际解决问题后，本篇来看下经常搭配使用的另一个关键工具：窗口 Window。窗口也有三种类型可供选择使用：Tumbling Windows：滚动...
Flink Windows（窗口）详解
weixin_39565641的博客
08-02 1214
Windows是流计算的核心。Windows将流分成有限大小的“buckets”，我们可以在其上应用聚合计算（或）等。
Flink之窗口 (Window) 上篇
四维大脑的博客
04-26 4266
在 Flink 中, 窗口就是用来处理无界流的核心。我们很容易把窗口想象成一个固定位置的“框”，数据源源不断地流过来，到某个时间点窗口该关闭了，就停止收集数据、触发计算并输出结果。例如，我们定义一个时间窗口，每 10 秒统计一次数据，那么就相当于把窗口放在那里，从 0 秒开始收集数据；到 10 秒时，处理当前窗口内所有数据，输出一个结果，然后清空窗口继续收集数据；到 20 秒时，再对窗口内所有数据进行计算处理，输出结果；依次类推。
flink window
09-20
窗口操作可以通过窗口函数（window function）实现，窗口函数定义了对窗口中的数据进行聚合和处理的逻辑。 使用窗口操作可以提高流处理的性能和效率，通过将连续的数据划分为有限的窗口，可以减少计算的复杂性。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值