基于flink常用4种滚动窗口api的使用

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

上篇：基于flink的Keyed的CountWindow聚合操作

这四种窗口分别是：

  • NoKeyedProcessingTime滚动窗口
  • KeyedProcessTime滚动窗口
  • NoKeyedEventTime滚动窗口
  • KeyedEventTime滚动窗口

1、NoKeyedProcessingTime滚动窗口

不分组，按照ProcessingTime划分为滚动窗口，然后调用reduce对窗口内的数据进行聚合

采用老api：setStreamTimeCharacteristic实现

直接代码：

package cn._51doit.flink.day04;

import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.*;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
/**
 * NoKeyedProcessingTime滚动窗口
 * 不分组，按照ProcessingTime划分为滚动窗口，然后调用reduce对窗口内的数据进行聚合
 * 老api【setStreamTimeCharacteristic】
 */
public class ProcessingTimeTumblingWindowAllDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());
        env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);

        DataStreamSource<String> lines = env.socketTextStream("Master", 8888);

        //将字符串转为数字【lamber表达式】
        //本地执行，执行并行度为4，所以调用map返回的DataStream的并行度为4
        SingleOutputStreamOperator<Integer> nums = lines.map(Integer::parseInt);

        //不分组划分【不keyby】
        AllWindowedStream<Integer, TimeWindow> windowed = nums.timeWindowAll(Time.seconds(5));

        windowed.sum(0).print();

        env.execute();

    }
}

控制台打印输出：

由此可见，当时间触发后，才会生成新的窗口，这里的需求是当5秒钟过去后会生成一个新的窗口进行聚合

查看job：http://localhost:8081/#/job/72ca56c8c64cd14ee98b8615f1cf6357/overview

采用新的api：TumblingAlignedProcessingTimeWindows

package cn._51doit.flink.day04;

import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.*;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.assigners.TumblingAlignedProcessingTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
/**
 * NoKeyedProcessingTime滚动窗口
 * 不分组，按照ProcessingTime划分为滚动窗口，然后调用reduce对窗口内的数据进行聚合
 * 新api【setStreamTimeCharacteristic】
 */
public class ProcessingTimeTumblingWindowAllDemo_02 {


    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());

        DataStreamSource<String> lines = env.socketTextStream("Master", 8888);

        //将字符串转为数字【lamber表达式】
        //本地执行，执行并行度为4，所以调用map返回的DataStream的并行度为4
        SingleOutputStreamOperator<Integer> nums = lines.map(Integer::parseInt);

        //不分组划分【不keyby】
        AllWindowedStream<Integer, TimeWindow> windowed = nums.windowAll(TumblingAlignedProcessingTimeWindows.of(Time.seconds(5)));

        windowed.sum(0).print();


        env.execute();

    }
}

2、KeyedProcessTime滚动窗口

先keybey，再划分ProcessingTime的滚动窗口

需求1、：窗口有多个分区，在多个分区里有多个组，组里面有数据就输出【在时间窗口10秒内输出】

第一种方式：调用sum方式实现增量聚合

直接代码

package cn._51doit.flink.day04;

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.KeyedStream;
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;
/**
 * KeyedProcessTime滚动窗口--【无界流】
 * 先keybey，再划分ProcessingTime的滚动窗口
 */
public class ProcessingTimeTumblingWindowDemo {
    public static void main(String [] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());


        DataStreamSource<String> lines = env.socketTextStream("Master", 8888);

        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndCount = lines.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]));
            }
        });

        //调用keyBy
        KeyedStream<Tuple2<String, Integer>, String> keyed = wordAndCount.keyBy(t -> t.f0);
        //NoKeyed window：不调用keyBy，然后调用windowAll方法，传入windowAssinger
        //Keyed window：先调用keyBy，然后调用windowAll方法，传入windowAssinger
        WindowedStream<Tuple2<String, Integer>, String, TimeWindow> windowed = keyed.window(TumblingProcessingTimeWindows.of(Time.seconds(10)));

        windowed.sum(1).print();

        env.execute();

    }
}

控制台打印输出：

查看job：http://localhost:8081/#/job/5c6b8e5441faa8bc58409f05d69b9e03/overview

第 2 种方式：调用reduce方式实现增量聚合

直接代码

package cn._51doit.flink.day04;

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.functions.ReduceFunction;
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.KeyedStream;
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;
/**
 * KeyedProcessTime滚动窗口--【无界流】
 * 先keybey，再划分ProcessingTime的滚动窗口
 * 说明：调用sum或者reduce方法都是增量聚合
 */
public class ProcessingTimeTumblingWindowDemo_01 {
    public static void main(String [] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());


        DataStreamSource<String> lines = env.socketTextStream("Master", 8888);

        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndCount = lines.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]));
            }
        });

        //调用keyBy
        KeyedStream<Tuple2<String, Integer>, String> keyed = wordAndCount.keyBy(t -> t.f0);
        //NoKeyed window：不调用keyBy，然后调用windowAll方法，传入windowAssinger
        //Keyed window：先调用keyBy，然后调用windowAll方法，传入windowAssinger
        WindowedStream<Tuple2<String, Integer>, String, TimeWindow> windowed = keyed.window(TumblingProcessingTimeWindows.of(Time.seconds(30)));


        windowed.reduce(new ReduceFunction<Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> reduce(Tuple2<String, Integer> value1, Tuple2<String, Integer> value2) throws Exception {
                value1.f1 = value1.f1 + value2.f1;
                return value1;
            }
        }).print();

        env.execute();


    }
}

3、NoKeyedEventTime滚动窗口

不分组，按照ProcessingTime划分为滚动窗口，然后调用reduce对窗口内的数据进行聚合

说明：

  • 从flink1.2版本之后，assignTimestampsAndWatermarks方法标记过时了
  • 如果是1.7~1.10的flink版本，assignTimestampsAndWatermarks方法使用时，为标记过时！

触发公式：

  • 当前分区中数据的数据携带的最大的EvenTime - 乱序延迟时间 >=窗口的结束时间就会触发该窗口

代码：

package cn._51doit.flink.day04;

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.TimeCharacteristic;
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.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
/**
 * NoKeyedEventTime滚动窗口
 *  不分组，按照ProcessingTime划分为滚动窗口，然后调用reduce对窗口内的数据进行聚合
 *老版本assignTimestampsAndWatermarks方法
 */
public class EventTimeTumblingWindowAllDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());
        //设置EventTime划分为时间标准
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);  //老api

        //当前分区中数据的数据携带的最大的EvenTime - 乱序延迟时间 >=窗口的结束时间就会触发该窗口

        DataStreamSource<String> lines = env.socketTextStream("Master", 8888);

        //提取数据的时间，将时间转成long类型【精确到毫秒】，生成watermark【水位线】
        //调用完assignTimestampsAndWatermarks方法后，得到的DataStream中的数据跟原来的是一样的
        SingleOutputStreamOperator<String> dataWithWaterMark = lines.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<String>(Time.seconds(0)) {  //设置为0，这里表示数据的延迟时间
            @Override
            public long extractTimestamp(String element) {
                //提取数据中的时间
                return Long.parseLong(element.split(",")[0]);
            }
        });

        SingleOutputStreamOperator<Integer> nums = dataWithWaterMark.map(new MapFunction<String, Integer>() {

            @Override
            public Integer map(String value) throws Exception {
                return Integer.parseInt(value.split(",")[1]);
            }
        });

        //划分滚动窗口
        AllWindowedStream<Integer, TimeWindow> windowed = nums.windowAll(TumblingEventTimeWindows.of(Time.seconds(5)));

        //对数据进行聚合
        windowed.sum(0).print();

        env.execute();


    }
}

测试发现，无法触发

查看job：http://localhost:8081/#/job/bb868e633149b42c04c970c1fe58a52b/overview

注意，我们在webui页面查看发现：TriggerWindow的并行度只有一个，所以只会被触发一次，即使满足触发公式都不会被触发，发现所有数据都跑到TriggerWindow执行

4、KeyedEventTime滚动窗口

先keybey，再划分ProcessingTime的滚动窗口

直接代码：老版本

package cn._51doit.flink.day04;

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.KeyedStream;
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.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
/**
 * KeyedEventTime滚动窗口--【无界流】
 * 老版本
 */
public class EventTimeTumblingWindowDemo {
    public static void main(String [] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());


        DataStreamSource<String> lines = env.socketTextStream("Master", 8888);

        SingleOutputStreamOperator<String> dataWithWaterMark = lines.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<String>(Time.seconds(0)) {
            @Override
            public long extractTimestamp(String element) {
                return Long.parseLong(element.split(",")[0]);
            }
        });

        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndCount = dataWithWaterMark.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[1], Integer.parseInt(fields[2]));
            }
        });

        //调用keyBy
        KeyedStream<Tuple2<String, Integer>, String> keyed = wordAndCount.keyBy(t -> t.f0);
        //NoKeyed window：不调用keyBy，然后调用windowAll方法，传入windowAssinger
        //Keyed window：先调用keyBy，然后调用windowAll方法，传入windowAssinger
        WindowedStream<Tuple2<String, Integer>, String, TimeWindow> windowed = keyed.window(TumblingEventTimeWindows.of(Time.seconds(5)));

        //调用方式可以调sum方法，也可以调reduce方法
        windowed.sum(1).print();

       /* windowed.reduce(new ReduceFunction<Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> reduce(Tuple2<String, Integer> value1, Tuple2<String, Integer> value2) throws Exception {
                value1.f1 = value1.f1 + value2.f1;
                return value1;
            }
        }).print();*/
        env.execute();


    }
}

控制台打印输出：

查看job：http://localhost:8081/#/job/ffcde22da27944eb0350afb4034f0fba/overview

我们在webui页面查看发现：

  • TriggerWindow的并行度发现有4个分区，所以只要满足触发公式都会被触发
  • 由于程序都跑到TriggerWindow里计算，而TriggerWindow有4个并行度，在执行程序后，输入有4条数据都会被触发，统计触发原则，除非一条数据没有下游，否则将按就近原则触发
  • 对于迟到的数据会做过标签不会输出

直接代码：新版本api

package cn._51doit.flink.day04;

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
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.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
public class EventTimeTumblingWindowDemo02 {
    public static void main(String [] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());


        DataStreamSource<String> lines = env.socketTextStream("Master", 8888);
        

        //先对DataStream调用map
        SingleOutputStreamOperator<Tuple3<Long,String, Integer>> wordAndCount = lines.map(new MapFunction<String, Tuple3<Long,String, Integer>>() {

            @Override
            public Tuple3<Long,String, Integer> map(String value) throws Exception {
                String[] fields = value.split(",");
                return Tuple3.of(Long.parseLong(fields[0]),fields[1], Integer.parseInt(fields[2]));
            }
        }).setParallelism(2);

        //创建一个WaterMark
        SingleOutputStreamOperator<Tuple3<Long, String, Integer>> wordAndOneWithWaterMarks = wordAndCount.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<Tuple3<Long, String, Integer>>(Time.seconds(0)) {
            @Override
            public long extractTimestamp(Tuple3<Long, String, Integer> element) {
                //数据提取出来
                return element.f0;
            }
        });

        /**
         * 调用keyBy【对数据进行keyby】
         * project:做投影
         */
        KeyedStream<Tuple, Tuple> keyed = wordAndOneWithWaterMarks.project(1, 2).keyBy(0);

        //NoKeyed window：不调用keyBy，然后调用windowAll方法，传入windowAssinger
        //Keyed window：先调用keyBy，然后调用windowAll方法，传入windowAssinger
        WindowedStream<Tuple, Tuple, TimeWindow> windowed = keyed.window(TumblingEventTimeWindows.of(Time.seconds(5)));

        //调用方式可以调sum方法，也可以调reduce方法
        windowed.sum(1).print();

        env.execute();


    }
}

查看job：http://localhost:8081/#/job/e79c400d027d1d6c8d3c1e0323123081/overview

发现，不在Source对应的DataStream生成Watermark，而是先调用map生成一个新的DataStream，在这个新的DataStream生成新的WaterMark

谢谢，分享完毕！

江湖侠客
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
Flink动态开窗——根据缓存的规则信息动态设置窗口size
二两窝子面的博客
11-21 380
Flink数据关联缓存的外部规则信息动态设置窗口size做动态开窗计算
Flink：基于事件驱动的滑动窗口使用
程序员无羡的博客
04-13 158
Flink：基于事件驱动的滑动窗口使用
Flink窗口机制
最新发布
别这么骄傲
04-21 657
时间是为窗口服务的。窗口是什么？为什么会有窗口呢？（1）Flink要处理的数据，一般是从Kafka过来的流式数据，如果只是单纯地统计流的数据量，是没办法统计的。（2）所以，要人为的 加上了一个时间区间限制（窗口），才可以进行统计。
Flink处理函数实战之四：窗口处理
程序员欣宸的博客
05-31 5396
学习Flink低阶处理函数中的ProcessAllWindowFunction和ProcessWindowFunction
flink实现窗口大小动态调整
weixin_44657084的博客
07-31 1391
经过在网上的搜索找到了一种可行的办法，那就是仿照官方代码去自定义一种WindowAssigner来以流量中的数据为参数来创建window。以此为依据，就可以现在流量中通过之前学过的广播流将输入流量与window大小输入流合并在一起，以此为输入，然后自定义的windowassigner就可以从输入中的window大小数据动态调整window大小。flink中的窗口的概念和计算机网络中流量窗口的形式类似。在现在这一流量安全监控的项目中，需要动态设置风险触发的频率，为此需要动态设置窗口的大小。...
Flink动态窗口(动态window参数)
物联网三分钟
09-28 2796
原文Stack Overflow上的大卫安德森的回答 Flink的窗口API不支持动态更改窗口大小。 需要自己用KeyedProcessFunction实现动态窗口参数 下面例子中的durationMsec就是窗口长度.我也是参照这个例子改的,把durationMsec通过传入元素的某个字段来请求获取.然后用Guava Cache缓存一定时间即可 public class PseudoWindow extends KeyedProcessFunction<String, KeyedDataPoint&
Flink基础系列32-Table API和Flink SQL之时间窗口
04-26
例如，`input.window(Tumble.over("10.minutes").on("rowtime").as("w"))`定义了一个基于事件时间的10分钟滚动窗口，窗口别名`w`在后续的`groupBy`和`select`操作中使用。 1.1.1 滚动窗口（Tumbling Windows） 滚动...
Flink window API.pptx
02-03
Flink的窗口API是处理无界数据流的关键工具，它允许开发者将无限的数据流分割成有限的数据集，以便进行有效的分析和处理。在大数据和实时分析的场景中，如电商用户行为分析、实时热门商品统计、实时流量统计、市场...
大数据之flink教程-TableAPI和SQL.pdf
07-27
- **分组窗口**：包括滚动窗口、滑动窗口和会话窗口，用于对数据流进行分组和时间窗口的划分。 - **Over Windows**：分为无界和有界的Over Window，用于基于所有历史数据或一定时间范围内的数据进行计算。 - **SQL中...
本书基于Flink的稳定版本1.13，从Flink数据处理思想开始讲解，带领读者深入理解Flink的基本架构，进而由浅入深，结合
02-17
10. **Windowing**：Flink的窗口机制允许用户定义不同类型的窗口（如滑动窗口、滚动窗口、会话窗口等），以适应不同场景的数据处理需求。 通过深入学习《剑指大数据——Flink学习精要（Java版）》，读者将能够熟练...
flink1.12入门到精通视频课程
07-15
03-[掌握]-Flink高级API-Window-基于时间的滑动和滚动窗口 04-[了解]-Flink高级API-Window-基于数量的滑动和滚动窗口 05-[了解]-Flink高级API-Window-会话窗口 06-[理解]-Flink高级API-Time-时间分类和事件时间的...
Flink详解系列之六--窗口机制
wr_java的博客
04-13 580
触发器决定了一个窗口何时可以被窗口函数处理，每一个窗口分配器都有一个默认的触发器，如果默认的触发器不能满足你的需要，你可以通过调用trigger(...)来指定一个自定义的触发器。否则，由于全局窗口没有一个自然的结尾，无法执行元素的聚合，将不会有计算被执行。从滑动窗口的使用来看，滚动窗口其实是滑动窗口的一个特例，但窗口大小和滑动间隔相等的时候，滑动窗口就是一个滚动窗口。基于计数的窗口是根据事件的个数来对窗口进行划分的，概念跟基于时间的滚动窗口差不多，只不过窗口大小的划分，有时间变成了事件的个数。
Flink中的Window详解
chbxw
06-03 1186
一、Flink中的Window详解之Window分类
Flink 滚动窗口、滑动窗口详解
热门推荐
qq_34125999的博客
02-10 1万+
滚动窗口有固定的大小，是一种对数据进行“均匀切片”的划分方式。窗口之间没有重叠，也不会有间隔，是“首尾相接”的状态。如果我们把多个窗口的创建，看作一个窗口的运动，那就好像它在不停地向前“翻滚”一样。这是最简单的窗口形式，我们之前所举的例子都是滚动窗口。也正是因为滚动窗口是“无缝衔接”，所以每个数据都会被分配到一个窗口，而且只会属于一个窗口。 滚动窗口可以基于时间定义，也可以基于数据个数定义；需要的参数只有一个，就是窗口的大小（window size）。比如我们可以定义一个长度为 1 小时的滚动时间窗口，那么
Flink窗口详解和各示例使用
长臂人猿的博客
08-05 2060
前言 Flink版本：1.12.1 将上面的数据类比于一个车流（带有一个值），如果你想获得所有车值的总和，那该怎么办呢？求和：不断的将数据相加，像聚合函数一样：Flink的常见算子和实例代码。  但是问题来了：实时数据流是不断的产生数据的，那么作为无界数据流，你永远不可能获得流的完整结果。也许你可以创建一个同样的求和数据流（无界）像这样： 关于事件时间和水印与窗口的联合使用及其demo代码：Flink事件时间和水印详解 小结 Flink 内置了几种类型的窗口分配器，如下图所示： 从大的类型来区分有:
Flink 实现动态时间窗口
q977734161的专栏
06-10 1045
目前常用的有基于处理时间以及基于时间时间的滑动窗口以及滚动窗口，不过这些窗口时间是写死的，当有需求可以根据配置动态调整窗口大小的时候就得重新启动，发布程序，这种方式在变更频率小的时候无所谓，当变更频率大的时候就很耗时间，那么接下来介绍一种可以动态更改时间的方法.........
flink 学习（七）flink 滚动窗口
码易的博客
04-16 4476
文章目录前言1.Tumbling-ProcessingTime-Window2.Tumbling-ProcessingTime-Windows-Offset3.Tumbling-Count-Window4.Tumbling-EventTime-Window 前言         Flink中的窗口算子，是处理无界流的核心，窗口将流分割成很多的“buckets”，每个bucket可以基于时间、元素个数等进行分隔，针对每一个buck
Flink动态窗口(二)
物联网三分钟
10-20 2086
第一篇地址 前面一篇只写了思路来源,不是很明确做法. 有些朋友有缘看到了不是很明白,后面换了种简单高效的方式,匆忙记录一下 下面只描述了滚动窗口的做法,滑动窗口做法类似 自定义WindowAssigner AsyncParamRequestFunction 继承 RichAsyncFunction 使用flink的异步IO获取到窗口大小等动态数据放到对应的元素中. 其中使用了定时过期的Guava Cache来减少数据的请求.具体代码就不贴了, 但是这样也就存在了这些数据一定时间的延迟更新,自己取舍 下面是
项目4-Flink-高级API1
08-08
"项目4-Flink-高级API1，主要涉及Flink的核心特性，包括Window操作、EventTime与Watermarker的使用、State管理和Checkpoint容错机制。" 在Flink的高级API中，有四个关键概念构成了Flink强大的流处理能力。首先，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值