← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共7章,点击直达)
一、系统设计方法论二、经典系统设计三、权限与安全系统四、高可用架构五、AI应用系统设计六、面试高频综合题面试速记口诀

Q130 系统设计与架构方案实战

20K Java+AI 岗位高频考点 — 系统设计是大厂面试的必考环节,考察全局视野和架构思维。覆盖秒杀系统、短链系统、Feed流、搜索引擎、消息推送、权限系统等经典场景。

一、系统设计方法论

1. 系统设计面试框架?


四步法(RESOLED):

1. Requirements(需求确认):
   - 功能需求:做什么?
   - 非功能需求:QPS/延迟/可用性/一致性
   - 估算:用户量/数据量/带宽

2. Estimation(容量估算):
   - QPS = 日活 × 每人请求数 / 86400
   - 存储 = 日增量 × 保留天数 × 单条大小
   - 带宽 = QPS × 平均请求大小

3. System Design(架构设计):
   - 画架构图(客户端→网关→服务→存储)
   - 选数据库(SQL/NoSQL/缓存/搜索引擎)
   - 设计API(接口+数据流)
   - 考虑可靠性(降级/限流/重试)

4. Optimization(深入优化):
   - 瓶颈在哪?(CPU/IO/网络/存储)
   - 如何扩展?(水平/垂直/分区)
   - 一致性如何保证?
   - 监控和告警?

2. 容量估算技巧?


常用数值:
- 单机MySQL:读写QPS 5000/1000
- 单机Redis:QPS 10万+
- 单机Kafka:TPS 10万+
- SSD随机读:10万IOPS
- 千兆网卡:125MB/s
- HTTP请求:1-10KB
- 图片:100KB-1MB
- 视频片段:1-10MB

估算示例(微博):
日活(DAU):1亿
每人每天发微博:2条
每条微博被看:100次

写QPS = 1亿 × 2 / 86400 ≈ 2300
读QPS = 1亿 × 2 × 100 / 86400 ≈ 23万(峰值×3 ≈ 70万)
存储 = 2亿条 × 1KB × 365天 ≈ 73TB/年

结论:读多写少,需要大量缓存+CDN

二、经典系统设计

3. 秒杀系统设计?


核心挑战:瞬时高并发(万级→百万级QPS)

架构分层:
用户 → CDN(静态页) → Nginx(限流) → 网关 → 秒杀服务 → MQ → 订单服务 → DB

关键设计:

1. 流量层层削峰:
   - 前端:按钮置灰、倒计时、验证码
   - CDN:静态资源CDN缓存
   - Nginx:限流(令牌桶)
   - 网关:IP限流+用户限流
   - 服务:库存预扣到Redis

2. 库存扣减(防超卖):
   // Redis Lua原子操作
   if redis.call('exists', KEYS[1]) == 1 then
       local stock = tonumber(redis.call('get', KEYS[1]))
       if stock >= tonumber(ARGV[1]) then
           redis.call('decrby', KEYS[1], ARGV[1])
           return 1
       end
   end
   return 0

3. 异步下单:
   Redis扣减成功 → 发MQ消息 → 异步创建订单
   用户轮询/推送结果

4. 防刷:
   - 用户维度限流
   - 黑名单
   - 风控规则

5. 兜底:
   - 熔断降级
   - 兜底页面(卖光了)

4. 短链系统设计?


需求:长URL → 短URL(如 t.cn/AbCd12)

核心算法:
方案1:自增ID + Base62编码
  ID: 1 → Base62: "1"
  ID: 1000000000 → Base62: "BFp3Q"
  问题:可预测,被遍历

方案2:MD5/SHA256哈希 + 取前6-8位
  问题:可能冲突,需要检查

方案3:号段模式(推荐)
  发号器分配唯一ID → Base62编码

架构:
用户访问短链 → Nginx → 短链服务 → 查映射 → 302重定向

存储:
MySQL(主):短码→长URL映射
Redis(缓存):热点短码缓存
BloomFilter:快速判断短码是否存在

优化:
- 301 vs 302:
  301永久重定向(浏览器缓存,无法统计)
  302临时重定向(每次经过服务,可统计,推荐)
- 预生成短码放入池中
- 分库分表(按短码首位分16库)

表设计:
CREATE TABLE short_url (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    short_code VARCHAR(10) UNIQUE,
    long_url VARCHAR(2048),
    created_at DATETIME,
    expire_at DATETIME,
    INDEX idx_short(short_code)
);

5. Feed流(信息流)设计?


两种模型:
推模式(Push):发帖时写入所有粉丝的收件箱
拉模式(Pull):读帖时从关注列表拉取
推拉结合:大V用拉,普通用户用推

推模式:
发帖 → 写入自己发件箱 + 所有粉丝收件箱
优点:读快(直接读自己的收件箱)
缺点:写放大(百万粉丝写百万次)
适合:粉丝少的大多数用户

拉模式:
读帖 → 拉取关注列表所有人的发件箱 → 合并排序
优点:写快(只写自己发件箱)
缺点:读慢(要合并多个列表)
适合:大V(粉丝多)

推拉结合:
- 粉丝<1000:推模式
- 粉丝≥1000:拉模式(在线粉丝实时推)

架构:
发帖 → 写发件箱(Redis ZSet) → 
  粉丝<1000? → 推到粉丝收件箱
  粉丝≥1000? → 只写发件箱

读Feed → 读收件箱(ZSet, 按时间排序) → 
  合并大V的发件箱 → 排序 → 返回

存储:
Redis ZSet:收件箱/发件箱(score=时间戳)
MySQL:持久化(归档)

6. 搜索系统设计?


架构:
用户搜索 → 搜索服务 → ES(全文检索) + Redis(热词) + DB(过滤)
                     → 排序服务(相关性+个性化)

核心组件:
1. 数据采集:
   MySQL → Canal → Kafka → ES同步

2. 索引设计:
   PUT /products {
     "mappings": {
       "properties": {
         "title": { "type": "text", "analyzer": "ik_max_word" },
         "category": { "type": "keyword" },
         "price": { "type": "double" },
         "sales": { "type": "integer" }
       }
     }
   }

3. 搜索逻辑:
   bool query: must(title匹配) + filter(分类+价格范围)
   sort: _score × 0.3 + sales × 0.3 + 时间衰减 × 0.4

4. 搜索建议:
   completion suggester / edge_ngram

5. 热词:
   Redis ZSet实时统计搜索词频率

优化:
- 分词器选择(ik_max_word / ik_smart)
- 搜索纠错(编辑距离)
- 搜索意图识别(AI辅助)
- 分面搜索(Facet):按分类/品牌聚合

7. 消息推送系统设计?


场景:站内信/App Push/短信/邮件

架构:
业务系统 → 消息中心 → 模板引擎 → 渠道路由 → 发送服务 → 第三方
                         ↓
                    去重/限流/优先级

核心设计:
1. 模板管理:
   template_id + 变量 → 渲染完整内容

2. 渠道路由:
   优先App Push → 短信兜底
   用户设置偏好(只接收重要通知)

3. 去重:
   相同内容N分钟内不重复推送
   Redis SET + TTL

4. 限流:
   单用户每天最多N条
   全局每天最多M条

5. 站内信:
   写入:发件箱+收件箱
   已读:Redis BitMap(用户×消息矩阵)

6. App Push:
   设备Token管理
   批量推送(厂商SDK)
   APNs(iOS) + FCM(Android) + 华为/小米/OPPO/VIVO

7. 短信:
   多厂商备选
   短信签名+模板审核
   验证码:Redis存储+5分钟过期+频率限制

三、权限与安全系统

8. RBAC权限系统设计?


RBAC = Role-Based Access Control

模型:
用户(User) → 角色(Role) → 权限(Permission)
         ↕           ↕
    用户-角色(多对多)  角色-权限(多对多)

表设计:
user(id, username, password, ...)
role(id, name, description)
permission(id, resource, action, description)
user_role(user_id, role_id)
role_permission(role_id, permission_id)

Spring Security实现:
@Configuration
@EnableMethodSecurity
public class SecurityConfig {
    @Bean
    SecurityFilterChain filterChain(HttpSecurity http) {
        return http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .requestMatchers("/api/orders/**").hasAnyRole("USER", "ADMIN")
                .anyRequest().authenticated())
            .oauth2ResourceServer(oauth2 -> oauth2.jwt(Customizer.withDefaults()))
            .build();
    }
}

// 方法级权限
@PreAuthorize("hasPermission(#id, 'order', 'read')")
public OrderDTO getOrder(Long id) { ... }

扩展:
- 数据权限(只能看自己部门的数据)
- 动态菜单(根据角色渲染菜单)
- 权限缓存(Redis)

9. OAuth2与JWT?


OAuth2授权码模式(最安全):
1. 客户端重定向到授权服务器
2. 用户登录并授权
3. 授权服务器返回code
4. 客户端用code换token
5. 客户端用token访问资源

Spring Authorization Server:
@Bean
public RegisteredClientRepository registeredClientRepository() {
    RegisteredClient client = RegisteredClient.withId(UUID.randomUUID().toString())
        .clientId("order-app")
        .clientSecret("{noop}secret")
        .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
        .redirectUri("http://localhost:8080/callback")
        .scope("read").scope("write")
        .build();
    return new InMemoryRegisteredClientRepository(client);
}

JWT结构:
Header: { alg: "RS256", typ: "JWT" }
Payload: { sub: "user123", roles: ["ADMIN"], exp: 1700000000 }
Signature: RS256(Header.Payload, private_key)

最佳实践:
- Access Token:短过期(15分钟)
- Refresh Token:长过期(7天),可撤销
- 使用RS256(非对称加密)
- Token存储:HttpOnly Cookie / Authorization Header

四、高可用架构

10. 限流设计?


算法:
1. 固定窗口:每分钟N个请求(边界突刺问题)
2. 滑动窗口:细粒度的固定窗口
3. 漏桶(Leaky Bucket):匀速处理(平滑流量)
4. 令牌桶(Token Bucket):匀速生成令牌(允许突发)

令牌桶实现(Guava RateLimiter):
@Bean
public RateLimiter rateLimiter() {
    return RateLimiter.create(1000); // 1000 QPS
}

// Spring Cloud Gateway限流
@Bean
public KeyResolver userKeyResolver() {
    return exchange -> Mono.just(
        exchange.getRequest().getHeaders().getFirst("X-User-Id"));
}

// Redis + Lua分布式限流
if redis.call('incr', KEYS[1]) == 1 then
    redis.call('expire', KEYS[1], ARGV[1])
end
local count = tonumber(redis.call('get', KEYS[1]))
if count > tonumber(ARGV[2]) then
    return 0
end
return 1

11. 熔断降级设计?


熔断器(Circuit Breaker)状态机:
CLOSED(正常) → 失败率>阈值 → OPEN(熔断)
OPEN → 超时 → HALF_OPEN(半开)
HALF_OPEN → 成功 → CLOSED
HALF_OPEN → 失败 → OPEN

Resilience4j:
CircuitBreakerConfig config = CircuitBreakerConfig.custom()
    .failureRateThreshold(50)
    .waitDurationInOpenState(Duration.ofSeconds(30))
    .slidingWindowSize(10)
    .permittedNumberOfCallsInHalfOpenState(5)
    .build();

CircuitBreaker cb = CircuitBreaker.of("orderService", config);
Supplier<Order> supplier = cb.decorateSupplier(() -> orderClient.getOrder(id));

降级策略:
1. 返回默认值(推荐商品列表 → 返回热门商品)
2. 返回缓存数据
3. 简化逻辑(去掉非核心步骤)
4. 页面降级(静态页面)

12. 分布式一致性?


场景:订单→库存→支付 需要一致

方案矩阵:
| 方案 | 一致性 | 性能 | 复杂度 | 适用 |
|------|--------|------|--------|------|
| 2PC | 强 | 低 | 中 | 数据库XA |
| TCC | 最终 | 高 | 高 | 资金 |
| Saga | 最终 | 高 | 中 | 长事务 |
| 本地消息表 | 最终 | 高 | 低 | 通用 |
| 事务消息 | 最终 | 高 | 低 | 异步场景 |

推荐方案:
1. 大多数场景:本地消息表 + MQ
2. 资金场景:TCC
3. 强一致:Seata AT
4. 长事务:Saga

CAP选择:
- 互联网业务:AP + 最终一致
- 金融核心:CP + 强一致

五、AI应用系统设计

13. RAG系统设计?


架构:
用户提问 → 意图识别 → Query改写 → 向量检索 → Rerank → 
  构造Prompt → LLM生成 → 流式输出

组件设计:

1. 文档处理Pipeline:
   上传 → 文档解析(PDF/Word/Markdown) → 分块(500字+100重叠)
   → Embedding → 写入向量库(Milvus/pgvector)

2. 检索策略:
   - 向量检索(Cosine Top-K)
   - 关键词检索(BM25)
   - 混合检索(RRF融合)
   - 元数据过滤

3. Rerank:
   BGE-Reranker/Cohere Rerank对候选重排序

4. Prompt模板:
   System: 你是XX助手,根据以下参考资料回答问题
   Context: {检索到的文档}
   Question: {用户问题}

5. 对话管理:
   滑动窗口保留最近10轮对话
   长期记忆:对话摘要存入向量库

6. 防幻觉:
   引用来源(返回文档片段+页码)
   置信度评估(相似度<阈值 → "我不知道")

14. AI应用网关设计?


统一接入层:管理多个AI模型调用

功能:
1. 模型路由:
   - 按任务类型路由(简单→Haiku, 复杂→Opus)
   - 按成本路由(内部用便宜模型)
   - 按延迟路由(实时用快模型)

2. 限流:
   - Token级别限流(每分钟N tokens)
   - 用户级限流
   - 模型配额

3. 缓存:
   - 相同Prompt的响应缓存
   - Embedding结果缓存

4. 观测:
   - Token使用量
   - 延迟分布
   - 成本统计
   - 错误率

5. 安全:
   - Prompt注入检测
   - 敏感词过滤
   - 输出审核

Spring AI实现:
@Bean
public ChatClient chatClient(ChatClient.Builder builder) {
    return builder.defaultSystem("你是一个助手")
        .defaultAdvisors(
            MessageChatMemoryAdvisor.with(chatMemory, 10),
            SimpleLoggerAdvisor.builder().build())
        .build();
}

六、面试高频综合题

15. 如何设计一个高并发系统?


分层防御:

1. 客户端层:
   - 请求合并(批量API)
   - 本地缓存
   - 防抖/节流

2. CDN/Nginx层:
   - 静态资源CDN
   - Nginx限流
   - Gzip压缩

3. 网关层:
   - 认证鉴权
   - 限流(令牌桶)
   - 熔断降级
   - 灰度路由

4. 服务层:
   - 缓存(Redis,热点数据)
   - 异步(MQ,削峰填谷)
   - 并行(CompletableFuture)
   - 线程池隔离

5. 数据层:
   - 读写分离
   - 分库分表
   - 连接池
   - 慢SQL优化

6. 基础设施:
   - 水平扩展(K8s HPA)
   - 异地多活
   - 容灾演练

16. 如何做技术选型?


选型维度:
1. 业务匹配度:是否适合当前业务场景
2. 团队能力:团队是否熟悉,学习成本
3. 社区活跃度:GitHub Star/Issue/Release
4. 性能:是否满足QPS/延迟要求
5. 可维护性:文档、监控、运维复杂度
6. 成本:License费用、人力成本、资源成本
7. 生态:与现有技术栈的集成难度

常见选型对比:
缓存:Redis(通用) vs Memcached(简单KV)
MQ:Kafka(大数据量) vs RocketMQ(事务) vs RabbitMQ(路由)
注册中心:Nacos(推荐) vs ZooKeeper(CP) vs Consul
网关:Spring Cloud Gateway vs Kong vs APISIX
搜索:Elasticsearch vs OpenSearch vs Meilisearch
向量库:Milvus(大规模) vs pgvector(小规模)

选型原则:
- 不追新,选成熟稳定的
- 不选最强,选最合适的
- 考虑团队能力和维护成本
- 能用开源不自己造轮子

17. 系统设计面试怎么答?


回答模板:

1. 澄清需求(2分钟):
   "确认一下,系统日活大概多少?峰值QPS呢?
    需要强一致还是最终一致?"

2. 容量估算(2分钟):
   "假设日活100万,每人每天100次请求,
    峰值QPS大约2000,存储..."

3. 高层设计(5分钟):
   "整体架构分为四层:
    客户端→CDN/Nginx→API网关→微服务→存储
    核心组件有..."

4. 深入设计(10分钟):
   "关键的XX模块,我这样设计:
    先用Redis缓存热点数据...
    异步用MQ解耦...
    限流用令牌桶..."

5. 讨论权衡(5分钟):
   "这个方案的trade-off是...
    如果QPS再高10倍,我会..."

6. 总结(1分钟):
   "总结一下,核心是缓存+异步+分层防御"

面试速记口诀

设计四步:需求确认→容量估算→高层设计→深入优化

>

秒杀三板斧:流量削峰(N层限流)、库存防超卖(Redis Lua)、异步下单(MQ)

>

高并发六层:客户端缓存→CDN→网关限流→服务异步→数据读写分离→水平扩展

>

选型三原则:不追新选成熟、不选强选合适、能开源不造轮