1、Window概述
streaming流式计算是一种被设计用于处理无限数据集的数据处理引擎,而无限数据集是指一种不断增长的本质上无限的数据集,而window是一种切割无限数据为有限块进行处理的手段。
Window是无限数据流处理的核心,Window将一个无限的stream拆分成有限大小的”buckets”桶,我们可以在这些桶上做计算操作。
2、Window类型
Window可以分成两类:
- CountWindow:按照指定的数据条数生成一个Window,与时间无关。
- TimeWindow:按照时间生成Window。
对于TimeWindow,可以根据窗口实现原理的不同分成三类:
- 滚动窗口(Tumbling Window)
- 滑动窗口(Sliding Window)
- 会话窗口(Session Window)
滚动窗口(Tumbling Windows)
将数据依据固定的窗口长度对数据进行切片。
特点:时间对齐,窗口长度固定,没有重叠。
滚动窗口分配器将每个元素分配到一个指定窗口大小的窗口中,滚动窗口有一个固定的大小,并且不会出现重叠。例如:如果你指定了一个5分钟大小的滚动窗口,窗口的创建如下图所示:
代码片段
1 val input: DataStream[T] = ... 2 3 // tumbling event-time windows 4 input 5 .keyBy(<key selector>) 6 .window(TumblingEventTimeWindows.of(Time.seconds(5))) 7 .<windowed transformation>(<window function>) 8 9 // tumbling processing-time windows 10 input 11 .keyBy(<key selector>) 12 .window(TumblingProcessingTimeWindows.of(Time.seconds(5))) 13 .<windowed transformation>(<window function>) 14 15 // daily tumbling event-time windows offset by -8 hours. 16 input 17 .keyBy(<key selector>) 18 .window(TumblingEventTimeWindows.of(Time.days(1), Time.hours(-8))) 19 .<windowed transformation>(<window function>)
适用场景:适合做BI统计等(做每个时间段的聚合计算)
滑动窗口(Sliding Windows)
滑动窗口是固定窗口的更广义的一种形式,滑动窗口由固定的窗口长度和滑动间隔组成。
特点:时间对齐,窗口长度固定,可以有重叠。
滑动窗口分配器将元素分配到固定长度的窗口中,与滚动窗口类似,窗口的大小由窗口大小参数来配置,另一个窗口滑动参数控制滑动窗口开始的频率。因此,滑动窗口如果滑动参数小于窗口大小的话,窗口是可以重叠的,在这种情况下元素会被分配到多个窗口中。
例如,你有10分钟的窗口和5分钟的滑动,那么每个窗口中5分钟的窗口里包含着上个10分钟产生的数据,如下图所示:
代码片段
1 val input: DataStream[T] = ... 2 3 // sliding event-time windows 4 input 5 .keyBy(<key selector>) 6 .window(SlidingEventTimeWindows.of(Time.seconds(10), Time.seconds(5))) 7 .<windowed transformation>(<window function>) 8 9 // sliding processing-time windows 10 input 11 .keyBy(<key selector>) 12 .window(SlidingProcessingTimeWindows.of(Time.seconds(10), Time.seconds(5))) 13 .<windowed transformation>(<window function>) 14 15 // sliding processing-time windows offset by -8 hours 16 input 17 .keyBy(<key selector>) 18 .window(SlidingProcessingTimeWindows.of(Time.hours(12), Time.hours(1), Time.hours(-8))) 19 .<windowed transformation>(<window function>)
适用场景:对最近一个时间段内的统计(求某接口最近5min的失败率来决定是否要报警)。
会话窗口(Session Windows)
由一系列事件组合一个指定时间长度的timeout间隙组成,类似于web应用的session,也就是一段时间没有接收到新数据就会生成新的窗口。
特点:时间无对齐。
session窗口分配器通过session活动来对元素进行分组,session窗口跟滚动窗口和滑动窗口相比,不会有重叠和固定的开始时间和结束时间的情况,相反,当它在一个固定的时间周期内不再收到元素,即非活动间隔产生,那个这个窗口就会关闭。一个session窗口通过一个session间隔来配置,这个session间隔定义了非活跃周期的长度,当这个非活跃周期产生,那么当前的session将关闭并且后续的元素将被分配到新的session窗口中去。
代码
1 val input: DataStream[T] = ... 2 3 // event-time session windows with static gap 4 input 5 .keyBy(<key selector>) 6 .window(EventTimeSessionWindows.withGap(Time.minutes(10))) 7 .<windowed transformation>(<window function>) 8 9 // event-time session windows with dynamic gap 10 input 11 .keyBy(<key selector>) 12 .window(EventTimeSessionWindows.withDynamicGap(new SessionWindowTimeGapExtractor[String] { 13 override def extract(element: String): Long = { 14 // determine and return session gap 15 } 16 })) 17 .<windowed transformation>(<window function>) 18 19 // processing-time session windows with static gap 20 input 21 .keyBy(<key selector>) 22 .window(ProcessingTimeSessionWindows.withGap(Time.minutes(10))) 23 .<windowed transformation>(<window function>) 24 25 26 // processing-time session windows with dynamic gap 27 input 28 .keyBy(<key selector>) 29 .window(DynamicProcessingTimeSessionWindows.withDynamicGap(new SessionWindowTimeGapExtractor[String] { 30 override def extract(element: String): Long = { 31 // determine and return session gap 32 } 33 })) 34 .<windowed transformation>(<window function>)
3、WindowAPI
3.1 TimeWindow
TimeWindow是将指定时间范围内的所有数据组成一个window,一次对一个window里面的所有数据进行计算。
1. 滚动窗口
Flink默认的时间窗口根据Processing Time 进行窗口的划分,将Flink获取到的数据根据进入Flink的时间划分到不同的窗口中。然后就可以对窗口的数据进行聚合等操作
1 val dataDS: DataStream[String] = env.socketTextStream("hadoop01", 9999) 2 3 val mapDS = dataDS.map(data=>{ 4 val datas = data.split(",") 5 (datas(0),1) 6 }) 7 8 val reduceDS: DataStream[(String, Int)] = mapDS.keyBy(_._1) 9 .timeWindow(Time.seconds(5)).reduce( 10 (t1, t2) => { 11 (t1._1, t1._2 + t2._2) 12 } 13 ) 14 15 reduceDS.print()
时间间隔可以通过Time.milliseconds(x),Time.seconds(x),Time.minutes(x)等其中的一个来指定。
2.滑动窗口
滑动窗口和滚动窗口的函数名是完全一致的,只是在传参数时需要传入两个参数,一个是window_size,一个是sliding_size。
下面代码中的sliding_size设置为了3s,也就是说,窗口每3s就计算一次,每一次计算的window范围是6s内的所有元素。
1 val dataDS: DataStream[String] = env.socketTextStream("hadoop01", 9999) 2 3 val mapDS = dataDS.map(data=>{ 4 val datas = data.split(",") 5 (datas(0),1) 6 }) 7 8 val reduceDS: DataStream[(String, Int)] = mapDS.keyBy(_._1) 9 .timeWindow(Time.seconds(6),Time.seconds(3)).reduce( 10 (t1, t2) => { 11 (t1._1, t1._2 + t2._2) 12 } 13 ) 14 15 reduceDS.print()
时间间隔可以通过Time.milliseconds(x),Time.seconds(x),Time.minutes(x)等其中的一个来指定。
3.2 CountWindow
CountWindow根据窗口中相同key元素的数量来触发执行,执行时只计算元素数量达到窗口大小的key对应的结果。
注意:CountWindow的window_size指的是相同Key的元素的个数,不是输入的所有元素的总数。
1.滚动窗口
默认的CountWindow是一个滚动窗口,只需要指定窗口大小即可,当元素数量达到窗口大小时,就会触发窗口的执行。
1 val dataDS: DataStream[String] = env.socketTextStream("hadoop01", 9999) 2 3 val mapDS = dataDS.map(data=>{ 4 val datas = data.split(",") 5 (datas(0),1) 6 }) 7 8 val reduceDS: DataStream[(String, Int)] = mapDS.keyBy(_._1) 9 .countWindow(3).reduce( 10 (t1, t2) => { 11 (t1._1, t1._2 + t2._2) 12 } 13 ) 14 15 reduceDS.print()
2.滑动窗口
滑动窗口和滚动窗口的函数名是完全一致的,只是在传参数时需要传入两个参数,一个是window_size,一个是sliding_size。
下面代码中的sliding_size设置为了2,也就是说,每收到两个相同key的数据就计算一次,每一次计算的window范围是3个元素。
1 val dataDS: DataStream[String] = env.socketTextStream("hadoop01", 9999) 2 3 val mapDS = dataDS.map(data=>{ 4 val datas = data.split(",") 5 (datas(0),datas(2).toInt) 6 }) 7 8 val reduceDS: DataStream[(String, Int)] = mapDS.keyBy(_._1) 9 .countWindow(3,2).reduce( 10 (t1, t2) => { 11 (t1._1, t1._2 + t2._2) 12 } 13 ) 14 15 reduceDS.print()
3.3 Window function
window function 定义了要对窗口中收集数据后所做的计算操作,主要可以分为两类:
- 增量聚合函数(incremental aggregation functions)
- 全窗口函数(full window functions)
增量聚合函数(incremental aggregation functions)
每条数据到来就进行计算,保持一个简单的状态。典型的增量聚合函数有
ReduceFunction
1 val dataDS: DataStream[String] = 2 env.socketTextStream("linux1", 9999) 3 4 val mapDS = dataDS.map(data=>{ 5 val datas = data.split(",") 6 (datas(0),datas(2).toInt) 7 }) 8 9 val reduceDS: DataStream[(String, Int)] = mapDS.keyBy(_._1) 10 .timeWindow(Time.seconds(3)).reduce( 11 new ReduceFunction[(String, Int)] { 12 override def reduce(t: (String, Int), t1: (String, Int)): (String, Int) = { 13 (t._1, t._2 + t1._2) 14 } 15 } 16 ) 17 18 reduceDS.print() 19 val dataDS: DataStream[String] = 20 env.socketTextStream("linux1", 9999) 21 22 val mapDS = dataDS.map(data=>{ 23 val datas = data.split(",") 24 (datas(0),datas(2).toInt) 25 }) 26 27 val reduceDS: DataStream[(String, Int)] = mapDS.keyBy(_._1) 28 .timeWindow(Time.seconds(3)).reduce( 29 new ReduceFunction[(String, Int)] { 30 override def reduce(t: (String, Int), t1: (String, Int)): (String, Int) = { 31 (t._1, t._2 + t1._2) 32 } 33 } 34 ) 35 36 reduceDS.print()
AggregateFunction
1 val dataDS: DataStream[String] = 2 env.socketTextStream("linux1", 9999) 3 4 val mapDS = dataDS.map(data=>{ 5 val datas = data.split(",") 6 (datas(0),datas(2).toInt) 7 }) 8 9 val aggregateDS: DataStream[(String, Int)] = mapDS.keyBy(_._1) 10 .countWindow(3).aggregate( 11 // TODO 此处聚合函数类似于Spark中的累加器 12 new AggregateFunction[(String, Int), (Int, Int), (String, Int)] { 13 override def createAccumulator(): (Int, Int) = { 14 (0,0) 15 } 16 17 override def add(in: (String, Int), acc: (Int, Int)): (Int, Int) = { 18 (in._2 + acc._1, acc._2 + 1) 19 } 20 21 override def getResult(acc: (Int, Int)): (String, Int) = { 22 ("sensor", (acc._1 / acc._2)) 23 } 24 25 override def merge(acc: (Int, Int), acc1: (Int, Int)): (Int, Int) = { 26 (acc._1 + acc1._1, acc._2 + acc1._2) 27 } 28 } 29 ) 30 31 aggregateDS.print()
全窗口函数(full window functions)
先把窗口所有数据收集起来,等到计算的时候会遍历所有数据。ProcessWindowFunction就是一个对整个窗口中数据处理的函数。
1 val dataDS: DataStream[String] = 2 env.socketTextStream("linux1", 9999) 3 4 val mapDS = dataDS.map(data=>{ 5 val datas = data.split(",") 6 (datas(0),datas(2).toInt) 7 }) 8 9 val processDS: DataStream[String] = mapDS.keyBy(_._1) 10 .countWindow(3) 11 .process(new ProcessWindowFunction[(String, Int), String, String, GlobalWindow] { 12 override def process(key: String, context: Context, elements: Iterable[(String, Int)], out: Collector[String]): Unit = { 13 //println(elements.mkString(",")) 14 out.collect(elements.mkString(",")) 15 } 16 }) 17 processDS.print()
3.4 其他API
- .trigger() —— 触发器
定义 window 什么时候关闭,触发计算并输出结果
- .evitor() —— 移除器
定义移除某些数据的逻辑
- .allowedLateness() —— 允许处理迟到的数据
- .sideOutputLateData() —— 将迟到的数据放入侧输出流
- .getSideOutput() —— 获取侧输出流