Window概述
streaming流式计算是一种被设计用于处理无限数据集的数据处理引擎，而无限数据集是指一种不断增长的本质上无限的数据集，而window是一种切割无限数据为有限块进行处理的手段。
Window是无限数据流处理的核心，Window将一个无限的stream拆分成有限大小的”buckets”桶，我们可以在这些桶上做计算操作。
Window类型
Window可以分成两类：
- CountWindow：按照指定的数据条数生成一个Window，与时间无关。
- TimeWindow：按照时间生成Window。
对于TimeWindow，可以根据窗口实现原理的不同分成三类：滚动窗口（Tumbling Window）、滑动窗口（Sliding Window）和会话窗口（Session Window）
Flink中的时间语义
在Flink的流式处理中，会涉及到时间的不同概念，如下图所示：
Event Time：是事件创建的时间。它通常由事件中的时间戳描述，例如采集的日志数据中，每一条日志都会记录自己的生成时间，Flink通过时间戳分配器访问事件时间戳。
Ingestion Time：是数据进入Flink的时间。
Processing Time：是每一个执行基于时间操作的算子的本地系统时间，与机器相关，默认的时间属性就是Processing Time。
Watermark
我们知道，流处理从事件产生，到流经source，再到operator，中间是有一个过程和时间的，虽然大部分情况下，流到operator的数据都是按照事件产生的时间顺序来的，但是也不排除由于网络、分布式等原因，导致乱序的产生，所谓乱序，就是指Flink接收到的事件的先后顺序不是严格按照事件的Event Time顺序排列的。
那么此时出现一个问题，一旦出现乱序，如果只根据eventTime决定window的运行，我们不能明确数据是否全部到位，但又不能无限期的等下去，此时必须要有个机制来保证一个特定的时间后，必须触发window去进行计算了，这个特别的机制，就是Watermark。
Watermark是一种衡量Event Time进展的机制。
Watermark是用于处理乱序事件的，而正确的处理乱序事件，通常用Watermark机制结合window来实现。
数据流中的Watermark用于表示timestamp小于Watermark的数据，都已经到达了，因此，window的执行也是由Watermark触发的。
Watermark可以理解成一个延迟触发机制，我们可以设置Watermark的延时时长t，每次系统会校验已经到达的数据中最大的maxEventTime，然后认定eventTime小于maxEventTime - t的所有数据都已经到达，如果有窗口的停止时间等于maxEventTime – t，那么这个窗口被触发执行。
/**
*/
object WindowTest {
def main(args: Array[String]): Unit = {
val env = StreamExecutionEnvironment.getExecutionEnvironment
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
env.getConfig.setAutoWatermarkInterval(100)
env.setParallelism(1)
// 读取数据
// val filePath = "src/main/resources/sensor.txt"
// val inputStream: DataStream[String] = env.readTextFile(filePath)
// val inputStream: DataStream[String] = env.socketTextStream("localhost", 7777)
val properties = new Properties()
properties.setProperty("bootstrap.servers", "10.4.14.27:9092")
properties.setProperty("group.id", "consumer-group")
properties.setProperty("key.deserializer","org.apache.kafka.common.serialization.StringDeserializer")
properties.setProperty("value.deserializer","org.apache.kafka.common.serialization.StringDeserializer")
properties.setProperty("atuo.offset.reset","latest")
val inputStream = env.addSource( new FlinkKafkaConsumer011[String]("windowtest", new SimpleStringSchema(), properties) )
val dataStream = inputStream
.map(line => {
val arr = line.split(",")
SensorReading(arr(0).trim, arr(1).trim.toLong, arr(2).trim.toDouble)
})
// TimestampAssigner
//对于排好序的数据，不需要延迟触发，可以只指定时间戳就行了
// .assignAscendingTimestamps( data => data.timestamp * 1000L ) // 升序数据的时间戳提取
.assignTimestampsAndWatermarks( new BoundedOutOfOrdernessTimestampExtractor[SensorReading](Time.seconds(3)) {
override def extractTimestamp(element: SensorReading): Long = element.timestamp * 1000L
} )
// 开窗聚合操作
val aggStream = dataStream
.keyBy(_.id)
// 窗口分配器
.timeWindow(Time.seconds(15)) // 15秒大小的滚动窗口
//window的开始时间
// timestamp - (timestamp - offset + windowSize) % windowSize
// 195-210 213的数据发送后窗口才关闭
// 210-225
// 可选API
// .trigger()
// .evictor()
// .allowedLateness(Time.minutes(1))
// .sideOutputLateData(new OutputTag[SensorReading]("late-data"))
// 窗口函数
// .minBy("temperature")
// .reduce( (curState, newData) => SensorReading(newData.id, newData.timestamp + 1, curState.temperature.max(newData.temperature))
//.reduce( new MyMaxTemp() )
.aggregate(new MyAvgTemp())
// aggStream.getSideOutput(new OutputTag[SensorReading]("late-data")).print("late")
dataStream.print("data")
aggStream.print("agg")
env.execute("window api job")
}
}
// 自定义取窗口最大温度值的聚合函数
class MyMaxTemp() extends ReduceFunction[SensorReading]{
override def reduce(value1: SensorReading, value2: SensorReading): SensorReading =
SensorReading(value1.id, value2.timestamp + 1, value1.temperature.max(value2.temperature))
}
// 自定义一个求平均温度的聚合函数
/**
* IN
* ACC id,总值,个数
* OUT
*/
class MyAvgTemp() extends AggregateFunction[SensorReading, (String, Double, Int), (String, Double)]{
override def add(value: SensorReading, accumulator: (String, Double, Int)): (String, Double, Int) =
( value.id, accumulator._2 + value.temperature, accumulator._3 + 1 )
override def createAccumulator(): (String, Double, Int) = ("", 0.0, 0)
override def getResult(accumulator: (String, Double, Int)): (String, Double) =
( accumulator._1, accumulator._2 / accumulator._3 )
override def merge(a: (String, Double, Int), b: (String, Double, Int)): (String, Double, Int) =
( a._1, a._2 + b._2, a._3 + b._3 )
}
测试数据：
sensor_1,1547718199,35.8
sensor_6,1547718201,15.4
sensor_7,1547718202,6.7
sensor_1,1547718213,30.9
sensor_1,1547718224,32.9
sensor_1,1547718228,20
sensor_1,1547718223,10
运行结果：
data> SensorReading(sensor_1,1547718199,35.8)
data> SensorReading(sensor_6,1547718201,15.4)
data> SensorReading(sensor_7,1547718202,6.7)
data> SensorReading(sensor_1,1547718213,30.9)
agg> (sensor_1,35.8)
agg> (sensor_6,15.4)
agg> (sensor_7,6.7)
窗口的起始时间和窗口大小
window的开始时间
timestamp - (timestamp - offset + windowSize) % windowSize
窗口大小 左闭右开，由于wartermark为3s
第一次窗口范围：[195-210) 213的数据发送后窗口才关闭