flink窗口函数

最新推荐文章于 2024-11-25 20:08:05 发布
原创 最新推荐文章于 2024-11-25 20:08:05 发布 · 373 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了Flink流处理引擎中的时间概念与窗口处理机制，包括事件时间、摄入时间和处理时间的区别，以及滚动窗口、滑动窗口和会话窗口的具体应用。

文章目录

概述

streaming流式计算是一种被设计用于处理无限数据集的数据处理引擎，而无限数据集是指一种不断增长的本质上无限的数据集，而window是一种切割无限数据为有限块进行处理的手段。
​ Window是无限数据流处理的核心，Window将一个无限的stream拆分成有限大小的”buckets”桶，我们可以在这些桶上做计算操作。

flink中的时间种类有哪些

Flink中的时间与现实世界中的时间是不一致的，在flink中被划分为事件时间，摄入时间，处理时间三种。
1、如果以EventTime为基准来定义时间窗口将形成EventTimeWindow,要求消息本身就应该携带EventTime
2、如果以IngesingtTime为基准来定义时间窗口将形成IngestingTimeWindow,以source的systemTime为准。
3、如果以ProcessingTime基准来定义时间窗口将形成ProcessingTimeWindow，以operator的systemTime为准。

window类型

时间窗口：按照时间生成window
滚动时间窗口
滑动时间窗口
会话窗口
计数窗口：按照指定的数据条数生成一个window，与时间无关
滚动计数窗口
滑动计数窗口

1、滚动窗口（tumbling windows）
依据固定的窗口长度对数据进行切分
时间对齐，窗口长度固定，没有重叠
在这里插入图片描述

2、滑动窗口（sliding windows）
可以按照固定的长度向后滑动固定的距离
滑动窗口由固定的窗口长度和滑动间隔组成
可以有重叠（是否重叠和滑动距离有关系）
滚动窗口可以看做是特殊的滑动窗口（窗口大小和滑动距离相同）
在这里插入图片描述
3、会话窗口（session windows）
由一系列事件组合一个指定时间长度的timeout间隙组成，也就是一段时间没有接收到新数据就会生成新的窗口
在这里插入图片描述

window api

1、timeWindow、countWindow、window

public class Window1 {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        Properties prop = new Properties();
        prop.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.232.211:9092");
        prop.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"group_2");
        prop.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");
        prop.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");
        prop.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");
        DataStreamSource<String> inputStream = env.addSource(new FlinkKafkaConsumer011<String>("sensor",
                new SimpleStringSchema(), prop));
        SingleOutputStreamOperator<SensorReading> mapStream = inputStream.map(new MapFunction<String, SensorReading>() {

            @Override
            public SensorReading map(String s) throws Exception {
                String[] split = s.split(",");
                return new SensorReading(split[0], Long.parseLong(split[1]), Double.parseDouble(split[2]));
            }
        });
        SingleOutputStreamOperator<SensorReading> maxStream = mapStream.keyBy("id")
                //滚动时间窗口 将数据流切分成不重叠的窗口
                //每一个事件只能属于一个窗口
                .timeWindow(Time.seconds(15))
                //滑动时间窗口  窗口是不间断的 需要平滑地进行窗口聚合
                //每5秒计算一次最近15秒的最高温度
//                .timeWindow(Time.seconds(15),Time.seconds(5))
                //每15个行为事件统计最高温度
//                .countWindow(15)
                //每2个计算一次最近6个事件的最高温度
//                .countWindow(6,2)
                //会话窗口 会话窗口在一段时间内没有接收到元素时，
                //即当发生不活动的间隙时，会话窗口关闭 静态
//                .window(EventTimeSessionWindows.withGap(Time.seconds(15)))
                .max("temperature");
        mapStream.print("max");
        env.execute("max_1");
    }
}

2、reduce

public class WindowReduce {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        Properties prop = new Properties();
        prop.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.232.211:9092");
        prop.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"group_3");
        prop.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common" +
                ".serialization.StringDeserializer");
        prop.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common" +
                ".serialization.StringDeserializer");
        prop.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");
        DataStreamSource<String> inputStream = env.addSource(new FlinkKafkaConsumer011<String>("sensor",
                new SimpleStringSchema(), prop));
        SingleOutputStreamOperator<SensorReading> mapStream = inputStream.map(new MapFunction<String, SensorReading>() {
            @Override
            public SensorReading map(String s) throws Exception {
                String[] split = s.split(",");
                return new SensorReading(split[0], Long.parseLong(split[1]), Double.parseDouble(split[2]));
            }
        });
        SingleOutputStreamOperator<SensorReading> resultStream = mapStream.keyBy("id")
                .countWindow(6, 2)
                //温度求和
                .reduce(new ReduceFunction<SensorReading>() {
                    @Override
                    public SensorReading reduce(SensorReading sensorReading, SensorReading t1) throws Exception {
                        return new SensorReading(sensorReading.getId(),
                                sensorReading.getTimestamp(),
                                sensorReading.getTemperature() + t1.getTemperature());
                    }
                });
        resultStream.print("sum");
        env.execute("reduce_1");
    }
}

在这里插入图片描述
在这里插入图片描述
3、aggregate

public class WindowAgg {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        Properties prop = new Properties();
        prop.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.232.211:9092");
        prop.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"group_3");
        prop.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common" +
                ".serialization.StringDeserializer");
        prop.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common" +
                ".serialization.StringDeserializer");
        prop.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");
        DataStreamSource<String> inputStream = env.addSource(new FlinkKafkaConsumer011<String>("sensor",
                new SimpleStringSchema(), prop));
        SingleOutputStreamOperator<SensorReading> mapStream = inputStream.map(new MapFunction<String, SensorReading>() {
            @Override
            public SensorReading map(String s) throws Exception {
                String[] split = s.split(",");
                return new SensorReading(split[0], Long.parseLong(split[1]), Double.parseDouble(split[2]));
            }
        });
        SingleOutputStreamOperator<Double> aggStream = mapStream.keyBy("id")
                .countWindow(6, 2)
                .aggregate(new AggregateFunction<SensorReading, Tuple2<Double, Integer>, Double>() {
                    @Override
                    public Tuple2<Double, Integer> createAccumulator() {
                        //初始值
                        return new Tuple2<>(0.0, 0);
                    }

                    @Override
                    public Tuple2<Double, Integer> add(SensorReading sensorReading, Tuple2<Double, Integer> doubleIntegerTuple2) {
                        //求和 温度值相加  个数+1
                        double temp = sensorReading.getTemperature() + doubleIntegerTuple2._1;
                        int count = doubleIntegerTuple2._2 + 1;
                        return new Tuple2<>(temp, count);
                    }

                    @Override
                    public Double getResult(Tuple2<Double, Integer> doubleIntegerTuple2) {
                        //求平均值
                        return doubleIntegerTuple2._1 / doubleIntegerTuple2._2;
                    }

                    @Override
                    public Tuple2<Double, Integer> merge(Tuple2<Double, Integer> doubleIntegerTuple2, Tuple2<Double, Integer> acc1) {
                        double temp = doubleIntegerTuple2._1 + acc1._1;
                        int i = doubleIntegerTuple2._2 + acc1._2;
                        return new Tuple2<>(temp, i);
                    }
                });
        aggStream.print("avg");
        env.execute("agg_1");
    }
}

在这里插入图片描述
在这里插入图片描述
4、allowedLateness

public class Window3 {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(2);
        //设置时间语义 事件发生时间 TimeCharacteristic.EventTime
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        Properties prop = new Properties();
        prop.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.232.211:9092");
        prop.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"sensor_group2");
        prop.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serizlization.StringDeserializer");
        prop.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serizlization.StringDeserializer");
        prop.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");
        DataStreamSource<String> inputStream = env.addSource(new FlinkKafkaConsumer011<String>
                ("sensor", new SimpleStringSchema(), prop));
        SingleOutputStreamOperator<SensorReading> mapStream = inputStream.map(new MapFunction<String, SensorReading>() {
            @Override
            public SensorReading map(String s) throws Exception {
                String[] split = s.split(",");
                return new SensorReading(split[0], Long.parseLong(split[1]), Double.parseDouble(split[2]));
            }//BoundedOutOfOrdernessTimestampExtractor 处理乱序时间 Time.seconds(0) 不延迟
        }).assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<SensorReading>(Time.seconds(0)) {
            @Override
            public long extractTimestamp(SensorReading sensorReading) {
                return sensorReading.getTimestamp() * 1000L;
            }
        });
        SingleOutputStreamOperator<SensorReading> maxResultStream
                = mapStream.keyBy("id")
                .timeWindow(Time.seconds(15))
                .allowedLateness(Time.seconds(30))
                .max("temperature");
        maxResultStream.print("max");
        env.execute("window3");
    }
}

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
5、sideOutputLateData

public class Window3 {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(2);
        //设置时间语义 事件发生时间 TimeCharacteristic.EventTime
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        Properties prop = new Properties();
        prop.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.232.211:9092");
        prop.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"sensor_group2");
        prop.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serizlization.StringDeserializer");
        prop.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serizlization.StringDeserializer");
        prop.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");
        DataStreamSource<String> inputStream = env.addSource(new FlinkKafkaConsumer011<String>
                ("sensor", new SimpleStringSchema(), prop));
        SingleOutputStreamOperator<SensorReading> mapStream = inputStream.map(new MapFunction<String, SensorReading>() {
            @Override
            public SensorReading map(String s) throws Exception {
                String[] split = s.split(",");
                return new SensorReading(split[0], Long.parseLong(split[1]), Double.parseDouble(split[2]));
            }//BoundedOutOfOrdernessTimestampExtractor 处理乱序时间 Time.seconds(0) 不延迟
        }).assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<SensorReading>(Time.seconds(0)) {
            @Override
            public long extractTimestamp(SensorReading sensorReading) {
                return sensorReading.getTimestamp() * 1000L;
            }
        });
        OutputTag<SensorReading> outputTag = new OutputTag<SensorReading>("late11111"){};
        SingleOutputStreamOperator<SensorReading> maxResultStream
                = mapStream.keyBy("id")
                .timeWindow(Time.seconds(15))
                .allowedLateness(Time.seconds(30))
                .sideOutputLateData(outputTag)
                .max("temperature");
        maxResultStream.print("max");
        DataStream<SensorReading> sideOutput = maxResultStream.getSideOutput(outputTag);
        sideOutput.print("sideout");
        env.execute("window");
    }
}

在这里插入图片描述
在这里插入图片描述

qzc_root
关注
Flink窗口函数全解析：大数据时间处理的关键技术
欢迎来到我的优快云空间！这里聚焦AI大模型应用实战，分享前沿技术、实战案例与开发经验。
10-05 612
在电商大促的实时销售大屏、物联网设备的实时监控、金融交易的实时风险预警等场景中，我们需要回答类似“过去5分钟的订单总量是多少？”“最近1小时各设备的平均温度是多少？”的问题。将无限的数据流按时间或事件特征切割成有限的“数据窗口”，并对每个窗口内的数据进行计算。本文将聚焦Flink的窗口机制，覆盖窗口类型、函数分类、核心组件（分配器/触发器/移除器）、实战案例及常见问题。
flink（七）：窗口函数
幻神舞的专栏
05-31 1722
文章目录说明窗口函数ReduceFunctionAggregateFunctionFoldFunction（新版本废弃）ProcessWindowFunctionIncremental Aggregation和ProcessWindowFunction整合总结 说明 本博客每周五更新一次，上周五太忙，推迟到今天更新，以后尽量周五更新。 本博文主要分享flink的窗口计算相关函数类型，窗口函数分类、特点和使用方法。 窗口函数 Flink中提供了四种类型的Window Function，分别为Reduce
Flink窗口函数
m0_63069778的博客
03-10 1605
看过上面3个案例，可以发现增量聚合函数ReduceFunction和AggregateFunction都是数据来一条处理一条，而全窗口函数ProcessWindowFunction则是在窗口结束的时候才执行计算，因此process的效率相对更低。但是process的优点在于它可以得到上下文信息，因此，将两者结合起来使用，既可以提升计算效率，又能得到窗口信息。以上两种方法不能看到窗口的信息，比如时间，因此引入全窗口函数，它提供了一个上下文对象，不仅能获取窗口信息，还能得到访问的当前时间和状态信息。
Flink中的窗口函数
weixin_40659514的博客
11-10 2167
flink中的窗口函数
flink 窗口函数
m0_50689246的博客
08-12 4037
flink窗口函数
Flink 窗口函数（Window Functions）全窗口函数
weixin_45417821的博客
04-17 3368
文章目录1）窗口函数（WindowFunction）2）处理窗口函数（ProcessWindowFunction） 窗口操作中的另一大类就是全窗口函数。与增量聚合函数不同，全窗口函数需要先收集窗口中的数据，并在内部缓存起来，等到窗口要输出结果的时候再取出数据进行计算。 很明显，这就是典型的批处理思路了— —先攒数据，等一批都到齐了再正式启动处理流程。这样做毫无疑问是低效的：因为窗口全部的计算任务都积压在了要输出结果的那一瞬间，而在之前收集数据的漫长过程中却无所事事。这就好比平时不用功，到考试之前通宵抱佛脚，
Flink 窗口函数（Window Functions）案例（结合增量聚合函数与全窗口函数场景）
weixin_45417821的博客
04-17 1233
网站里面，特别是电商场景，一般情况都要统计哪些是热门商品，或者哪个url的访问最大。 前提是根据每个url对应的访问量统计出来，然后再去排序，做其他选择 我们可以将页面访问量按照窗口，基于窗口划分，每个url它们分别被点击访问了几次 这里我们为了方便处理，单独定义了一个 POJO 类 UrlViewCount 来表示聚合输出结果的数据类型，包含了 url、浏览量以及窗口的起始结束时间。 Gitee中 public class UrlViewCount { public String url; //.
Flink入门（3）-Flink窗口函数
weixin_38813363的博客
03-03 857
Flink窗口函数滚动窗口(Trumblingwindow)滚动事件窗口滑动窗口(SlidingWindow)滑动时间窗口滑动事件窗口会话窗口(SessionWindow)window算子代码解析window算子WindowedStream 的apply方法 滚动窗口(Trumblingwindow) 时间对齐，窗口长度固定，没有重叠 WindowedStream<Tuple2<String, Integer>, Tuple, TimeWindow> timeWindow = ke
云星数据---Apache Flink实战系列(精品版)】：Flink其他操作及内容002-Flink基于流的windowAndFunction操作001
云星数据-http://www.cloud-star.com.cn
11-22 860
一、流处理的基本概念1.全局窗口（Global Windows）1.1全局窗口概念1.用户上京东购物，会进行一系列的操作，比如（点击、浏览、搜索、购买、付款等），用户的操作可以被记录为用户操作数据流。 2.京东上的用户会同时有多个，每个用户的操作都是独立的，随机的，因此用户之间的行为没有必然联系，没有统一规律。 3.该窗口仅在有一个自定义trigger时才有用。否则由于global window没有
flink自定义窗口函数
优快云_bird的博客
10-21 944
https://blog.youkuaiyun.com/shenxiaoming77/article/details/70807953
Flink (Windows Function 窗口函数)
最新发布
GDDGHS_的博客
11-25 848
输入类型是输入流中的元素类型，AggregateFunction有一个add方法可以将一个输入元素添加到一个累加器中。该接口还具有创建初始累加器(createAccumulator方法)、将两个累加器合并到一个累加器(merge方法)以及从累加器中提取输出(类型为OUT)的方法。指在窗口触发的时候才会对窗口内的所有数据进行一次计算（等窗口的数据到齐，才开始进行聚合计算，可实现对窗口内的数据进行排序等需求）l 增量函数：窗口保存一份中间数据，每流入一个新元素，新元素与中间数据两两合一，生成新的中间数据。
Flink流式计算框架中的窗口函数
Running-小猛的博客
06-17 1431
一、窗口（window） （1）一般真实的流都是无界的，怎样处理无界的数据？ （2）可以把无限的数据流进行切分，得到有限的数据集进行处理——也就是得到有界流； （3）窗口（window）就是将无限流切割为有限流的一种方式，它会将流数据分发到有限大小的桶（bucket）中进行分析； 二、window类型 （1）时间窗口（Time Window）：滚动时间窗口，滑动时间窗口，会话窗口； （2）计数窗口（Count Window）：滚动计数窗口，滑动计数窗口； 1、滚动窗口（Tumb..
Flink--窗口函数（window function）
MLwodejia的博客
02-21 942
窗口函数（window function）增量聚合函数（incremental aggregation functions全窗口函数（full window functions）其他APIwindow API 总览 window function定义了要对窗口中收集的数据做的计算操作 主要分为两类： 增量聚合函数（incremental aggregation functions 每条数据到来就进行计算，保持一个简单的状态 ReduceFunction, AggregateFunction 全窗口函数（
flink 常用窗口函数
congge_study的博客
01-16 3021
flink 常用窗口函数
[实时流基础 flink] 窗口函数
程序员三木的博客
04-01 1473
尚硅谷学习笔记。
flink中窗口函数(一)基础函数
qq_44665283的博客
03-29 1405
flink中窗口函数(一)基础函数 (1)ReduceFunction A ReduceFunction specifies how two elements from the input are combined to produce an output element of the same type. Flink uses a ReduceFunction to incrementally aggregate(增量聚合) the elements of a window. ReduceFunction
Flink 窗口函数与聚合
大数据开发
07-23 868
Flink可以对数据进行分段计算.类似于批处理,批的概念相当于一段时间内的数据,窗口定义了时间的范围 窗口函数代码 //Time.seconds(2)表示窗口时间范围为2秒 Time.seconds(1) 表示窗口时间跨度为1秒 data.timeWindow(Time.seconds(2), Time.seconds(1)); 时间窗口长度为2秒,两次执行的时间跨度为1秒 ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值