Flink学习（十八） 状态管理与状态编程
Flink中的状态
由一个任务维护，并且用来计算某个结果的所有数据，都属于这个任务的状态；可以认为状态就是一个本地变量，可以被任务的业务逻辑访问；Flink会进行状态管理，包括状态一致性，故障处理以及高效存储和访问，以使开发人员可以专注于应用程序的逻辑。
在Flink中，状态始终与特定算子相关联，为了使运行的Flink了解算子的状态，算子需要预先注册其状态。
总的来说，有两种类型的状态：
算子状态（Operator State）： 算子状态的作用范围限定为算子任务。
键控状态（Keyed State）: 根据输入数据流中定义的键（key）来维护和访问。
算子状态（Operator State）
算子状态的作用范围限定为算子任务，由同一个并行任务所处理的所有数据都可以访问到相同的状态，状态对于同一任务而言使共享的，算子状态不能由相同或不同算子的另一个任务访问。
算子状态数据结构
列表状态（List State）: 将状态表示为一组数据的列表。
联合列表状态（Union list state）: 也将状态表示为数据的列表，它与常规列表状态的区别在于，在发生故障时，或者从保存点（savepoint）启动应用程序时如何恢复。
广播状态（Broadcast state）： 如果一个算子有多项任务，而它的每项任务状态又都相同，那么这种特殊情况最适合应用广播状态。
键控状态（Keyed State）
键控状态时根据输入数据流中定义的键（key）来维护和访问的，Flink为每隔key维护一个状态实例，并将具有相同键的所有数据，都分区到同一个算子任务中，这个任务会维护和处理这个key对应的状态，当文物处理一条数据时，它会自动将状态的访问范围限定为当前数据的key。
键控状态数据结构
值状态（Value state）: 将状态表示为单个的值。
列表状态（list state）: 将状态表示为一组数据的列表。
映射状态（Map state）： 将状态表示为一组key-value对。
聚合状态（Reducing state & aggregating State）： 将状态表示为一个用于聚合操作的列表。
键控状态的使用（值状态（Value state）举例：）
声明一个键控状态
//定义一个状态,用来保存上一个数据的温度值
//用懒加载的方式，一开始定义的时候我们还不执行，等到调用的时候去执行
//所有的状态都这么定义 当成一个变量直接用
lazy val lastTemp: ValueState[Double] = getRuntimeContext.getState(new ValueStateDescriptor[Double]("lastTemp", classOf[Double]))
读取状态
//每来一条数据的时候，从状态中取出上一次的温度值
val preTemp = lastTemp.value()
对状态赋值
//更新温度值
lastTemp.update(value.temperature)
状态后端（State Backends）
每传入一条数据，有状态的算子任务都会读取和更新状态。由于有效的状态访问对于处理数据的低延迟至关重要，因此每隔并行任务都会在本地维护其状态，以确保快速的状态访问。状态的存储，访问以及维护，由一个可插入的组件决定，这个组件就叫做状态呀
后端（state backend），状态后端主要负责两件事：一是本地的状态管理，以及将检查点（checkpoint）状态写入远程存储。
//开启checkpoint 传入参数代表每隔多久进行checkpoint
env.enableCheckpointing(60000)
//状态后端
// env.setStateBackend(new MemoryStateBackend())
// env.setStateBackend(new RocksDBStateBackend(""))
状态编程小应用（三种方式实现）
/**
* 需求：
* 检测两次温度超过一定的范围的话 就报警
* 传感器的温度 跳变太大
*/
方式一：继承 KeyedProcessFunction 抽象类
class TempChangeAlert(thresHold: Double) extends KeyedProcessFunction[String, SensorReading, (String, Double, Double)] {
//定义一个状态变量，保存上次的温度值
lazy val lastTempState: ValueState[Double] = getRuntimeContext.getState(new ValueStateDescriptor[Double]("lastTemp", classOf[Double]))
override def processElement(value: SensorReading, ctx: KeyedProcessFunction[String, SensorReading, (String, Double, Double)]#Context, out: Collector[(String, Double, Double)]): Unit = {
//获取上一次的温度值
val lastTemp = lastTempState.value()
//用当前的温度值和上次的温度值计算一个差值，如果大于预设值，就报警‘
val diff = (value.temperature - lastTemp).abs
if(lastTemp==0.0){
println(s"方法一,第一条数据进来,$value")
}else if(diff > thresHold) {
out.collect((value.id, lastTemp, value.temperature))
}
//做完一次处理之后将状态进行更新
lastTempState.update(value.temperature)
}
}
方式二：继承 RichFlatMapFunction 抽象类
class TempChangeAlertFlatMap(thresHold: Double) extends RichFlatMapFunction[SensorReading,(String,Double,Double)]{
//定义
private var lastTempState:ValueState[Double] = _
override def open(parameters: Configuration): Unit = {
//初始化的时候声明变量
lastTempState = getRuntimeContext.getState(new ValueStateDescriptor[Double]("lastTemp",classOf[Double]))
}
override def flatMap(value: SensorReading, out: Collector[(String, Double, Double)]): Unit = {
//获取上一次的温度值
val lastTemp = lastTempState.value()
//用当前的温度值和上次的温度值计算一个差值，如果大于预设值，就报警‘
val diff = (value.temperature - lastTemp).abs
if(lastTemp==0.0){
println(s"方法二,第一条数据进来,$value")
}else if(diff > thresHold) {
out.collect((value.id, lastTemp, value.temperature))
}
//做完一次处理之后将状态进行更新
lastTempState.update(value.temperature)
}
}
方式三：keyBy后调用 flatMapWithState 方法
//实现方式3
val processedStream4 = dataStream.keyBy(_.id)
.flatMapWithState[(String,Double,Double),Double]{
//没有状态的话，也就是没有数据来过，那么就将当前数据温度值存入状态
case (input:SensorReading,None) => {
println(s"方法三，第一条数据进来，$input")
(List.empty,Some(input.temperature))
}
//如果有状态的话，就与上一次的温度值比较差值，如果大于预设值，就报警
case (input:SensorReading,lastTemp:Some[Double]) => {
val diff = (input.temperature - lastTemp.get).abs
if(diff>10.0){
(List((input.id,lastTemp.get,input.temperature)),Some(input.temperature))
}else{
(List.empty,Some(input.temperature))
}
}
}
完整代码：
package com.wyh.statebackendApi
import org.apache.flink.api.common.functions.RichFlatMapFunction
import org.apache.flink.api.common.state.{ValueState, ValueStateDescriptor}
import org.apache.flink.configuration.Configuration
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
/**
* 需求：
* 检测两次温度超过一定的范围的话 就报警
* 传感器的温度 跳变太大
*/
//温度传感器读数样例类
case class SensorReading(id: String, timestamp: Long, temperature: Double)
object Demo1 {
def main(args: Array[String]): Unit = {
val env = StreamExecutionEnvironment.getExecutionEnvironment
env.setParallelism(1)
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
//开启checkpoint 传入参数代表每隔多久进行checkpoint
env.enableCheckpointing(60000)
//状态后端
// env.setStateBackend(new MemoryStateBackend())
// env.setStateBackend(new RocksDBStateBackend(""))
val stream = env.socketTextStream("localhost", 7777)
//Transform操作
val dataStream: DataStream[SensorReading] = stream.map(data => {
val dataArray = data.split(",")
SensorReading(dataArray(0).trim, dataArray(1).trim.toLong, dataArray(2).trim.toDouble)
})
//===到来的数据是升序的，准时发车，用assignAscendingTimestamps
//指定哪个字段是时间戳 需要的是毫秒 * 1000
// .assignAscendingTimestamps(_.timestamp * 1000)
//===处理乱序数据
// .assignTimestampsAndWatermarks(new MyAssignerPeriodic())
//==底层也是周期性生成的一个方法 处理乱序数据 延迟1秒种生成水位 同时分配水位和时间戳 括号里传的是等待延迟的时间
.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[SensorReading](Time.seconds(1)) {
override def extractTimestamp(t: SensorReading): Long = {
t.timestamp * 1000
}
})
// val processedStream = dataStream.keyBy(_.id)
// .process(new TempIncreAlert())
//实现方式1
val processedStream2 = dataStream.keyBy(_.id)
.process(new TempChangeAlert(10.0))
//实现方式2
val processedStream3 = dataStream.keyBy(_.id)
.flatMap(new TempChangeAlertFlatMap(10.0))
//实现方式3
val processedStream4 = dataStream.keyBy(_.id)
.flatMapWithState[(String,Double,Double),Double]{
//没有状态的话，也就是没有数据来过，那么就将当前数据温度值存入状态
case (input:SensorReading,None) => {
println(s"方法三，第一条数据进来，$input")
(List.empty,Some(input.temperature))
}
//如果有状态的话，就与上一次的温度值比较差值，如果大于预设值，就报警
case (input:SensorReading,lastTemp:Some[Double]) => {
val diff = (input.temperature - lastTemp.get).abs
if(diff>10.0){
(List((input.id,lastTemp.get,input.temperature)),Some(input.temperature))
}else{
(List.empty,Some(input.temperature))
}
}
}
processedStream2.printToErr("processedStream2 data")
processedStream3.printToErr("processedStream3 data")
processedStream4.printToErr("processedStream4 data")
dataStream.print("input data")
env.execute("StateBackend Test")
}
}
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]))
//判断温度连续上升
//跟上一次数据进行比较 如果比较一直大 10秒种内进行报警
//注册一个定时器 把上一次的数据保存成当前的状态
override def processElement(value: SensorReading, ctx: KeyedProcessFunction[String, SensorReading, String]#Context, out: Collector[String]): Unit = {
//每来一条数据的时候，从状态中取出上一次的温度值
val preTemp = lastTemp.value()
var curTimerTs = currentTimer.value()
//更新温度值
lastTemp.update(value.temperature)
//加个if判断最开始的温度是否为0来判断是否是第一条数据 温度上升且没有设置过定时器，则注册定时器
if (preTemp == 0.0) {
println("这是第一条数据进来")
} else if ((value.temperature > preTemp) && (curTimerTs == 0L)) {
val timerTs = ctx.timerService().currentProcessingTime() + 10000L
//传入当前时间加1 是时间戳
ctx.timerService().registerProcessingTimeTimer(timerTs)
currentTimer.update(timerTs)
} else if (value.temperature <= preTemp) {
//如果温度下降 或者是第一条数据 删除定时器
ctx.timerService().deleteProcessingTimeTimer(curTimerTs)
//删除定时器之后将状态清空
currentTimer.clear()
}
}
//在回调函数中执行定时器到的逻辑
//当前的时间 ctx上下文 out输出信息
override def onTimer(timestamp: Long, ctx: KeyedProcessFunction[String, SensorReading, String]#OnTimerContext, out: Collector[String]): Unit = {
//直接输出报警信息
out.collect(ctx.getCurrentKey + "温度连续上升")
//考虑真实情况，将状态都清空
currentTimer.clear()
}
}
class TempChangeAlert(thresHold: Double) extends KeyedProcessFunction[String, SensorReading, (String, Double, Double)] {
//定义一个状态变量，保存上次的温度值
lazy val lastTempState: ValueState[Double] = getRuntimeContext.getState(new ValueStateDescriptor[Double]("lastTemp", classOf[Double]))
override def processElement(value: SensorReading, ctx: KeyedProcessFunction[String, SensorReading, (String, Double, Double)]#Context, out: Collector[(String, Double, Double)]): Unit = {
//获取上一次的温度值
val lastTemp = lastTempState.value()
//用当前的温度值和上次的温度值计算一个差值，如果大于预设值，就报警‘
val diff = (value.temperature - lastTemp).abs
if(lastTemp==0.0){
println(s"方法一,第一条数据进来,$value")
}else if(diff > thresHold) {
out.collect((value.id, lastTemp, value.temperature))
}
//做完一次处理之后将状态进行更新
lastTempState.update(value.temperature)
}
}
class TempChangeAlertFlatMap(thresHold: Double) extends RichFlatMapFunction[SensorReading,(String,Double,Double)]{
//定义
private var lastTempState:ValueState[Double] = _
override def open(parameters: Configuration): Unit = {
//初始化的时候声明变量
lastTempState = getRuntimeContext.getState(new ValueStateDescriptor[Double]("lastTemp",classOf[Double]))
}
override def flatMap(value: SensorReading, out: Collector[(String, Double, Double)]): Unit = {
//获取上一次的温度值
val lastTemp = lastTempState.value()
//用当前的温度值和上次的温度值计算一个差值，如果大于预设值，就报警‘
val diff = (value.temperature - lastTemp).abs
if(lastTemp==0.0){
println(s"方法二,第一条数据进来,$value")
}else if(diff > thresHold) {
out.collect((value.id, lastTemp, value.temperature))
}
//做完一次处理之后将状态进行更新
lastTempState.update(value.temperature)
}
}
运行测试：
输入数据：
结果：
