定位:系统设计面试总是不知道从哪开始、答不到点子上。本节精选10道高频系统设计题,每道按"澄清需求→规模估算→高层设计→深入设计→Trade-off"的标准框架组织,附带ASCII架构图和Java核心代码。
每道题按以下结构回答(严格遵循):
Step 1: 澄清需求(Clarify) → 问清楚功能边界和规模
Step 2: 规模估算(Estimate) → QPS、存储、带宽
Step 3: 高层设计(HLD) → 核心组件和交互(画ASCII图)
Step 4: 深入设计(Deep Dive) → 关键技术选型和trade-off
面试节奏:Step1-2 共2分钟 → Step3 共3分钟 → Step4 共5分钟
https://s.example.com/abc123| 指标 | 值 |
|---|---|
| 写QPS | 100万/86400 = 12/s |
| 读QPS | 100万 x 1000 / 86400 = 12K/s |
| 存储 | 100万/天 x 1KB x 365天 = 365GB/年 |
| 缓存 | 热点100万条 x 1KB = 1GB |
写入流程:
客户端 ──→ [API Gateway] ──→ [短链服务] ──→ 生成短码
│ │
│ ┌─────────┼─────────┐
│ ↓ ↓ ↓
│ [Redis] [MySQL] [异步MQ]
│ 热缓存 持久化 数据同步
读取流程:
客户端 ──→ [API Gateway] ──→ [短链服务] ──→ 查Redis → 302重定向
│
miss → 查MySQL → 回写Redis
@Service
public class ShortUrlService {
private static final String BASE62 =
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
@Autowired
private StringRedisTemplate redisTemplate;
// 生成短链:分布式ID + Base62编码
public String generateShortUrl(String longUrl) {
long id = snowflakeId(); // 雪花算法生成分布式ID
String shortCode = base62Encode(id); // 62^7 = 3.5万亿,够用
redisTemplate.opsForValue().set(
"short:" + shortCode, longUrl, 30, TimeUnit.DAYS);
return "https://s.example.com/" + shortCode;
}
// 读取长URL
public String getLongUrl(String shortCode) {
String key = "short:" + shortCode;
String longUrl = redisTemplate.opsForValue().get(key);
if (longUrl != null) return longUrl;
// 缓存miss → 查DB → 回写缓存
longUrl = urlMapper.selectByShortCode(shortCode);
if (longUrl != null) {
redisTemplate.opsForValue().set(key, longUrl, 30, TimeUnit.DAYS);
}
return longUrl;
}
}
Trade-off:301(永久重定向,浏览器缓存,不可统计)vs 302(临时重定向,每次经过服务端,可统计点击)。
| 指标 | 值 |
|---|---|
| 峰值QPS | 10万 |
| 日消息量 | 5000万条 |
| 存储 | 5000万 x 1KB = 50GB/天 |
| 在线连接数 | 200万(20%在线) |
业务系统 ──→ [消息API] ──→ [MQ] ──→ [消息路由服务]
│
┌────────────────┼────────────────┐
↓ ↓ ↓
[APP推送] [WebSocket] [短信/邮件]
(Firebase/APNs) (Netty集群) (第三方SDK)
│ │ │
└────────────────┼────────────────┘
↓
[消息状态存储]
(已读/未读/发送状态)
@Service
public class PushService {
@Autowired
private RocketMQTemplate mqTemplate;
// 发送推送(异步入MQ,削峰填谷)
public void push(PushMessage msg) {
mqTemplate.syncSend("push-topic",
MessageBuilder.withPayload(msg)
.setKeys(msg.getMessageId())
.setTags(msg.getChannel().name())
.build());
}
// 消费者:按渠道分发
@RocketMQMessageListener(topic = "push-topic", consumerGroup = "push-group")
public class PushConsumer implements RocketMQListener<PushMessage> {
@Override
public void onMessage(PushMessage msg) {
switch (msg.getChannel()) {
case APP: apnsPush(msg); break;
case WEB: websocketPush(msg); break;
case SMS: smsPush(msg); break;
case EMAIL: emailPush(msg); break;
}
// 更新推送状态
updatePushStatus(msg.getMessageId(), PushStatus.SENT);
}
}
}
Trade-off:推送保证"至少一次"vs"恰好一次"。至少一次实现简单,业务需要幂等;恰好一次开销大,需要去重表。
| 指标 | 值 |
|---|---|
| 写QPS | 50万/天 = 6/s |
| 读QPS | 5000万 x 10次 = 5800/s |
| 存储动态 | 50万/天 x 1KB = 500MB/天 |
写路径(推模式):
用户发动态 → 写入发件箱 → 推送到粉丝收件箱(Redis List)
读路径(拉模式补充大V):
用户刷新 → 合并[收件箱 + 关注大V的发件箱] → 排序 → 返回
推拉结合策略:
普通用户(<1000粉丝) → 推模式
大V(>1000粉丝) → 拉模式(不推,读时拉取)
@Service
public class FeedService {
private static final int FAN_OUT_THRESHOLD = 1000;
// 发送动态
public void publish(Feed feed) {
// 1. 写入发件箱
redisTemplate.opsForList().leftPush(
"feed:outbox:" + feed.getAuthorId(), toJson(feed));
// 2. 普通用户推模式,大V跳过
if (getFollowerCount(feed.getAuthorId()) <= FAN_OUT_THRESHOLD) {
getFollowers(feed.getAuthorId()).forEach(fid ->
redisTemplate.opsForList().leftPush(
"feed:inbox:" + fid, toJson(feed)));
}
}
// 获取动态流
public List<Feed> getFeed(Long userId, int page, int size) {
// 1. 收件箱(已推送的)
List<Feed> inbox = getInboxFeeds(userId, page, size);
// 2. 拉取关注的大V发件箱
List<Feed> bigV = getBigVFeeds(userId, size);
// 3. 合并排序
return mergeAndSort(inbox, bigV, page, size);
}
}
Trade-off:推模式写放大(粉丝多时写入量大)但读快;拉模式写轻但读时需要合并排序。推拉结合是最佳平衡。
客户端 → [网关限流(Guava RateLimiter)] → [分布式限流(Redis+Lua)] → 服务
两层限流:
第一层:本地令牌桶(快速拒绝,无网络开销)
第二层:Redis滑动窗口(精确控制总量)
@Component
public class DistributedRateLimiter {
@Autowired
private StringRedisTemplate redisTemplate;
// Redis + Lua 滑动窗口限流
private static final String LUA_SCRIPT =
"local key = KEYS[1]\n" +
"local window = tonumber(ARGV[1])\n" +
"local limit = tonumber(ARGV[2])\n" +
"local now = tonumber(ARGV[3])\n" +
"redis.call('ZREMRANGEBYSCORE', key, 0, now - window)\n" +
"local count = redis.call('ZCARD', key)\n" +
"if count < limit then\n" +
" redis.call('ZADD', key, now, now .. '-' .. math.random(1e6))\n" +
" redis.call('EXPIRE', key, math.ceil(window / 1000))\n" +
" return 1\n" +
"end\n" +
"return 0";
public boolean isAllowed(String key, int limit, long windowMs) {
Long result = redisTemplate.execute(
new DefaultRedisScript<>(LUA_SCRIPT, Long.class),
List.of("rate:" + key),
String.valueOf(windowMs), String.valueOf(limit),
String.valueOf(System.currentTimeMillis()));
return result != null && result == 1;
}
}
Trade-off:令牌桶(允许突发流量)vs 漏桶(匀速输出)。大多数场景用令牌桶更灵活。
客户端 → [本地缓存(Caffeine)] → [Redis集群] → [MySQL]
L1 (ms级过期) L2 (min级过期) 持久层
穿透防护: 布隆过滤器 + 空值缓存(TTL 5min)
击穿防护: 互斥锁(Redisson) + 逻辑过期
雪崩防护: 随机过期时间(基准TTL ± 随机偏移)
@Service
public class CacheService {
@Autowired private StringRedisTemplate redisTemplate;
@Autowired private RedissonClient redissonClient;
// 穿透防护:布隆过滤器 + 空值缓存
public Product getProduct(Long id) {
String key = "product:" + id;
String cached = redisTemplate.opsForValue().get(key);
if (cached != null) {
return "NULL".equals(cached) ? null :
JSON.parseObject(cached, Product.class);
}
// 布隆过滤器预检
RBloomFilter<Long> bloom = redissonClient.getBloomFilter("product:bloom");
if (!bloom.contains(id)) return null;
// 击穿防护:互斥锁
RLock lock = redissonClient.getLock("lock:" + key);
try {
if (lock.tryLock(5, 30, TimeUnit.SECONDS)) {
// Double-check
cached = redisTemplate.opsForValue().get(key);
if (cached != null) return JSON.parseObject(cached, Product.class);
Product p = productMapper.selectById(id);
long ttl = 3600 + ThreadLocalRandom.current().nextLong(600);
if (p != null) {
redisTemplate.opsForValue().set(key, toJSON(p), ttl, SECONDS);
} else {
redisTemplate.opsForValue().set(key, "NULL", 300, SECONDS);
}
return p;
}
} finally {
if (lock.isHeldByCurrentThread()) lock.unlock();
}
return null;
}
}
Trade-off:强一致性(写DB后同步删缓存)vs 最终一致性(异步删缓存+延迟双删)。大多数场景选最终一致性。
用户输入"jav" → 前端防抖300ms → 后端查询Redis ZSet → 返回Top10
索引构建:
"java" → 每个前缀建Sorted Set:
suggest:j → {java:100, javascript:80, ...}
suggest:ja → {java:100, javascript:80, ...}
suggest:jav → {java:100, javascript:80, ...}
suggest:java → {java:100}
@Service
public class SearchSuggestService {
@Autowired
private StringRedisTemplate redisTemplate;
// 构建索引
public void index(String term, int score) {
for (int i = 1; i <= Math.min(term.length(), 10); i++) {
String prefix = term.substring(0, i).toLowerCase();
redisTemplate.opsForZSet().add("suggest:" + prefix, term, score);
}
}
// 查询建议
public List<String> suggest(String query, int limit) {
Set<String> result = redisTemplate.opsForZSet()
.reverseRange("suggest:" + query.toLowerCase(), 0, limit - 1);
return result != null ? new ArrayList<>(result) : Collections.emptyList();
}
// 更新搜索热度
public void recordSearch(String term) {
for (int i = 1; i <= Math.min(term.length(), 10); i++) {
String prefix = term.substring(0, i).toLowerCase();
redisTemplate.opsForZSet().incrementScore("suggest:" + prefix, term, 1);
}
}
}
Trade-off:前缀ZSet方案(简单,空间换时间)vs Trie树(省空间,实现复杂)。Redis ZSet方案更常用。
任务管理 → [Redis ZSet延迟队列] → [调度器争抢执行]
│
┌────────────┼────────────┐
↓ ↓ ↓
节点A 节点B 节点C
(抢锁执行) (抢锁执行) (抢锁执行)
关键:Redis ZREM原子操作保证任务只被一个节点消费
@Service
public class DelayQueueService {
@Autowired
private StringRedisTemplate redisTemplate;
// 添加延迟任务
public void addTask(String taskId, long executeTimeMs) {
redisTemplate.opsForZSet().add("delay:queue", taskId, executeTimeMs);
}
// 消费到期任务(定时轮询)
@Scheduled(fixedRate = 1000)
public void consume() {
long now = System.currentTimeMillis();
Set<String> tasks = redisTemplate.opsForZSet()
.rangeByScore("delay:queue", 0, now);
if (tasks == null) return;
for (String taskId : tasks) {
// 原子移除(只有一次成功)
Boolean removed = redisTemplate.opsForZSet()
.remove("delay:queue", taskId);
if (Boolean.TRUE.equals(removed)) {
executeTask(taskId);
}
}
}
}
Trade-off:Redis ZSet轮询(简单,有1s延迟)vs Redisson延迟队列(精确,依赖重)vs MQ延迟消息(推荐,RocketMQ支持18级延迟)。
业务事件 → [事件总线] → [MQ] → [通知路由] → 渠道适配器
│
┌──────────┬───────┼───────┬──────────┐
↓ ↓ ↓ ↓ ↓
[站内信] [短信] [邮件] [APP推送] [WebPush]
│ │ │ │ │
└──────────┴───────┴───────┴──────────┘
↓
[发送状态记录]
@Service
public class NotificationService {
@Autowired
private NotificationTemplateMapper templateMapper;
// 统一发送入口
public void send(NotificationEvent event) {
// 1. 加载模板并渲染
String content = renderTemplate(event.getTemplateId(), event.getParams());
event.setContent(content);
// 2. 频率检查
if (!checkRateLimit(event.getUserId(), event.getChannel())) {
return; // 超频,丢弃
}
// 3. 投递到MQ
mqTemplate.syncSend("notification-topic",
MessageBuilder.withPayload(event)
.setTags(event.getChannel().name()).build());
}
// 模板渲染
private String renderTemplate(Long templateId, Map<String, String> params) {
NotificationTemplate tpl = templateMapper.selectById(templateId);
String content = tpl.getContent();
for (Map.Entry<String, String> e : params.entrySet()) {
content = content.replace("${" + e.getKey() + "}", e.getValue());
}
return content;
}
}
Trade-off:同步发送(实时性好,阻塞业务)vs 异步MQ发送(解耦削峰,有延迟)。生产选异步MQ。
客户端 ──→ [Nginx(LB)] ──→ [Spring Cloud Gateway集群]
│
┌───────────────┼───────────────┐
↓ ↓ ↓
[Auth Filter] [RateLimit] [LogFilter]
(JWT校验) (Redis令牌桶) (链路追踪)
│ │ │
└───────────────┼───────────────┘
↓
┌───────────────┼───────────────┐
↓ ↓ ↓
[用户服务] [订单服务] [商品服务]
# application.yml - Gateway路由配置
spring:
cloud:
gateway:
routes:
- id: user-service
uri: lb://user-service
predicates:
- Path=/api/user/**
filters:
- name: RequestRateLimiter
args:
redis-rate-limiter.replenishRate: 100
redis-rate-limiter.burstCapacity: 200
key-resolver: "#{@userKeyResolver}"
@Component
public class JwtAuthFilter implements GlobalFilter {
@Override
public Mono<Void> filter(ServerWebExchange ctx, GatewayFilterChain chain) {
String token = ctx.getRequest().getHeaders().getFirst("Authorization");
if (token == null || !validateJwt(token)) {
ctx.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
return ctx.getResponse().setComplete();
}
// 解析userId放入header,下游服务可直接使用
String userId = parseUserId(token);
ctx.getRequest().mutate().header("X-User-Id", userId).build();
return chain.filter(ctx);
}
}
Trade-off:网关层认证(统一,但耦合)vs 服务层认证(灵活,但重复)。推荐网关做粗粒度认证,服务做细粒度鉴权。
| 指标 | 值 |
|---|---|
| 参与用户 | 100万 |
| 商品库存 | 1万件 |
| 峰值QPS | 10万 |
| 秒杀窗口 | 10秒 |
前端 → [CDN静态化] → [Nginx限流] → [Gateway] → [秒杀服务]
│
┌───────┼───────┐
↓ ↓ ↓
[Redis] [MQ] [DB]
(预扣库存) (异步) (最终落单)
@Service
public class SeckillService {
@Autowired
private StringRedisTemplate redisTemplate;
@Autowired
private RedissonClient redissonClient;
// 秒杀前:库存预热到Redis
public void preloadStock(Long productId, int stock) {
redisTemplate.opsForValue().set("seckill:stock:" + productId,
String.valueOf(stock));
}
// 秒杀核心:Redis Lua原子扣减
private static final String SECKILL_LUA =
"local stock = tonumber(redis.call('GET', KEYS[1]))\n" +
"if stock <= 0 then return 0 end\n" +
"redis.call('DECR', KEYS[1])\n" +
"return 1";
public SeckillResult seckill(Long userId, Long productId) {
// 1. 幂等检查
Boolean existed = redisTemplate.opsForSet()
.isMember("seckill:users:" + productId, userId.toString());
if (Boolean.TRUE.equals(existed)) {
return SeckillResult.fail("已参与过");
}
// 2. Lua原子扣库存
Long result = redisTemplate.execute(
new DefaultRedisScript<>(SECKILL_LUA, Long.class),
List.of("seckill:stock:" + productId));
if (result == null || result == 0) {
return SeckillResult.fail("已售罄");
}
// 3. 记录已购买用户(防重复)
redisTemplate.opsForSet().add("seckill:users:" + productId,
userId.toString());
// 4. 异步创建订单
mqTemplate.asyncSend("seckill-order-topic",
MessageBuilder.withPayload(
new SeckillOrder(userId, productId)).build());
return SeckillResult.success("排队中");
}
}
Trade-off:同步下单(实时反馈但吞吐低)vs 异步排队(高吞吐但用户需轮询结果)。秒杀场景必须选异步。
| 题号 | 题目 | 核心考点 | 关键技术 |
|---|---|---|---|
| 1 | 短链系统 | ID生成 + 缓存 | 雪花算法、Redis、302 |
| 2 | 消息推送 | 多渠道 + 异步投递 | MQ、WebSocket、APNs |
| 3 | 朋友圈 | 推拉模型 + 时间线排序 | Redis List、推拉结合 |
| 4 | 限流器 | 限流算法 + 分布式 | Lua脚本、令牌桶 |
| 5 | 分布式缓存 | 穿透/击穿/雪崩 | 布隆过滤器、互斥锁 |
| 6 | 搜索建议 | 前缀匹配 + TopK | Redis ZSet |
| 7 | 定时任务 | 延迟队列 + 分布式锁 | Redis ZSet、Redisson |
| 8 | 通知系统 | 多渠道 + 模板渲染 | MQ、模板引擎 |
| 9 | API网关 | 路由 + 鉴权 + 限流 | Gateway、JWT |
| 10 | 秒杀系统 | 防超卖 + 削峰 | Lua原子扣减、MQ异步 |
1. 重复问题(确认理解)
"您是要设计XXX系统对吗?我确认几个关键点..."
2. 给出高层设计(先画大图)
"整体分N个组件,分别是..."
3. 选择一个关键点深入(展示深度)
"其中XXX最关键,我来详细说..."
4. 主动讨论trade-off(展示思维广度)
"这里有两个方案:A的优点是...B相反..."
5. 提出可扩展性思考(展示系统思维)
"如果量级再增长10倍,我会..."
6. 收尾总结
"总结一下,核心思路是..."
选一道未讲过的题(如"设计一个短视频推荐系统"),用四步法写一份答案提纲。
针对秒杀系统,写出以下三个方案的Trade-off分析:
1. 同步扣库存 vs 异步扣库存
2. MySQL悲观锁 vs Redis Lua扣库存
3. 单节点限流 vs 分布式限流
为"消息推送系统"画一张更详细的ASCII架构图,包含:
找同学互相面试,从10道题中随机抽2道,每道限时15分钟,用四步法回答。