Flink入门2

2024-05-13 | 0 评论 | 0 浏览

一、时间语义与 Wartermark

1、 Flink 中的时间语义

在 Flink 的流式处理中，会涉及到时间的不同概念，如下图所示：

Event Time ：是事件创建的时间。它通常由事件中的时间戳描述，例如采集的
日志数据中，每一条日志都会记录自己的生成时间，Flink 通过时间戳分配器访问事
件时间戳。
Ingestion Time ：是数据进入 Flink 的时间。
Processing Time ：是每一个执行基于时间操作的算子的本地系统时间，与机器
相关，默认的时间属性就是 Processing Time。

一个例子——电影《星球大战》：

例如，一条日志进入 Flink 的时间为 2017-11-12 10:00:00.123，到达 Window 的

系统时间为 2017-11-12 10:00:01.234，日志的内容如下：

2017-11-02 18:37:15.624 INFO Fail over to rm2

对于业务来说，要统计 1min 内的故障日志个数，哪个时间是最有意义的？——

eventTime，因为我们要根据日志的生成时间进行统计。

2、 EventTime 的引入

在 Flink 的流式处理中，绝大部分的业务都会使用 eventTime ，一般只在
eventTime 无法使用时，才会被迫使用 ProcessingTime 或者 IngestionTime。

如果要使用 EventTime，那么需要引入 EventTime 的时间属性，引入方式如下所

示：

val env = StreamExecutionEnvironment.getExecutionEnvironment
// 从调用时刻开始给 env 创建的每一个 stream 追加时间特征
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

3、 Watermark

3.1、基本概念

我们知道，流处理从事件产生，到流经 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，那么这个窗口被触发执行。

有序流的 Watermarker 如下图所示：（Watermark 设置为 0）

乱序流的 Watermarker 如下图所示：（Watermark 设置为 2）

当 Flink 接收到数据时，会按照一定的规则去生成 Watermark，这条 Watermark
就等于当前所有到达数据中的 maxEventTime - 延迟时长，也就是说，Watermark 是
由数据携带的，一旦数据携带的 Watermark 比当前未触发的窗口的停止时间要晚，
那么就会触发相应窗口的执行。由于 Watermark 是由数据携带的，因此，如果运行
过程中无法获取新的数据，那么没有被触发的窗口将永远都不被触发。
上图中，我们设置的允许最大延迟到达时间为 2s，所以时间戳为 7s 的事件对应
的 Watermark 是 5s，时间戳为 12s 的事件的 Watermark 是 10s，如果我们的窗口 1
是 1s~5s，窗口 2 是 6s~10s，那么时间戳为 7s 的事件到达时的 Watermarker 恰好触
发窗口 1，时间戳为 12s 的事件到达时的 Watermark 恰好触发窗口 2。

Watermark 就是触发前一窗口的“关窗时间”，一旦触发关门那么以当前时刻

为准在窗口范围内的所有所有数据都会收入窗中。

只要没有达到水位那么不管现实中的时间推进了多久都不会触发关窗。

3.2、Watermark 的引入

watermark 的引入很简单，对于乱序数据，最常见的引用方式如下：

dataStream.assignTimestampsAndWatermarks( new 
BoundedOutOfOrdernessTimestampExtractor[SensorReading](Time.millisecond
s(1000)) {
 override def extractTimestamp(element: SensorReading): Long = {
 element.timestamp * 1000
 }
} )

Event Time 的使用一定要 指定数据源中的时间戳 。否则程序无法知道事件的事
件时间是什么(数据源里的数据没有时间戳的话，就只能使用 Processing Time 了)。
我们看到上面的例子中创建了一个看起来有点复杂的类，这个类实现的其实就
是分配时间戳的接口。Flink 暴露了 TimestampAssigner 接口供我们实现，使我们可
以自定义如何从事件数据中抽取时间戳。

val env = StreamExecutionEnvironment.getExecutionEnvironment
// 从调用时刻开始给 env 创建的每一个 stream 追加时间特性
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
val readings: DataStream[SensorReading] = env
.addSource(new SensorSource) .assignTimestampsAndWatermarks(new MyAssigner())

MyAssigner 有两种类型

AssignerWithPeriodicWatermarks
AssignerWithPunctuatedWatermarks

以上两个接口都继承自 TimestampAssigner。

Assigner with periodic watermarks

周期性的生成 watermark：系统会周期性的将 watermark 插入到流中(水位线也
是一种特殊的事件!)。默认周期是 200 毫秒。可以使用
ExecutionConfig.setAutoWatermarkInterval()方法进行设置。

val env = StreamExecutionEnvironment.getExecutionEnvironment
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
// 每隔 5 秒产生一个 watermark
env.getConfig.setAutoWatermarkInterval(5000)

产生 watermark 的逻辑：每隔 5 秒钟，Flink 会调用

AssignerWithPeriodicWatermarks 的 getCurrentWatermark()方法。如果方法返回一个
时间戳大于之前水位的时间戳，新的 watermark 会被插入到流中。这个检查保证了
水位线是单调递增的。如果方法返回的时间戳小于等于之前水位的时间戳，则不会
产生新的 watermark。

例子，自定义一个周期性的时间戳抽取：

class PeriodicAssigner extends
AssignerWithPeriodicWatermarks[SensorReading] {
val bound: Long = 60 * 1000 // 延时为 1 分钟
var maxTs: Long = Long.MinValue // 观察到的最大时间戳
override def getCurrentWatermark: Watermark = {
new Watermark(maxTs - bound) }
override def extractTimestamp(r: SensorReading, previousTS: Long) = {
maxTs = maxTs.max(r.timestamp) r.timestamp
} }

一种简单的特殊情况是，如果我们事先得知数据流的时间戳是单调递增的，也

就是说没有乱序，那我们可以使用 assignAscendingTimestamps，这个方法会直接使

用数据的时间戳生成 watermark。

val stream: DataStream[SensorReading] = ...
val withTimestampsAndWatermarks = stream
.assignAscendingTimestamps(e => e.timestamp)
>> result: E(1), W(1), E(2), W(2), ...

而对于乱序数据流，如果我们能大致估算出数据流中的事件的最大延迟时间，

就可以使用如下代码：

val stream: DataStream[SensorReading] = ...
val withTimestampsAndWatermarks = stream.assignTimestampsAndWatermarks(
new SensorTimeAssigner
)
class SensorTimeAssigner extends
BoundedOutOfOrdernessTimestampExtractor[SensorReading](Time.seconds(5)) {
// 抽取时间戳
override def extractTimestamp(r: SensorReading): Long = r.timestamp
}
>> relust: E(10), W(0), E(8), E(7), E(11), W(1), ...

Assigner with punctuated watermarks

间断式地生成 watermark。和周期性生成的方式不同，这种方式不是固定时间的，

而是可以根据需要对每条数据进行筛选和处理。直接上代码来举个例子，我们只给

sensor_1 的传感器的数据流插入 watermark：

class PunctuatedAssigner extends
AssignerWithPunctuatedWatermarks[SensorReading] {
val bound: Long = 60 * 1000
override def checkAndGetNextWatermark(r: SensorReading, extractedTS:
Long): Watermark = {
if (r.id == "sensor_1") {
new Watermark(extractedTS - bound) } else {
null
} }
override def extractTimestamp(r: SensorReading, previousTS: Long): Long
= { r.timestamp
} 
}

4、 EvnetTime 在 window 中的使用

案例一：Flink窗口操作之简单测试

4.1、滚动窗口（TumblingEventTimeWindows）

代码具体实现：

package com.apache.watermark

import com.apache.flinkapi.SensorReading
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.time.Time
/**
 * Watermark 的引入
 */
object WindowTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    //从文件读取数据
 //   val inputStream = env.readTextFile("D:\\Flink\\src\\main\\resources\\sensor.txt")
  val inputStream=env.socketTextStream("spark2.x",7777)

    val dataStream = inputStream
      .map(
        data => {
          val dataArray = data.split(",")
          SensorReading(dataArray(0).trim, dataArray(1).trim.toLong, dataArray(2).trim.toDouble)
        })

    //统计10秒内最小的温度
    val minTemPerWindowStream = dataStream
      .map(data => (data.id, data.temperature))
      .keyBy(_._1)
      .timeWindow(Time.seconds(10))   //开时间窗口
      .reduce((data1, data2) => (data1._1, data1._2.min(data2._2))) // 用reduce做增量聚合

    minTemPerWindowStream.print("min temp")
    dataStream.print("input data")

    env.execute("window test")
  }
}

启动程序后，视频演示：表示10秒之内统计数据

01:03

案例二：Flink窗口操作之事件时间测试

代码具体实现：

package com.apache.watermark

import com.apache.flinkapi.SensorReading
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.functions.{AssignerWithPeriodicWatermarks, AssignerWithPunctuatedWatermarks}
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.watermark.Watermark
import org.apache.flink.streaming.api.windowing.time.Time
/**
 * Watermark 的引入
 */
object WindowTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    // 设置事件时间
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    env.getConfig.setAutoWatermarkInterval(100L)


    val inputStream=env.socketTextStream("spark2.x",7777)

    val dataStream = inputStream.map(data => {
          val dataArray = data.split(",")
          SensorReading(dataArray(0).trim, dataArray(1).trim.toLong, dataArray(2).trim.toDouble)
        })

      .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[SensorReading](Time.seconds(1)) {
        override def extractTimestamp(t: SensorReading): Long = t.timestamp * 1000L
      })


    //统计15秒内最小的温度,隔5秒输出一次
    val minTemPerWindowStream = dataStream
      .map(data => (data.id, data.temperature))
      .keyBy(_._1)
      .timeWindow(Time.seconds(15),Time.seconds(5))   //开时间窗口
      .reduce((data1, data2) => (data1._1, data1._2.min(data2._2))) // 用reduce做增量聚合

    minTemPerWindowStream.print("min temp")
    dataStream.print("input data")

    env.execute("window test")
  }
}

/*
class MyAssigner() extends AssignerWithPeriodicWatermarks[SensorReading]{
  val bound=60000
  var maxTs = Long.MinValue

  override def getCurrentWatermark: Watermark = new Watermark(maxTs-bound)

  override def extractTimestamp(t: SensorReading, l: Long): Long = {
    maxTs = maxTs.max(t.timestamp* 1000)
    t.timestamp*1000
  }
}*/

class MyAssigner() extends AssignerWithPunctuatedWatermarks[SensorReading]{
  override def checkAndGetNextWatermark(t: SensorReading, l: Long): Watermark =new Watermark(l)

  override def extractTimestamp(t: SensorReading, l: Long): Long = t.timestamp*1000

}

启动程序后，视频演示：事件时间测试表示执行多少个才能把窗口关闭，由于这里简单测试没遇到窗口关闭

00:37

案例三：Flink窗口操作之Window起始点

视频演示：

06:53

二、ProcessFunction API（底层 API）

我们之前学习的转换算子是无法访问事件的时间戳信息和水位线信息的。而这
在一些应用场景下，极为重要。例如 MapFunction 这样的 map 转换算子就无法访问
时间戳或者当前事件的事件时间。
基于此，DataStream API 提供了一系列的 Low-Level 转换算子。可以访问时间
戳、watermark 以及注册定时事件 。还可以输出 特定的一些事件 ，例如超时事件等。
Process Function 用来构建事件驱动的应用以及实现自定义的业务逻辑(使用之前的
window 函数和转换算子无法实现)。例如，Flink SQL 就是使用 Process Function 实
现的。

Flink 提供了 8 个 Process Function：

（1）ProcessFunction
最基本的处理函数，基于DataStream直接调用.process()时作为参数传入。

（2）KeyedProcessFunction
对流按键分区后的处理函数，基于KeyedStream调用.process()时作为参数传入。要想使用定时器，比如基于KeyedStream。

（3）ProcessWindowFunction
开窗之后的处理函数，也是全窗口函数的代表。基于WindowedStream调用.process()时作为参数传入。

（4）ProcessAllWindowFunction
同样是开窗之后的处理函数，基于AllWindowedStream调用.process()时作为参数传入。

（5）CoProcessFunction
合并（connect）两条流之后的处理函数，基于ConnectedStreams调用.process()时作为参数传入。关于流的连接合并操作，我们会在后续章节详细介绍。

（6）ProcessJoinFunction
间隔连接（interval join）两条流之后的处理函数，基于IntervalJoined调用.process()时作为参数传入。

（7）BroadcastProcessFunction
广播连接流处理函数，基于BroadcastConnectedStream调用.process()时作为参数传入。这里的“广播连接流”BroadcastConnectedStream，是一个未keyBy的普通DataStream与一个广播流（BroadcastStream）做连接（conncet）之后的产物。关于广播流的相关操作，我们会在后续章节详细介绍。

（8）KeyedBroadcastProcessFunction
按键分区的广播连接流处理函数，同样是基于BroadcastConnectedStream调用.process()时作为参数传入。与BroadcastProcessFunction不同的是，这时的广播连接流，是一个KeyedStream与广播流（BroadcastStream）做连接之后的产物。

1、KeyedProcessFunction

这里我们重点介绍 KeyedProcessFunction。

KeyedProcessFunction 用来操作 KeyedStream。KeyedProcessFunction 会处理流
的每一个元素，输出为 0 个、1 个或者多个元素。所有的 Process Function 都继承自
RichFunction 接口，所以都有 open()、close()和 getRuntimeContext()等方法。

而 KeyedProcessFunction[KEY, IN, OUT]还额外提供了两个方法:

processElement(v: IN, ctx: Context, out: Collector[OUT]),

流中的每一个元素都会调用这个方法，调用结果将会放在 Collector 数据类型中输出。**Context **可以访问元素的时间戳，元素的 key，以及 **TimerService **时间服务。Context
还可以将结果输出到别的流(side outputs)。

onTimer(timestamp: Long, ctx: OnTimerContext, out: Collector[OUT])

是一个回调函数。当之前注册的定时器触发时调用。参数 timestamp 为定时器所设定
的触发的时间戳。Collector 为输出结果的集合。OnTimerContext 和
processElement 的 Context 参数一样，提供了上下文的一些信息，例如定时器
触发的时间信息(事件时间或者处理时间)。

2、TimerService 和定时器（Timers）

Context 和 OnTimerContext 所持有的 TimerService 对象拥有以下方法:

currentProcessingTime(): Long 返回当前处理时间
 currentWatermark(): Long 返回当前 watermark 的时间戳
 registerProcessingTimeTimer(timestamp: Long): Unit 会注册当前 key 的

processing time 的定时器。当 processing time 到达定时时间时，触发 timer。

registerEventTimeTimer(timestamp: Long): Unit 会注册当前 key 的 event time

定时器。当水位线大于等于定时器注册的时间时，触发定时器执行回调函数。

deleteProcessingTimeTimer(timestamp: Long): Unit 删除之前注册处理时间定

时器。如果没有这个时间戳的定时器，则不执行。

deleteEventTimeTimer(timestamp: Long): Unit 删除之前注册的事件时间定时

器，如果没有此时间戳的定时器，则不执行。

当定时器 timer 触发时，会执行回调函数 onTimer()。注意定时器 timer 只能在

keyed streams 上面使用。

下面举个例子说明 KeyedProcessFunction 如何操作 KeyedStream。

需求：监控温度传感器的温度值，如果温度值在一秒钟之内(processing time)连

续上升，则报警。

val warnings = readings
.keyBy(_.id) .process(new TempIncreaseAlertFunction)

看一下 TempIncreaseAlertFunction 如何实现, 程序中使用了 ValueState 这样一个

状态变量。

具体代码实现：

package com.apache.watermark

import com.apache.flinkapi.SensorReading
import org.apache.flink.api.common.state.{ValueState, ValueStateDescriptor}
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.KeyedProcessFunction
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.util.Collector

/**
 * 需求：监控温度传感器的温度值，如果温度值在一秒钟之内(processing time)连续上升，则报警。
 */
object ProcessFunctionTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

    val stream=env.socketTextStream("spark2.x",7777)

    val dataStream = stream.map(data => {
      val dataArray = data.split(",")
      SensorReading(dataArray(0).trim, dataArray(1).trim.toLong, dataArray(2).trim.toDouble)
    })
      .assignTimestampsAndWatermarks( new BoundedOutOfOrdernessTimestampExtractor[SensorReading]( Time.seconds(1) ) {
        override def extractTimestamp(element: SensorReading): Long = element.timestamp * 1000
      } )
    val processedStream = dataStream.keyBy(_.id)
      .process( new TempIncreAlert() )

    dataStream.print("input data")
    processedStream.print("processed data")

    env.execute("ProcessFunctionTest")
  }
}
class TempIncreAlert() extends KeyedProcessFunction[String, SensorReading, String]{

  // 定义一个状态，用来保存上一个数据的温度值
  lazy val lastTemp:  ValueState[Double] = getRuntimeContext.getState( new ValueStateDescriptor[Double]("lastTemp", classOf[Double]) )

  // 定义一个状态，用来保存定时器的时间戳
  lazy val currentTimer: ValueState[Long] = getRuntimeContext.getState( new ValueStateDescriptor[Long]("currentTimer", classOf[Long]) )


  override def processElement(value: SensorReading, context: KeyedProcessFunction[String, SensorReading, String]#Context, collector: Collector[String]): Unit = {

    // 先取出上一个温度值
    val preTemp = lastTemp.value()
    // 更新温度值
    lastTemp.update( value.temperature )

    val curTimerTs = currentTimer.value()

    //温度上升且没有设过定时器，则注册定时器
    if(value.temperature >preTemp && curTimerTs ==0){
      val timerTs= context.timerService().currentProcessingTime()+ 10000L
      context.timerService().registerEventTimeTimer(timerTs)
      currentTimer.update(timerTs)
    }else if(preTemp > value.temperature || preTemp == 0.0){
      // 如果温度下降，或是第一条数据，删除定时器并清空状态
      context.timerService().deleteProcessingTimeTimer( curTimerTs )
      currentTimer.clear()
    }
  }

  override def onTimer(timestamp: Long, ctx: KeyedProcessFunction[String, SensorReading, String]#OnTimerContext, out: Collector[String]): Unit ={
    // 输出报警信息
    out.collect( ctx.getCurrentKey + " 温度连续上升" )
    currentTimer.clear()
  }
}

启动程序，控制台打印数据

3、侧输出流（SideOutput）

大部分的 DataStream API 的算子的输出是单一输出，也就是某种数据类型的流。
除了 split 算子，可以将一条流分成多条流，这些流的数据类型也都相同。process
function 的 side outputs 功能可以产生多条流，并且这些流的数据类型可以不一样。
一个 side output 可以定义为 OutputTag[X]对象，X 是输出流的数据类型。process
function 可以通过 Context 对象发射一个事件到一个或者多个 side outputs。

下面是一个示例程序：

val monitoredReadings: DataStream[SensorReading] = readings
 .process(new FreezingMonitor)
monitoredReadings
 .getSideOutput(new OutputTag[String]("freezing-alarms"))
 .print()
readings.print()

接下来我们实现 FreezingMonitor 函数，用来监控传感器温度值，将温度值低于
32F 的温度输出到 side output。

具体代码实现：

package com.apache.watermark

import com.apache.flinkapi.SensorReading
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.ProcessFunction
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.util.Collector

//侧输出流
object SideOutputTest {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

    val stream=env.socketTextStream("spark2.x",7777)

    val dataStream = stream.map(data => {
      val dataArray = data.split(",")
      SensorReading(dataArray(0).trim, dataArray(1).trim.toLong, dataArray(2).trim.toDouble)
    })
      .assignTimestampsAndWatermarks( new BoundedOutOfOrdernessTimestampExtractor[SensorReading]( Time.seconds(1) ) {
        override def extractTimestamp(element: SensorReading): Long = element.timestamp * 1000
      } )
    val processedStream = dataStream
      .process( new FreezingAlert() )

  //  dataStream.print("input data")
    processedStream.print("processed data")
    processedStream.getSideOutput( new OutputTag[String]("freezing alert") ).print("alert data")

    env.execute("ProcessFunctionTest")
  }
}

// 冰点报警，如果小于32F，输出报警信息到侧输出流
class FreezingAlert() extends ProcessFunction[SensorReading, SensorReading]{

  override def processElement(value: SensorReading, context: ProcessFunction[SensorReading, SensorReading]#Context, collector: Collector[SensorReading]): Unit = {
    if( value.temperature < 32.0 ){
      context.output( new OutputTag[String]( "freezing alert" ), "freezing alert for " + value.id )
    }
    collector.collect( value )
  }
}

启动程序，控制台打印数据

00:26

4、CoProcessFunction

对于两条输入流，DataStream API 提供了 CoProcessFunction 这样的 low-level
操作。CoProcessFunction 提供了操作每一个输入流的方法: processElement1()和
processElement2()。
类似于 ProcessFunction，这两种方法都通过 Context 对象来调用。这个 Context
对象可以访问事件数据，定时器时间戳，TimerService，以及 side outputs。
CoProcessFunction 也提供了 onTimer()回调函数。

原文链接https://zhuanlan.zhihu.com/p/138568208

标题：Flink入门2
作者：michael
地址：https://blog.junxworks.cn/articles/2024/05/11/1715406360584.html

一、 时间语义与 Wartermark