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

增量窗口函数

增量窗口函数

本课用同一组订单事件分别实现窗口求和与平均值,让你看清 ReduceFunction 和 AggregateFunction 如何在数据到达时持续更新结果,而不是等窗口关闭后再遍历全部元素。

学习目标

  • 理解增量窗口函数的执行时机与状态特点
  • 能根据输入、累加器和输出类型选择合适接口
  • 能运行并验证窗口求和与平均值示例

增量聚合的本质

增量窗口函数会在每条事件进入所属窗口时立即更新中间结果。窗口算子只需保存当前归约值或累加器;触发器判定窗口可以计算后,再输出最终结果。对于固定大小的累加器,状态体积不会随窗口元素数量线性增长。

增量窗口聚合的数据流

ReduceFunction<T> 的输入、状态和输出都是同一种类型,适合求和、最大值、最小值等“两个同类值合成一个同类值”的计算。AggregateFunction<IN, ACC, OUT> 将输入、累加器和结果拆开,适合平均值、比例、统计摘要等需要独立中间状态的计算。

接口 中间状态 适合场景
ReduceFunction<T> 一个 T 同类型求和、最大值、最小值
AggregateFunction<IN, ACC, OUT> 自定义 ACC 平均值、计数与多指标统计

完整示例

下面使用事件时间和 10 秒滚动窗口。ReduceFunction 计算每个用户的金额合计,AggregateFunction 用“总金额 + 条数”累加器计算平均金额。将代码放入已引入 Flink DataStream API 的 Java 项目中运行。

java
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;

import java.time.Duration;
import java.util.Locale;

public class IncrementalWindowFunctionDemo {

    public static class OrderEvent {
        public String userId;
        public long amount;
        public long eventTime;

        public OrderEvent() {
        }

        public OrderEvent(String userId, long amount, long eventTime) {
            this.userId = userId;
            this.amount = amount;
            this.eventTime = eventTime;
        }
    }

    public static class SumReduce implements ReduceFunction<OrderEvent> {
        @Override
        public OrderEvent reduce(OrderEvent left, OrderEvent right) {
            // 每到一条事件,只保留合并后的当前结果。
            return new OrderEvent(
                    left.userId,
                    left.amount + right.amount,
                    Math.max(left.eventTime, right.eventTime));
        }
    }

    public static class AverageAggregate
            implements AggregateFunction<
                    OrderEvent,
                    Tuple3<String, Long, Long>,
                    Tuple2<String, Double>> {

        @Override
        public Tuple3<String, Long, Long> createAccumulator() {
            return Tuple3.of("", 0L, 0L);
        }

        @Override
        public Tuple3<String, Long, Long> add(
                OrderEvent value,
                Tuple3<String, Long, Long> accumulator) {
            // 累加器分别保存用户、总金额和事件条数。
            return Tuple3.of(
                    value.userId,
                    accumulator.f1 + value.amount,
                    accumulator.f2 + 1L);
        }

        @Override
        public Tuple2<String, Double> getResult(
                Tuple3<String, Long, Long> accumulator) {
            return Tuple2.of(
                    accumulator.f0,
                    (double) accumulator.f1 / accumulator.f2);
        }

        @Override
        public Tuple3<String, Long, Long> merge(
                Tuple3<String, Long, Long> left,
                Tuple3<String, Long, Long> right) {
            String userId = left.f0.isEmpty() ? right.f0 : left.f0;
            return Tuple3.of(
                    userId,
                    left.f1 + right.f1,
                    left.f2 + right.f2);
        }
    }

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

        DataStream<OrderEvent> events = env
                .fromElements(
                        new OrderEvent("alice", 20L, 1_000L),
                        new OrderEvent("bob", 10L, 2_000L),
                        new OrderEvent("alice", 30L, 4_000L),
                        new OrderEvent("bob", 50L, 9_000L),
                        new OrderEvent("alice", 40L, 12_000L))
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<OrderEvent>forMonotonousTimestamps()
                                .withTimestampAssigner(
                                        (event, previousTimestamp) ->
                                                event.eventTime));

        events
                .keyBy(event -> event.userId)
                .window(TumblingEventTimeWindows.of(Duration.ofSeconds(10)))
                .reduce(new SumReduce())
                .map(event -> String.format(
                        Locale.ROOT,
                        "user=%s, sum=%d",
                        event.userId,
                        event.amount))
                .returns(Types.STRING)
                .print("reduce");

        events
                .keyBy(event -> event.userId)
                .window(TumblingEventTimeWindows.of(Duration.ofSeconds(10)))
                .aggregate(new AverageAggregate())
                .map(result -> String.format(
                        Locale.ROOT,
                        "user=%s, avg=%.1f",
                        result.f0,
                        result.f1))
                .returns(Types.STRING)
                .print("aggregate");

        env.execute("incremental-window-function-demo");
    }
}

预期输出如下;不同分支或不同 key 的行顺序可能变化,但结果集合应一致。

text
reduce> user=alice, sum=50
reduce> user=bob, sum=60
aggregate> user=alice, avg=25.0
aggregate> user=bob, avg=30.0
reduce> user=alice, sum=40
aggregate> user=alice, avg=40.0

前四行对应事件时间区间 [0, 10000),后两行对应 [10000, 20000)。有界数据源结束时会推进最终水位线,因此最后一个窗口也能触发。

关键边界与选择

ReduceFunction 必须返回与输入相同的类型,因此为了保存合计值,示例复用了 OrderEvent.amount 字段。生产代码若不希望混淆“原始事件”和“聚合结果”,应定义语义更清晰的结果类型,并改用 AggregateFunction。

AggregateFunction.merge() 在滚动窗口中通常不会执行,但会话窗口发生合并时可能调用。实现时不能简单返回任意一侧,否则合并窗口会丢失部分统计值。

增量聚合降低的是窗口状态体积,不代表没有状态。key 数量、并行度、窗口数量和允许迟到时间仍会决定状态规模;累加器也应避免保存不断增长的列表或字符串。

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

目录与阅读设置

阅读设置

17

记录一个想法

增量窗口函数

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

登录哪都通