Flink 实现实时计算
在本节中,我们将使用 Apache Flink 来构建热搜榜的实时计算模块。Flink 是一个强大的流处理引擎,能够提供低延迟、高吞吐的实时数据处理能力。
- 低延迟:毫秒级延迟,适合实时热搜计算
- 精确一次语义:保证数据处理的准确性
- 状态管理:内置状态存储,支持容错
- 窗口计算:丰富的时间窗口操作
- 可扩展性:水平扩展,处理海量数据
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ Kafka │ │ Flink │ │ Redis │
│ (事件流) │───▶│ (计算引擎) │───▶│ (结果存储) │
└─────────────┘ └─────────────┘ └─────────────┘
首先,在 pom.xml 中添加 Flink 相关依赖:
配置要点
- 配置表达的是环境差异和运行参数,不是业务规则本身。
- 队列、缓存、存储和服务参数决定系统在高峰期的缓冲能力。
定义热搜事件和结果的数据模型:
数据模型是整条 Flink 链路的契约。上游的事件格式、下游的 Sink 写入逻辑、状态存储的序列化,全部依赖这里定义的两个类。模型设计得好,后续的算子就只是拼装;模型设计得含糊,每一层都要互相猜测字段含义。
两个核心类的职责划分:
| 类 | 职责 | 生命周期 | 生产者 | 消费者 |
|---|---|---|---|---|
HotSearchEvent | 描述一次用户互动 | 流中的每条记录 | Kafka 解析算子 | 窗口聚合函数 |
HotSearchResult | 描述一个内容在某个窗口内的热度 | 每个窗口每条内容一条 | 窗口聚合函数 | TopN 处理函数、Redis Sink |
HotSearchEvent 的字段设计:
| 字段 | 类型 | 必需 | 说明 |
|---|---|---|---|
contentId | String | 是 | 内容 ID,分组的 key |
eventType | String | 是 | 事件类型:view / like / comment / share |
eventTime | long | 是 | 事件发生时刻的毫秒时间戳,不是消费时刻 |
userId | String | 是 | 用户 ID,用于反作弊维度聚合 |
weight | double | 是 | 行为权重,由上游反作弊服务给出 |
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;
}
}
聚合函数的三个约束:
merge必须满足结合律和交换律。Flink 在并行重分区和窗口合并时会调用它,如果聚合不可交换,结果会依赖数据到达顺序,违反精确一次语义。求和是安全的。- 增量聚合阶段拿不到窗口结束时刻。这是
ProcessWindowFunction与AggregateFunction的关键区别。如果时间衰减必须以窗口末尾为基准,就只能用ProcessWindowFunction保留事件明细,代价是状态更大。折中做法是像上面这样,聚合阶段只累加,最后由ProcessWindowFunction补一次衰减。 - 事件的
weight应该在上游算好。聚合函数里不要调用外部服务,否则重放会放大调用量。
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做分层聚合。
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 设计的三个要点:
- 必须是幂等的。Flink 的精确一次语义保证的是「恰好一次的状态变更」,但 Sink 失败重试时仍然可能重复提交。幂等的做法是让相同输入产生相同结果:用窗口结束时间作为版本号,同一个窗口重复写入只是覆盖同样的值。
- 不要让读取方看到半成品。如果直接往正式 key 里逐条
ZADD,读取方可能在写入过程中拉到不完整的榜单。稳妥的做法是先写临时 key,再用RENAME原子替换;或者用版本号让读取方只读已完成的版本。 - 连接池要放在
open里创建。Sink 的invoke是并发调用的,连接池本身是线程安全的,但每个invoke新建连接会导致连接数暴涨。open只会被调用一次,是初始化资源的正确位置。
批量写入。逐条 ZADD 在数据量大时往返开销明显。可以在 Sink 内部做微批:先在内存里攒够一批或等到时间边界,再用 Pipeline 一次性写出。
创建 flink-conf.yaml 配置文件:
配置要点
- 配置表达的是环境差异和运行参数,不是业务规则本身。
1. 本地运行
验证要点
- 命令只用于验证系统状态,读者不需要记具体参数。
2. 提交到 Flink 集群
验证要点
- 命令只用于验证系统状态,读者不需要记具体参数。
3. Docker 部署
部署要点
- 镜像只负责提供稳定运行环境,业务可靠性仍然取决于状态、监控和回滚策略。
配置要点
- 配置表达的是环境差异和运行参数,不是业务规则本身。
关键指标监控
Flink 作业的监控要覆盖四个层面:数据是否进来、计算是否跟得上、状态是否健康、结果是否正确。只看作业「在运行」是不够的——一个持续反压、延迟不断累积但从未失败的作业,比一个直接宕掉的作业更危险。
| 指标 | Flink 指标名 | 含义 | 关注点 |
|---|---|---|---|
| 消费延迟 | KafkaSourceReader.currentFetchOffset 与消费位点的差值 | 消息积压量 | 持续增长说明处理能力不足 |
| 吞吐量 | numRecordsIn / numRecordsOut | 每秒处理的事件数 | 突降说明上游或下游异常 |
| 背压程度 | backPressuredTimeMsPerSecond | 每秒被背压的时长 | 接近 1000 说明下游成为瓶颈 |
| Checkpoint 耗时 | lastCheckpointDuration | 单次 Checkpoint 的时长 | 持续变长说明状态在膨胀 |
| Checkpoint 失败率 | numberOfFailedCheckpoints | 失败的次数 | 连续失败会触发重启 |
| 状态大小 | taskManager.operatorStateSize / keyedStateSize | 算子持有的状态体积 | 持续增长且不回落说明状态无法回收 |
| 水位线延迟 | currentOutputWatermark 与当前时间的差 | 事件时间推进滞后 | 滞后扩大说明上游事件时间不准 |
| 垃圾回收停顿 | gcTime | GC 消耗的时间占比 | 过高说明堆内存压力过大 |
| 结果校验 | 与离线计算结果的偏差 | 实时与离线的一致性 | 偏差过大说明聚合逻辑有问题 |
告警规则的建议:
| 级别 | 条件 | 排查方向 |
|---|---|---|
| P0 | 作业进入 FAILED 状态 | 查看异常堆栈,重点关注 Checkpoint 失败和状态反序列化 |
| P0 | 消费延迟持续增长且不收敛 | 下游算子处理能力不足,或存在数据倾斜 |
| P1 | 背压比例持续高于阈值 | 检查下游 Sink 的写入速度与网络状况 |
| P1 | Checkpoint 耗时持续增长 | 状态膨胀,考虑缩短窗口或改用增量聚合 |
| P1 | 水位线延迟持续扩大 | 上游事件时间字段异常,或乱序容忍度设置过小 |
| P2 | GC 时间占比偏高 | 调大 TaskManager 内存或减少单批处理的数据量 |
| P2 | 实时与离线结果偏差超阈值 | 检查聚合函数的 merge 是否满足结合律 |
监控数据的三种采集方式:
- Flink 内置指标。通过 REST API 暴露,Prometheus 抓取即可。这是最基础的来源,覆盖吞吐、延迟、背压、Checkpoint 和状态。
- 自定义指标。用
RichSinkFunction里的Counter和Gauge打业务维度的标记,比如「本窗口产出的 TopN 条目数」「被判定为异常而丢弃的事件数」。这些是内置指标覆盖不到的部分。 - 端到端对账。实时结果与离线批处理结果做定期比对,比对内容包括榜单前 N 条的排名和分数偏差。这是最强的正确性验证手段,能发现所有指标都正常但算错了的情况。
关于对账的实践要点:
- 允许合理的偏差。实时与离线的实现细节不同(水位线丢弃延迟数据、窗口边界处理),分数出现小幅偏差是正常的。要先确定一个可接受的偏差区间,超过才算异常。
- 对账要分层做。先比对总量(事件数、热度总和),再比对 TopN 的成员,最后比对具体分数。总量对不上说明聚合逻辑有问题,成员对不上说明排序有问题。
- 对账结果本身要被监控。如果对账任务连续多天没跑或者一直失败,说明这条验证链路已经失效,失去了它本该有的价值。
不要只监控集群资源。CPU、内存、网络这些基础设施指标反映的是「作业跑得累不累」,而上面这些指标反映的是「结果对不对」。两者要一起看,但后者才是业务真正关心的。
性能调优建议
- 并行度设置:根据数据量调整并行度
- 状态后端:使用 RocksDB 处理大状态
- 检查点间隔:平衡容错和性能
- 水位线策略:根据数据乱序程度调整
通过 Flink 实现热搜榜实时计算系统,我们能够:
- ✅ 实现毫秒级延迟的实时计算
- ✅ 保证数据的精确一次处理
- ✅ 支持水平扩展处理海量数据
- ✅ 提供丰富的时间窗口操作
- ✅ 内置状态管理和容错机制
在实际生产中,还需要考虑:
- 数据倾斜处理
- 背压监控
- 资源优化
- 多租户隔离
发现内容有问题?
告诉我们哪里需要改进。
