热门排名系统 - 完整架构设计

1. 系统概述

热门排名系统是一个高并发、低延迟的实时数据处理系统,用于计算和展示各类内容的热度排名。系统需要支撑每日亿级的事件处理量,并在秒级内完成热度计算和排名更新。

1.1 设计目标

  • 高吞吐量:支持 10 万 + QPS 的事件写入
  • 低延迟:排名更新延迟 < 1 秒
  • 高可用:99.99% 的服务可用性
  • 可扩展:支持水平扩展以应对流量增长
  • 数据一致性:保证最终一致性,关键数据强一致

1.2 核心指标

指标目标值说明
写入吞吐量100,000 QPS峰值事件处理能力
查询延迟< 50msP99 排名查询延迟
计算延迟< 1s事件到排名更新的延迟
数据保留30 天原始事件数据保留周期
可用性99.99%月度服务可用性

2. 系统架构图

┌─────────────────────────────────────────────────────────────────────────────┐
│                              客户端层 (Client Layer)                         │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐      │
│  │   Web    │  │   iOS    │  │  Android │  │   API    │  │  第三方  │      │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘      │
└───────┼─────────────┼─────────────┼─────────────┼─────────────┼────────────┘
        │             │             │             │             │
        └─────────────┴──────┬──────┴─────────────┴─────────────┘
                             │
                    ┌────────▼────────┐
                    │   负载均衡器    │
                    │  (Load Balancer)│
                    └────────┬────────┘
                             │
┌────────────────────────────┼────────────────────────────────────────────────┐
│                        接入层 (Access Layer)                                │
│  ┌─────────────────────────┴─────────────────────────┐                     │
│  │              API Gateway (Kong/Nginx)              │                     │
│  │  • 请求路由  • 限流熔断  • 身份认证  • 日志记录    │                     │
│  └─────────────────────────┬─────────────────────────┘                     │
└────────────────────────────┼────────────────────────────────────────────────┘
                             │
        ┌────────────────────┼────────────────────┐
        │                    │                    │
        ▼                    ▼                    ▼
┌───────────────┐   ┌───────────────┐   ┌───────────────┐
│   写入服务    │   │   查询服务    │   │   管理服务    │
│  Write Service│   │ Query Service │   │ Admin Service │
└───────┬───────┘   └───────┬───────┘   └───────┬───────┘
        │                   │                   │
        │                   │                   │
┌───────▼───────────────────▼───────────────────▼───────┐
│                  消息队列层 (Message Queue)            │
│  ┌─────────────────────────────────────────────────┐  │
│  │              Apache Kafka / Pulsar               │  │
│  │  • events-topic  • ranking-topic  • sync-topic  │  │
│  └─────────────────────────────────────────────────┘  │
└───────────────────────────┬───────────────────────────┘
                            │
        ┌───────────────────┼───────────────────┐
        │                   │                   │
        ▼                   ▼                   ▼
┌───────────────┐   ┌───────────────┐   ┌───────────────┐
│  实时计算引擎  │   │  数据存储层   │   │   缓存层     │
│  (Flink/Storm)│   │ (Storage)     │   │  (Redis)     │
│  • 热度计算   │   │ • MySQL       │   │ • 排名缓存   │
│  • 窗口聚合   │   │ • ClickHouse  │   │ • 热点数据   │
│  • 实时排名   │   │ • Elasticsearch│  │ • 分布式锁   │
└───────┬───────┘   └───────┬───────┘   └───────┬───────┘
        │                   │                   │
        └───────────────────┼───────────────────┘
                            │
┌───────────────────────────▼───────────────────────────┐
│                  监控与运维层 (Observability)          │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────┐  │
│  │ Prometheus│  │  Grafana │  │   ELK    │  │ Jaeger│ │
│  └──────────┘  └──────────┘  └──────────┘  └──────┘  │
└───────────────────────────────────────────────────────┘

3. 核心组件详解

3.1 接入层 (Access Layer)

接入层是系统的入口,负责处理所有外部请求。

3.1.1 API Gateway

配置要点

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

3.1.2 负载均衡

策略:加权轮询 (Weighted Round Robin)
健康检查:每 5 秒检测后端服务状态
会话保持:基于用户 ID 的一致性哈希

3.2 服务层 (Service Layer)

3.2.1 写入服务 (Write Service)

负责接收和处理用户行为事件。

写入流程:

  1. 接收事件请求,进行参数校验
  2. 生成全局唯一事件 ID
  3. 写入消息队列(异步解耦)
  4. 返回成功响应
  5. 后台消费者处理事件

3.2.2 查询服务 (Query Service)

负责提供排名查询接口。

查询优化策略:

  • 多级缓存:本地缓存 + Redis + 数据库
  • 预计算:定时预计算常用维度的排名
  • 分页优化:使用游标分页避免深度分页问题
  • 读写分离:查询走从库,减轻主库压力

3.2.3 管理服务 (Admin Service)

提供系统管理和配置功能。

功能模块:
  - 排名规则配置:调整热度计算公式参数
  - 数据查看:查看原始事件和计算结果
  - 系统监控:查看系统运行状态
  - 异常处理:手动修正异常数据
  - 灰度发布:控制新规则的发布范围

3.3 消息队列层 (Message Queue)

3.3.1 Topic 设计

主题规划:
├── events-raw          # 原始事件(保留 30 天)
│   ├── partitions: 32
│   └── replication: 3
│
├── events-processed    # 处理后事件(保留 7 天)
│   ├── partitions: 16
│   └── replication: 3
│
├── ranking-updates     # 排名更新通知(保留 1 天)
│   ├── partitions: 8
│   └── replication: 3
│
└── system-events       # 系统事件(保留 90 天)
    ├── partitions: 4
    └── replication: 3

3.3.2 消息格式

配置要点

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

3.4 实时计算引擎 (Stream Processing)

实时计算层由一个 Flink 作业承担,拓扑分为五段,每一段的职责和失败影响都被刻意约束在可控范围内。

Kafka (events-raw)
    │
    ▼
┌────────────────────┐
│ 1. 事件解析         │  反序列化、字段校验、异常事件丢弃
│    Parse            │
└─────────┬──────────┘
          ▼
┌────────────────────┐
│ 2. 反作弊过滤       │  按设备/IP/行为规则判定
│    AntiFraud        │  异常事件标记权重为 0
└─────────┬──────────┘
          ▼
┌────────────────────┐
│ 3. 热度累加         │  KeyedProcessFunction 维护每内容热度
│    HeatAccumulator  │  增量更新 + 时间衰减
└─────────┬──────────┘
          ▼
┌────────────────────┐
│ 4. 周期快照         │  每 30 秒输出一次全量 TopN
│    Snapshot         │
└─────────┬──────────┘
          ▼
┌────────────────────┐
│ 5. 排名写入         │  写临时 key + RENAME 原子替换
│    RedisWriter      │
└────────────────────┘
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.eventtime.WatermarkOutputStrategy;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.CheckpointingMode;
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.streaming.api.functions.sink.v2.Sink;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.util.Collector;

import java.time.Duration;

/**
 * 热搜榜实时计算作业的骨架。
 *
 * 设计要点:
 * - 五段拓扑职责单一,任何一段的故障都能被隔离在自身范围内;
 * - 热度累加用键控状态,状态规模与内容数量成正比;
 * - 快照输出与写入分离,计算抖动不会直接影响 Redis 写入。
 */
public class HotRankingFlinkJob {

    /** 热度衰减系数(每小时)。 */
    private static final double LAMBDA_PER_HOUR = 0.05;

    /** 快照输出周期(毫秒)。 */
    private static final long SNAPSHOT_INTERVAL_MS = 30_000L;

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

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

        // Checkpoint 间隔要大于作业处理一轮数据的时间,否则 checkpoint 会持续超时
        env.enableCheckpointing(60_000L);
        env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);
        env.getCheckpointConfig().setMinPauseBetweenCheckpoints(30_000L);
        env.getCheckpointConfig().setCheckpointTimeout(120_000L);
        // 状态较大时启用增量 checkpoint,避免每次全量快照
        env.getCheckpointConfig().enableIncrementalCheckpoints(true);

        // 段 1:事件解析
        DataStream<HotEvent> parsed = env
                .fromSource(kafkaSource(), watermarks(), "kafka-source")
                .name("kafka-source")
                .flatMap(new EventParser())
                .name("parse-event")
                .returns(HotEvent.class);

        // 段 2:反作弊过滤
        SingleOutputStreamOperator<HotEvent> filtered = parsed
                .filter(new AntiFraudFilter())
                .name("anti-fraud");

        // 段 3:热度累加,按内容 ID 分组
        SingleOutputStreamOperator<HeatEntry> accumulated = filtered
                .keyBy(event -> event.contentId())
                .process(new HeatAccumulator(LAMBDA_PER_HOUR))
                .name("heat-accumulator");

        // 段 4:周期快照
        SingleOutputStreamOperator<List<HeatEntry>> snapshot = accumulated
                .window(TumblingEventTimeWindows.of(
                        org.apache.flink.streaming.api.windowing.time.Time
                                .milliseconds(SNAPSHOT_INTERVAL_MS)))
                .process(new SnapshotProcessFunction())
                .name("snapshot");

        // 段 5:写入 Redis
        snapshot.addSink(new RedisWriterSink("ranking:hot"))
                .name("redis-writer");

        env.execute("hot-ranking-flink");
    }
}

热度累加算子是这个作业的核心,它实现了「热度 = f(旧热度, 新事件, 时间衰减)」的增量公式:

/**
 * 热度累加算子。
 *
 * 每个内容维护一份状态:当前热度与最后更新时间。
 * 每条事件到达时先把旧热度衰减到当前时刻,再叠加本次贡献。
 */
public class HeatAccumulator
        extends KeyedProcessFunction<String, HotEvent, HeatEntry> {

    private static final long serialVersionUID = 1L;

    private final double lambdaPerHour;

    /** 内容状态。 */
    public static class HeatState {
        public double heat;
        public long updatedAt;

        public HeatState() {
        }

        public HeatState(double heat, long updatedAt) {
            this.heat = heat;
            this.updatedAt = updatedAt;
        }
    }

    private transient ValueState<HeatState> state;

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

    @Override
    public void open(Configuration parameters) {
        state = getRuntimeContext().getState(
                new ValueStateDescriptor<>("heat-state", HeatState.class));
        // 给状态设置 TTL,内容长期无互动后自动回收,防止状态无限增长
        state.enableTimeToLive(org.apache.flink.api.common.time.Time.hours(24));
    }

    @Override
    public void processElement(HotEvent event, Context ctx, Collector<HeatEntry> out) throws Exception {
        HeatState current = state.value();
        if (current == null) {
            current = new HeatState(0.0, event.eventTime());
        }

        double elapsedHours = (event.eventTime() - current.updatedAt) / 3_600_000.0;
        if (elapsedHours < 0) {
            // 事件乱序或时钟回拨,不做衰减
            elapsedHours = 0.0;
        }

        double decayed = current.heat * Math.exp(-lambdaPerHour * elapsedHours);
        double updated = decayed + event.contribution();

        current.heat = updated;
        current.updatedAt = event.eventTime();
        state.update(current);

        out.collect(new HeatEntry(event.contentId(), updated, event.eventTime()));
    }
}

五段拓扑的设计取舍:

设计点做法理由
解析与计算分离解析失败只丢一条事件,不影响整条链路脏数据不应该拖垮作业
反作弊在计算之前异常事件权重直接置 0避免异常数据进入热度累加后无法剥离
热度用键控状态状态与内容数量成正比比窗口明细聚合的状态小得多
快照与写入分离先算完整快照,再写 Redis避免边算边写导致的半成品榜单
写入用临时 key + RENAME读取方永远看到完整快照消除读写并发导致的不一致

并行度与容错的要点:

  • 并行度由 Kafka 分区数决定。反作弊过滤和热度累加是逐条处理的,可以直接跟分区数对齐;但快照算子需要看到全局数据,它的并行度决定了每个分片能产出的条目数——快照应该包含所有分片的数据,因此最终合并时要做全局汇总。
  • 状态 TTL 是必需的。内容热度状态如果不设 TTL,内容总量会随时间单调增长,最终把状态撑爆。TTL 要设置得比「内容在榜的最长时间」更长。
  • Checkpoint 间隔要与处理耗时匹配。如果一轮数据处理就要十几秒,Checkpoint 间隔设为十几秒会导致 checkpoint 持续超时。观察 lastCheckpointDuration 来调整。

3.4.2 热度计算公式

热度分数 = Σ(事件权重 × 时间衰减因子 × 质量系数)

其中:
  事件权重:
    - 浏览 (view): 1
    - 点赞 (like): 3
    - 评论 (comment): 5
    - 分享 (share): 10
    - 收藏 (favorite): 8
    
  时间衰减因子:
    decay(t) = e^(-λt)
    λ = 0.1 (可调参数,控制衰减速度)
    
  质量系数:
    - 新用户行为:0.8
    - 活跃用户行为:1.0
    - 高价值用户行为:1.2
    - 异常行为检测:0.0 (直接过滤)

3.5 数据存储层 (Storage Layer)

3.5.1 MySQL - 元数据存储

数据设计要点

  • 核心是在 targets 里保存业务事实,而不是把规则散落在应用逻辑里。
  • 索引服务于高频查询,重点是缩小扫描范围,而不是堆更多字段。
  • 关键字段包括 id、target_type、target_id、title、created_at、updated_at、ranking_score、rank_position,它们决定后续查询和管理能力。

3.5.2 ClickHouse - 事件明细存储

数据设计要点

  • 核心是在 events_raw 里保存业务事实,而不是把规则散落在应用逻辑里。
  • 关键字段包括 event_time、processing_time、time_bucket,它们决定后续查询和管理能力。

3.5.3 Elasticsearch - 搜索与日志

索引设计:
  - events-logs-*: 事件日志,用于问题排查
  - ranking-history-*: 排名历史,支持复杂查询
  - system-metrics-*: 系统指标,用于监控分析

3.6 缓存层 (Cache Layer)

3.6.1 Redis 数据结构设计

# 实时排名缓存 (有序集合)
ZSET ranking:video:24h
  - video_001: 95.678
  - video_002: 89.234
  - video_003: 82.456

# 目标分数缓存 (哈希)
HASH score:video:video_001
  - value: 95.678
  - updated_at: 1699999999
  - time_range: 24h

# 排名位置缓存 (字符串)
STRING rank:video:video_001:24h = 5

# 去重缓存 (集合)
SET viewed:user_123:video_001:20240101

# 限流计数器
STRING rate:user_123:write = 150 (TTL: 60s)

3.6.2 缓存策略

缓存更新策略:
  - 写入时更新:新事件到达时更新相关缓存
  - 定时刷新:每 5 分钟全量刷新排名
  - 懒加载:查询时如缓存失效则回源加载
  
缓存失效策略:
  - 基于时间:排名缓存 5 分钟过期
  - 基于事件:目标状态变更时失效
  - 主动失效:管理操作触发失效

4. 数据流设计

4.1 写入数据流

用户请求 → API Gateway → Write Service → Kafka → Flink → Redis/DB
    │                                              │
    │                                              ▼
    │                                       ClickHouse (归档)
    │
    ▼
异步响应 (立即返回)

4.2 查询数据流

用户请求 → API Gateway → Query Service → Redis (缓存命中?)
                              │              │
                              │         命中: 返回
                              │              │
                              ▼              ▼
                         未命中: 查询数据库   返回
                              │
                              ▼
                         更新缓存
                              │
                              ▼
                         返回结果

4.3 排名计算流

Kafka (events) → Flink (窗口聚合) → 分数计算 → 排名计算
                                           │
                                           ▼
                                    Redis (实时更新)
                                           │
                                           ▼
                                    Kafka (通知) → 其他服务

5. 技术选型

5.1 技术栈总览

层级技术选型理由
接入层Nginx + Kong高性能、插件丰富、易于扩展
服务层Java + Spring Boot生态完善、团队熟悉、稳定性高
消息队列Apache Kafka高吞吐、持久化、生态成熟
流计算Apache Flink精确一次、低延迟、状态管理
关系数据库MySQL 8.0成熟稳定、支持事务
分析数据库ClickHouse列式存储、查询性能优异
缓存Redis Cluster高性能、数据结构丰富
搜索引擎Elasticsearch全文检索、日志分析
监控Prometheus + Grafana云原生、可视化强大
链路追踪Jaeger分布式追踪、问题定位

5.2 版本规划

第一阶段 (基础版):
  - Kafka + Flink + Redis + MySQL
  - 支持基础排名功能
  
第二阶段 (增强版):
  - 增加 ClickHouse 存储
  - 完善监控和告警
  
第三阶段 (高级版):
  - 增加机器学习预测
  - 支持个性化排名

6. 部署架构

6.1 集群规划

生产环境集群:
├── K8s 集群 (应用服务)
│   ├── 命名空间:ranking-prod
│   ├── 节点数:20
│   └── 资源:80C 256G
│
├── Kafka 集群
│   ├── Broker 数:6
│   └── 存储:10TB SSD
│
├── Flink 集群
│   ├── JobManager: 3 (HA)
│   ├── TaskManager: 20
│   └── 资源:160C 512G
│
├── Redis 集群
│   ├── 节点:18 (6 主 12 从)
│   └── 内存:512GB
│
├── MySQL 集群
│   ├── 主从:1 主 3 从
│   └── 存储:2TB SSD
│
└── ClickHouse 集群
    ├── 节点:8
    └── 存储:50TB HDD

6.2 高可用设计

多活部署:
  - 同城双活:两个可用区同时提供服务
  - 数据同步:数据库主从复制 + 消息队列镜像
  - 故障切换:自动检测 + 快速切换 (< 30s)

容灾备份:
  - 数据备份:每日全量 + 每小时增量
  - 异地灾备:关键数据异地备份
  - 恢复演练:每季度进行灾备演练

7. 性能优化

7.1 写入优化

  • 批量写入:累积一定数量后批量写入,减少网络开销
  • 异步处理:写入后立即返回,后台异步处理
  • 分区策略:按目标类型分区,提高并行度
  • 压缩传输:启用消息压缩,减少带宽占用

7.2 查询优化

  • 索引优化:建立合理的复合索引
  • 查询下推:将过滤条件下推到存储层
  • 结果缓存:缓存热点查询结果
  • 预计算:提前计算常用维度的结果

7.3 计算优化

  • 状态后端:使用 RocksDB 状态后端,支持大状态
  • 增量计算:只计算变化的部分
  • 并行度调优:根据数据量调整并行度
  • 反压处理:合理处理反压,避免数据丢失

8. 监控与告警

8.1 核心指标

业务指标:
  - 事件写入速率 (QPS)
  - 排名查询速率 (QPS)
  - 排名更新延迟 (秒)
  - 热门目标数量

系统指标:
  - CPU 使用率
  - 内存使用率
  - 磁盘使用率
  - 网络带宽

质量指标:
  - 服务可用性 (%)
  - 请求错误率 (%)
  - P99 延迟 (毫秒)
  - 数据一致性

8.2 告警规则

严重告警 (电话 + 短信):
  - 服务不可用 > 1 分钟
  - 错误率 > 5%
  - 数据延迟 > 5 分钟

警告告警 (短信 + 邮件):
  - CPU > 80%
  - 内存 > 85%
  - 磁盘 > 80%
  - 延迟 > 1 秒

提示告警 (邮件):
  - 流量异常波动
  - 配置变更
  - 定期报告

9. 安全设计

9.1 访问控制

  • 身份认证:所有请求需要有效令牌
  • 权限校验:基于角色的访问控制
  • 接口限流:防止恶意请求
  • 敏感操作:关键操作需要二次确认

9.2 数据安全

  • 传输加密:全链路 HTTPS
  • 数据脱敏:敏感信息脱敏存储
  • 访问审计:所有操作记录日志
  • 数据备份:定期备份防止丢失

10. 总结

本架构设计提供了一个完整的热门排名系统解决方案,具备以下特点:

  1. 高可用:多层冗余设计,保证服务持续可用
  2. 高性能:优化的数据流和缓存策略,支持高并发
  3. 可扩展:微服务架构,支持水平扩展
  4. 易维护:完善的监控和告警,便于问题定位
  5. 安全可靠:多层次安全防护,保障数据安全

后续可根据实际业务需求进行迭代优化,逐步完善系统功能。

发现内容有问题?

告诉我们哪里需要改进。