20K Java+AI 岗位高频考点 — 系统设计是大厂面试的必考环节,考察全局视野和架构思维。覆盖秒杀系统、短链系统、Feed流、搜索引擎、消息推送、权限系统等经典场景。
四步法(RESOLED):
1. Requirements(需求确认):
- 功能需求:做什么?
- 非功能需求:QPS/延迟/可用性/一致性
- 估算:用户量/数据量/带宽
2. Estimation(容量估算):
- QPS = 日活 × 每人请求数 / 86400
- 存储 = 日增量 × 保留天数 × 单条大小
- 带宽 = QPS × 平均请求大小
3. System Design(架构设计):
- 画架构图(客户端→网关→服务→存储)
- 选数据库(SQL/NoSQL/缓存/搜索引擎)
- 设计API(接口+数据流)
- 考虑可靠性(降级/限流/重试)
4. Optimization(深入优化):
- 瓶颈在哪?(CPU/IO/网络/存储)
- 如何扩展?(水平/垂直/分区)
- 一致性如何保证?
- 监控和告警?
常用数值:
- 单机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
核心挑战:瞬时高并发(万级→百万级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. 兜底:
- 熔断降级
- 兜底页面(卖光了)
需求:长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)
);
两种模型:
推模式(Push):发帖时写入所有粉丝的收件箱
拉模式(Pull):读帖时从关注列表拉取
推拉结合:大V用拉,普通用户用推
推模式:
发帖 → 写入自己发件箱 + 所有粉丝收件箱
优点:读快(直接读自己的收件箱)
缺点:写放大(百万粉丝写百万次)
适合:粉丝少的大多数用户
拉模式:
读帖 → 拉取关注列表所有人的发件箱 → 合并排序
优点:写快(只写自己发件箱)
缺点:读慢(要合并多个列表)
适合:大V(粉丝多)
推拉结合:
- 粉丝<1000:推模式
- 粉丝≥1000:拉模式(在线粉丝实时推)
架构:
发帖 → 写发件箱(Redis ZSet) →
粉丝<1000? → 推到粉丝收件箱
粉丝≥1000? → 只写发件箱
读Feed → 读收件箱(ZSet, 按时间排序) →
合并大V的发件箱 → 排序 → 返回
存储:
Redis ZSet:收件箱/发件箱(score=时间戳)
MySQL:持久化(归档)
架构:
用户搜索 → 搜索服务 → 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):按分类/品牌聚合
场景:站内信/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分钟过期+频率限制
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)
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
算法:
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
熔断器(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. 页面降级(静态页面)
场景:订单→库存→支付 需要一致
方案矩阵:
| 方案 | 一致性 | 性能 | 复杂度 | 适用 |
|------|--------|------|--------|------|
| 2PC | 强 | 低 | 中 | 数据库XA |
| TCC | 最终 | 高 | 高 | 资金 |
| Saga | 最终 | 高 | 中 | 长事务 |
| 本地消息表 | 最终 | 高 | 低 | 通用 |
| 事务消息 | 最终 | 高 | 低 | 异步场景 |
推荐方案:
1. 大多数场景:本地消息表 + MQ
2. 资金场景:TCC
3. 强一致:Seata AT
4. 长事务:Saga
CAP选择:
- 互联网业务:AP + 最终一致
- 金融核心:CP + 强一致
架构:
用户提问 → 意图识别 → 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. 防幻觉:
引用来源(返回文档片段+页码)
置信度评估(相似度<阈值 → "我不知道")
统一接入层:管理多个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();
}
分层防御:
1. 客户端层:
- 请求合并(批量API)
- 本地缓存
- 防抖/节流
2. CDN/Nginx层:
- 静态资源CDN
- Nginx限流
- Gzip压缩
3. 网关层:
- 认证鉴权
- 限流(令牌桶)
- 熔断降级
- 灰度路由
4. 服务层:
- 缓存(Redis,热点数据)
- 异步(MQ,削峰填谷)
- 并行(CompletableFuture)
- 线程池隔离
5. 数据层:
- 读写分离
- 分库分表
- 连接池
- 慢SQL优化
6. 基础设施:
- 水平扩展(K8s HPA)
- 异地多活
- 容灾演练
选型维度:
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(小规模)
选型原则:
- 不追新,选成熟稳定的
- 不选最强,选最合适的
- 考虑团队能力和维护成本
- 能用开源不自己造轮子
回答模板:
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→网关限流→服务异步→数据读写分离→水平扩展
>
选型三原则:不追新选成熟、不选强选合适、能开源不造轮