flink窗口函数

最新推荐文章于 2024-06-02 14:57:21 发布
最新推荐文章于 2024-06-02 14:57:21 发布
阅读量216 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qzc_root/article/details/118364160
版权

文章目录

概述

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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Flink流式计算框架中的窗口函数
Running-小猛的博客
06-17 1314
一、窗口（window） （1）一般真实的流都是无界的，怎样处理无界的数据？ （2）可以把无限的数据流进行切分，得到有限的数据集进行处理——也就是得到有界流； （3）窗口（window）就是将无限流切割为有限流的一种方式，它会将流数据分发到有限大小的桶（bucket）中进行分析； 二、window类型 （1）时间窗口（Time Window）：滚动时间窗口，滑动时间窗口，会话窗口； （2）计数窗口（Count Window）：滚动计数窗口，滑动计数窗口； 1、滚动窗口（Tumb..
flink（七）：窗口函数
幻神舞的专栏
05-31 1370
文章目录说明窗口函数ReduceFunctionAggregateFunctionFoldFunction（新版本废弃）ProcessWindowFunctionIncremental Aggregation和ProcessWindowFunction整合总结 说明 本博客每周五更新一次，上周五太忙，推迟到今天更新，以后尽量周五更新。 本博文主要分享flink的窗口计算相关函数类型，窗口函数分类、特点和使用方法。 窗口函数 Flink中提供了四种类型的Window Function，分别为Reduce
FLINK-窗口算子
最新发布
ALX3li的博客
06-02 707
在流处理中，我们往往需要面对的是连续不断、无休无止的无界流，不可能等到所有所有数据都到齐了才开始处理。所以聚合计算其实只能针对当前已有的数据——之后再有数据到来，就需要继续叠加、再次输出结果。这样似乎很“实时”，但现实中大量数据一般会同时到来，需要并行处理，这样频繁地更新结果就会给系统带来很大负担了。更加高效的做法是，把无界流进行切分，每一段数据分别进行聚合，结果只输出一次。这就相当于将无界流的聚合转化为了有界数据集的聚合，这就是所谓的“窗口”（Window）聚合操作。
flink 窗口函数
m0_50689246的博客
08-12 2542
flink窗口函数
Flink窗口函数
cts618
06-19 370
2.1 窗口函数的分类2.2 增量聚合函数2.2.1 ReduceFunction2.2.1.1 业务需求2.2.1.2 源码①增量聚合函数 →窗口中的元素从第二个开始，每进入一个元素，就会执行一次；然后将迄今为止执行的结果与新的元素进行比较，获得最新的值。以此类推，直到窗口关闭，触发sink操作。 →适用场景：窗口中的元素体量大，否则，容易导致OOM的发生。 →特点：不需要记录窗口中所有的元素，只需要保留迄今为止增量计算的结果即可。②全窗口函数 → 待到窗口关闭后，窗口中所有的元素然后一起进行计算，触发s
云星数据---Apache Flink实战系列(精品版)】：Flink其他操作及内容002-Flink基于流的windowAndFunction操作001
云星数据-http://www.cloud-star.com.cn
11-22 785
一、流处理的基本概念1.全局窗口（Global Windows）1.1全局窗口概念1.用户上京东购物，会进行一系列的操作，比如（点击、浏览、搜索、购买、付款等），用户的操作可以被记录为用户操作数据流。 2.京东上的用户会同时有多个，每个用户的操作都是独立的，随机的，因此用户之间的行为没有必然联系，没有统一规律。 3.该窗口仅在有一个自定义trigger时才有用。否则由于global window没有
flink 1.14.4 源码下载
04-03
4. **SQL支持**：Table API 和 SQL 支持可能得到了增强，例如增加了更多的SQL函数，支持更复杂的查询语法，以及提升了对时间窗口操作的处理效率。 5. ** connectors与格式**：Flink支持各种数据源和接收器，如Kafka...
flink-sql集成rabbitmq
06-29
Flink SQL支持标准的SQL语法，并且通过Table API提供了丰富的函数和操作符，包括聚合、窗口、连接等。 **RabbitMQ** 是基于AMQP（Advanced Message Queuing Protocol）协议的消息代理，能够可靠地路由和存储消息。...
flink 1.15.0安装包
05-06
这个版本引入了更多的SQL标准支持，比如窗口函数的增强，使得用户能够更方便地处理时间窗口和滑动窗口。此外，还优化了查询优化器，提高了查询执行效率。对于Table API，新的API设计更加简洁，使得开发者可以更直观...
flink动态业务规则
08-18
4. **Event Time** 和 **Watermarks**：Flink 支持事件时间窗口，使得在时间敏感的业务规则中能够正确处理延迟到达的数据。 综上所述，"Flink 动态业务规则"是一个重要的功能，它结合了 Flink 的强大流处理能力和...
大数据技术之Flink教程
04-02
3. **分层API**：Flink提供层次化的API，包括底层的过程函数（Process Function），它允许直接处理有状态流，适用于复杂计算；DataStream API和DataSet API是核心API，分别处理有界和无界流数据，提供丰富的转换和...
Flink中的窗口函数
weixin_40659514的博客
11-10 1685
flink中的窗口函数
flink自定义窗口函数
CSDN_bird的博客
10-21 846
https://blog.csdn.net/shenxiaoming77/article/details/70807953
Flink--窗口函数（window function）
MLwodejia的博客
02-21 808
窗口函数（window function）增量聚合函数（incremental aggregation functions全窗口函数（full window functions）其他APIwindow API 总览 window function定义了要对窗口中收集的数据做的计算操作 主要分为两类： 增量聚合函数（incremental aggregation functions 每条数据到来就进行计算，保持一个简单的状态 ReduceFunction, AggregateFunction 全窗口函数（
flink 常用窗口函数
congge_study的博客
01-16 2845
flink 常用窗口函数
[实时流基础 flink] 窗口函数
程序员三木的博客
04-01 1148
尚硅谷学习笔记。
Flink 窗口函数（Window Functions）全窗口函数
weixin_45417821的博客
04-17 2925
文章目录1）窗口函数（WindowFunction）2）处理窗口函数（ProcessWindowFunction） 窗口操作中的另一大类就是全窗口函数。与增量聚合函数不同，全窗口函数需要先收集窗口中的数据，并在内部缓存起来，等到窗口要输出结果的时候再取出数据进行计算。 很明显，这就是典型的批处理思路了— —先攒数据，等一批都到齐了再正式启动处理流程。这样做毫无疑问是低效的：因为窗口全部的计算任务都积压在了要输出结果的那一瞬间，而在之前收集数据的漫长过程中却无所事事。这就好比平时不用功，到考试之前通宵抱佛脚，
flink中窗口函数(一)基础函数
qq_44665283的博客
03-29 1276
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 窗口函数与聚合
weixin_42660202的博客
07-23 739
Flink可以对数据进行分段计算.类似于批处理,批的概念相当于一段时间内的数据,窗口定义了时间的范围 窗口函数代码 //Time.seconds(2)表示窗口时间范围为2秒 Time.seconds(1) 表示窗口时间跨度为1秒 data.timeWindow(Time.seconds(2), Time.seconds(1)); 时间窗口长度为2秒,两次执行的时间跨度为1秒 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值