FLink学习笔记：09-Flink 的状态编程应用
文章目录
- 概述
-
- 无状态流计算
- 有状态流计算
- 状态分类：
-
- 算子状态(Operator State)
- 键控状态(Keyed State)
-
- ValueState[T]
- ListState[T]
- MapState[KU,VU]
- ReducingState[T]
- AggregatingState[I, O] 聚合状态
- 状态运用编程实例
概述
流式计算分为无状态和有状态两种情况。
无状态流计算
无状态的计算观察每个独立事件，并根据最后一个事件输出结果。
无状态流处理过程如下：
无状态流每次只转换处理一条输入记录，并且只根据最新的输入记录输出结果。
下列示例均为有状态流处理：
- 流处理应用程序从传感器接收温度读数，并在温度超过90度时发出警告。
- 流处理应用程序从数据源接收到一条记录时，对数据进行文本大小写转换操作
- 流处理应用程序从数据源接收到一条记录时，对数据进行数据类型转换操作等ETL处理。
有状态流计算
有状态的计算则会基于多个事件输出结果。有状态流处理过程如下：
有状态流需要维护所有已处理记录的状态值，并且根据每条输入的记录更新状态，因此输出记录反映的是综合多个事件之后的结果。
下列示例均为有状态流处理：
- 所有类型的窗口。例如，计算过去一小时的平均温度，就是有状态的计算。
- 所有用于复杂事件处理的状态机。例如，若在一分钟内收到两个相差 20 度以上的温度读数，则发出警告，这是有状态的计算。
- 流与流之间的所有关联操作，以及流与静态表或动态表之间的关联操作， 都是有状态的计算。
状态分类：
Flink内置的很多算子，数据源source，数据存储 sink都是有状态的，流中的数 据都是buffer records，会保存一定的元素或者元数据。例如: ProcessWindowFunction会缓存输入流的数据，ProcessFunction 会保存设置的定时器信息等等。在 Flink 中，状态始终与特定算子相关联。
总的来说，可以分为下列两大类：
- 算子状态（operator state）
- 键控状态（keyed state）
算子状态(Operator State)
算子状态的作用范围限定为算子任务。这意味着由同一并行任务所处理的所有 数据都可以访问到相同的状态，状态对于同一任务而言是共享的。算子状态不能由 相同或不同算子的另一个任务访问。
如上图所示，算子的状态对于同一任务中的所有数据都是共享的，但是对于在不同并行度中的同一任务，只能访问各自的状态。（跨并行度，资源在不同的slot中，对各自是不可见，有独立的内存空间）
Flink为算子状态提供三种基本数据结构：
- 列表状态(List state)
将状态表示为一组数据的列表。 - 联合列表状态（Union list state）
通列表状态一样，也将状态表示为数据的列表。它与常规列表的状态的区别在于，发生故障时或者从保存快照点(savepoint)启动应用程序时如何恢复。 - 广播状态(Broadcast state)
如果一个算子有多项任务，而它的每项任务状态又相同，那么这种特殊情况很适合使用广播状态。
键控状态(Keyed State)
键控状态是根据输入数据流中定义的键（key）来维护和访问的。Flink 为每个键值维护 一个状态实例，并将具有相同键的所有数据，都分区到同一个算子任务中，这个任务会维护 和处理这个 key 对应的状态。当任务处理一条数据时，它会自动将状态的访问范围限定为当 前数据的 key。因此，具有相同 key 的所有数据都会访问相同的状态。Keyed State 很类似于 一个分布式的 key-value map 数据结构，只能用于 KeyedStream（keyBy 算子处理之后）。
如上图所示：
- 监控状态在同一算子任务中数据只能访问到自己Key对应的状态，而不能方位其他Key的状态
- 不同任务中的数据只能访问各自的状态，无法跨任务共享状态
Flink 的Keyed State支持以下数据类型:
ValueState[T]
保存单个的值，值的类型为T。
//定义一个ValueState
lazy val lastTempState:ValueState[Double] = getRuntimeContext.getState(new ValueStateDescriptor[Double]("lastTempState",classOf[Double]))
//获取值
lasteTempState.value()
//设置值
lasteTempState.update(T value)
//清空状态
lasteTempState.clear()
ListState[T]
保存一个列表，列表里的元素的数据类型为 T。基本操作如下：
//定义一个ListState
lazy val listState:ListState[Double] = getRuntimeContext.getListState(new ListStateDescriptor[Double]("listState",classOf[Double]))
//获取数据
val data = listState.get()
//添加数据
listState.add(2.0)
val dataList = new util.ArrayList[Double]()
dataList.add(5.0)
dataList.add(5.2)
listState.addAll(dataList)
//清空状态
listState.clear()
//设置状态(覆盖原有list列表)
listState.update(dataList)
MapState[KU,VU]
保存一个键值对，基本操作如下：
//定义一个MapState
lazy val mapState:MapState[String,Double] = getRuntimeContext.getMapState(new MapStateDescriptor[String,Double]("mapState",classOf[String],classOf[Double]))
//设置值
mapState.put("00001",12.3)
val mapData = new util.HashMap[String,Double]()
mapData.put("00002",23.4)
mapData.put("00003",22.4)
mapState.putAll(mapData)
//判断是否包含某个键
mapState.contains("00003")
//删除键值对
mapState.remove("000003")
//判断是否为空
mapState.isEmpty
//获取所有的键
mapState.keys()
//获取所有的值
mapState.values()
//清空状态
mapState.clear()
ReducingState[T]
每往reduce状态中append一个数据，就会自动调用预先设定的reduce函数，基本操作如下所示：
class myReuceFunction extends ReduceFunction[Double] {
override def reduce(value1: Double, value2: Double): Double = {
value1+value2
}
}
//定义一个ReducingState[T]
lazy val reduceState:ReducingState[Double] = getRuntimeContext.getReducingState(new ReducingStateDescriptor[Double]("reduceState",new myReuceFunction,classOf[Double]))
//添加值，会自动调用预先设定的reduce function
reduceState.add(23)
//获取值
reduceState.get()
//清空状态
reduceState.clear()
AggregatingState[I, O] 聚合状态
class myAggrateFunction extends AggregateFunction[Double,Double,Double]{
override def createAccumulator(): Double = {
0.0
}
override def add(value: Double, accumulator: Double): Double = {
accumulator+value
}
override def getResult(accumulator: Double): Double = {
accumulator
}
override def merge(a: Double, b: Double): Double = {
a+b
}
}
//创建AggregatingState[I, O]状态
lazy val aggregatingState = getRuntimeContext.getAggregatingState(new AggregatingStateDescriptor[Double,Double,Double]("aggrateState",new myAggrateFunction,classOf[Double] ))
//聚合运算
aggregatingState.add(23.0)
//获取结果
aggregatingState.get()
//清空状态
aggregatingState.clear()
AggregateFunction参数说明:IN 输入的数据类型，ACC 表示的是累加器的数据类型，OUT表述输出结果的数据类型
* @param The type of the values that are aggregated (input values)
* @param The type of the accumulator (intermediate aggregate state).
* @param The type of the aggregated result
*/
@PublicEvolving
public interface AggregateFunction extends Function, Serializable {
TIPS： 以上所有的状态的声明和操作必须在RichFunction中，因为需要访问上下文环境。
状态运用编程实例
需求:对于温度传感器温度值跳变，超过10度，进行预警
代码：
package com.hjt.yxh.hw.apitest
import java.{lang, util}
import org.apache.flink.streaming.api.scala._
import org.apache.flink.api.common.functions.{RichFlatMapFunction, RichMapFunction}
import org.apache.flink.api.common.state.{ListState, ListStateDescriptor, ValueState, ValueStateDescriptor}
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment
import org.apache.flink.util.Collector
object StateTest {
def main(args: Array[String]): Unit = {
val env = StreamExecutionEnvironment.getExecutionEnvironment
val inpuPath = "D:\\LearnWorkSpace\\FlinkDemo\\src\\main\\resources\\Data\\sensor.txt"
val datastream = env.readTextFile(inpuPath)
.filter(_.nonEmpty)
.map(data=>{
val array = data.split(",")
SensorReading(array(0),array(1).toLong,array(2).toDouble)
})
//需求:对于温度传感器温度值跳变，超过10度，进行预警
val alertStream = datastream
.keyBy(data=>{
data.id
})
// .flatMap(new TempChangeAlert(10.0))
.flatMapWithState[(String,Double,Double),Double]({
case (data:SensorReading,None) =>(List.empty,Some(data.temperature))
case (data:SensorReading,lastTemp:Some[Double])=>{
if ((data.temperature - lastTemp.get).abs >= 10.0){
(List((data.id,lastTemp.get,data.temperature)),Some(data.temperature))
}
else {
(List.empty,Some(data.temperature))
}
}
})
env.execute("state test job")
}
}
class TempChangeAlert(threshold: Double) extends RichFlatMapFunction[SensorReading,(String,Double,Double)]{
//定义状态保存上一次的温度值
lazy val lastestTempState: ValueState[Double] = getRuntimeContext.getState(new ValueStateDescriptor[Double]("lastestTempState",classOf[Double]))
lazy val firstFlagState:ValueState[Boolean]=getRuntimeContext.getState(new ValueStateDescriptor[Boolean]("firstFlagState",classOf[Boolean]))
firstFlagState.update(true)
override def flatMap(value: SensorReading, out: Collector[(String, Double, Double)]): Unit = {
if (firstFlagState.value()) {
//保存这一次的温度状态
lastestTempState.update(value.temperature)
return
}
//获取上一次的温度
val lastTemp = lastestTempState.value()
val diff = (value.temperature - lastTemp).abs
if (diff > threshold)
out.collect((value.id, lastTemp, value.temperature))
//保存这一次的温度状态
lastestTempState.update(value.temperature)
}
}