一、方案定位

千级结果基数、固定维度的大屏场景,采用最短链路:埋点 → Flink → Redis → 大屏。Kafka 与 ClickHouse/Doris 不进默认链路,作为按条件触发的扩展,并预留演进接口。有状态组件仅 Flink + Redis 两个,运维面最小。

通用抽象:高基数明细事件 → 按固定分组键做窗口聚合 → 产出“分组键 × 排序指标”结果集 → 按排序指标实时取 Top N / 读当前值。凡满足“事件持续到达 + 查询模式固定 + 结果基数可控”的场景均可直接套用。

聚合逻辑档位:本方案定位在中档——窗口聚合 + 异步维表 + 缓存命中 + eventId 去重。不追求极简(纯计数),也不引入高复杂度(多流 Join、同步维表、大状态 UDF)。事件量结论由这个档位决定,不是从吞吐区间取算术中位。

二、量级假设

2.1 三个口径

口径假设值对应结论
事件量中等聚合逻辑下稳定支撑约 2000–3000 条/秒;免测试上界 2000 条/秒;3000 条/秒需轻量监控确认;≥5000 条/秒必须压测;日均 ≤ 500 万条数字由聚合复杂度档位决定,不是区间算术中位
结果基数区市 × 维度组合 ≤ 5000 个 ZSet member,按窗口分 key 后单 key ≤ 1000 member单 ZSet 千级 member 完全够用,无需分片;TTL 控制 key 总量
查询量大屏并发 ≤ 50 QPS,单次读 Top 20Redis 直读无压力,本地缓存非必需;并发升至数百 QPS 再考虑缓存或 OLAP

2.2 稳定支撑 2000–3000 条/秒的成立前提(必须同时满足)

  1. 聚合逻辑处于中等复杂度:窗口聚合 + 维表异步 I/O + 高缓存命中 + eventId 去重。若维表同步查或多流 Join,降为高复杂度档,2000–3000 不成立,需压测或扩并行度。
  2. 地域分布相对均匀。省/市/区天然倾斜,头部大市占比高时,总量 ≤ 3000 也可能打满某一路并行度;存在明显头部倾斜时,即使总量 ≤ 3000 也要先看热点 key 背压,不能免测。
  3. Redis 写入按“聚合结果数 × 4 命令”折算。每个 AggResult 发 4 条 Pipeline 命令(zadd / expire / hset / expire),必须拿折算后的命令数与 ops/s 对齐,不能拿事件量直接比 ops/s,否则量纲错位。
  4. 反压阈值指明为 backpressured 时间占比,OK 区间 0%–10%。busy% 与 backpressured% 含义相反,不作为该阈值依据。
  5. “波动 ≤ 2 倍基线”中基线定义为过去 7 天同刻 P50,不是日均、不是滑动均值,避免评审时滑回主观。
  6. 去重 state 必须使用 RocksDB state backend + 增量 checkpoint。按 3000 条/秒、10 分钟 TTL 估算,活跃去重 key 约 180 万,堆内存不可承载;RocksDB 是 2000–3000 档免测的硬性运维前提。

不满足任一条时:2000–3000 降级为“需压测确认”,而非“免测试稳定支撑”。

2.3 阈值依据

  • 低复杂度聚合(纯计数/求和,无维表、无状态去重)在 CPU 模式下单并行度可到约 20000 条/秒。
  • 中档聚合逻辑下,窗口聚合 + 异步维表 + 缓存命中 + eventId 去重会使实际吞吐下降,2000–3000 是折算后的保守区间,不是低复杂度吞吐线。
  • Redis Pipeline 批量写入 118K–125K ops/s 是命令吞吐,不是记录吞吐;每个 AggResult 4 条命令,需先折算再与事件量对齐。

三个口径分别支撑“Flink 并行度够”“ZSet 够用”“Redis 不瓶颈”三个结论,不可混用。

三、整体架构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
前端埋点 ──HTTP──> Flink(EventSource 抽象)
│
├─ 清洗 / 按 eventId 跨窗口去重(RocksDB state)/ 维表关联(异步 IO + 缓存)
├─ 按 groupKey(省,市,区,维度) 窗口预聚合
│ ├─ allowedLateness(30s) 内迟到:触发重算并再写一次 Redis(覆盖幂等)
│ └─ 超 allowedLateness:进 late-data 侧输出,仅告警不重算
└─ 窗口结束写 或 限频刷写(sink.flush.mode 二选一)
│
▼
Redis
├─ ZSet:rank:{window}:{省}:{维度},member = city#district
└─ Hash:val:{window}:{省}:{维度},field = city#district
│
▼
大屏后端(只读 Redis,本地短缓存可选)

四、各组件位置与作用

1. 埋点上报

  • 采集业务行为事件:{province, city, district, dimension, score, eventId, ts}。
  • 必须携带 幂等 ID(eventId) 与事件时间戳 ts,供 Flink 去重与窗口对齐。
  • 上报接口独立于业务主流程,失败不影响业务提交。

2. Flink(核心计算层)

  • Source 抽象:封装 EventSource 接口,HTTP 与 Kafka 是两种实现。抽象层暴露能力标识(如 supportsReplay),不承诺统一投递语义——Kafka Source 可重放,HTTP Source 不可重放,上层据此决定是否开启 exactly-once。
  • 计算逻辑:按 groupKey(省, 市, 区, 维度) 分组做滚动窗口聚合;维表关联走异步 I/O + 缓存,乱序处理用 Watermark。同步 IO 会破坏 2.2 的前提 1。
  • 窗口与迟到处理:窗口设 .allowedLateness(30s),分两段语义:

    • 30 秒内迟到:触发窗口重算并再次向 Sink 输出 AggResult,靠 ZADD/HSET 同 member/field 覆盖保证结果幂等;
    • 超 30 秒迟到:通过 .sideOutputLateData(LATE_TAG) 进侧输出,仅记录 + 告警,不重算。
      这两段与“去重超 TTL 重计”并列,均属精度取舍,需在 SLA 中说明。
  • 写入策略:两套策略由配置项 sink.flush.mode = tumbling | sliding 二选一,同一作业只跑一套,不并行:

    • tumbling(默认):窗口结束写,避免每条埋点刷榜;
    • sliding:大屏要求秒级刷新时,滑动窗口 + 限频刷写(如每 5 秒刷一次),不死等窗口结束。
  • 去重:按 eventId 做 keyed state 跨窗口去重,状态 TTL ≥ 窗口长度 + 允许迟到时间,state backend 必须为 RocksDB + 增量 checkpoint(见 2.2 第 6 条)。这是端到端幂等的一环,与 Sink 侧窗口幂等是两层不同保障。状态超 TTL 后,迟到的重复事件会再次计入——用状态资源换精度,需在 SLA 中明确可接受。

3. Redis(结果存储与查询加速)

  • ZSet:rank:{window}:{省}:{维度},存排名索引,ZADD score member,大屏 ZREVRANGE ... WITHSCORES 取 Top N,千级数据微秒级返回。
  • Hash:val:{window}:{省}:{维度},存各维度当前值,大屏按 key 直读。
  • member 硬约束:必须使用 city#district 复合串,不得只写 district。聚合粒度含市,存储粒度必须含市;否则跨市同名区(如“高新区”“城关区”)在 Redis 里是同一 member,ZADD 后一个覆盖一个,Top N 静默出错。展示层按 # 拆回市/区。
  • member 分隔符前提:member = city#district 的正确性依赖市名、区名不含 #(中国行政区名成立);split("#", 2) 限 2 段,district 内含 # 不受影响,city 内含才错位。
  • TTL 是下界约束:TTL ≥ 窗口长度 + 允许迟到时间 + 大屏回看缓冲期。例:1 分钟窗口、允许迟到 5 秒、回看上一窗口对比,TTL 取 5–10 分钟;有更长回看则 TTL 必须覆盖,否则回看期内榜单消失。
  • 冷热分层按需:千级数据下 ZREVRANGE 本身极快,本地缓存/快照仅在并发升高时引入,不作为默认项。
  • 边界认知:ZSet 只承担固定榜单/阈值过滤;“我的排名”“明细回溯”不在其能力范围,触发 OLAP 扩展条件。

4. 大屏后端

  • 只读 Redis,不做聚合,组装 JSON 返回。
  • window 参数来源:由后端统一提供“当前有效窗口”接口,前端不自行推算,避免高并发时读空窗口。
  • member 拆分:从 Redis 读到的 city#district 由展示层按 # 拆回市/区。
  • 可选一层本地短缓存,按并发情况决定是否启用。

五、关键约束

事项结论
HTTP 直连 ≠ 省掉 Kafka是责任转移:Kafka 把“可重放缓冲”做成组件能力,HTTP 直连变成应用代码责任。必须显式处理超时、重试、幂等、批量、背压。
不丢数据的条件端到端 exactly-once = 可重放 Source + 跨窗口按 eventId 去重 + 幂等/事务 Sink,三者缺一不可。HTTP Source 不可重放,链路只能“尽力去重”,不承诺 exactly-once。
窗口幂等 ≠ 端到端幂等ZADD/HSET 同 member/field 覆盖只解决同一窗口重算;跨窗口重试需 Flink keyed state 按 eventId 去重。
去重 state TTL 的取舍状态超 TTL 后迟到重复事件会再次计入,用资源换精度,需在 SLA 中明确可接受。
迟到超窗的取舍allowedLateness(30s) 内迟到:触发窗口重算并再写一次 Redis,靠 member/field 覆盖保证幂等;超 allowedLateness:进 late-data 侧输出,仅告警不重算。两者与去重超 TTL 重计并列为精度取舍。
去重 state backend必须 RocksDB + 增量 checkpoint;按 3000 条/秒、10 分钟 TTL 约 180 万活跃 key,堆内存不可承载。
member 唯一性member 必须 city#district 复合串,不得只写 district,否则跨市同名区静默覆盖。
member 分隔符前提市名、区名不含 #;split("#", 2) 限 2 段,district 内含 # 不受影响。
窗口写入`sink.flush.mode = tumbling \sliding` 二选一;默认 tumbling,秒级大屏切 sliding,不并行。
TTL 是下界约束TTL ≥ 窗口长度 + 允许迟到 + 大屏回看缓冲期,否则回看期榜单消失。
Source 抽象可替换实现,但不承诺统一语义,需暴露 supportsReplay 等能力标识。
失败可见性Redis 写入失败记录日志 + 告警 counter,不静默吞掉;不做 side output 旁路,实时补偿/对账落盘属扩展条件。
聚合粒度用 groupKey(省,市,区,维度) 统一封装,分隔符 #,避免与 Redis key 前缀 : 冲突。
冷热分层按需引入,千级结果基数下非默认。
稳定区与压测区中等聚合逻辑下:≤2000 条/秒免测;2000–3000 轻量监控;≥5000 必须压测。
倾斜与免测总量 ≤3000 但头部倾斜明显时不免测,先看热点 key 背压。

六、扩展触发条件

触发信号加回组件作用
上报峰值不可控、需要缓冲/重放Kafka削峰、解耦、可重放
多下游消费、审计/告警/离线复用Kafka避免改 Source
前端任意维度、下钻、明细回溯ClickHouse/DorisAd-hoc 查询和明细
历史趋势、跨窗口对比、对账、离线重算ClickHouse/Doris可回溯历史,Redis 结构不承担
大屏并发 + 查询复杂度同时上升,Redis 直读抖动ClickHouse/Doris分担读压力,保留热榜加速
“我的排名” / 任意 member 排名ClickHouse/Doris 或额外索引ZSet 只擅长 Top N,不擅长任意位次查询
事件量持续 ≥5000 条/秒且压测反压 HIGHKafka 或调并行度先压测定位瓶颈,再决定加缓冲还是扩并行
聚合逻辑升为高复杂度(同步维表/多流 Join)压测或扩并行度,必要时加 Kafka中档吞吐结论不再适用
失败数据要求实时补偿 / 对账落盘补偿流 / 重试队列当前仅 log + counter,补偿属扩展条件
迟到事件要求重算允许更大 lateness 或离线重算当前超窗仅侧输出告警,不重算

“峰值可控”的可操作标准:峰值 ≤2000 条/秒且波动幅度 ≤ 2 倍基线(过去 7 天同刻 P50)时,HTTP 直连可接受;波动超过 2 倍或出现持续尖峰,视为“峰值不可控”,加 Kafka。

OLAP 选型:追加型宽表聚合优先 ClickHouse;需要 Upsert、多表 Join 或高并发点查优先 Doris/StarRocks。

演进方式:加 Kafka 只改 Source 实现;加 OLAP 只加一个 Sink(Flink 双写:聚合结果写 Redis 做热榜,明细/宽表写 OLAP 做自由查询),Redis 写入逻辑不变。

七、代码骨架

1. EventSource 抽象

1
2
3
4
5
public interface EventSource {
String name();
boolean supportsReplay(); // Kafka=true, HTTP=false
DataStream<Event> stream(StreamExecutionEnvironment env);
}

2. Flink 预聚合 + 跨窗口去重 + 双写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public class AggJob {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
// 去重 state 约 180 万活跃 key,必须 RocksDB + 增量 checkpoint
env.setStateBackend(new EmbeddedRocksDBStateBackend(true));
env.enableCheckpointing(10_000); // 按 Redis 写入容忍度调整

EventSource source = Config.useKafka()
? new KafkaEventSource()
: new HttpEventSource(); // supportsReplay=false,上层据此降级语义

DataStream<Event> events = source.stream(env)
.assignTimestampsAndWatermarks(
WatermarkStrategy.<Event>forBoundedOutOfOrderness(Duration.ofSeconds(5))
.withTimestampAssigner((e, t) -> e.ts));

// 跨窗口去重:keyed state 按 eventId,RocksDB 承载,状态 TTL >= 窗口 + 允许迟到
// 超 TTL 后迟到重复事件会再次计入,属资源换精度的取舍
DataStream<Event> deduped = events
.keyBy(e -> e.eventId)
.process(new DedupFunction(Duration.ofMinutes(10)));

// 超 allowedLateness 的迟到事件进侧输出,仅告警,不重算
OutputTag<Event> LATE_TAG = new OutputTag<Event>("late-event") {};

// 刷写模式二选一:tumbling(默认)/ sliding(秒级大屏)
// 注意:aggregate 返回 SingleOutputStreamOperator,getSideOutput 只在该类型可见
SingleOutputStreamOperator<AggResult> agg;
if ("sliding".equals(Config.flushMode())) {
agg = deduped
.keyBy(e -> groupKey(e.province, e.city, e.district, e.dimension))
.window(SlidingEventTimeWindows.of(Time.minutes(1), Time.seconds(5)))
.allowedLateness(Time.seconds(30))
.sideOutputLateData(LATE_TAG)
.aggregate(new ScoreAggregator());
} else {
agg = deduped
.keyBy(e -> groupKey(e.province, e.city, e.district, e.dimension))
.window(TumblingEventTimeWindows.of(Time.minutes(1)))
.allowedLateness(Time.seconds(30))
.sideOutputLateData(LATE_TAG)
.aggregate(new ScoreAggregator());
}

// 双写:失败仅 log + counter 告警,不做 side output 旁路
agg.addSink(new RedisDualSink());

// 超 allowedLateness 的迟到事件仅记录 + 告警,不重算
agg.getSideOutput(LATE_TAG).addSink(new LateEventAuditSink());

env.execute("assessment-realtime-agg");
}

// 分隔符用 #,避免与 Redis key 前缀的 : 冲突
static String groupKey(String... parts) {
return String.join("#", Arrays.stream(parts)
.map(p -> p == null ? "" : p).toArray(String[]::new));
}
}

3. Redis 双写 Sink(幂等 + TTL + 失败 log/counter)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class RedisDualSink extends RichSinkFunction<AggResult> {
private JedisPool pool;
private Counter alertCounter;

@Override
public void open(Configuration c) {
JedisPoolConfig cfg = new JedisPoolConfig();
cfg.setMaxTotal(64); // 按并行度 × 单任务并发调整
cfg.setMaxIdle(16);
cfg.setMinIdle(4);
cfg.setMaxWaitMillis(2000); // 连接池耗尽时快速失败
pool = new JedisPool(cfg, "redis-host", 6379, 2000);
alertCounter = getRuntimeContext().getMetricGroup().counter("redis_write_failed");
}

@Override
public void invoke(AggResult r, Context ctx) {
String window = r.windowStart; // 如 20261118_1530
String rankKey = "rank:" + window + ":" + r.province + ":" + r.dimension;
String valKey = "val:" + window + ":" + r.province + ":" + r.dimension;
// member 必须 city#district,避免跨市同名区覆盖
String member = r.city + "#" + r.district;
// TTL >= 窗口长度 + 允许迟到 + 大屏回看缓冲期
int ttl = 600;

try (Jedis jedis = pool.getResource()) {
Pipeline p = jedis.pipelined();
p.zadd(rankKey, r.score, member); // 同 member 覆盖 -> 窗口重算幂等
p.expire(rankKey, ttl);
p.hset(valKey, member, String.valueOf(r.score)); // 同 field 覆盖 -> 幂等
p.expire(valKey, ttl);
p.sync();
} catch (Exception ex) {
// SinkFunction.Context 无 output(),失败仅 log + counter
log.error("redis dual-write failed, key={}, member={}", rankKey, member, ex);
alertCounter.inc();
}
}
}

4. 大屏读取(只读,无聚合,member 拆分展示)

1
2
3
4
5
6
7
8
9
10
11
12
13
// window 由后端“当前有效窗口”接口统一提供,前端不自行推算
// member 形如 "杭州市#高新区",展示层按 # 拆回 city / district
public List<RankItem> topN(String window, String province, String dimension, int n) {
String key = "rank:" + window + ":" + province + ":" + dimension;
try (Jedis jedis = pool.getResource()) {
return jedis.zrevrangeWithScores(key, 0, n - 1).stream()
.map(t -> {
String[] parts = ((String) t.getElement()).split("#", 2);
return new RankItem(parts[0], parts[1], t.getScore());
})
.collect(Collectors.toList());
}
}

5. 刷写模式切换

1
2
3
// 由配置项 sink.flush.mode 控制,同一作业只跑一套,不并行
// tumbling(默认):窗口结束写,避免每条埋点刷榜
// sliding(秒级大屏):滑动窗口 1min/5s + 限频刷写

6. 迟到事件审计(仅记录,不重算)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 超 allowedLateness 的迟到事件进侧输出,仅落审计存储 + 告警,不重算窗口
// allowedLateness 内的迟到由窗口重算 + Redis 覆盖幂等处理,不走这里
// 若要求超窗重算,属扩展条件(更大 lateness 或离线重算)
public class LateEventAuditSink extends RichSinkFunction<Event> {
private Counter lateCounter;

@Override
public void open(Configuration c) {
lateCounter = getRuntimeContext().getMetricGroup().counter("late_event_dropped");
}

@Override
public void invoke(Event e, Context ctx) {
lateCounter.inc();
log.warn("late event beyond allowedLateness, eventId={}, ts={}", e.eventId, e.ts);
auditStore.append(e); // 落审计存储,供对账;不触发重算
}
}

八、通用适用场景

核心抽象:高基数明细事件 → 固定分组键窗口聚合 → “分组键 × 排序指标”结果集 → 实时 Top N / 读当前值。满足“事件持续到达 + 查询模式固定 + 结果基数可控”即可直接套用。

直接适用(同构场景,架构不动)

场景分组键排序指标
测评/考试省/市/区/维度完成率、平均分、维度得分
销售/业绩榜大区/门店/销售员GMV、订单数、客单价
内容/流量热榜品类/频道曝光量、点击量、转化率(需时间衰减时 Flink 侧重算 score)
游戏/活动榜区服/公会/玩法积分、胜率、击杀数(高并发写用限频刷写)
运营监控大屏省份/机房/服务QPS、错误率、延迟(阈值过滤用 ZRANGEBYSCORE)
物流/履约看板区域/仓库当日单量、准时率、积压量
金融/风控榜单机构/产品交易量、异常率(要求不丢不重时需加 Kafka)

边界外(触发扩展)

场景特征为什么不够加什么
任意维度组合查询ZSet 只支持单分数排序,无 SQL 语义OLAP
明细回溯Redis 只存聚合,不存明细OLAP 或明细存储
历史趋势/跨窗口对比/对账ZSet 只存近期窗口,TTL 过期即消失OLAP
“我的排名”/任意位次ZSet 只擅长 Top N,任意位次需 ZRANK + 复杂分页过滤OLAP 或额外索引
高并发 + 复杂查询同时上升Redis 直读抖动OLAP 分担 + 热榜缓存
要求 exactly-onceHTTP Source 不可重放Kafka 做可重放 Source

通用边界由“查询模式是否固定”决定,不由业务领域决定:一旦从“取 Top N”变成“任意 SQL”,通用性到头,该加 OLAP。

九、监控与压测判读

9.1 分区间策略

事件量区间(中等聚合逻辑)策略
≤2000 条/秒,分布均匀免测上线,基础监控即可
2000–3000 条/秒可上线,轻量监控反压与 Redis Pipeline p99
3000–5000 条/秒上线前压测,确认反压与连接池余量
≥5000 条/秒必须压测,按判读结果决定加 Kafka 或扩并行度
任意区间但头部倾斜明显不免测,先看热点 key 背压

9.2 监控要点

位置风险处理
HTTP Source峰值重试、超时、乱序保持幂等 ID,必要时加 Kafka
Flink 聚合groupKey 倾斜导致局部背压看 groupKey 分布,必要时调并行度
Redis SinkPipeline 失败、连接池耗尽log + counter 告警;连接池配 maxTotal/timeout
迟到事件allowedLateness 内触发重算(覆盖幂等);超窗进侧输出重算量可接受;late_event_dropped counter + 审计落盘,不重算

9.3 压测判读

  • Flink 反压:看 backpressured 时间占比(不是 busy%)。OK 区间 0%–10%,LOW 10%–50%,HIGH 50% 以上。Source/Sink 出现 HIGH 说明该环节跟不上;全链路 OK 但数据积压,瓶颈在 Source 读取或网络。
  • Redis:redis-cli --latency 看 RTT,配合 Pipeline p99 延迟;p99 无明显劣化则 Redis 不是问题。
  • 口径对齐:Redis 侧比较的是“聚合结果数 × 4 命令”折算后的命令吞吐,不是事件量本身。

十、结论

精简版可作为默认方案:Flink 窗口预聚合 + Redis 双写(ZSet 排名 / Hash 当前值,带 TTL、幂等与失败告警),大屏只读。HTTP Source 抽象为可替换实现,但不承诺统一投递语义;Kafka 按“需缓冲/重放/多下游”加回,OLAP 按“任意查询/明细/历史对账/并发升高/任意位次”加回,演进只改 Source 或加 Sink。

量级:中等聚合逻辑(窗口聚合 + 异步维表 + 缓存命中 + eventId 去重 + RocksDB state)下,稳定支撑约 2000–3000 条/秒;免测试上界 2000 条/秒,3000 条/秒需轻量监控,≥5000 条/秒必须压测。结果基数单 key ≤ 1000 member、查询量 ≤ 50 QPS 不变。该数字由聚合复杂度档位决定,不是吞吐区间的算术中位;聚合逻辑升为高复杂度(同步维表/多流 Join)时,中档结论不再适用,需重新压测。

数据正确性硬约束:Redis 榜单 member 必须为 city#district 复合串,聚合粒度含市,存储粒度必须含市,否则跨市同名区静默覆盖,Top N 出错;正确性依赖市名、区名不含 #。

精度取舍:去重 state 超 TTL 后迟到重复事件会再次计入;窗口 allowedLateness(30s) 内迟到触发重算并再写一次 Redis(覆盖幂等),超 allowedLateness 进 late-data 侧输出仅告警不重算。三者均为用资源换精度,需在 SLA 中一并说明。

AI