原文连接 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逻辑。

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 gap
input
    .keyBy(<key selector>)
    .window(EventTimeSessionWindows.withGap(Time.minutes(10)))
    .<windowed transformation>(<window function>)

// event-time Session窗口，动态的Session gap
input
    .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 gap
input
    .keyBy(<key selector>)
    .window(ProcessingTimeSessionWindows.withGap(Time.minutes(10)))
    .<windowed transformation>(<window function>)


// processing-time Session窗口，动态的Session gap
input
    .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 definitions
class 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()方法，执行任何需要清除的相应窗口

上面的方法中有两个需要注意的地方:

1. 前三个通过返回一个TriggerResult来决定如何操作调用他们的事件，这些操作可以是下面操作中的一个：
   CONTINUE：什么也不做
   FIRE：触发计算
   PURGE：清除窗口中的数据
   FIRE_AND_PURGE：触发计算并清除窗口中的数据
2. 这些函数可以注册 "处理时间定时器" 或者 "事件时间计时器"，被用来为后续的操作使用

触发和清除（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)