Java 如何在Fink中实例化MapStateDescriptor以计算多个流查询？
我试图计算3个不同房间的平均温度，每个房间有3个温度传感器。我正在使用Flink（Java）。首先，我用一个房间（a、B或C）的键拆分传感器，然后创建一个Java 如何在Fink中实例化MapStateDescriptor以计算多个流查询？,java,apache-flink,stateful,Java,Apache Flink,Stateful,我试图计算3个不同房间的平均温度，每个房间有3个温度传感器。我正在使用Flink（Java）。首先，我用一个房间（a、B或C）的键拆分传感器，然后创建一个RichFlatMapFunction，其中保存一个MapState，以保存温度，而我只有3次测量。三次测量后，我计算平均值。为了使用MapState，我需要一个mapstatescriptor，我不知道如何正确实例化它。有人能帮我吗？谢谢 public class SensorsMultipleReadingMqttEdgentQEP2 {
RichFlatMapFunctionMapStateMapStatemapstatescriptorpublic class SensorsMultipleReadingMqttEdgentQEP2 {
private boolean checkpointEnable = false;
private long checkpointInterval = 10000;
private CheckpointingMode checkpointMode = CheckpointingMode.EXACTLY_ONCE;
public SensorsMultipleReadingMqttEdgentQEP2() throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setStreamTimeCharacteristic(TimeCharacteristic.IngestionTime);
if (checkpointEnable) {
env.enableCheckpointing(checkpointInterval, checkpointMode);
}
DataStream<MqttTemperature> temperatureStream01 = env.addSource(new TemperatureMqttConsumer("topic-edgent-01"));
DataStream<MqttTemperature> temperatureStream02 = env.addSource(new TemperatureMqttConsumer("topic-edgent-02"));
DataStream<MqttTemperature> temperatureStream03 = env.addSource(new TemperatureMqttConsumer("topic-edgent-03"));
DataStream<Tuple2<String, Double>> averageStream01 = temperatureStream01.map(new SensorMatcher()).keyBy(0)
.flatMap(new AverageTempMapper());
DataStream<Tuple2<String, Double>> averageStream02 = temperatureStream02.map(new SensorMatcher()).keyBy(0)
.flatMap(new AverageTempMapper());
DataStream<Tuple2<String, Double>> averageStream03 = temperatureStream03.map(new SensorMatcher()).keyBy(0)
.flatMap(new AverageTempMapper());
DataStream<Tuple2<String, Double>> averageStreams = averageStream01.union(averageStream02)
.union(averageStream03);
averageStreams.print();
env.execute("SensorsMultipleReadingMqttEdgentQEP");
}
public static class SensorMatcher implements MapFunction<MqttTemperature, Tuple2<String, MqttTemperature>> {
private static final long serialVersionUID = 7035756567190539683L;
@Override
public Tuple2<String, MqttTemperature> map(MqttTemperature value) throws Exception {
String key = "no-room";
if (value.getId().equals(1) || value.getId().equals(2) || value.getId().equals(3)) {
key = "room-A";
} else if (value.getId().equals(4) || value.getId().equals(5) || value.getId().equals(6)) {
key = "room-B";
} else if (value.getId().equals(7) || value.getId().equals(8) || value.getId().equals(9)) {
key = "room-C";
} else {
System.err.println("Sensor not defined in any room.");
}
return new Tuple2<>(key, value);
}
}
public static class AverageTempMapper
extends RichFlatMapFunction<Tuple2<String, MqttTemperature>, Tuple2<String, Double>> {
private static final long serialVersionUID = -4780146677198295204L;
private MapState<String, Tuple2<Integer, Double>> modelState;
@Override
public void open(Configuration parameters) throws Exception {
TypeInformation<Tuple2<String, Tuple2<Integer, Double>>> typeInformation = TypeInformation
.of(new TypeHint<Tuple2<String, Tuple2<Integer, Double>>>() {
});
// HOW TO INSTANTIATE THIS descriptor?
MapStateDescriptor<String, Tuple2<Integer, Double>> descriptor = new MapStateDescriptor<>("modelState",
String.class, Tuple2.class);
modelState = getRuntimeContext().getMapState(descriptor);
}
@Override
public void flatMap(Tuple2<String, MqttTemperature> value, Collector<Tuple2<String, Double>> out)
throws Exception {
Double temp = null;
Integer count = 0;
if (modelState.contains(value.f0)) {
count = modelState.get(value.f0).f0 + 1;
temp = (modelState.get(value.f0).f1 + value.f1.getTemp());
} else {
count = 1;
temp = value.f1.getTemp();
}
modelState.put(value.f0, Tuple2.of(count, temp));
if (count >= 3) {
out.collect(Tuple2.of("room", null));
}
}
}
}
公共类传感器MultipleReadingMQTTedgentQEP2{
私有布尔检查点启用=false；
专用长检查点间隔=10000；
private checkpointMode checkpointMode=checkpointMode.justly_一次；
public SensorsMultipleReadingMqttEdgentQEP2（）引发异常{
StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment（）；
环境设置流时间特征（时间特征、摄取时间）；
如果（启用检查点）{
环境启用检查点（检查点间隔、检查点模式）；
}
DataStream temperatureStream01=env.addSource（新TemperatureMqttConsumer（“topic-edgent-01”）；
DataStream temperatureStream02=env.addSource（新TemperatureMqttConsumer（“topic-edgent-02”）；
DataStream temperatureStream03=env.addSource（新TemperatureMqttConsumer（“topic-edgent-03”）；
DataStream averageStream01=temperatureStream01.map（新的传感器匹配器（））.keyBy（0）
.flatMap（新的AverageTempMapper（））；
DataStream averageStream02=temperatureStream02.map（新的传感器匹配器（））.keyBy（0）
.flatMap（新的AverageTempMapper（））；
DataStream averageStream03=temperatureStream03.map（新的传感器匹配器（））.keyBy（0）
.flatMap（新的AverageTempMapper（））；
DataStream averageStreams=averageStream01.union（averageStream02）
.union（平均流量03）；
averageStreams.print（）；
环境执行（“传感器多功能读取MQTTEDGENTQEP”）；
}
公共静态类SensorMatcher实现映射函数{
私有静态最终长serialVersionUID=7035756567190539683L；
@凌驾
公共Tuple2映射（MqttTemperature值）引发异常{
String key=“没有房间”；
如果（value.getId（）.equals（1）| | value.getId（）.equals（2）| | value.getId（）.equals（3））{
key=“房间-A”；
}else如果（value.getId（）.equals（4）| | value.getId（）.equals（5）| | value.getId（）.equals（6））{
key=“房间B”；
}else如果（value.getId（）.equals（7）| | value.getId（）.equals（8）| | value.getId（）.equals（9））{
key=“C室”；
}否则{
System.err.println（“未在任何房间中定义传感器”）；
}
返回新的Tuple2（键，值）；
}
}
公共静态类AverageTempMapper
扩展RichFlatMapFunction{
私有静态最终长serialVersionUID=-4780146677198295204L；
私有映射状态模型状态；
@凌驾
公共void open（配置参数）引发异常{
类型信息类型信息=类型信息
.of（新类型提示（）{
});
//如何实例化这个描述符？
MapStateDescriptor描述符=新的MapStateDescriptor（“modelState”，
String.class，Tuple2.class）；
modelState=getRuntimeContext（）.getMapState（描述符）；
}
@凌驾
公共void平面图（Tuple2值，收集器输出）
抛出异常{
双温=零；
整数计数=0；
if（modelState.contains（value.f0））{
count=modelState.get（value.f0）.f0+1；
temp=（modelState.get（value.f0.f1+value.f1.getTemp（））；
}否则{
计数=1；
temp=value.f1.getTemp（）；
}
modelState.put（value.f0，Tuple2.of（count，temp））；
如果（计数>=3）{
out.collect（Tuple2.of（“房间”，空））；
}
}
}
}
public class SensorsMultipleReadingMqttEdgentQEP2 {
private boolean checkpointEnable = false;
private long checkpointInterval = 10000;
private CheckpointingMode checkpointMode = CheckpointingMode.EXACTLY_ONCE;
public SensorsMultipleReadingMqttEdgentQEP2() throws Exception {
// Start streaming from fake data source sensors
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
// obtain execution environment, run this example in "ingestion time"
env.setStreamTimeCharacteristic(TimeCharacteristic.IngestionTime);
if (checkpointEnable) {
env.enableCheckpointing(checkpointInterval, checkpointMode);
}
DataStream<MqttTemperature> temperatureStream01 = env.addSource(new TemperatureMqttConsumer("topic-edgent-01"));
DataStream<MqttTemperature> temperatureStream02 = env.addSource(new TemperatureMqttConsumer("topic-edgent-02"));
DataStream<MqttTemperature> temperatureStream03 = env.addSource(new TemperatureMqttConsumer("topic-edgent-03"));
DataStream<Tuple2<String, Double>> averageStream01 = temperatureStream01.map(new SensorMatcher()).keyBy(0)
.flatMap(new AverageTempMapper());
DataStream<Tuple2<String, Double>> averageStream02 = temperatureStream02.map(new SensorMatcher()).keyBy(0)
.flatMap(new AverageTempMapper());
DataStream<Tuple2<String, Double>> averageStream03 = temperatureStream03.map(new SensorMatcher()).keyBy(0)
.flatMap(new AverageTempMapper());
DataStream<Tuple2<String, Double>> averageStreams = averageStream01.union(averageStream02)
.union(averageStream03);
averageStreams.print();
env.execute("SensorsMultipleReadingMqttEdgentQEP");
}
public static class SensorMatcher implements MapFunction<MqttTemperature, Tuple2<String, MqttTemperature>> {
private static final long serialVersionUID = 7035756567190539683L;
@Override
public Tuple2<String, MqttTemperature> map(MqttTemperature value) throws Exception {
String key = "no-room";
if (value.getId().equals(1) || value.getId().equals(2) || value.getId().equals(3)) {
key = "room-A";
} else if (value.getId().equals(4) || value.getId().equals(5) || value.getId().equals(6)) {
key = "room-B";
} else if (value.getId().equals(7) || value.getId().equals(8) || value.getId().equals(9)) {
key = "room-C";
} else {
System.err.println("Sensor not defined in any room.");
}
return new Tuple2<>(key, value);
}
}
public static class AverageTempMapper
extends RichFlatMapFunction<Tuple2<String, MqttTemperature>, Tuple2<String, Double>> {
private static final long serialVersionUID = -4780146677198295204L;
private MapState<String, Tuple2<Integer, Double>> modelState;
private Integer threshold = 3;
@Override
public void open(Configuration parameters) throws Exception {
TypeInformation<Tuple2<Integer, Double>> typeInformation = TypeInformation
.of(new TypeHint<Tuple2<Integer, Double>>() {
});
MapStateDescriptor<String, Tuple2<Integer, Double>> descriptor = new MapStateDescriptor<String, Tuple2<Integer, Double>>(
"modelState", TypeInformation.of(String.class), typeInformation);
modelState = getRuntimeContext().getMapState(descriptor);
}
@Override
public void flatMap(Tuple2<String, MqttTemperature> value, Collector<Tuple2<String, Double>> out)
throws Exception {
Integer count = 0;
Double temp = 0.0;
if (modelState.contains(value.f0)) {
// there is already a value on the state
count = modelState.get(value.f0).f0 + 1;
temp = modelState.get(value.f0).f1 + value.f1.getTemp();
modelState.put(value.f0, Tuple2.of(1, value.f1.getTemp()));
} else {
// there is no value on the state
count = 1;
temp = value.f1.getTemp();
}
modelState.put(value.f0, Tuple2.of(count, temp));
if (count >= threshold) {
// only compute the average after the threshold
out.collect(Tuple2.of(value.f0, temp / count));
// clear the modelState value in order to compute new values next time
modelState.put(value.f0, Tuple2.of(0, 0.0));
}
}
}
}
公共类传感器MultipleReadingMQTTedgentQEP2{
私有布尔检查点启用=false；
专用长检查点间隔=10000；
private checkpointMode checkpointMode=checkpointMode.justly_一次；
public SensorsMultipleReadingMqttEdgentQEP2（）引发异常{
//从假数据源传感器开始流式传输
StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment（）；
//获取执行环境，在“摄取时间”中运行此示例
环境设置流时间特征（时间特征、摄取时间）；
如果（启用检查点）{
环境启用检查点（检查点间隔、检查点模式）；
}
DataStream temperatureStream01=env.addSource（新TemperatureMqttConsumer（“topic-edgent-01”）；
DataStream temperatureStream02=env.addSource（新TemperatureMqttConsumer（“topic-edgent-02”）；
DataStream temperatureStream03=env.addSource（新TemperatureMqttConsumer（“topic-edgent-03”）；
DataStream averageStream01=temperatureStream01.map（新的传感器匹配器（））.keyBy（0）
.flatMap（新的AverageTempMapper（））；
DataStream averageStream02=temperatureStream02.map（新的传感器匹配器（））.keyBy（0）
.flatMap（新的AverageTempMapper（））；
DataStream averageStream03=temperatureStream03.map（新的传感器匹配器（））.keyBy（0）
.flatMap（新的AverageTempMapper（））；
数据流平均值
MapStateDescriptor<String, Tuple2<Integer, Double>> modelState = new MapStateDescriptor<>(
"modelState",
BasicTypeInfo.STRING_TYPE_INFO,
TupleTypeInfo.getBasicTupleTypeInfo(Integer.class, Double.class));
this.modelState = getRuntimeContext().getMapState(modelState);
public static class AverageTempMapper extends RichFlatMapFunction<Tuple2<String, MqttTemperature>, Tuple2<String, Double>> {
private static final long serialVersionUID = -4780146677198295204L;
private ValueState<Tuple2<Integer, Double>> modelState;
@Override
public void open(Configuration parameters) {
this.modelState = getRuntimeContext().getState(new ValueStateDescriptor<>("modelState", TupleTypeInfo.getBasicTupleTypeInfo(Integer.class, Double.class)));
}
@Override
public void flatMap(Tuple2<String, MqttTemperature> value, Collector<Tuple2<String, Double>> out) throws Exception {
Double temp;
Integer count;
if (modelState.value() != null) {
Tuple2<Integer, Double> state = modelState.value();
count = state.f0 + 1;
temp = state.f1 + value.f1.getTemp();
} else {
count = 1;
temp = value.f1.getTemp();
}
modelState.update(Tuple2.of(count, temp));
if (count >= 3) {
out.collect(Tuple2.of(value.f0, temp/count));
}
}
}