设计原则

在设计热门排名系统时,遵循正确的设计原则是确保系统可扩展性、可靠性和可维护性的关键。本章将详细介绍我们在架构设计中遵循的核心原则。

一、核心设计原则

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();
    }
}

校验的三个原则:

  1. 拒绝要早、要快。校验放在链路的入口,在任何昂贵操作(写库、聚合、写入 ZSet)之前完成。被拒绝的数据一旦进了下游,清理成本远高于拦截成本。
  2. 拒绝要留痕。每一条被拒绝的数据都要记录原因和来源。没有日志的拒绝,等于数据凭空消失,排查时完全看不出发生了什么。
  3. 拒绝的阈值要配置化。硬编码的阈值在业务变化时只能改代码重新发布,而数据校验的阈值往往是需要根据线上表现调整的。

校验失败的处理策略:

失败原因处理方式
格式错误、参数越界丢弃,记录日志,不需要告警
时间戳异常丢弃或修正到当前时间,记录日志
单条数据触发配额超限丢弃该条,累计到阈值时告警
持续失败率异常暂停该来源的接入并告警

最后一条最重要:数据验证要有「来源熔断」的概念。某个上游突然开始大量发送非法数据时,不应该让这些数据一路走到计算层才被发现。校验器要按来源统计失败率,超过阈值就暂停该来源的接入并告警。

校验的成本要控制。校验本身有开销,尤其是涉及数据库查询的跨字段校验。可以用两级策略:常规路径只做格式和范围校验(纯内存操作,开销可忽略),只有通过初筛的数据才进入昂贵校验。

监控上要盯的指标:

指标说明关注点
各来源的拒绝率按数据来源统计突增说明上游出了问题或有人在攻击
各层校验的拒绝数定位是哪一层规则在拦截某层长期为 0 说明规则没生效
拒绝原因的分布按原因归类某类原因占比高说明有系统性问题
校验本身的耗时校验占请求处理时间的比例超过 5% 说明校验过重

2. 访问控制

  • 接口层:基于 JWT 的身份认证
  • 服务层:基于角色的访问控制 (RBAC)
  • 数据层:行级权限控制

3. 数据安全

  • 传输加密:全站 HTTPS
  • 存储加密:敏感数据加密存储
  • 数据脱敏:日志中脱敏敏感信息

八、总结

遵循上述设计原则,我们可以构建一个:

特性实现方式
高可用冗余设计 + 降级策略 + 熔断机制
高性能缓存优先 + 预计算 + 分级存储
可扩展水平扩展 + 分片策略 + 模块化
可维护配置外部化 + 可观测性 + 文档化
安全数据验证 + 访问控制 + 数据安全

在后续章节中,我们将基于这些原则详细设计系统的具体组件和实现方案。


相关阅读:

  • 01-系统概述
  • 02-需求分析
  • 04-核心组件

下一步: 继续学习 04-核心组件设计

发现内容有问题?

告诉我们哪里需要改进。