Flink迟到数据处理

一、迟到的数据如何处理？

Event Time语义下我们使用Watermark来判断数据是否迟到。一个迟到元素是指元素到达窗口算子时，该元素本该被分配到某个窗口，但由于延迟，窗口已经触发计算。目前Flink有三种处理迟到数据的方式：
（1）直接将迟到数据丢弃：会造成数据丢失
（2）将迟到数据发送到另一个流：输出到侧输出流，保证数据的完整性，可更新计算结果
（3）重新执行一次计算，将迟到数据考虑进来，更新计算结果：数据准确率高，保证数据完整性

二、业务实现：将迟到数据输出到侧输出流

import org.apache.flink.api.common.functions.{AggregateFunction}
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.function.WindowFunction
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.util.Collector
object AllowedLatenessDemo {

  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    // 使用eventTime
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

    val stream= env.socketTextStream("flink101", 8888)
      .map(line => {
        var arr = line.split(",")
        Log(arr(0).trim,arr(1).trim, arr(2).trim, arr(3).trim, arr(4).trim.toLong, arr(5).trim.toLong)
      })

    val ds = stream.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[Log](Time.seconds(2)){
      override def extractTimestamp(element: Log): Long = {
        element.callTime  // EventTime
      }
    })

    // 定义一个侧输出流的标签
    val lateTag = new OutputTag[Log]("late")

    // 分组，开窗
    val result = ds.keyBy(_.sid)
        .timeWindow(Time.seconds(10), Time.seconds(5))
    // 设置迟到的数据超过了2秒的情况下，交给AllowedLateness处理
    // 也分两种情况，第一种：允许数据迟到5秒（迟到2-5秒），再次迟到触发窗口函数，触发的条件是 watermark < end-of-window + AllowedLateness
    // 第二种：迟到的数据在5秒以上，输出到侧流中
        .allowedLateness(Time.seconds(5)) // 运行数据迟到5秒，还可以触发窗口
        .sideOutputLateData(lateTag)
        .aggregate(new MyAggregateCountFunction, new OutputResultWindowFunction)  // 窗口聚合函数

    // 正常的结果数据
    result.print("normal data")
    result.getSideOutput(lateTag).print("late data")  // 迟到时间超过5秒的数据，根据业务做处理，如果正常数据存储到mysql中，迟到的数据需要进行update

    env.execute("AllowedLatenessDemo")
  }

  // 统计通话的次数
  class MyAggregateCountFunction extends AggregateFunction[Log, Long, Long] {
    override def createAccumulator(): Long = 0

    override def add(in: Log, acc: Long): Long = acc + 1

    override def getResult(acc: Long): Long = acc

    override def merge(acc: Long, acc1: Long): Long = acc + acc1
  }

  // AggregateFunction 输出是这个函数的输入
  class OutputResultWindowFunction extends WindowFunction[Long, String, String, TimeWindow] {
    override def apply(key: String, window: TimeWindow, input: Iterable[Long], out: Collector[String]): Unit = {
      var value = input.iterator.next()
      var sb = new StringBuilder
      sb.append("窗口的范围：")
        .append(window.getStart)
        .append("--")
        .append(window.getEnd)
        .append(", 通话的次数是: ")
        .append(value)
      out.collect(sb.toString())
    }
  }
}

总结

allowedLateness设置窗口结束后还要等待长为lateness的时间，某个迟到元素的Event Time大于窗口结束时间但是小于结束时间+lateness，该元素仍然会被加入到该窗口中。