一、基本处理函数(ProcessFunction)
ProcessFunction底层继承了AbstractRichFunction，有两个泛型表示输入和输出。其中有一个抽象方法processElement必须要实现，另一个非抽象方法onTimer
1) 抽象方法processElement对于流中的每个元素都会调用一次，参数包括三个，输入的数据值value、上下文ctx、收集器collector out，这个方法没有返回值，处理之后的输出数据是通过收集器out定义的
2) 非抽象方法onTimer类似于闹钟，只有在注册好的定时器触发时才会调用
二、处理函数的分类
1) ProcessFunction
是最基本的处理函数，基于DataStream直接调用process时作为参数传入
2) keyedProcessFunction
对流按键分区后的处理函数，基于keyedStream调用process时作为参数传入
3) ProcessWindowFunction
开窗之后的处理函数，也是全窗口函数的代表。基于WindowedStream调用process
4) ProcessAllWindowFunction
开窗之后的处理函数，基于AllWindowedStream调用process作为参数
5) CoProcessFunction
合并两条流之后的处理函数，基于ConnectedStream调用process实现
6) ProcessJoinFunction
间隔联结(Interval join)两条流之后的处理函数，基于IntervalJoined调用process实现
7) BroadcastProcessFunction
广播连接流处理函数，是一个没有keyby的DataStream和广播流BroadcastStream做connect之后的
8) keyedBroadcastProcessFunction
按键分区的广播流连接的处理函数。是一个keyby之后的keyedStream和一个广播流BroadcastStream做连接之后的产物
三、keyedProcessFunction
只有在KeyedStream中才支持使用TimerService设置定时器，在之前已经注册过定时器(通过上下文ctx.timerservice方法)，并且现在达到了触发时间。
定时器总结
1. 只有keyed才有
2. 是通过watermark触发的，watermark = 当前事件最大的事件 - 等时间 - 1ms， 会推迟一条数据
3. 在process中获取当前的watermark，显示的是上一次的watermark，因为process还没接收到这条数据对应生成的新的watermark
1. 练习TopN
案例需求：实时统计一段时间内的出现次数最多的水位。例如，统计最近10秒钟内出现次数最多的两个水位，并且每5秒钟更新一次。我们知道，这可以用一个滑动窗口来实现。于是就需要开滑动窗口收集传感器的数据，按照不同的水位进行统计，而后汇总排序并最终输出前两名。
1 使用ProcessAllWindowFunction
public class ProcessAllWindowTopNDemo {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(1);
SingleOutputStreamOperator<WaterSensor> sensorDS = env
.socketTextStream("hadoop102", 7777)
.map(new WaterSensorMapFunction())
.assignTimestampsAndWatermarks(
WatermarkStrategy
.<WaterSensor>forBoundedOutOfOrderness(Duration.ofSeconds(3))
.withTimestampAssigner((element, ts) -> element.getTs() * 1000L)
);
// 最近10秒= 窗口长度， 每5秒输出 = 滑动步长
// TODO 思路一： 所有数据到一起， 用hashmap存， key=vc，value=count值
sensorDS.windowAll(SlidingEventTimeWindows.of(Time.seconds(10), Time.seconds(5)))
.process(new MyTopNPAWF())
.print();
env.execute();
}
public static class MyTopNPAWF extends ProcessAllWindowFunction<WaterSensor, String, TimeWindow> {
@Override
public void process(Context context, Iterable<WaterSensor> elements, Collector<String> out) throws Exception {
// 定义一个hashmap用来存，key=vc，value=count值
Map<Integer, Integer> vcCountMap = new HashMap<>();
// 1.遍历数据, 统计 各个vc出现的次数
for (WaterSensor element : elements) {
Integer vc = element.getVc();
if (vcCountMap.containsKey(vc)) {
// 1.1 key存在，不是这个key的第一条数据，直接累加
vcCountMap.put(vc, vcCountMap.get(vc) + 1);
} else {
// 1.2 key不存在，初始化
vcCountMap.put(vc, 1);
}
}
// 2.对 count值进行排序: 利用List来实现排序
List<Tuple2<Integer, Integer>> datas = new ArrayList<>();
for (Integer vc : vcCountMap.keySet()) {
datas.add(Tuple2.of(vc, vcCountMap.get(vc)));
}
// 对List进行排序，根据count值 降序
datas.sort(new Comparator<Tuple2<Integer, Integer>>() {
@Override
public int compare(Tuple2<Integer, Integer> o1, Tuple2<Integer, Integer> o2) {
// 降序， 后 减 前
return o2.f1 - o1.f1;
}
});
// 3.取出 count最大的2个 vc
StringBuilder outStr = new StringBuilder();
outStr.append("================================\n");
// 遍历 排序后的 List，取出前2个， 考虑可能List不够2个的情况 ==》 List中元素的个数 和 2 取最小值
for (int i = 0; i < Math.min(2, datas.size()); i++) {
Tuple2<Integer, Integer> vcCount = datas.get(i);
outStr.append("Top" + (i + 1) + "\n");
outStr.append("vc=" + vcCount.f0 + "\n");
outStr.append("count=" + vcCount.f1 + "\n");
outStr.append("窗口结束时间=" + DateFormatUtils.format(context.window().getEnd(), "yyyy-MM-dd HH:mm:ss.SSS") + "\n");
outStr.append("================================\n");
}
out.collect(outStr.toString());
}
}
}2 使用KeyedProcessFunction
1. 按照vc分组keyby，开窗10s，步长为5s，使用aggregate聚合(解决：增量聚合，全窗口打标签)。
2. 但是聚合完就没有窗口信息了，开窗后变为WindowedStream，聚合之后变为DataStream
要保证同一个窗口的数据进行TopN，keyby窗口的标签
3. process
-》 processElement，来一条计算一条
-》 要排序，得有这个窗口范围所有计算结果，才能一起排序
-》存起来：HashMap：key为窗口标签，value=List
-》 存多久：理论上，同一个窗口的结果应该同时触发输出
-》 只需要一个短暂的延迟即可，等1ms去排序
-》注册一个定时器
public class KeyedProcessFunctionTopNDemo {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setParallelism(1);
SingleOutputStreamOperator<WaterSensor> sensorDS = env
.socketTextStream("hadoop102", 7777)
.map(new WaterSensorMapFunction())
.assignTimestampsAndWatermarks(
WatermarkStrategy
.<WaterSensor>forBoundedOutOfOrderness(Duration.ofSeconds(3))
.withTimestampAssigner((element, ts) -> element.getTs() * 1000L)
);
// 最近10秒= 窗口长度， 每5秒输出 = 滑动步长
/**
* TODO 思路二： 使用 KeyedProcessFunction实现
* 1、按照vc做keyby，开窗，分别count
* ==》 增量聚合，计算 count
* ==》 全窗口，对计算结果 count值封装 ， 带上 窗口结束时间的 标签
* ==》 为了让同一个窗口时间范围的计算结果到一起去
*
* 2、对同一个窗口范围的count值进行处理： 排序、取前N个
* =》 按照 windowEnd做keyby
* =》 使用process， 来一条调用一次，需要先存，分开存，用HashMap,key=windowEnd,value=List
* =》 使用定时器，对 存起来的结果 进行 排序、取前N个
*/
// 1. 按照 vc 分组、开窗、聚合（增量计算+全量打标签）
// 开窗聚合后，就是普通的流，没有了窗口信息，需要自己打上窗口的标记 windowEnd
SingleOutputStreamOperator<Tuple3<Integer, Integer, Long>> windowAgg = sensorDS.keyBy(sensor -> sensor.getVc())
.window(SlidingEventTimeWindows.of(Time.seconds(10), Time.seconds(5)))
.aggregate(
new VcCountAgg(),
new WindowResult()
);
// 2. 按照窗口标签（窗口结束时间）keyby，保证同一个窗口时间范围的结果，到一起去。排序、取TopN
windowAgg.keyBy(r -> r.f2)
.process(new TopN(2))
.print();
env.execute();
}
public static class VcCountAgg implements AggregateFunction<WaterSensor, Integer, Integer> {
@Override
public Integer createAccumulator() {
return 0;
}
@Override
public Integer add(WaterSensor value, Integer accumulator) {
return accumulator + 1;
}
@Override
public Integer getResult(Integer accumulator) {
return accumulator;
}
@Override
public Integer merge(Integer a, Integer b) {
return null;
}
}
/**
* 泛型如下：
* 第一个：输入类型 = 增量函数的输出 count值，Integer
* 第二个：输出类型 = Tuple3(vc，count，windowEnd) ,带上 窗口结束时间 的标签
* 第三个：key类型 ， vc，Integer
* 第四个：窗口类型
*/
public static class WindowResult extends ProcessWindowFunction<Integer, Tuple3<Integer, Integer, Long>, Integer, TimeWindow> {
@Override
public void process(Integer key, Context context, Iterable<Integer> elements, Collector<Tuple3<Integer, Integer, Long>> out) throws Exception {
// 迭代器里面只有一条数据，next一次即可
Integer count = elements.iterator().next();
long windowEnd = context.window().getEnd();
out.collect(Tuple3.of(key, count, windowEnd));
}
}
public static class TopN extends KeyedProcessFunction<Long, Tuple3<Integer, Integer, Long>, String> {
// 存不同窗口的 统计结果，key=windowEnd，value=list数据
private Map<Long, List<Tuple3<Integer, Integer, Long>>> dataListMap;
// 要取的Top数量
private int threshold;
public TopN(int threshold) {
this.threshold = threshold;
dataListMap = new HashMap<>();
}
@Override
public void processElement(Tuple3<Integer, Integer, Long> value, Context ctx, Collector<String> out) throws Exception {
// 进入这个方法，只是一条数据，要排序，得到齐才行 ===》 存起来，不同窗口分开存
// 1. 存到HashMap中
Long windowEnd = value.f2;
if (dataListMap.containsKey(windowEnd)) {
// 1.1 包含vc，不是该vc的第一条，直接添加到List中
List<Tuple3<Integer, Integer, Long>> dataList = dataListMap.get(windowEnd);
dataList.add(value);
} else {
// 1.1 不包含vc，是该vc的第一条，需要初始化list
List<Tuple3<Integer, Integer, Long>> dataList = new ArrayList<>();
dataList.add(value);
dataListMap.put(windowEnd, dataList);
}
// 2. 注册一个定时器， windowEnd+1ms即可（
// 同一个窗口范围，应该同时输出，只不过是一条一条调用processElement方法，只需要延迟1ms即可
ctx.timerService().registerEventTimeTimer(windowEnd + 1);
}
@Override
public void onTimer(long timestamp, OnTimerContext ctx, Collector<String> out) throws Exception {
super.onTimer(timestamp, ctx, out);
// 定时器触发，同一个窗口范围的计算结果攒齐了，开始 排序、取TopN
Long windowEnd = ctx.getCurrentKey();
// 1. 排序
List<Tuple3<Integer, Integer, Long>> dataList = dataListMap.get(windowEnd);
dataList.sort(new Comparator<Tuple3<Integer, Integer, Long>>() {
@Override
public int compare(Tuple3<Integer, Integer, Long> o1, Tuple3<Integer, Integer, Long> o2) {
// 降序， 后 减 前
return o2.f1 - o1.f1;
}
});
// 2. 取TopN
StringBuilder outStr = new StringBuilder();
outStr.append("================================\n");
// 遍历 排序后的 List，取出前 threshold 个， 考虑可能List不够2个的情况 ==》 List中元素的个数 和 2 取最小值
for (int i = 0; i < Math.min(threshold, dataList.size()); i++) {
Tuple3<Integer, Integer, Long> vcCount = dataList.get(i);
outStr.append("Top" + (i + 1) + "\n");
outStr.append("vc=" + vcCount.f0 + "\n");
outStr.append("count=" + vcCount.f1 + "\n");
outStr.append("窗口结束时间=" + vcCount.f2 + "\n");
outStr.append("================================\n");
}
// 用完的List，及时清理，节省资源
dataList.clear();
out.collect(outStr.toString());
}
}
}2. 侧输出流(Side output)
可以认为是"主流"上分叉出的"支流"。具体应用时，可以在处理函数ProcessElement或者onTimer中，调用上下文的output方法就可以
output方法需要传入两个参数，第一个是输出标签，用来标识侧输出流，第二个是要输出的数据
如果想要获取这个侧输出流，可以基于处理之后的DataStream直接调用getSideOutput方法，传入对应的outputtag。
上下文提供侧流可以用来告警，主流正常执行
扫一扫
944
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
