目录
ProcessFunction API(底层 API)
转换算子是无法访问事件的时间戳信息和水位线信息的。而这 在一些应用场景下，极为重要。例如 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
1 KeyedProcessFunction
KeyedProcessFunction 用来操作 KeyedStream。KeyedProcessFunction 会处理流的每一个元素，输出为 0 个、1 个或者多个元素。所有的 Process Function 都继承自 RichFunction 接口，所以都有 open()、close()和 getRuntimeContext()等方法。而 KeyedProcessFunction<K, I, O>还额外提供了两个方法:
1）processElement(I value, Context ctx, Collector<O> out), 流中的每一个元素都 会调用这个方法，调用结果将会放在 Collector 数据类型中输出。Context 可以访问元素的时间戳，元素的 key，以及 TimerService 时间服务。Context 还
可以将结果输出到别的流(side outputs)。
2）onTimer(long timestamp, OnTimerContext ctx, Collector<O> out) 是一个回调函数。当之前注册的定时器触发时调用。参数 timestamp 为定时器所设定的触发的时间戳。Collector 为输出结果的集合。OnTimerContext 和 processElement 的 Context 参数一样，提供了上下文的一些信息，例如定时器触发的时间信息(事件时间或者处理时间)。
2 TimerService 和 定时器(Timers)
Context 和 OnTimerContext 所持有的 TimerService 对象拥有以下方法:
-
long currentProcessingTime() 返回当前处理时间
-
long currentWatermark() 返回当前 watermark 的时间戳
-
void registerProcessingTimeTimer(long timestamp) 会注册当前 key 的processing time 的定时器。当 processing time 到达定时时间时，触发 timer。
-
void registerEventTimeTimer(long timestamp) 会注册当前 key 的 event time 定时器。当水位线大于等于定时器注册的时间时，触发定时器执行回调函数。
-
void deleteProcessingTimeTimer(long timestamp) 删除之前注册处理时间定时器。如果没有这个时间戳的定时器，则不执行。
-
void deleteEventTimeTimer(long timestamp) 删除之前注册的事件时间定时器，如果没有此时间戳的定时器，则不执行。当定时器 timer 触发时，会执行回调函数 onTimer()。注意定时器 timer 只能在keyed streams 上面使用。
代码实现KeyedProcessFunction API的一些功能：
package com.dongda.processfunction;
import com.dongda.beans.SensorReading;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;
public class ProcessTest1_KeyedProcessFunction {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1
//从文件里面读取数据
DataStream<String> inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");
//转成SensorReading类型,分配了时间戳和watermark
DataStream<SensorReading> dataStream = inputStream.map(line -> {
String[] fields = line.split(",");
return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
});
//测试KeyedProcessFunction,先分组然后自定义处理
dataStream.keyBy("id")
.process(new MyProcess())
.print();
env.execute();
}
private static class MyProcess extends KeyedProcessFunction<Tuple, SensorReading, Integer> {
ValueState<Long> tsTimerState;
@Override
public void open(Configuration parameters) throws Exception {
tsTimerState = getRuntimeContext().getState(new ValueStateDescriptor<Long>("ts-timer",Long.class));
}
@Override
public void processElement(SensorReading sensorReading, Context context, Collector<Integer> out) throws Exception {
out.collect(sensorReading.getId().length());
//context
context.timestamp();
context.getCurrentKey();
// context.output();
context.timerService().currentWatermark();//用当前的定时器服务去获取当前的处理时间wartermark
context.timerService().currentProcessingTime();
context.timerService().registerProcessingTimeTimer(context.timerService().currentProcessingTime() + 1000L);//注册定时服务
//当前的定时器只针对当前的key有效
// tsTimerState.update(context.timerService().currentProcessingTime() + 1000L);
//如果我们想去清空，直接把当前key的值拿出来去做清空
// context.timerService().deleteProcessingTimeTimer(tsTimerState.value());
}
//onTimer去定时触发操作
@Override
public void onTimer(long timestamp, OnTimerContext ctx, Collector<Integer> out) throws Exception {
System.out.println(timestamp + "定时器触发");
//onTimer里面还可以获取当前上下文的key
ctx.getCurrentKey();
// ctx.output();//获取侧输出流
//用out获取主流
}
@Override
public void close() throws Exception {
tsTimerState.clear();
}
}
}
下面举个例子说明 KeyedProcessFunction 如何操作 KeyedStream。
需求:监控温度传感器的温度值，如果温度值在 10 秒钟之内(processing time) 连续上升，则报警。
package com.dongda.processfunction;
import com.dongda.beans.SensorReading;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;
public class ProcessTest2_ApplicationCase {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1
//从文件里面读取数据
DataStream<String> inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");
//转成SensorReading类型,分配了时间戳和watermark
DataStream<SensorReading> dataStream = inputStream.map(line -> {
String[] fields = line.split(",");
return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
});
//测试KeyedProcessFunction,先分组然后自定义处理
dataStream.keyBy("id")
.process(new TempConsIncreWarning(10))
.print();
env.execute();
}
//实现自定义处理函数，检测一段时间内的温度上升，输出报警
private static class TempConsIncreWarning extends KeyedProcessFunction<Tuple, SensorReading, String> {
//定义私有属性，当前统计的时间间隔
private Integer interval;
public TempConsIncreWarning(Integer interval) {
this.interval = interval;
}
//定义状态，保持上一次的温度值，定时器时间戳
private ValueState<Double> lastTempState;
private ValueState<Long> timerTsState;
//在生命周期open里面获取当前的生命周期句柄
@Override
public void open(Configuration parameters) throws Exception {
lastTempState = getRuntimeContext().getState(new ValueStateDescriptor<Double>("last-temp", Double.class, Double.MIN_VALUE));
timerTsState = getRuntimeContext().getState(new ValueStateDescriptor<Long>("timer-ts", Long.class));
}
@Override
public void processElement(SensorReading value, Context ctx, Collector<String> out) throws Exception {
//取出状态
Double lastTemp = lastTempState.value();
Long timerTs = timerTsState.value();
//如果温度上升并且没有定时器,注册10秒后的定时器，开始等待
if (value.getTemperature() > lastTemp && timerTs == null) {
//计算出定时器时间戳
Long ts = ctx.timerService().currentProcessingTime() + interval * 1000L;
ctx.timerService().registerProcessingTimeTimer(ts);
//更新定时器状态
timerTsState.update(ts);
}
//如果温度下降，那么删除定时器
else if (value.getTemperature() < lastTemp && timerTs != null) {
ctx.timerService().deleteProcessingTimeTimer(timerTs);
//状态清空
timerTsState.clear();
}
//更新温度状态
lastTempState.update(value.getTemperature());
}
@Override
public void onTimer(long timestamp, OnTimerContext ctx, Collector<String> out) throws Exception {
//定时器触发，这个其实不需要做任何判断了，只要触发定时器一定是连续上升，没有被清空，所以只要被触发就输出报警信息
out.collect("传感器"+ctx.getCurrentKey().getField(0)+"温度值连续"+interval+"上升");
//光输出还不算完，还需要清空状态。现在这个状态，timer里面还有。定时器触发和timer的状态不是一回事，timer不会自动清空
timerTsState.clear();
}
@Override
public void close() throws Exception {
lastTempState.clear();
}
}
}
3 侧输出流(SideOutput)
大部分的 DataStream API 的算子的输出是单一输出，也就是某种数据类型的流。 除了 split 算子，可以将一条流分成多条流，这些流的数据类型也都相同。process function 的 side outputs 功能可以产生多条流，并且这些流的数据类型可以不一样。 一个 side output 可以定义为 OutputTag[X]对象，X 是输出流的数据类型。process function 可以通过 Context 对象发射一个事件到一个或者多个 side outputs。
下面是一个示例程序，用来监控传感器温度值，将温度值低于 30 度的数据输出 到 side output。
package com.dongda.processfunction;
import com.dongda.beans.SensorReading;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.ProcessFunction;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;
import sun.awt.SunHints;
public class ProcessTest3_SideOutputCase {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(1);//为了方便观察打印出来的结果，将全局并行度设置为1
//从文件里面读取数据
DataStream<String> inputStream = env.readTextFile("/Users/haitaoyou/developer/flink/src/main/resources/sensor.txt");
//转成SensorReading类型,分配了时间戳和watermark
DataStream<SensorReading> dataStream = inputStream.map(line -> {
String[] fields = line.split(",");
return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
});
//定义一个OutputTag,用来表示侧输出流低温流
OutputTag<SensorReading> lowTempTag = new OutputTag<SensorReading>("lowTemp") {
};
//测试KeyedProcessFunction,先分组然后自定义处理
SingleOutputStreamOperator<SensorReading> highTempStream = dataStream.process(new ProcessFunction<SensorReading, SensorReading>() {
@Override
public void processElement(SensorReading sensorReading, Context context, Collector<SensorReading> collector) throws Exception {
//判断温度，大于30度，高温流输出到主流；小于低温流输出到侧流
if (sensorReading.getTemperature()>30){
collector.collect(sensorReading);
}else {
context.output(lowTempTag, sensorReading);
}
}
});
highTempStream.print("high-temp");
highTempStream.getSideOutput(lowTempTag).print("low-temp");
env.execute();
}
}
输出结果为：
4 CoProcessFunction
对于两条输入流，DataStream API 提供了 CoProcessFunction 这样的 low-level 操作。CoProcessFunction 提供了操作每一个输入流的方法: processElement1()和 processElement2()。
类似于 ProcessFunction，这两种方法都通过 Context 对象来调用。这个 Context 对象可以访问事件数据，定时器时间戳，TimerService，以及 side outputs。 CoProcessFunction 也提供了 onTimer()回调函数。
7512
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
