Flink中窗口的划分与应用

最新推荐文章于 2024-01-19 09:47:25 发布
最新推荐文章于 2024-01-19 09:47:25 发布
阅读量1.3k 收藏 2
点赞数 1
分类专栏： Flink Bigdata
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzxlfly/article/details/108933015
版权

一、Window 分类

1、数据集类型划分

 Flink根据上游数据集是否为KeyedStream类型，即是否使用keyBy(...)， 分为Keyed Window和Non-Keyed Window

（1）Keyed Window

上游数据集如果是KeyedStream类型，即使用了keyBy(...)，则调用DataStreamAPI的window()方法，数据会根据Key在不同的Task实例中并行分别计算，最后得出针对每个Key统计的结果。

 程序调用流程如下：

stream
       .keyBy(...)               <-  keyed versus non-keyed windows
       .window(...)              <-  required: "assigner"
      [.trigger(...)]            <-  optional: "trigger" (else default trigger)
      [.evictor(...)]            <-  optional: "evictor" (else no evictor)
      [.allowedLateness(...)]    <-  optional: "lateness" (else zero)
      [.sideOutputLateData(...)] <-  optional: "output tag" (else no side output for late data)
       .reduce/aggregate/fold/apply()      <-  required: "function"
      [.getSideOutput(...)]      <-  optional: "output tag"

（2）Non-Keyed Window

上游数据集如果非KeyedStream类型，即没有使用keyBy(...)，则调用WindowsAll()方法，所有的数据都会在窗口算子中由到一个Task中计算，并得到全局统计结果。

 程序调用流程如下：

stream
       .windowAll(...)           <-  required: "assigner"
      [.trigger(...)]            <-  optional: "trigger" (else default trigger)
      [.evictor(...)]            <-  optional: "evictor" (else no evictor)
      [.allowedLateness(...)]    <-  optional: "lateness" (else zero)
      [.sideOutputLateData(...)] <-  optional: "output tag" (else no side output for late data)
       .reduce/aggregate/fold/apply()      <-  required: "function"
      [.getSideOutput(...)]      <-  optional: "output tag"

 

2、按业务类型划分

基于业务数据的方面考虑，Flink支持四种窗口类型，由Fink WindowAssigner负责定义

（1）Tumbling Windows

滚动窗口是根据固定时间进行切分，且窗口和窗口之间的元素互不重叠。 这种类型的窗口的最大特点是比较简单，只需要指定一个窗口长度（window size）。

 如下代码，是对滚动窗口的使用

DataStream<T> input = ...;

// tumbling event-time windows
input
    .keyBy(<key selector>)
    .window(TumblingEventTimeWindows.of(Time.seconds(5)))
    .<windowed transformation>(<window function>);

// tumbling processing-time windows
input
    .keyBy(<key selector>)
    .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
    .<windowed transformation>(<window function>);

// daily tumbling event-time windows offset by -8 hours.
input
    .keyBy(<key selector>)
    .window(TumblingEventTimeWindows.of(Time.days(1), Time.hours(-8)))
    .<windowed transformation>(<window function>);

 

（2）Sliding Windows

滑动窗口也是一种比较常见的窗口类型，其特点是在滚动窗口基础之上增加了窗口滑动时间（SlideTime），且允许窗口数据发生重叠。当Windows size固定之后，窗口并不像滚动窗口按照Windows Size向前移动，而是根据设定的SlideTime向前滑动。

窗口之间的数据重叠大小根据Windows size和Slidetime决定，当Slide time小于Windows size便会发生窗口重叠，Slide size大于Windows size就会出现窗口不连续，数据可能不能在任何一个窗口内计算，Slidesize和Windowssize相等时，SlidingWindows其实就是TumblingWindows。

 如下代码，是对滑动窗口的使用

DataStream<T> input = ...;

// sliding event-time windows
input
    .keyBy(<key selector>)
    .window(SlidingEventTimeWindows.of(Time.seconds(10), Time.seconds(5)))
    .<windowed transformation>(<window function>);

// sliding processing-time windows
input
    .keyBy(<key selector>)
    .window(SlidingProcessingTimeWindows.of(Time.seconds(10), Time.seconds(5)))
    .<windowed transformation>(<window function>);

// sliding processing-time windows offset by -8 hours
input
    .keyBy(<key selector>)
    .window(SlidingProcessingTimeWindows.of(Time.hours(12), Time.hours(1), Time.hours(-8)))
    .<windowed transformation>(<window function>);

（3）Session Windows

会话窗口（Session Windows）主要是将某段时间内活跃度较高的数据聚合成一个窗口进行计算， 窗口的触发的条件是Session Gap，是指在规定的时间内如果没有数据活跃接入，则认为窗口结束，然后触发窗口计算结果。需要注意的是如果数据一直不间断地进入窗口，也会导致窗口始终不触发的情况。与滑动窗口、滚动窗口不同的是，Session Windows不需要有固定 windows size 和 slide time，只需要定义Session Gap，来规定不活跃数据的时间上限即可。

 如下代码，是对会话窗口的使用 

DataStream<T> input = ...;

// event-time session windows with static gap
input
    .keyBy(<key selector>)
    .window(EventTimeSessionWindows.withGap(Time.minutes(10)))
    .<windowed transformation>(<window function>);
    
// event-time session windows with dynamic gap
input
    .keyBy(<key selector>)
    .window(EventTimeSessionWindows.withDynamicGap((element) -> {
        // determine and return session gap
    }))
    .<windowed transformation>(<window function>);

// processing-time session windows with static gap
input
    .keyBy(<key selector>)
    .window(ProcessingTimeSessionWindows.withGap(Time.minutes(10)))
    .<windowed transformation>(<window function>);
    
// processing-time session windows with dynamic gap
input
    .keyBy(<key selector>)
    .window(ProcessingTimeSessionWindows.withDynamicGap((element) -> {
        // determine and return session gap
    }))
    .<windowed transformation>(<window function>);

 

（4）Global Windows

全局窗口会将相同的键的元素分配给同一个窗口。全局窗口因为没有一个自然的结束点，因此必须指定自定义触发器，否则，不会执行任何计算。

 如下代码，是对全局窗口的使用

DataStream<T> input = ...;

input
    .keyBy(<key selector>)
    .window(GlobalWindows.create())
    .<windowed transformation>(<window function>);

 

二、Window聚合函数

Flink中提供了四种类型的Window Function，分别为ReduceFunction、AggregateFunction 以及 ProcessWindowFunction,（sum 、max、min)等。

前三种类型的 Window Fucntion 按照计算原理的不同可以分为两大类：

（1）增量聚合函数：对应有 ReduceFunction、AggregateFunction；
增量聚合函数计算性能较高，占用存储空间少，主要因为基于中间状态的计算结果，窗口中只维护中间结果状态值，不需要缓存原始数据。
（2）全量窗口函数：对应有 ProcessWindowFunction、 WindowFunction
全量窗口函数使用的代价相对较高，性能比较弱， 主要因为此时算子需要对所有属于该窗口的接入数据进行缓存， 然后等到窗口触发的时候，对所有的原始数据进行汇总计算。

1、ReduceFunction

（1）说明

ReduceFunction定义了对输入的两个相同类型的数据元素按照指定的计算方法进行聚合的逻辑，然后输出类型相同的一个结果元素。即ReduceFunction的输入类型和输出类型必须相同

（2）案例

输入如下键值对，按key对value求和

[root@localhost ~]# nc -lk 8888
c 1
d 2
c 1
c 2
d 3

 完整代码如下：

import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.windowing.WindowFunction;
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 org.apache.flink.util.Collector;
 
public class TestFlinkOperator {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //按key求和
        DataStreamSource<String> dataStream = env.socketTextStream("122.114.85.238",8888);
        dataStream
        .map(new MyMapFunction())
        .keyBy(0)
        //滚动窗口，计算每个5秒的输入元素的和
        .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
        //按key累加
        .reduce((v1,v2) -> Tuple2.of(v1.f0, Long.valueOf(v1.f1) +Long.valueOf(v2.f1)))
		.print();
        env.execute();
    }
}

/**
 * 转换输入文本为二元组
 *
 */
class MyMapFunction implements MapFunction<String, Tuple2<String, Long>> {
	private static final long serialVersionUID = 1L;

	@Override
	public Tuple2<String, Long> map(String value) throws Exception {
		String[] split = value.split(" ");
		return Tuple2.of(split[0], Long.valueOf(split[1]));
	}
}

 输出

2> (c,4)
3> (d,5)

2、AggregateFunction

（1）说明

和ReduceFunction相似，AggregateFunction也是基于中间状态计算结果的增量计算函数，但AggregateFunction在窗口计算上更加通用。ReduceFunction的输入类型和输出类型可以相同。AggregateFunction接口相对ReduceFunction更加灵活，实现复杂度也相对较高。

AggregateFunction接口中定义了四个个需要复写的方法，createAccumulator()创建一个累加器，add()定义数据的添加逻辑，getResult定义了根据accumulator计算结果的逻辑，merge方法定义合并accumulator的逻辑。

（2）案例

输入如下键值对，按key对value求和

[root@localhost ~]# nc -lk 8888
c 1
d 2
c 1
c 2
d 3

 完整代码如下：

import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.windowing.WindowFunction;
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 org.apache.flink.util.Collector;
 
public class TestFlinkOperator {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //按key求和
        DataStreamSource<String> dataStream = env.socketTextStream("122.114.85.238",8888);
        dataStream
        .map(new MyMapFunction())
        .keyBy(0)
        //滚动窗口，计算每个5秒的输入元素的和
        .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
        //MyAggregateFunction求和，OutResultWindowFunction输出MyAggregateFunction结果
		.aggregate(new MyAggregateFunction(),new OutResultWindowFunction())
		.print();
        env.execute();
    }
}

/**
 * 转换输入文本为二元组
 *
 */
class MyMapFunction implements MapFunction<String, Tuple2<String, Long>> {
	private static final long serialVersionUID = 1L;

	@Override
	public Tuple2<String, Long> map(String value) throws Exception {
		String[] split = value.split(" ");
		return Tuple2.of(split[0], Long.valueOf(split[1]));
	}
}

/**
 *聚合累加
 */
class MyAggregateFunction implements AggregateFunction<Tuple2<String,Long>, Long, Long>{
	private static final long serialVersionUID = -4705678584168230654L;

	@Override
	public Long createAccumulator() {
		return 0L;
	}

	@Override
	public Long add(Tuple2<String, Long> value, Long accumulator) {
		return accumulator + value.f1;
	}

	@Override
	public Long getResult(Long accumulator) {
		return accumulator;
	}

	@Override
	public Long merge(Long a, Long b) {
		return a+b;
	}
	
}
 
/**
 * 输出结果
 */
class OutResultWindowFunction implements WindowFunction<Long,Tuple2<String,Long>,Tuple,TimeWindow> {
	
	private static final long serialVersionUID = -153402576910925970L;

	@Override
	public void apply(Tuple key, TimeWindow window, Iterable<Long> input,
			Collector<Tuple2<String, Long>> out) throws Exception {
		out.collect(Tuple2.of(key.getField(0), input.iterator().next()));
	}
}

输出：

2> (c,4)
3> (d,5)

 

3、ProcessWindowFunction

（1）说明

前面提到的ReduceFunction和AggregateFunction都是基于中间状态实现增量计算的窗口函数，虽然已经满足绝大多数场景，但在某些情况下，统计更复杂的指标可能需要依赖于窗口中所有的数据元素， 或需要操作窗口中的状态数据和窗口元数据， 这时就需要使用到ProcessWindowsFunction，ProcessWindowsFunction能够更加灵活地支持基于窗口全部数据元素的结果计算，例如对整个窗口数据排序取 TopN，这样的需要就必须使用ProcessWindowFunction。

（2）案例

输入成绩如下，对每次输入的成绩，按班级对每个人的成绩倒序排序

[root@localhost ~]# nc -lk 8888
二班 wm 100
一班 lisi 85
一班 ww 80
一班 zs 76
一班 ml 90
二班 zs 76
二班 ml 91

完整代码如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

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.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
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 org.apache.flink.util.Collector;
 
public class TestFlinkOperator {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //按key求和
        DataStreamSource<String> dataStream = env.socketTextStream("122.114.85.238",8888);
        dataStream
        .map(new MyMapFunction())
        .keyBy(0)
        //滚动窗口，计算每个5秒的输入元素的和
        .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
        //自定义实现排序逻辑
        .process(new MyProcessWindowFunction())
		.print();
        env.execute();
    }
}

class MyProcessWindowFunction extends ProcessWindowFunction<Tuple3<String,String,Long>, List<Tuple3<String,String,Long>>, Tuple, TimeWindow> {

	private static final long serialVersionUID = 1L;

	@Override
	public void process(
			Tuple key,
			ProcessWindowFunction<Tuple3<String,String, Long>, List<Tuple3<String,String,Long>>, Tuple, TimeWindow>.Context context,
			Iterable<Tuple3<String,String, Long>> it, 
			Collector<List<Tuple3<String,String,Long>>> out) throws Exception {
		
		List<Tuple3<String, String,Long>> list = new ArrayList<>();
		
		Iterator<Tuple3<String,String, Long>> iterator = it.iterator();
		while(iterator.hasNext()) {
			Tuple3<String, String,Long> tuple2 = iterator.next();
			list.add(tuple2);
		}
		Collections.sort(list, new Comparator<Tuple3<String, String,Long>>() {
	        @Override
	        public int compare(Tuple3<String, String,Long> o1, Tuple3<String,String, Long> o2) {
	            //降序，o1,o2反过来则升序
	            return o2.f2.compareTo(o1.f2);
	        }
	    });
		out.collect(list);
	}
	
}

/**
 * 转换输入文本为二元组
 *
 */
class MyMapFunction implements MapFunction<String, Tuple3<String,String, Long>> {
	private static final long serialVersionUID = 1L;

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

输出：

2> [(二班,wm,100), (二班,ml,91), (二班,zs,76)]
4> [(一班,ml,90), (一班,lisi,85), (一班,ww,80), (一班,zs,76)]

参考：https://ci.apache.org/projects/flink/flink-docs-release-1.9/zh/dev/stream/operators/windows.html

Relian哈哈
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flink 窗口的应用与实现.pdf
03-21
在实际应用中，Flink 可以与 Kafka 进行集成，Kafka 作为消息队列，负责接收和传递原始事件。Flink 的 ETL（提取、转换、加载）过程可以利用窗口功能对数据进行预处理，例如聚合（Aggregate）、过滤（Filter）等。...
Flink学习22：窗口的划分
hzp666的博客
08-31 852
主要有2种窗口，一个基于时间窗口，一个是基于数据窗口。时间窗口中起止时间是，左闭右开。
Flink系列之：窗口Top-N
zhengzaifeidelushang的博客
12-17 351
例如：在 Flink SQL Client 中，如果类型是 TIMESTAMP(3) ，2020-04-15 08:05 应该显示成 2020-04-15 08:05:00.000。例如：在 Flink SQL Client 中，如果类型是 TIMESTAMP(3) ，2020-04-15 08:05 应该显示成 2020-04-15 08:05:00.000。这条Flink SQL查询的目标是在表Bid中根据时间窗口对数据进行分组，并找出每个窗口内价格最高的三个供应商。
Flink窗口及其分类-详细说明
勇敢牛牛，不怕困难！
11-19 5234
Flink 是一种流式计算引擎，主要是来处理无界数据流的，数据源源不断、无穷无尽。想要更加方便高效地处理无界流，一种方式就是将无限数据切割成有限的“数据块”进行处理，这就是所谓的“窗口”（Window）。所以在 Flink 中，窗口其实并不是一个“框”，流进来的数据被框住了就只能进这一个窗口。相比之下，我们应该把窗口理解成一个“桶”。在 Flink 中，窗口可以把流切割成有限大小的多个“存储桶”（bucket)；每个数据都会分发到对应的桶中，当到达窗口结束时间时，就对每个桶中收集的数据进行计算处理。
flink中的分区、分组与分流
最新发布
qq_39889944的博客
01-19 742
介绍了flink中分区、分流和分组的概念，并配上了图片与代码。
flink是如何划分窗口的
weixin_43639977的博客
06-09 902
最近有个困惑，那就是flink的窗口到底是如何划分的，看很多博主的介绍说flink的窗口是系统定义好的，如何定义的都没说，话不多说搞源码。 在这@Override public Collection<TimeWindow> assignWindows(Object element, long timestamp, WindowAssignerContext context) { if (timestamp > Long.MIN_VALUE) { List<TimeWin
Flink窗口详解
勇心在馨
02-23 3471
一、Window类型 1、时间窗口（TimeWindow） （1）滚动时间窗口（Tumbling Window） 将数据依据固定的窗口长度对数据进行切分 特点：时间对齐，窗口长度固定，没有重叠 （2）滑动时间窗口（Sliding Window） 滑动窗口是固定窗口的更广义的一种形式，滑动窗口由固定的窗口长度和滑动间隔组成 特点：窗口长度固定，可以有重叠 （3）会话窗口（Se...
Flink开发-时间语义与窗口分类
qq884121435的博客
08-12 382
Flink开发-时间语义与窗口分类1.Flink的三种时间语义1.1 Event Time 事件时间1.2 Processing Time 处理时间1.3 Ingestion Time 进入时间1.4 设置时间标准2.Window Assinger2.1 滚动窗口（Tumbling Windows）2.2 滑动窗口（Sliding Windows）2.3 会话窗口（Session Windows）2.4 GlobalWindow3.窗口程序的骨架3.1 Non-Keyed Windows3.2 Keyed
Flink窗口全解析：三种时间窗口、窗口处理函数使用及案例
czl689的专栏
03-14 3089
我们经常需要在一个时间窗口维度上对数据进行聚合，窗口是流处理应用中经常需要解决的问题。Flink的窗口算子为我们提供了方便易用的API，我们可以将数据流切分成一个个窗口，对窗口内的数据进行处理。本文将介绍如何在Flink上进行窗口的计算。 一个Flink窗口应用的大致骨架结构如下所示： // Keyed Window stream .keyBy(...) <- 按照一个Key进行分组 .window(...) &
【Flink系列】窗口系列简介
qq_42875020的博客
10-17 2624
【Flink系列】窗口系列简介
Flink之窗口 (Window) 上篇
四维大脑的博客
04-26 4176
在 Flink 中, 窗口就是用来处理无界流的核心。我们很容易把窗口想象成一个固定位置的“框”，数据源源不断地流过来，到某个时间点窗口该关闭了，就停止收集数据、触发计算并输出结果。例如，我们定义一个时间窗口，每 10 秒统计一次数据，那么就相当于把窗口放在那里，从 0 秒开始收集数据；到 10 秒时，处理当前窗口内所有数据，输出一个结果，然后清空窗口继续收集数据；到 20 秒时，再对窗口内所有数据进行计算处理，输出结果；依次类推。
Flink在美团平台的实践与应用
01-27
上图呈现的是当前美团实时计算平台的简要架构。...standalone模式的部署方式，Flink由于其现在运行的环境，美团选择的是OnYARN模式，除了计算引擎之外，我们还提供一些实时存储功能，用于存储计算的中间状态、计算
Flink 中文文档资料.zip
01-17
flink Flink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料...
flink中文教程.zip
03-02
flink中文教程： 目录： 概念 教程 例子 应用开发 部署与运营 调试和监控 IDE开发 内幕
Flink 的Window 操作（基于flink 1.3描述）
weixin_33958585的博客
09-25 272
Window是无限数据流处理的核心，Window将一个无限的stream拆分成有限大小的”buckets”桶，我们可以在这些桶上做计算操作。本文主要聚焦于在Flink中如何进行窗口操作，以及程序员如何从window提供的功能中获得最大的收益。 　　窗口化的Flink程序的一般结构如下，第一个代码段中是分组的流，而第二段是非分组的流。正如我们所见，唯一的区别是分组的stream调用keyBy(…)...
大数据开发 | Flink中的窗口分类和生命周期
zjjcchina的博客
05-25 110
窗口的创建时间点是第一个属于窗口的元素到达后，不同的窗口有着不同的触发规则，触发器触发以后会进行计算，然后关闭销毁窗口。Gap是一个动态的值，也是说，间隔达到这个动态的值，那么就关闭窗口，有新的数据来，会再开启一个新窗口，只要动态值内有新的数据来，那么这个动态的值就会被刷新。到达结束时间时，窗口不再收集数据，触发计算，输出结果，并将窗口关闭销毁。比如Gap=10，只要10s没有接收到数据，那么就关闭这个窗口，有新的数据来，会再开启一个新的窗口，只要10s内有新的数据来，那么这个10s会被刷新。
208.Flink（三）：窗口的使用，处理函数的使用
鹏哥哥Aaa
09-27 798
窗口的使用，处理函数的使用
Flink窗口基础(一)
popping_w的博客
09-01 201
Flink窗口基础(一) 1、窗口概念： 流式计算是一种被设计用于处理无限数据集的数据处理引擎，而无限数据集是指一种不断增长的本质上无限的数据集，而Window窗口是一种切割无限数据为有限块进行处理的手段。 2、窗口的分类： 时间驱动：基于时间的窗口 **时间驱动→滚动窗口(Tumbling Windows)：**滚动窗口有固定的大小, 窗口与窗口之间不会重叠也没有缝隙。 滚动窗口能将数据流切分成不重叠的窗口，每一个事件只能属于一个窗口。如图 code： env .socketTextStream("
Apache Flink：Keyed Window与Non-Keyed Window
微信搜：import_bigdata，大数据领域硬核原创作者
08-02 1511
Apache Flink中，Window操作在流式数据处理中是非常核心的一种抽象，它把一个无限流数据集分割成一个个有界的Window（或称为Bucket），然后就可以非常...
flink原理与实践全套教学课件.
09-26
Flink是一个开源的流式处理框架，可以用于构建大规模、高可靠性的实时数据...总之，Flink原理与实践全套教学课件将帮助学习者全面了解Flink的原理和使用方法，并通过实例演示帮助学习者掌握Flink在实际项目中的应用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值