设计原则
在设计热门排名系统时,遵循正确的设计原则是确保系统可扩展性、可靠性和可维护性的关键。本章将详细介绍我们在架构设计中遵循的核心原则。
1. 单一职责原则 (SRP)
每个模块应该只有一个引起它变化的原因。在热门排名系统中:
┌─────────────────────────────────────────────────────────────┐
│ 热门排名系统 │
├─────────────┬─────────────┬─────────────┬─────────────────┤
│ 数据采集 │ 分数计算 │ 排名生成 │ 缓存服务 │
│ 模块 │ 模块 │ 模块 │ 模块 │
└─────────────┴─────────────┴─────────────┴─────────────────┘
实践要点:
- 数据采集模块只负责从各数据源收集原始数据
- 分数计算模块专注于算法实现,不关心数据来源
- 排名生成模块只处理排序逻辑
- 缓存服务独立管理缓存生命周期
2. 开闭原则 (OCP)
系统应对扩展开放,对修改封闭。这意味着:
- 新增数据源时,只需实现新的采集器接口
- 调整排名算法时,不影响现有数据处理流程
- 添加新的排名维度时,无需重构核心代码
3. 依赖倒置原则 (DIP)
高层模块不应依赖低层模块,两者都应依赖抽象:
┌────────────────────────────────────────────────────────────┐
│ 业务逻辑层 │
│ (依赖抽象接口,不依赖具体实现) │
├────────────────────────────────────────────────────────────┤
│ 抽象接口 │
│ (ScoreCalculator, DataFetcher, RankStore) │
├────────────────────────────────────────────────────────────┤
│ 具体实现层 │
│ (RedisScoreCalculator, APIDataFetcher, MySQLRankStore) │
└────────────────────────────────────────────────────────────┘
1. 分层架构
采用清晰的分层结构,确保各层职责明确:
| 层级 | 职责 | 技术选型 |
|---|---|---|
| 接入层 | 请求路由、限流、认证 | Nginx, API Gateway |
| 服务层 | 业务逻辑处理 | Go/Java Microservices |
| 计算层 | 分数计算、排名生成 | Spark, Flink |
| 存储层 | 数据持久化 | MySQL, Redis, ES |
| 缓存层 | 热点数据缓存 | Redis, Memcached |
2. 事件驱动架构
使用事件驱动模式解耦系统组件:
数据采集 ──→ [内容发布事件] ──→ 消息队列 ──→ 分数计算服务
──→ 排名更新服务
──→ 通知服务
优势:
- 组件间松耦合
- 易于水平扩展
- 支持异步处理
- 提高系统容错性
3. CQRS 模式
将读取和写入操作分离:
┌─────────────────────────────────────────────────────────────┐
│ 写入端 │
│ 内容发布 → 事件存储 → 更新读模型 → 缓存失效 │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ 读取端 │
│ 查询请求 → 读模型 (优化) → Redis 缓存 → 返回结果 │
└─────────────────────────────────────────────────────────────┘
1. 缓存优先策略
请求处理流程:
1. 检查本地缓存 (L1) → 命中则返回
2. 检查分布式缓存 (L2) → 命中则返回并更新 L1
3. 查询数据库 → 返回并更新两级缓存
缓存策略:
- 热门数据:永不过期,手动失效
- 普通数据:TTL 30 分钟
- 实时数据:TTL 5 秒,支持主动刷新
2. 预计算原则
对于计算密集型的排名操作,采用预计算策略:
┌─────────────────────────────────────────────────────────────┐
│ 定时预计算任务 │
│ │
│ 每 5 分钟 → 计算全局热门榜单 → 存入缓存 │
│ 每 1 分钟 → 计算分类热门榜单 → 存入缓存 │
│ 实时触发 → 计算个性化推荐 → 存入用户缓存 │
└─────────────────────────────────────────────────────────────┘
3. 分级存储原则
根据数据访问频率采用不同的存储策略:
| 数据热度 | 存储介质 | 访问延迟 | 成本 |
|---|---|---|---|
| 超热 (前 100) | Redis 内存 | < 1ms | 高 |
| 热门 (前 1000) | Redis + SSD | < 10ms | 中 |
| 温数据 | MySQL + SSD | < 50ms | 低 |
| 冷数据 | MySQL + HDD | < 200ms | 极低 |
1. 冗余设计
关键组件必须有多副本:
┌──────────────┐
│ 负载均衡 │
└──────┬───────┘
┌───────────────┼───────────────┐
↓ ↓ ↓
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ 服务实例 1 │ │ 服务实例 2 │ │ 服务实例 3 │
└─────────────┘ └─────────────┘ └─────────────┘
↓ ↓ ↓
┌─────────────────────────────────────────────┐
│ Redis Cluster │
│ (3 Master + 3 Slave) │
└─────────────────────────────────────────────┘
2. 降级策略
当系统压力过大时,按优先级降级:
正常状态 → 关闭实时计算 → 关闭个性化 → 返回静态榜单 → 返回错误页
↓ ↓ ↓ ↓ ↓
100% 80% 50% 20% 服务不可用
降级措施:
- 一级降级:停止非核心功能(如个性化推荐)
- 二级降级:延长缓存时间,减少计算频率
- 三级降级:返回预计算的静态榜单
- 四级降级:返回友好错误提示
3. 熔断机制
使用熔断器保护下游服务:
熔断解决的是级联故障问题。下游服务变慢时,上游线程会堆积在等待里,最终把自己的连接池、线程池全部占满,整个链路一起垮掉——而下游可能只需要几秒就恢复了。熔断器的做法是:检测到下游异常,主动快速失败,不再把请求送过去。
三个状态与转换:
失败率低于阈值 失败率超过阈值
┌──────────────┐ ┌──────────────┐
│ │ ─────────► │ │
│ CLOSED │ │ OPEN │
│ (正常放行) │ ◄───────── │ (快速失败) │
│ │ 等待冷却 │ │
└──────────────┘ └──────────────┘
▲ │
│ 探测请求成功 │ 冷却期满
│ ▼
┌──────────────┐ ┌──────────────┐
│ │ │ │
│ HALF_OPEN │ ◄───────── │ │
│ (放行少量) │ │ │
└──────────────┘ └──────────────┘
| 状态 | 行为 | 进入条件 | 退出条件 |
|---|---|---|---|
| CLOSED | 正常放行,统计失败率 | 初始状态 | 失败率超阈值转 OPEN |
| OPEN | 直接失败,不发请求 | 失败率超阈值或连续失败数超限 | 冷却期满转 HALF_OPEN |
| HALF_OPEN | 只放行少量探测请求 | 冷却期满 | 探测成功转 CLOSED,失败转 OPEN |
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
/**
* 熔断器。
*
* 三个状态:CLOSED 正常放行,OPEN 快速失败,HALF_OPEN 放行少量探测请求。
*
* 关键设计:
* 1. 统计的是滑动窗口内的失败率,不是累计值;
* 2. OPEN 状态下的失败是立即返回,不占用任何下游资源;
* 3. HALF_OPEN 的探测请求数有限,不会对刚恢复的下游造成二次冲击。
*/
public class CircuitBreaker {
/** 熔断器状态。 */
public enum State {
/** 正常放行。 */
CLOSED,
/** 快速失败。 */
OPEN,
/** 放行少量探测请求。 */
HALF_OPEN
}
/** 触发熔断的失败率阈值。 */
private static final double FAILURE_RATE_THRESHOLD = 0.5;
/** 触发熔断的最小请求数,样本太少时不做判断。 */
private static final int MIN_REQUESTS = 20;
/** 熔断后的冷却时间(毫秒)。 */
private static final long COOL_DOWN_MILLIS = 5_000L;
/** HALF_OPEN 状态放行的探测请求数。 */
private static final int PROBE_LIMIT = 3;
/** 当前状态。 */
private volatile State state = State.CLOSED;
/** 窗口内的请求总数。 */
private final AtomicInteger totalRequests = new AtomicInteger();
/** 窗口内的失败数。 */
private final AtomicInteger failedRequests = new AtomicInteger();
/** 状态切换的时刻。 */
private final AtomicLong stateChangedAt = new AtomicLong(System.currentTimeMillis());
/** HALF_OPEN 状态下已放行的探测请求数。 */
private final AtomicInteger probeCount = new AtomicInteger();
/**
* 判定当前是否允许调用下游。
*/
public boolean allowRequest() {
if (state == State.CLOSED) {
return true;
}
if (state == State.OPEN) {
// 冷却期满后转入 HALF_OPEN
if (System.currentTimeMillis() - stateChangedAt.get() >= COOL_DOWN_MILLIS) {
transitionTo(State.HALF_OPEN);
probeCount.set(0);
return allowProbe();
}
return false;
}
return allowProbe();
}
/**
* HALF_OPEN 状态下只放行有限数量的探测请求。
*/
private boolean allowProbe() {
return probeCount.incrementAndGet() <= PROBE_LIMIT;
}
/**
* 记录一次调用结果。
*/
public void recordResult(boolean success) {
totalRequests.incrementAndGet();
if (!success) {
failedRequests.incrementAndGet();
}
if (state == State.HALF_OPEN) {
// 探测请求成功就恢复;失败则立即重新熔断
if (success) {
transitionTo(State.CLOSED);
resetStatistics();
} else {
transitionTo(State.OPEN);
}
return;
}
if (state == State.CLOSED
&& totalRequests.get() >= MIN_REQUESTS
&& failureRate() >= FAILURE_RATE_THRESHOLD) {
transitionTo(State.OPEN);
}
}
/**
* 当前失败率。
*/
public double failureRate() {
int total = totalRequests.get();
if (total == 0) {
return 0.0;
}
return (double) failedRequests.get() / total;
}
/**
* 切换状态。
*/
private void transitionTo(State next) {
this.state = next;
this.stateChangedAt.set(System.currentTimeMillis());
}
/**
* 重置统计量。
*/
private void resetStatistics() {
totalRequests.set(0);
failedRequests.set(0);
}
}
熔断参数怎么定:
| 参数 | 建议取值 | 理由 |
|---|---|---|
| 失败率阈值 | 50% | 太低会频繁误熔断,太高则熔断来得太晚 |
| 最小请求数 | 20 到 50 | 样本太少时一次失败就能占满比例,误判概率高 |
| 冷却时间 | 5 到 30 秒 | 要足够让下游的瞬时抖动过去,但不能太长 |
| 探测请求数 | 3 到 5 | 太少可能误判下游仍未恢复,太多会造成二次冲击 |
熔断器要分级。不同的下游有不同的容忍度,不能用同一套参数:
| 下游 | 熔断策略 | 理由 |
|---|---|---|
| Redis(榜单读取) | 快速失败并返回兜底榜单 | 读不到榜单时返回上一份快照 |
| 内容详情服务 | 熔断后隐藏该模块 | 不展示详情比展示错误信息好 |
| 画像服务 | 降级为默认画像 | 权重调整退化为静态权重 |
| 埋点上报 | 直接丢弃 | 监控数据不能拖垮主链路 |
熔断和降级是配套的。熔断决定「不再调用下游」,降级决定「不调用之后返回什么」。只有熔断没有降级,熔断器一打开,用户看到的就是错误页。
熔断状态必须可观测。至少要监控:熔断次数、熔断持续时长、各下游的熔断状态。这些指标出问题时,排查的第一句话往往是「现在是不是熔断状态」——不暴露这个状态就只能靠猜。
1. 水平扩展设计
所有服务应支持无状态水平扩展:
┌─────────────┐
│ K8s │
│ Controller │
└──────┬──────┘
│ 自动扩缩容
┌───────────────┼───────────────┐
↓ ↓ ↓
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Pod 1 │ │ Pod 2 │ │ Pod N │
└─────────┘ └─────────┘ └─────────┘
2. 分片策略
对于大规模数据,采用分片存储:
内容分片策略:
┌─────────────────────────────────────────────────────────────┐
│ 分片 0: content_id % 100 = 0-19 → MySQL Shard 1 │
│ 分片 1: content_id % 100 = 20-39 → MySQL Shard 2 │
│ 分片 2: content_id % 100 = 40-59 → MySQL Shard 3 │
│ 分片 3: content_id % 100 = 60-79 → MySQL Shard 4 │
│ 分片 4: content_id % 100 = 80-99 → MySQL Shard 5 │
└─────────────────────────────────────────────────────────────┘
3. 模块化设计
系统应按业务模块划分,支持独立部署和扩展:
┌─────────────────────────────────────────────────────────────┐
│ API Gateway │
└─────────────────────────────────────────────────────────────┘
│ │ │ │
↓ ↓ ↓ ↓
┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ 内容服务 │ │ 排名服务 │ │ 用户服务 │ │ 统计服务 │
│ (独立部署) │ │ (独立部署) │ │ (独立部署) │ │ (独立部署) │
└─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘
1. 配置外部化
所有配置应存储在外部配置中心:
配置要点
- 配置表达的是环境差异和运行参数,不是业务规则本身。
2. 可观测性
系统必须具备完善的监控和日志:
┌─────────────────────────────────────────────────────────────┐
│ 可观测性三层 │
├─────────────────────────────────────────────────────────────┤
│ Metrics: Prometheus + Grafana (指标监控) │
│ Logging: ELK Stack (日志收集与分析) │
│ Tracing: Jaeger/Zipkin (分布式追踪) │
└─────────────────────────────────────────────────────────────┘
3. 文档化
- API 文档:使用 OpenAPI/Swagger 自动生成
- 架构文档:使用 C4 模型描述系统结构
- 运行文档:包含部署、运维、故障处理指南
1. 数据验证
所有输入数据必须经过严格验证:
数据验证是热榜系统的第一道防线。榜单的输入有两个来源:用户的实时行为和外部系统写入的数据。前者数量巨大、来源不可控,后者虽然量小但直接影响榜单的存储内容。任何一条脏数据进入榜单,都可能污染排名,且因为榜单是全站共享的,影响面会被放大。
验证要分层做,因为不同来源的信任程度完全不同:
| 层次 | 验证内容 | 拒绝后的处理 | 成本 |
|---|---|---|---|
| 格式校验 | 字段是否齐全、类型是否正确 | 丢弃并计数 | 最低 |
| 范围校验 | 数值是否在合理区间内 | 丢弃并计数 | 低 |
| 语义校验 | 逻辑是否自洽(时间、状态) | 丢弃并告警 | 中 |
| 跨字段校验 | 多个字段之间是否矛盾 | 丢弃并告警 | 中 |
| 来源校验 | 调用方是否有权限、是否在名单内 | 拒绝并告警 | 高 |
范围校验要针对每个字段单独定义上下界,而不是用一个统一的规则:
import java.time.Instant;
/**
* 行为事件校验器。
*
* 每一层校验对应一组明确的规则,
* 任何一层不通过都拒绝这条数据,并记录拒绝原因。
*/
public class BehaviorEventValidator {
/** 单个内容在时间窗口内的最大互动数,超过视为刷量。 */
private static final int MAX_INTERACTIONS_PER_WINDOW = 10_000;
/** 允许的最大事件时间偏差(毫秒),超出说明时间戳有问题。 */
private static final long MAX_EVENT_TIME_SKEW_MILLIS = 3_600_000L;
/** 允许的最大未来时间偏移(毫秒),用于容忍时钟不同步。 */
private static final long MAX_FUTURE_SKEW_MILLIS = 60_000L;
/** 校验结果。 */
public record ValidationResult(boolean valid, String reason) {
static ValidationResult ok() {
return new ValidationResult(true, null);
}
static ValidationResult reject(String reason) {
return new ValidationResult(false, reason);
}
}
/**
* 校验一条行为事件。
*/
public ValidationResult validate(BehaviorEvent event, long nowMillis) {
// 第一层:格式校验
if (event.contentId() == null || event.contentId().isBlank()) {
return ValidationResult.reject("内容 ID 为空");
}
if (event.userId() == null || event.userId().isBlank()) {
return ValidationResult.reject("用户 ID 为空");
}
if (event.eventType() == null || !event.eventType().matches("view|like|comment|share")) {
return ValidationResult.reject("事件类型非法: " + event.eventType());
}
// 第二层:范围校验
if (event.weight() < 0 || event.weight() > 1.5) {
return ValidationResult.reject("权重超出允许区间: " + event.weight());
}
// 第三层:语义校验(事件时间)
if (event.eventTime() > nowMillis + MAX_FUTURE_SKEW_MILLIS) {
// 事件时间在未来,可能是客户端时钟错误或伪造
return ValidationResult.reject("事件时间超前");
}
if (nowMillis - event.eventTime() > MAX_EVENT_TIME_SKEW_MILLIS) {
// 事件时间过旧,早于当前计算窗口能接受的范围
return ValidationResult.reject("事件时间过旧");
}
// 第四层:跨字段校验
if (event.eventType().equals("view") && event.weight() > 1.0) {
// 浏览事件的权重不应超过 1,这是权重来源被篡改的信号
return ValidationResult.reject("浏览事件的权重异常");
}
return ValidationResult.ok();
}
}
校验的三个原则:
- 拒绝要早、要快。校验放在链路的入口,在任何昂贵操作(写库、聚合、写入 ZSet)之前完成。被拒绝的数据一旦进了下游,清理成本远高于拦截成本。
- 拒绝要留痕。每一条被拒绝的数据都要记录原因和来源。没有日志的拒绝,等于数据凭空消失,排查时完全看不出发生了什么。
- 拒绝的阈值要配置化。硬编码的阈值在业务变化时只能改代码重新发布,而数据校验的阈值往往是需要根据线上表现调整的。
校验失败的处理策略:
| 失败原因 | 处理方式 |
|---|---|
| 格式错误、参数越界 | 丢弃,记录日志,不需要告警 |
| 时间戳异常 | 丢弃或修正到当前时间,记录日志 |
| 单条数据触发配额超限 | 丢弃该条,累计到阈值时告警 |
| 持续失败率异常 | 暂停该来源的接入并告警 |
最后一条最重要:数据验证要有「来源熔断」的概念。某个上游突然开始大量发送非法数据时,不应该让这些数据一路走到计算层才被发现。校验器要按来源统计失败率,超过阈值就暂停该来源的接入并告警。
校验的成本要控制。校验本身有开销,尤其是涉及数据库查询的跨字段校验。可以用两级策略:常规路径只做格式和范围校验(纯内存操作,开销可忽略),只有通过初筛的数据才进入昂贵校验。
监控上要盯的指标:
| 指标 | 说明 | 关注点 |
|---|---|---|
| 各来源的拒绝率 | 按数据来源统计 | 突增说明上游出了问题或有人在攻击 |
| 各层校验的拒绝数 | 定位是哪一层规则在拦截 | 某层长期为 0 说明规则没生效 |
| 拒绝原因的分布 | 按原因归类 | 某类原因占比高说明有系统性问题 |
| 校验本身的耗时 | 校验占请求处理时间的比例 | 超过 5% 说明校验过重 |
2. 访问控制
- 接口层:基于 JWT 的身份认证
- 服务层:基于角色的访问控制 (RBAC)
- 数据层:行级权限控制
3. 数据安全
- 传输加密:全站 HTTPS
- 存储加密:敏感数据加密存储
- 数据脱敏:日志中脱敏敏感信息
遵循上述设计原则,我们可以构建一个:
| 特性 | 实现方式 |
|---|---|
| 高可用 | 冗余设计 + 降级策略 + 熔断机制 |
| 高性能 | 缓存优先 + 预计算 + 分级存储 |
| 可扩展 | 水平扩展 + 分片策略 + 模块化 |
| 可维护 | 配置外部化 + 可观测性 + 文档化 |
| 安全 | 数据验证 + 访问控制 + 数据安全 |
在后续章节中,我们将基于这些原则详细设计系统的具体组件和实现方案。
相关阅读:
- 01-系统概述
- 02-需求分析
- 04-核心组件
下一步: 继续学习 04-核心组件设计
发现内容有问题?
告诉我们哪里需要改进。
