原文连接 https://ci.apache.org/projects/flink/flink-docs-release-1.6/dev/stream/operators/windows.html
Windows是无限数据流（infinite streams）处理的核心，Windows将一个stream拆分成有限大小的"桶（buckets）"，可以在这些桶上做计算操作。
窗口化的Flink程序的一般结构如下，第一个代码段中是分组的流，第二段是非分组的流。区别是分组的stream调用keyBy(...)和window(...)，非分组的stream中window(...)换成了windowAll(...)
分组窗口（Keyed Windows）
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"
无分组窗口（Non-Keyed Windows）
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"
方括号[]内的命令是可选的，这表明Flink允许你根据最符合你的要求来定义自己的window逻辑。
[toc]
Window生命周期（Window Lifecycle）
简单地说，当一个属于window的元素到达之后这个window就创建了，而当时间（event time或者processing time）超过window的创建时间和用户指定的延迟时间相加时，窗口将被彻底清除。
Flink确保了==只清除基于时间的window，其他类型的window不清除==，例如：Global window。举个例子：对于一个每5分钟创建无覆盖的窗口，允许一个1分钟的时延的窗口策略，Flink将会在12:00到12:05这段时间内第一个元素到达时创建窗口，当水印（wartmark）通过12:06时，移除这个窗口。
此外，每个window都有一个 Trigger 和一个Function（例如：ProcessWindowFunction，ReduceFunction，AggregateFunction和FoldFunction）。Function包含了应用于窗口内容的计算，Trigger指定了函数何时被触发。一个触发策略可以是 "当窗口中的元素个数超过4个时" 或者 "当水印达到窗口的边界时"。触发器还可以决定在窗口创建和删除之间的任意时刻，清除窗口的内容。清除仅指清除window内的元素而不是window的元数据，新的数据还是可以被添加到当前的window中。
除了上面的提到之外，还可以指定一个 Evictor，Evictor可以在触发器触发之后和在函数被应用之前或者之后，清除窗口中的元素。
分组和非分组Windows（Keyed vs Non-Keyed Windows）
首先，第一件事是==指定stream是分组的还是未分组的，这个必须在定义window之前定义好==。使用keyBy(...)会将stream拆分成逻辑分组的数据流，如果keyBy(...)函数不被调用的话，stream将不是分组的。
在分组stream中，任何正在传入的事件的属性都可以被当做 Specifying Keys，分组stream将通过多任务并发执行window计算，每一个逻辑分组stream在执行中是独立地进行的。
在非分组stream中，原始stream不会拆分成多个逻辑stream并且所有的window逻辑将在一个任务中执行，并发度为1。
窗口分配器（Window Assingers）
指定完你的数据流是分组的还是非分组的之后，接下来需要定义一个窗口分配器（WindowAssigner）。窗口分配定义了元素如何分配到窗口中，这是通过调用window(...)或者windowAll(...)时，选择的窗口分配器（WindowAssigner）来指定的。
WindowAssigner是==负责将每一个到来的元素分配给一个或者多个窗口==，Flink提供了一些常用的预定义窗口分配器，即：滚动窗口（tumbling windows）、滑动窗口（sliding windows）、会话窗口（session windows）和全局窗口（globalwindows），也可以通过继承WindowAssigner类来自定义自己的窗口。除了全局窗口分配器，其他所有的内置窗口分配器都是通过时间来分配元素到窗口中的，这个时间要么是event time，要么是processing time。
了解更多processing time和event time的区别及时间戳（timestamp）和水印（watermark）是如何产生的，查看 event time
滚动窗口（Tumbling Windows）
滚动窗口分配器将每个元素分配的一个指定窗口大小的窗口中，==滚动窗口有一个固定的大小，并且不会出现重叠==。例如：指定了一个5分钟大小的滚动窗口，当前窗口将被评估并将按下图说明每5分钟创建一个新的窗口。
Tumbling Windows
val input: DataStream[T] = ...// 滚动event-time窗口input .keyBy(<key selector>) .window(TumblingEventTimeWindows.of(Time.seconds(5))) .<windowed transformation>(<window function>) // 滚动processing-time窗口input .keyBy(<key selector>) .window(TumblingProcessingTimeWindows.of(Time.seconds(5))) .<windowed transformation>(<window function>)// 每日偏移8小时的滚动event-time窗口input .keyBy(<key selector>) .window(TumblingEventTimeWindows.of(Time.days(1), Time.hours(-8))) .<windowed transformation>(<window function>)
时间间隔可以通过Time.milliseconds(x)，Time.seconds(x)，Time.minutes(x)等其中的一个来指定。
在上面的最后一个例子中，滚动窗口分配器接受了一个可选的偏移参数，可以用来改变窗口的排列。例如：没有偏移的情况，按小时的滚动窗口将按整点时间对齐，会得到一系列窗口如： 1:00:00 ~ 1:59:59、 2:00:00 ~ 2:59:59 等。如果指定了一个15分钟的偏移，将得到的窗口如下： 1:15:00 ~ 2:14:59、 2:15:00 ~ 3:14:59 等。
时间偏移一个很大的用处是用来调准非0时区的窗口，例如：在中国你需要指定一个8小时的时间偏移。
滑动窗口（Sliding Windows）
滑动窗口分配器将元素分配到固定长度的窗口中，与滚动窗口类似，窗口的大小由窗口大小参数来配置，另一个==窗口滑动参数控制滑动窗口开始的频率==。因此，滑动窗口如果滑动参数小于滚动参数的话，窗口是可以重叠的，在这种情况下元素会被分配到多个窗口中。例如：你有10分钟的窗口和5分钟的滑动，那么每个窗口中5分钟的窗口里包含着上个10分钟产生的数据。
Sliding Windows
val input: DataStream[T] = ...// 滑动event-time窗口input .keyBy(<key selector>) .window(SlidingEventTimeWindows.of(Time.seconds(10), Time.seconds(5))) .<windowed transformation>(<window function>) // 滑动processing-time窗口input .keyBy(<key selector>) .window(SlidingProcessingTimeWindows.of(Time.seconds(10), Time.seconds(5))) .<windowed transformation>(<window function>)// 偏移8小时的滑动processing-time窗口input .keyBy(<key selector>) .window(SlidingProcessingTimeWindows.of(Time.hours(12), Time.hours(1), Time.hours(-8))) .<windowed transformation>(<window function>)
除了需要指定滑动时间参数，其他与滚动窗口类似，也可以指定偏移
会话窗口（Session Windows）
会话窗口分配器==通过session活动来对元素进行分组==，会话窗口跟滚动窗口和滑动窗口相比，==不会有重叠和固定的开始时间和结束时间的情况==。相应的，当它在一个固定的时间周期内不再收到元素，即非活动间隔产生，那个这个窗口就会关闭。
会话窗口可以配置一个静态session gap或定义了非活跃周期的session gap提取函数。当这个非活跃周期产生，当前的会话窗口将关闭并且后续的元素将被分配到新的会话窗口中。
Session Windows
val input: DataStream[T] = ...// event-time Session窗口，固定的Session gapinput
.keyBy(<key selector>)
.window(EventTimeSessionWindows.withGap(Time.minutes(10)))
.<windowed transformation>(<window function>)
// event-time Session窗口，动态的Session gapinput
.keyBy(<key selector>)
.window(EventTimeSessionWindows.withDynamicGap(new SessionWindowTimeGapExtractor[String] {
override def extract(element: String): Long = {
// 确定和返回session gap
}
}))
.<windowed transformation>(<window function>)// processing-time Session窗口，固定的Session gapinput
.keyBy(<key selector>)
.window(ProcessingTimeSessionWindows.withGap(Time.minutes(10)))
.<windowed transformation>(<window function>)// processing-time Session窗口，动态的Session gapinput
.keyBy(<key selector>)
.window(DynamicProcessingTimeSessionWindows.withDynamicGap(new SessionWindowTimeGapExtractor[String] {
override def extract(element: String): Long = {
// 确定和返回session gap
}
}))
.<windowed transformation>(<window function>)session windows没有一个固定的开始和结束时间。session windows操作为每一个到达的元素创建一个新的窗口，并合间隔时间小于指定时间间隔的窗口。为了进行合并，session windows的操作需要指定一个合并触发器（Trigger）和一个合并窗口函数（Window Function），如：ReduceFunction、AggregateFunction或者ProcessWindowFunction。
全局窗口（Global Windows）
全局窗口分配器==将所有具有相同key的元素分配到同一个全局窗口中==，这个窗口模式++仅适用于用户还需自定义触发器的情况++。否则，由于==全局窗口没有一个自然的结尾==，无法执行元素的聚合，将不会有计算被执行。
[图片上传失败...(image-24f35a-1534762158575)]
val input: DataStream[T] = ... input .keyBy(<key selector>) .window(GlobalWindows.create()) .<windowed transformation>(<window function>)
窗口函数（Window Functions）
定义完窗口分配器后，我们还需要为每一个窗口指定我们需要执行的计算，这是窗口的责任，当系统决定一个窗口已经准备好执行之后，这个窗口函数将被用来处理窗口中的每一个元素（可能是分组的）。当一个窗口准备好之后，Flink是如何决定的？
window函数可以是ReduceFunction、AggregateFunction、FoldFunction或ProcessWindowFunction中的一个。前面两个更高效一些，因为在++每个窗口中增量地对每一个到达的元素执行聚合操作++。一个ProcessWindowFunction可以获取一个窗口中的所有元素的迭代器（Iterable）以及元素所属窗口的额外元信息。
有ProcessWindowFunction的窗口化操作会比其他的操作效率要差一些，因为Flink内部在调用函数之前会将窗口中的所有元素都缓存起来。这个可以通过ProcessWindowFunction和ReduceFunction、AggregateFunction、FoldFunction结合使用来获取窗口中所有元素的增量聚合和额外的窗口元数据
ReduceFunction
ReduceFunction指定了如何==通过两个输入的参数进行合并输出一个同类型的参数==的过程，Flink使用ReduceFunction来对窗口中的元素进行增量聚合。
val input: DataStream[(String, Long)] = ...
input
.keyBy(<key selector>)
.window(<window assigner>)
.reduce { (v1, v2) => (v1._1, v1._2 + v2._2) }AggregateFunction
聚合函数是ReduceFunction的一种广义函数，具有三种类型：输入类型（in）、累加器类型（ACC）和输出类型（out）。输入类型是输入流中的元素类型，而聚合函数有一种将一个输入元素添加到累加器的方法。该接口还具有用于创建初始累加器的方法，用于将两个累加器合并为一个累加器，并从累加器中提取输出。
/**
* 这个AverageAggregate用来持续计算sum和count，getResult方法计算平均值
*/class AverageAggregate extends AggregateFunction[(String, Long), (Long, Long), Double] { // 创建初始累加器
override def createAccumulator() = (0L, 0L) // 将一个输入元素添加到累加器
override def add(value: (String, Long), accumulator: (Long, Long)) =
(accumulator._1 + value._2, accumulator._2 + 1L) // 输出结果
override def getResult(accumulator: (Long, Long)) = accumulator._1 / accumulator._2 // 合并累加器
override def merge(a: (Long, Long), b: (Long, Long)) =
(a._1 + b._1, a._2 + b._2)
}/* */val input: DataStream[(String, Long)] = ...
input
.keyBy(<key selector>)
.window(<window assigner>)
.aggregate(new AverageAggregate)FoldFunction
1.6.0+已经过期
FoldFunction指定了一个输入元素如何与一个输出类型的元素合并的过程，这个FoldFunction会被每一个加入到窗口中的元素和当前的输出值增量地调用，第一个元素是与一个预定义的类型为输出类型的初始值合并。
val input: DataStream[(String, Long)] = ...
input
.keyBy(<key selector>)
.window(<window assigner>) // 追加所有输入的长整型到一个空的字符串中。
.fold("") { (acc, v) => acc + v._2 }fold()不能应用于Session window或者其他可合并的窗口中。
ProcessWindowFunction
一个ProcessWindowFunction获得一个包含了window中的所有元素的迭代器（Iterable），和一个Context对象包含访问时间和状态信息，提供了更大的灵活性。这些带来了性能的成本和资源的消耗，因为window中的元素无法进行增量迭代，而是缓存起来直到window被认为是可以处理时。
val input: DataStream[(String, Long)] = ...
input
.keyBy(_._1)
.timeWindow(Time.minutes(5))
.process(new MyProcessWindowFunction())class MyProcessWindowFunction extends ProcessWindowFunction[(String, Long), String, String, TimeWindow] {
def process(key: String, context: Context, input: Iterable[(String, Long)], out: Collector[String]): () = {
var count = 0L for (in <- input) {
count = count + 1
}
out.collect(s"Window ${context.window} count: $count")
}
}上面的例子展示了统计一个window中元素个数，此外，还将window的信息添加到输出中。
使用ProcessWindowFunction来做简单的聚合操作，如:计数操作，性能是相当差的。将ReduceFunction跟ProcessWindowFunction结合起来，来获取增量聚合和添加到ProcessWindowFunction中的信息，性能更好。
ProcessWindowFunction with Incremental Aggregation
ProcessWindowFunction可以跟ReduceFunction、AggregateFunction或者FoldFunction结合来增量地对到达window中的元素进行聚合。当window关闭之后，ProcessWindowFunction就能提供聚合结果。当获取到WindowFunction额外的window元信息后就可以进行增量计算窗口了。
Incremental Window Aggregation with ReduceFunction
val input: DataStream[SensorReading] = ...
input
.keyBy(<key selector>)
.timeWindow(<duration>)
.reduce(
(r1: SensorReading, r2: SensorReading) => { if (r1.value > r2.value) r2 else r1 },
( key: String,
window: TimeWindow,
minReadings: Iterable[SensorReading], out: Collector[(Long, SensorReading)] ) =>
{
val min = minReadings.iterator.next() out.collect((window.getStart, min))
}
)Incremental Window Aggregation with AggregateFunction
val input: DataStream[(String, Long)] = ...
input
.keyBy(<key selector>)
.timeWindow(<duration>)
.aggregate(new AverageAggregate(), new MyProcessWindowFunction())// Function definitionsclass AverageAggregate extends AggregateFunction[(String, Long), (Long, Long), Double] {
...
}class MyProcessWindowFunction extends ProcessWindowFunction[Double, (String, Double), String, TimeWindow] {
def process(key: String, context: Context, averages: Iterable[Double], out: Collector[(String, Double]): () = {
val average = averages.iterator.next() out.collect((key, average))
}
}Incremental Window Aggregation with FoldFunction
val input: DataStream[SensorReading] = ...
input
.keyBy(<key selector>)
.timeWindow(<duration>)
.fold (
("", 0L, 0),
(acc: (String, Long, Int), r: SensorReading) => { ("", 0L, acc._3 + 1) },
( key: String,
window: TimeWindow,
counts: Iterable[(String, Long, Int)], out: Collector[(String, Long, Int)] ) =>
{
val count = counts.iterator.next() out.collect((key, window.getEnd, count._3))
}
)触发器（Triggers）
触发器决定了一个窗口何时可以被窗口函数处理，每一个窗口分配器都有一个默认的触发器，如果默认的触发器不能满足需要，你可以通过调用trigger(...)来指定一个自定义的触发器。
触发器的接口有5个方法来允许触发器处理不同的事件:
onElement()方法，每个元素被添加到窗口时调用onEventTime()方法，当一个已注册的事件时间计时器启动时调用onProcessingTime()方法，当一个已注册的处理时间计时器启动时调用onMerge()方法，与状态性触发器相关，当使用会话窗口时，两个触发器对应的窗口合并时，合并两个触发器的状态。clear()方法，执行任何需要清除的相应窗口
上面的方法中有两个需要注意的地方:
前三个通过返回一个TriggerResult来决定如何操作调用他们的事件，这些操作可以是下面操作中的一个：
CONTINUE：什么也不做
FIRE：触发计算
PURGE：清除窗口中的数据
FIRE_AND_PURGE：触发计算并清除窗口中的数据这些函数可以注册 "处理时间定时器" 或者 "事件时间计时器"，被用来为后续的操作使用
触发和清除（Fire and Purge）
一旦一个触发器决定一个窗口已经准备好进行处理，它将触发并返回FIRE或者FIRE_AND_PURGE。这是窗口操作==发送当前窗口结果的信号==，给定一个拥有一个ProcessWindowFunction的窗口，那么所有的元素都将发送到ProcessWindowFunction中（可能之后还会发送到驱逐器[Evitor]中）。ReduceFunction、AggregateFunction或者FoldFunction的窗口仅仅发送他们想要的聚合结果。
当一个触发器触发时，它可以是FIRE或者FIRE_AND_PURGE，如果是FIRE，将保持window中的内容，如果是FIRE_AND_PURGE，会清除window的内容。默认情况下，预实现的触发器仅仅是FIRE，不会清除window的状态。
清除操作仅清除window的内容，并留下潜在的窗口元信息和完整的触发器状态。
默认触发器（Default Triggers of WindowAssigners）
默认的触发器适用于许多种情况，例如：所有的事件时间分配器都有一个EventTimeTrigger作为默认的触发器，这个触发器仅在当水印通过窗口的最后时间时触发。
GlobalWindow默认的触发器是
NeverTrigger，是永远不会触发的，因此，在使用GlobalWindow时，需要定义一个自定义触发器。
通过调用
trigger(...)来指定一个触发器，你就重写了WindowAssigner的默认触发器。例如：如果你为TumblingEventTimeWindows指定了一个CountTrigger，就不会再通过时间来获取触发了，而是通过计数。现在，如果你想通过时间和计数来触发的话，你需要写自定义的触发器。
内置的和自定义的触发器（Build-in and Custom Triggers）
Flink有一些内置的触发器:
EventTimeTrigger，根据由水印衡量的事件时间的进度来的
ProcessingTimeTrigger，根据处理时间来触发
CountTrigger，一旦窗口中的元素个数超出了给定的限制就会触发
PurgingTrigger，作为另一个触发器的参数并将它转换成一个清除类型
如果想实现一个自定义的触发器，需要使用抽象类Trigger。这个API还在优化中，后续的Flink版本可能会改变。
驱逐器（Evictors）
Flink的窗口模型允许指定一个除了WindowAssigner和Trigger之外的可选参数Evitor，这个可以通过调用evitor(...)方法来实现。这个驱逐器可以在触发器触发之前或者之后，或者窗口函数被应用之前清理窗口中的元素。为了达到这个目的，Evitor接口有两个方法:
void evictBefore(Iterable<TimestampedValue<T>> elements, int size, W window, EvictorContext evictorContext);void evictAfter(Iterable<TimestampedValue<T>> elements, int size, W window, EvictorContext evictorContext);
evitorBefore()方法包含了在window function之前应用的驱逐逻辑，而evitorAfter()方法包含了在window function之后应用的驱逐逻辑。在window function应用之前被驱逐的元素将不会再被window function处理。
Flink有三个预实现的驱逐器:
CountEvitor：在窗口中保持一个用户指定数量的元素，并在窗口的开始处丢弃剩余的其他元素
DeltaEvitor：通过一个DeltaFunction和一个阈值，计算窗口缓存中最近的一个元素和剩余的所有元素的delta值，并清除delta值大于或者等于阈值的元素
TimeEvitor：对于一个给定的窗口，使用一个毫秒级的interval作为参数，它会找出元素中的最大时间戳max_ts，并清除时间戳小于（max_ts - interval）的元素。
默认情况下，所有预实现的evitor都是在window function前应用它们的逻辑
指定一个Evitor要防止预聚合，因为窗口中的所有元素必须得在计算之前传递到驱逐器中
Flink 并不保证窗口中的元素是有序的，所以驱逐器可能从窗口的开始处清除，元素到达的先后不是那么必要。
允许延迟（Allowed Lateness）
当使用event-time的window时，可能会出现元素到达晚了，Flink用来与事件时间联系的水印（watermark）已经过了元素所属的窗口的最后时间。
默认情况下，当水印已经过了窗口的最后时间时，晚到的元素会被丢弃。然而，Flink允许为窗口操作指定一个最大允许时延，允许时延指定了元素可以晚到多长时间，默认情况下是0，也就是说水印之后到达的元素将被丢弃。
水印已经过了窗口最后时间后才来的元素，如果还未到窗口最后时间加时延时间，那么元素任然添加到窗口中。如果依赖触发器的使用的话，晚到但是未丢弃的元素可能会导致窗口再次被触发。
为了达到这个目的，Flink将保持窗口的状态直到允许时延的发生，一旦发生，Flink将清除Window，删除window的状态。
val input: DataStream[T] = ... input .keyBy(<key selector>) .window(<window assigner>) .allowedLateness(<time>) .<windowed transformation>(<window function>)
当使用GlobalWindows分配器时，没有数据会被认为是延迟的，因为Global Window的最后时间是Long.MAX_VALUE。
以Side Output来获取延迟数据（Getting late data as a side output）
使用Flink的 Side Output 特性，你可以获得一个已经被丢弃的延迟数据流。
首先你需要在窗口化的数据流中调用sideOutputLateData(OutputTag)指定你需要获取延迟数据。然后，你就可以在window操作的结果中获取到Side output了。
val lateOutputTag = OutputTag[T]("late-data")
val input: DataStream[T] = ...
val result = input
.keyBy(<key selector>)
.window(<window assigner>)
.allowedLateness(<time>)
.sideOutputLateData(lateOutputTag)
.<windowed transformation>(<window function>)
val lateStream = result.getSideOutput(lateOutputTag)
作者：Alex90
链接：https://www.jianshu.com/p/551b714bdbbf
共同学习，写下你的评论
评论加载中...
作者其他优质文章
