大数据与流处理 / 系统课时

ProcessFunction

ProcessFunction

本课用一个传感器流完成按设备计数、事件时间超时回调和高温侧输出。学完后,你能判断何时应从普通转换算子升级到 ProcessFunction,并正确组合键控状态、定时器与多路输出。

学习目标

  • 理解 ProcessFunction 家族的职责与执行入口
  • 在 KeyedProcessFunction 中访问状态、时间戳和定时器
  • 使用侧输出分离异常数据,并验证主流与侧流结果

为什么使用 ProcessFunction

map、filter 和 flatMap 适合无状态或简单转换;当处理逻辑需要同时观察当前事件、保存按键状态、等待未来时间点或把数据发送到不同结果流时,ProcessFunction 提供了更底层的控制能力。

只有先经过 keyBy,状态和定时器才会按键隔离。每个键拥有独立状态,定时器触发时也会自动恢复注册该定时器的键上下文。

KeyedProcessFunction 数据处理关系图

核心执行模型

processElement 会为每条输入记录调用一次。Context 可读取事件时间戳、当前 Watermark、处理时间,并通过 TimerService 注册或删除定时器;Collector 用于发送主输出,ctx.output 用于发送侧输出。

能力 典型入口 关键限制
按键状态 getRuntimeContext().getState(...) 必须作用于 KeyedStream
时间与定时器 ctx.timerService()、onTimer(...) 事件时间定时器依赖 Watermark 推进
主输出 out.collect(...) 类型由函数输出泛型决定
侧输出 ctx.output(outputTag, value) 获取侧流时必须复用同一个 OutputTag

主示例:状态、定时器与侧输出

下面的完整作业按 sensorId 统计记录数。每条事件都会把空闲检测定时器重置到事件时间后 5 秒;温度达到 80 度时,记录同时进入高温侧输出。

java
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.OpenContext;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple3;
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.KeyedProcessFunction;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;

import java.util.Arrays;

public class ProcessFunctionJob {
    private static final OutputTag<String> HOT_TAG =
            new OutputTag<String>("hot-readings") {};

    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env =
                StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        DataStream<Tuple3<String, Long, Double>> input = env
                .fromCollection(Arrays.asList(
                        Tuple3.of("sensor-a", 1000L, 70.0),
                        Tuple3.of("sensor-b", 2000L, 65.0),
                        Tuple3.of("sensor-a", 3000L, 85.5)))
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple3<String, Long, Double>>forMonotonousTimestamps()
                                .withTimestampAssigner((event, previous) -> event.f1));

        SingleOutputStreamOperator<String> main = input
                .keyBy(event -> event.f0)
                .process(new SensorProcessFunction());

        main.print("main");
        main.getSideOutput(HOT_TAG).print("hot");
        env.execute("process-function-demo");
    }

    private static class SensorProcessFunction
            extends KeyedProcessFunction<String, Tuple3<String, Long, Double>, String> {
        private ValueState<Integer> countState;
        private ValueState<Long> timerState;

        @Override
        public void open(OpenContext openContext) throws Exception {
            countState = getRuntimeContext().getState(
                    new ValueStateDescriptor<>("count", Integer.class));
            timerState = getRuntimeContext().getState(
                    new ValueStateDescriptor<>("idle-timer", Long.class));
        }

        @Override
        public void processElement(
                Tuple3<String, Long, Double> value,
                Context ctx,
                Collector<String> out) throws Exception {
            Integer current = countState.value();
            int next = current == null ? 1 : current + 1;
            countState.update(next);

            // 新事件到达时取消旧定时器,只保留最新空闲截止时间。
            Long oldTimer = timerState.value();
            if (oldTimer != null) {
                ctx.timerService().deleteEventTimeTimer(oldTimer);
            }
            long newTimer = value.f1 + 5000L;
            ctx.timerService().registerEventTimeTimer(newTimer);
            timerState.update(newTimer);

            out.collect("reading sensor=" + value.f0
                    + " count=" + next + " temp=" + value.f2);

            if (value.f2 >= 80.0) {
                ctx.output(HOT_TAG,
                        "hot sensor=" + value.f0 + " temp=" + value.f2);
            }
        }

        @Override
        public void onTimer(
                long timestamp,
                OnTimerContext ctx,
                Collector<String> out) throws Exception {
            out.collect("idle sensor=" + ctx.getCurrentKey()
                    + " count=" + countState.value()
                    + " timer=" + timestamp);
            countState.clear();
            timerState.clear();
        }
    }
}

预期输出如下。print 前缀可能因运行环境不同而变化,侧输出与主输出的显示顺序也可能交错,但核心内容应一致。

text
reading sensor=sensor-a count=1 temp=70.0
reading sensor=sensor-b count=1 temp=65.0
reading sensor=sensor-a count=2 temp=85.5
hot sensor=sensor-a temp=85.5
idle sensor=sensor-b count=1 timer=7000
idle sensor=sensor-a count=2 timer=8000

验证与关键边界

示例使用有界数据源。数据源结束时会发送最终 Watermark,因此尚未触发的事件时间定时器会执行;在持续运行的 Kafka 等数据源中,触发时机取决于 Watermark 策略和各并行分区的推进情况。

不要保存 Context 或 Collector 供异步线程以后使用,它们只在当前回调期间有效。高频事件若不断注册新定时器,应删除旧定时器或进行时间对齐,否则定时器数量会增加状态与检查点开销。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

ProcessFunction

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通