前言

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

ProcessFunction
KeyedProcessFunction
CoProcessFunction
ProcessJoinFunction
BroadcastProcessFunction
KeyedBroadcastProcessFunction
ProcessWindowFunction
ProcessAllWindowFunction

Flink Process Function 主要作用处理流的数据、注册使用定时器、根据业务把部分数据输出到侧输出流（SideOutput）、对connectedStream做处理
下面通过KeyedProcessFunction 来实现处理流中的元素和注册定时器调用定时器；ProcessFunction来把需要的数据输出到侧输出流；使用CoProcessFunction实现两个流connect后并做以其中一个流做流开关

KeyedProcessFunction 处理流中的元素和注册定时器调用定时器

KeyedProcessFunction 类的介绍和结构分析

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

KeyedProcessFunction

KeyedProcessFunction[KEY, IN, OUT]提供了两个方法:

processElement(v: IN, ctx: Context, out: Collector[OUT]), 流中的每一个元素都会调用这个方法，调用结果将会放在Collector数据类型中输出。每次对该函数的调用processElement( )都会得到一个Context对象，Context可以访问元素的时间戳，元素的key，以及TimerService时间服务。TimerService可以为将来event- /process-time 注册回调。Context还可以将结果输出到别的流(side outputs)。
onTimer(timestamp: Long, ctx: OnTimerContext, out: Collector[OUT])是一个回调函数。当当前watermark前进到计时器的时间戳时或超过计时器的时间戳时，调用该方法。参数timestamp为定时器所设定的触发的时间戳。Collector为输出结果的集合。OnTimerContext和processElement的Context参数一样，提供了上下文的一些信息，例如定时器触发的时间信息(事件时间或者处理时间)。

KeyedProcessFunction[KEY, IN, OUT]提供了两个类 :

Context
OnTimerContext
OnTimerContext继承于Context
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 删除之前注册的事件时间定时器，如果没有此时间戳的定时器，则不执行。

KeyedProcessFunction 实现注册定时器并回调onTimer()

当register的定时器timer触发时，会执行回调函数onTimer()。注意定时器timer只能在keyed streams上面使用。

下面举个例子说明KeyedProcessFunction如何操作KeyedStream，使用时间服务根据业务注册定时报警。
需求：监控温度传感器的温度值，如果温度值在一秒钟之内(processing time)连续上升，则报警。
自定义的sensorSource 传感器会300ml发送一次温度数据。一秒内一个窗口，假如是连续上升的就报警。

import com.rex.{SensorReading, SensorSource}
import org.apache.flink.api.common.state.ValueStateDescriptor
import org.apache.flink.api.scala.typeutils.Types
import org.apache.flink.streaming.api.functions.KeyedProcessFunction
import org.apache.flink.streaming.api.scala._
import org.apache.flink.util.Collector

object TempIncreaseAlert {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val stream = env
      .addSource(new SensorSource)
      .keyBy(_.id)
      .process(new TempIncreaseAlertFunction)

    stream.print()

    env.execute()
  }

  class TempIncreaseAlertFunction extends KeyedProcessFunction[String, SensorReading, String] {

    // 初始化一个状态变量，用来保存最近一次的温度值
    // 懒加载，惰性赋值
    // 当执行到process算子时，才会初始化，所以是懒加载
    // 为什么不直接使用scala的变量呢？比如：var lastTemp: Double = _
    // 通过配置，状态变量可以通过检查点操作，保存在hdfs里面
    // 当程序故障时，可以从最近一次检查点恢复
    // 所以要有一个名字`last-temp`和变量的类型（需要明确告诉flink状态变量的类型）
    // 状态变量只会被初始化一次，运行程序时，如果没有这个状态变量，就初始化一个
    // 如果有这个状态变量，直接读取
    // 所以是`单例模式`
    // 默认值是0.0
    lazy val lastTemp = getRuntimeContext.getState(
      new ValueStateDescriptor[Double]("last-temp", Types.of[Double])
    )

    // 用来保存报警定时器的时间戳，默认值是0L
    lazy val timerTs = getRuntimeContext.getState(
      new ValueStateDescriptor[Long]("ts", Types.of[Long])
    )

    override def processElement(value: SensorReading, ctx: KeyedProcessFunction[String, SensorReading, String]#Context, out: Collector[String]): Unit = {
      // 获取最近一次温度, 需要使用`.value()`方法
      // 如果来的是第一条温度，那么prevTemp是0.0
      val prevTemp = lastTemp.value()
      // 将来的温度值更新到lastTemp状态变量, 使用update方法
      lastTemp.update(value.temperature)

      val curTimerTs = timerTs.value()

      if (prevTemp == 0.0 || value.temperature < prevTemp) {
        // 如果来的温度是第一条温度，或者来的温度小于最近一次温度
        // 删除报警定时器
        ctx.timerService().deleteProcessingTimeTimer(curTimerTs)
        // 清空保存定时器时间戳的状态变量, 使用clear方法
        timerTs.clear()
      } else if (value.temperature > prevTemp && curTimerTs == 0L) {
        // 来的温度大于最近一次温度，并且我们没有注册报警定时器，因为curTimerTs等于0L
        val ts = ctx.timerService().currentProcessingTime() + 1000L
        ctx.timerService().registerProcessingTimeTimer(ts)
        timerTs.update(ts)
      }
    }

    override def onTimer(timestamp: Long, ctx: KeyedProcessFunction[String, SensorReading, String]#OnTimerContext, out: Collector[String]): Unit = {
      out.collect("传感器ID为：" + ctx.getCurrentKey + " 的传感器温度连续1s上升！")
      timerTs.clear() // 清空定时器
    }
  }
}

ProcessFunction来把需要的数据输出到侧输出流

侧输出流（SideOutput）

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

下面举个例子说明如何操作process function 操作发送数据到side outputs
实现FreezingMonitor函数，用来监控传感器温度值，将温度值低于32F的温度输出到side output。

import com.rex.{SensorReading, SensorSource}
import org.apache.flink.streaming.api.functions.ProcessFunction
import org.apache.flink.streaming.api.scala._
import org.apache.flink.util.Collector

object FreezingAlarm {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    val stream = env
      .addSource(new SensorSource)
      // 没有keyBy，没有开窗！
      .process(new FreezingAlarmFunction)

//    stream.print() // 打印常规输出
    // 侧输出标签的名字必须是一样的
    stream.getSideOutput(new OutputTag[String]("freezing-alarm")).print() // 打印侧输出流

    env.execute()
  }

  // `ProcessFunction`处理的是没有keyBy的流
  class FreezingAlarmFunction extends ProcessFunction[SensorReading, SensorReading] {

    // 定义一个侧输出标签，实际上就是侧输出流的名字
    // 侧输出流中的元素的泛型是String
    lazy val freezingAlarmOut = new OutputTag[String]("freezing-alarm")

    override def processElement(value: SensorReading, ctx: ProcessFunction[SensorReading, SensorReading]#Context, out: Collector[SensorReading]): Unit = {
      if (value.temperature < 32.0) {
        // 第一个参数是侧输出标签，第二个参数是发送的数据
        ctx.output(freezingAlarmOut, s"${value.id}的传感器低温报警！")
      }
      // 将所有读数发送到常规输出
      out.collect(value)
    }
  }
}

CoProcessFunction 操作两个不同的输入流

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

下面举例子使用CoProcessFunction 操作ConnectedStream
业务：两个流，一个无限流数据来自温度传感器，第二个流有限流数据来自集合
数据流二表示指定的传感器ID，CoProcessFunction 通过数据流二指定的ID来给数据流一的元素做开关。对指定的传感器可以执行10s钟。详细看代码

import com.rex.{SensorReading, SensorSource}
import org.apache.flink.api.common.state.ValueStateDescriptor
import org.apache.flink.api.scala.typeutils.Types
import org.apache.flink.streaming.api.functions.co.CoProcessFunction
import org.apache.flink.streaming.api.scala._
import org.apache.flink.util.Collector

object CoProcessFunctionExample {
  def main(args: Array[String]): Unit = {
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    // 第一条流，是一条无限流
    val readings = env.addSource(new SensorSource)

    // 第二条流，是一条有限流，只有一个元素
    // 用来做开关，对`sensor_2`的数据放行10s
    val switches = env.fromElements(
      ("sensor_2", 10 * 1000L),
      ("sensor_10", 5 * 1000L)
    )

    val result = readings
      .connect(switches)
      // 将相同key的数据放在一起处理
      .keyBy(_.id, _._1) // on readings.id = switches._1
      .process(new ReadingFilter)

    result.print()

    env.execute()
  }

  class ReadingFilter extends CoProcessFunction[SensorReading, (String, Long), SensorReading] {
    // 初始值是false
    // 每一个key都有对应的状态变量
    lazy val forwardingEnabled = getRuntimeContext.getState(
      new ValueStateDescriptor[Boolean]("switch", Types.of[Boolean])
    )

    // 处理来自传感器的流数据
    override def processElement1(value: SensorReading, ctx: CoProcessFunction[SensorReading, (String, Long), SensorReading]#Context, out: Collector[SensorReading]): Unit = {
      // 如果开关是true，就允许数据流向下发送
      if (forwardingEnabled.value()) {
        out.collect(value)
      }
    }

    // 处理来自开关流的数据
    override def processElement2(value: (String, Long), ctx: CoProcessFunction[SensorReading, (String, Long), SensorReading]#Context, out: Collector[SensorReading]): Unit = {
      // 打开开关
      forwardingEnabled.update(true)
      // 开关元组的第二个值就是放行时间
      val ts = ctx.timerService().currentProcessingTime() + value._2
      ctx.timerService().registerProcessingTimeTimer(ts)
    }

    override def onTimer(timestamp: Long, ctx: CoProcessFunction[SensorReading, (String, Long), SensorReading]#OnTimerContext, out: Collector[SensorReading]): Unit = {
      // 关闭开关
      forwardingEnabled.clear()
    }
  }
}