Flink 实现实时计算

在本节中,我们将使用 Apache Flink 来构建热搜榜的实时计算模块。Flink 是一个强大的流处理引擎,能够提供低延迟、高吞吐的实时数据处理能力。

  • 低延迟:毫秒级延迟,适合实时热搜计算
  • 精确一次语义:保证数据处理的准确性
  • 状态管理:内置状态存储,支持容错
  • 窗口计算:丰富的时间窗口操作
  • 可扩展性:水平扩展,处理海量数据

系统架构

┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   Kafka     │    │   Flink     │    │   Redis     │
│  (事件流)   │───▶│  (计算引擎) │───▶│  (结果存储) │
└─────────────┘    └─────────────┘    └─────────────┘

项目依赖

首先,在 pom.xml 中添加 Flink 相关依赖:

配置要点

  • 配置表达的是环境差异和运行参数,不是业务规则本身。
  • 队列、缓存、存储和服务参数决定系统在高峰期的缓冲能力。

数据模型

定义热搜事件和结果的数据模型:

数据模型是整条 Flink 链路的契约。上游的事件格式、下游的 Sink 写入逻辑、状态存储的序列化,全部依赖这里定义的两个类。模型设计得好,后续的算子就只是拼装;模型设计得含糊,每一层都要互相猜测字段含义。

两个核心类的职责划分:

类职责生命周期生产者消费者
HotSearchEvent描述一次用户互动流中的每条记录Kafka 解析算子窗口聚合函数
HotSearchResult描述一个内容在某个窗口内的热度每个窗口每条内容一条窗口聚合函数TopN 处理函数、Redis Sink

HotSearchEvent 的字段设计:

字段类型必需说明
contentIdString是内容 ID,分组的 key
eventTypeString是事件类型:view / like / comment / share
eventTimelong是事件发生时刻的毫秒时间戳,不是消费时刻
userIdString是用户 ID,用于反作弊维度聚合
weightdouble是行为权重,由上游反作弊服务给出

eventTime 是整个模型里最容易出错的一个字段。它必须是事件发生的时刻,不是 Flink 消费的时刻。用消费时刻会带来两个后果:延迟到达的事件被算成「刚刚发生」,内容热度出现跳变;水位线永远追不上真实时间,窗口无法按预期触发。

weight 字段体现了「外部计算前移」的设计。异常检测、信誉查询这类依赖外部服务的逻辑,放在 Flink 内部会让容错重放把外部调用放大成倍——作业重启一次,同一批事件会再次调用一遍检测服务。放在上游算好、作为事件字段带进来,Flink 就只做纯计算,重放多少次都不会多调一次外部服务。

模型要满足 POJO 要求,否则 Flink 会退回到 Kryo 序列化:

  • 公开字段(不是 private 加 getter)
  • 有 public 无参构造
  • 字段类型可推断(不要用泛型、接口、Object 这类擦除后无法推断的类型)
  • 实现 Serializable 并声明 serialVersionUID

事件模型:

import java.io.Serializable;

/**
 * 热搜事件:用户的一次互动。
 *
 * 必须使用 POJO(公开字段 + 无参构造 + 字段类型可推断),
 * 否则 Flink 会退回到 Kryo 序列化,性能明显下降。
 */
public class HotSearchEvent implements Serializable {

    private static final long serialVersionUID = 1L;

    /** 内容 ID。 */
    public String contentId;

    /** 事件类型:view / like / comment / share。 */
    public String eventType;

    /** 事件时间(毫秒时间戳),以事件发生时刻为准,不是消费时刻。 */
    public long eventTime;

    /** 用户 ID。 */
    public String userId;

    /** 行为权重,由上游反作弊服务给出。 */
    public double weight;

    /** 无参构造,POJO 序列化要求。 */
    public HotSearchEvent() {
    }

    public HotSearchEvent(String contentId, String eventType, long eventTime,
                          String userId, double weight) {
        this.contentId = contentId;
        this.eventType = eventType;
        this.eventTime = eventTime;
        this.userId = userId;
        this.weight = weight;
    }
}

结果模型只需要三个字段:

import java.io.Serializable;

/**
 * 热搜计算结果:某个窗口内单个内容的热度。
 */
public class HotSearchResult implements Serializable {

    private static final long serialVersionUID = 1L;

    /** 内容 ID。 */
    public String contentId;

    /** 热度分数。 */
    public double score;

    /** 窗口结束时间。 */
    public long windowEnd;

    public HotSearchResult() {
    }

    public HotSearchResult(String contentId, double score, long windowEnd) {
        this.contentId = contentId;
        this.score = score;
        this.windowEnd = windowEnd;
    }
}

windowEnd 字段是幂等写入的关键。它是窗口的结束时刻,同一个窗口的多次计算结果,这个值完全相同。Redis Sink 用它做版本号(ranking:hot:w1753932000000),同一个窗口重复写入只是覆盖同样的值,而不同窗口的结果互不干扰。

模型设计的四条检查项:

检查项不满足的后果
事件时间是发生时刻热度跳变,窗口触发异常
POJO 规范退化为 Kryo 序列化,吞吐和延迟都明显变差
外部服务调用前移到上游Flink 重放导致外部服务被放大调用
结果携带窗口结束时间Sink 无法幂等,重启后产生重复数据

作业主类负责把 Source、窗口聚合、TopN 和 Sink 串起来:

import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.connector.kafka.source.KafkaSource;
import org.apache.flink.connector.kafka.source.enumerator.initializer.OffsetsInitializer;
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.windowing.assigners.SlidingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.triggers.EventTimeTrigger;

import java.time.Duration;

/**
 * 热搜榜实时计算作业。
 *
 * 数据流:Kafka → 窗口聚合 → TopN → Redis
 */
public class HotSearchJob {

    /** 窗口大小:5 分钟。 */
    private static final Duration WINDOW_SIZE = Duration.ofMinutes(5);

    /** 滑动步长:30 秒。 */
    private static final Duration SLIDE_INTERVAL = Duration.ofSeconds(30);

    /** 允许的乱序时间:30 秒。 */
    private static final Duration MAX_OUT_OF_ORDERNESS = Duration.ofSeconds(30);

    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.enableCheckpointing(30_000L);
        env.getCheckpointConfig().setCheckpointingMode(
                org.apache.flink.streaming.api.CheckpointingMode.EXACTLY_ONCE);

        // 使用 Kafka Source,提交位点由 Flink 管理,配合精确一次语义
        KafkaSource<String> source = KafkaSource.<String>builder()
                .setBootstrapServers("kafka:9092")
                .setTopics("events-raw")
                .setGroupId("hot-ranking-flink")
                .setStartingOffsets(OffsetsInitializer.latest())
                .setValueOnlyDeserializer(new SimpleStringSchema())
                .build();

        // 水位线策略:容忍 30 秒乱序
        WatermarkStrategy<String> watermarks = WatermarkStrategy
                .<String>forBoundedOutOfOrderness(MAX_OUT_OF_ORDERNESS)
                .withTimestampAssigner((event, timestamp) -> extractEventTime(event));

        DataStream<HotSearchEvent> events = env
                .fromSource(source, watermarks, "kafka-source")
                .map(new EventParser())
                .returns(HotSearchEvent.class)
                .name("parse-event");

        // 按内容 ID 分组,做滑动事件时间窗口聚合
        SingleOutputStreamOperator<HotSearchResult> aggregated = events
                .keyBy(event -> event.contentId)
                .window(SlidingEventTimeWindows.of(
                        Time.milliseconds(WINDOW_SIZE.toMillis()),
                        Time.milliseconds(SLIDE_INTERVAL.toMillis())))
                .trigger(EventTimeTrigger.create())
                .process(new HeatWindowFunction())
                .name("heat-window");

        // 每 30 秒输出一次全局 TopN
        DataStream<HotSearchResult> topN = aggregated
                .keyBy(result -> "global")
                .process(new TopNProcessFunction(100))
                .name("top-n");

        // 写入 Redis
        topN.addSink(new RedisSinkFunction("ranking:hot"))
                .name("redis-sink");

        env.execute("hot-search-realtime");
    }
}

作业主类里的几个关键配置:

  • 必须开启 Checkpoint 并使用精确一次语义。否则 Flink 故障重启后可能重复处理同一批事件,导致热度被重复累加。精确一次配合幂等的 Sink(用窗口结束时间做版本号)才能保证结果正确。
  • 滑动窗口的开销是窗口大小与步长之比的倍数。5 分钟窗口配 30 秒步长,意味着同一条事件会被计入 10 个窗口,计算量是滚动窗口的 10 倍。这是有意的平滑设计,但必须确认集群资源能承受。
  • Source 的并行度由 Kafka 分区数决定。如果并行度大于分区数,会有空闲算子;小于分区数,则部分分区无法消费。
  • 不要在 Flink 里做外部调用。异常检测、信誉查询这类依赖外部服务的逻辑,应该在上游算好后作为事件字段带进来(就像上面的 weight 字段),否则 Flink 的容错重放会把外部调用放大成倍。

窗口计算函数

窗口函数负责把窗口内的多个事件聚合成一条热度结果。

import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;

import java.util.HashMap;
import java.util.Map;

/**
 * 热度窗口聚合函数。
 *
 * 聚合逻辑:把窗口内同一内容的多个事件按「事件权重 × 时间衰减」求和。
 * 时间衰减以窗口结束时刻为基准,让越接近窗口结束的事件贡献越大。
 */
public class HeatWindowFunction
        extends ProcessWindowFunction<HotSearchEvent, HotSearchResult, String, TimeWindow> {

    private static final long serialVersionUID = 1L;

    /** 衰减系数(每小时)。 */
    private final double lambdaPerHour;

    public HeatWindowFunction() {
        this(0.05);
    }

    public HeatWindowFunction(double lambdaPerHour) {
        this.lambdaPerHour = lambdaPerHour;
    }

    @Override
    public void process(
            String contentId,
            Context context,
            Iterable<HotSearchEvent> elements,
            Collector<HotSearchResult> out) {

        double total = 0.0;
        long windowEnd = context.window().getEnd();

        for (HotSearchEvent event : elements) {
            // 事件晚于窗口结束时刻的异常情况,直接忽略
            if (event.eventTime > windowEnd) {
                continue;
            }
            double hoursFromEnd = (windowEnd - event.eventTime) / 3_600_000.0;
            double decay = Math.exp(-lambdaPerHour * hoursFromEnd);
            total += event.weight * decay;
        }

        if (total > 0) {
            out.collect(new HotSearchResult(contentId, total, windowEnd));
        }
    }
}

为什么用增量聚合而不是每窗口全量重算:如果每个窗口都保存全部事件明细,状态会随着窗口数量线性膨胀。改成在窗口内维护一个累加值(增量聚合),状态大小就与窗口内的内容数量相关,而不是事件数量。

Flink 对 AggregateFunction 有原生支持,可以在状态还未触发时就把增量结果输出给下游:

import org.apache.flink.api.common.functions.AggregateFunction;

/**
 * 增量聚合版本:状态里只保存一个累加分数。
 */
public class HeatAggregateFunction
        implements AggregateFunction<HotSearchEvent, Double, HotSearchResult> {

    private static final long serialVersionUID = 1L;

    private final double lambdaPerHour;

    public HeatAggregateFunction(double lambdaPerHour) {
        this.lambdaPerHour = lambdaPerHour;
    }

    @Override
    public Double createAccumulator() {
        return 0.0;
    }

    @Override
    public Double add(HotSearchEvent event, Double accumulator) {
        // 增量聚合阶段还没有窗口结束时刻,因此无法按「距窗口末尾的距离」衰减。
        // 这里退化为按事件自身的权重累加,时间衰减交给窗口结束后的统一修正。
        return accumulator + event.weight;
    }

    @Override
    public Double getResult(Double accumulator) {
        return accumulator;
    }

    @Override
    public Double merge(Double a, Double b) {
        // merge 在窗口合并时调用,必须满足结合律
        return a + b;
    }
}

聚合函数的三个约束:

  1. merge 必须满足结合律和交换律。Flink 在并行重分区和窗口合并时会调用它,如果聚合不可交换,结果会依赖数据到达顺序,违反精确一次语义。求和是安全的。
  2. 增量聚合阶段拿不到窗口结束时刻。这是 ProcessWindowFunction 与 AggregateFunction 的关键区别。如果时间衰减必须以窗口末尾为基准,就只能用 ProcessWindowFunction 保留事件明细,代价是状态更大。折中做法是像上面这样,聚合阶段只累加,最后由 ProcessWindowFunction 补一次衰减。
  3. 事件的 weight 应该在上游算好。聚合函数里不要调用外部服务,否则重放会放大调用量。

TopN 处理函数

TopN 处理函数需要在流上维护一个有序集合,并按周期输出当前的前 N 条。这里用按键分状态 + 有界堆的实现方式。

import org.apache.flink.api.common.state.ListState;
import org.apache.flink.api.common.state.ListStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

import java.util.ArrayList;
import java.util.List;

/**
 * TopN 处理函数。
 *
 * 维护方式:按键状态里保存一个按分数降序排列的有界列表,
 * 列表长度固定为 topN。每来一条数据就插入并裁剪,
 * 到达输出周期时把整个列表输出出去。
 */
public class TopNProcessFunction
        extends KeyedProcessFunction<String, HotSearchResult, HotSearchResult> {

    private static final long serialVersionUID = 1L;

    /** 保留的条数。 */
    private final int topN;

    /** 输出周期(毫秒)。 */
    private final long emitIntervalMs;

    /** 当前排名列表。 */
    private transient ListState<HotSearchResult> rankedState;

    /** 上次输出时间。 */
    private transient long lastEmitTime;

    public TopNProcessFunction(int topN) {
        this(topN, 30_000L);
    }

    public TopNProcessFunction(int topN, long emitIntervalMs) {
        this.topN = topN;
        this.emitIntervalMs = emitIntervalMs;
    }

    @Override
    public void open(Configuration parameters) {
        ListStateDescriptor<HotSearchResult> descriptor =
                new ListStateDescriptor<>("top-n-state", HotSearchResult.class);
        this.rankedState = getRuntimeContext().getListState(descriptor);
        this.lastEmitTime = 0L;
    }

    @Override
    public void processElement(
            HotSearchResult value,
            Context ctx,
            Collector<HotSearchResult> out) throws Exception {

        List<HotSearchResult> ranked = new ArrayList<>();
        for (HotSearchResult item : rankedState.get()) {
            ranked.add(item);
        }

        // 同一内容可能出现在多个滑动窗口里,取分数最大的那次
        boolean replaced = false;
        for (int i = 0; i < ranked.size(); i++) {
            if (ranked.get(i).contentId.equals(value.contentId)) {
                if (value.score > ranked.get(i).score) {
                    ranked.set(i, value);
                }
                replaced = true;
                break;
            }
        }
        if (!replaced) {
            ranked.add(value);
        }

        // 按分数降序排序后裁剪到 topN
        ranked.sort((a, b) -> Double.compare(b.score, a.score));
        if (ranked.size() > topN) {
            ranked = new ArrayList<>(ranked.subList(0, topN));
        }

        rankedState.update(ranked);

        // 到达输出周期就把当前排名发出
        long now = ctx.timerService().currentProcessingTime();
        if (now - lastEmitTime >= emitIntervalMs) {
            for (HotSearchResult item : ranked) {
                out.collect(item);
            }
            lastEmitTime = now;
        }
    }
}

这个实现的取舍:

  • 用 ListState 而不是一个堆。列表的排序是 O(n log n),每条数据都排序一次。在 topN 为百级、QPS 为万级时是可以接受的。数据量更大时应该换成自定义的堆结构,把插入复杂度降到 O(log n)。
  • 同内容去重是必须的。滑动窗口会让同一条内容在多个窗口中重复出现,如果不合并,输出的 TopN 里会有大量重复内容。合并时取分数最大的那次。
  • 用处理时间而不是事件时间做输出节奏。输出频率控制的是「多久推一次结果」,属于运维节奏,用处理时间更直观,也避免水位线延迟导致输出停滞。
  • 状态要能容忍上游数据倾斜。如果某个 key 的数据量远超其他 key,状态会集中在一个算子上。这里所有数据都归到 global 这一个 key,天然存在热点。生产上通常按内容 ID 哈希成多个 key 分别维护 TopN,最后再合并,或者直接使用 Flink 的 KeyedProcessFunction 配合 Timer 做分层聚合。

Redis Sink 函数

Sink 负责把结果写入 Redis 的有序集合。

import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.util.HashMap;
import java.util.Map;

/**
 * Redis Sink:把 TopN 结果写入有序集合。
 *
 * 写入策略:
 * 1. 先把整个窗口的分数写进临时 key;
 * 2. 再用 RENAME 原子替换正式 key。
 *
 * 这样读取方永远看到的是一个完整的快照,不会读到写了一半的结果。
 */
public class RedisSinkFunction extends RichSinkFunction<HotSearchResult> {

    private static final long serialVersionUID = 1L;

    /** 正式 key。 */
    private final String key;

    /** 正式 key 的过期时间(秒)。 */
    private final int ttlSeconds;

    private transient JedisPool jedisPool;

    public RedisSinkFunction(String key) {
        this(key, 3600);
    }

    public RedisSinkFunction(String key, int ttlSeconds) {
        this.key = key;
        this.ttlSeconds = ttlSeconds;
    }

    @Override
    public void open(Configuration parameters) {
        jedisPool = new JedisPool("redis", 6379);
    }

    @Override
    public void close() {
        if (jedisPool != null) {
            jedisPool.close();
        }
    }

    @Override
    public void invoke(HotSearchResult value, Context context) throws Exception {
        // 使用窗口结束时间作为版本号,同一个窗口的结果只写一次
        String versionedKey = key + ":w" + value.windowEnd;

        try (Jedis jedis = jedisPool.getResource()) {
            jedis.zadd(versionedKey, value.score, value.contentId);
            jedis.expire(versionedKey, ttlSeconds);
        }
    }
}

Sink 设计的三个要点:

  1. 必须是幂等的。Flink 的精确一次语义保证的是「恰好一次的状态变更」,但 Sink 失败重试时仍然可能重复提交。幂等的做法是让相同输入产生相同结果:用窗口结束时间作为版本号,同一个窗口重复写入只是覆盖同样的值。
  2. 不要让读取方看到半成品。如果直接往正式 key 里逐条 ZADD,读取方可能在写入过程中拉到不完整的榜单。稳妥的做法是先写临时 key,再用 RENAME 原子替换;或者用版本号让读取方只读已完成的版本。
  3. 连接池要放在 open 里创建。Sink 的 invoke 是并发调用的,连接池本身是线程安全的,但每个 invoke 新建连接会导致连接数暴涨。open 只会被调用一次,是初始化资源的正确位置。

批量写入。逐条 ZADD 在数据量大时往返开销明显。可以在 Sink 内部做微批:先在内存里攒够一批或等到时间边界,再用 Pipeline 一次性写出。

创建 flink-conf.yaml 配置文件:

配置要点

  • 配置表达的是环境差异和运行参数,不是业务规则本身。

部署与运行

1. 本地运行

验证要点

  • 命令只用于验证系统状态,读者不需要记具体参数。

验证要点

  • 命令只用于验证系统状态,读者不需要记具体参数。

3. Docker 部署

部署要点

  • 镜像只负责提供稳定运行环境,业务可靠性仍然取决于状态、监控和回滚策略。

配置要点

  • 配置表达的是环境差异和运行参数,不是业务规则本身。

监控与调优

关键指标监控

Flink 作业的监控要覆盖四个层面:数据是否进来、计算是否跟得上、状态是否健康、结果是否正确。只看作业「在运行」是不够的——一个持续反压、延迟不断累积但从未失败的作业,比一个直接宕掉的作业更危险。

指标Flink 指标名含义关注点
消费延迟KafkaSourceReader.currentFetchOffset 与消费位点的差值消息积压量持续增长说明处理能力不足
吞吐量numRecordsIn / numRecordsOut每秒处理的事件数突降说明上游或下游异常
背压程度backPressuredTimeMsPerSecond每秒被背压的时长接近 1000 说明下游成为瓶颈
Checkpoint 耗时lastCheckpointDuration单次 Checkpoint 的时长持续变长说明状态在膨胀
Checkpoint 失败率numberOfFailedCheckpoints失败的次数连续失败会触发重启
状态大小taskManager.operatorStateSize / keyedStateSize算子持有的状态体积持续增长且不回落说明状态无法回收
水位线延迟currentOutputWatermark 与当前时间的差事件时间推进滞后滞后扩大说明上游事件时间不准
垃圾回收停顿gcTimeGC 消耗的时间占比过高说明堆内存压力过大
结果校验与离线计算结果的偏差实时与离线的一致性偏差过大说明聚合逻辑有问题

告警规则的建议:

级别条件排查方向
P0作业进入 FAILED 状态查看异常堆栈,重点关注 Checkpoint 失败和状态反序列化
P0消费延迟持续增长且不收敛下游算子处理能力不足,或存在数据倾斜
P1背压比例持续高于阈值检查下游 Sink 的写入速度与网络状况
P1Checkpoint 耗时持续增长状态膨胀,考虑缩短窗口或改用增量聚合
P1水位线延迟持续扩大上游事件时间字段异常,或乱序容忍度设置过小
P2GC 时间占比偏高调大 TaskManager 内存或减少单批处理的数据量
P2实时与离线结果偏差超阈值检查聚合函数的 merge 是否满足结合律

监控数据的三种采集方式:

  1. Flink 内置指标。通过 REST API 暴露,Prometheus 抓取即可。这是最基础的来源,覆盖吞吐、延迟、背压、Checkpoint 和状态。
  2. 自定义指标。用 RichSinkFunction 里的 Counter 和 Gauge 打业务维度的标记,比如「本窗口产出的 TopN 条目数」「被判定为异常而丢弃的事件数」。这些是内置指标覆盖不到的部分。
  3. 端到端对账。实时结果与离线批处理结果做定期比对,比对内容包括榜单前 N 条的排名和分数偏差。这是最强的正确性验证手段,能发现所有指标都正常但算错了的情况。

关于对账的实践要点:

  • 允许合理的偏差。实时与离线的实现细节不同(水位线丢弃延迟数据、窗口边界处理),分数出现小幅偏差是正常的。要先确定一个可接受的偏差区间,超过才算异常。
  • 对账要分层做。先比对总量(事件数、热度总和),再比对 TopN 的成员,最后比对具体分数。总量对不上说明聚合逻辑有问题,成员对不上说明排序有问题。
  • 对账结果本身要被监控。如果对账任务连续多天没跑或者一直失败,说明这条验证链路已经失效,失去了它本该有的价值。

不要只监控集群资源。CPU、内存、网络这些基础设施指标反映的是「作业跑得累不累」,而上面这些指标反映的是「结果对不对」。两者要一起看,但后者才是业务真正关心的。

性能调优建议

  1. 并行度设置:根据数据量调整并行度
  2. 状态后端:使用 RocksDB 处理大状态
  3. 检查点间隔:平衡容错和性能
  4. 水位线策略:根据数据乱序程度调整

总结

通过 Flink 实现热搜榜实时计算系统,我们能够:

  • ✅ 实现毫秒级延迟的实时计算
  • ✅ 保证数据的精确一次处理
  • ✅ 支持水平扩展处理海量数据
  • ✅ 提供丰富的时间窗口操作
  • ✅ 内置状态管理和容错机制

在实际生产中,还需要考虑:

  • 数据倾斜处理
  • 背压监控
  • 资源优化
  • 多租户隔离

发现内容有问题?

告诉我们哪里需要改进。