← 返回首页 📚 实战课程
📑 本篇章节导航 (共14章,点击直达)
系统设计面试四步法第1题:URL短链接系统第2题:消息推送系统第3题:朋友圈/动态流第4题:限流器第5题:分布式缓存第6题:搜索建议(Search Autocomplete)第7题:定时任务调度第8题:通知系统第9题:API网关第10题:秒杀系统十题速查总结面试回答通用框架四、练习篇(10%)

P4-06 - 系统设计面试题精讲

定位:系统设计面试总是不知道从哪开始、答不到点子上。本节精选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分钟

第1题:URL短链接系统

Step 1:澄清需求

Step 2:规模估算

指标值
写QPS100万/86400 = 12/s
读QPS100万 x 1000 / 86400 = 12K/s
存储100万/天 x 1KB x 365天 = 365GB/年
缓存热点100万条 x 1KB = 1GB

Step 3:高层设计


写入流程:
客户端 ──→ [API Gateway] ──→ [短链服务] ──→ 生成短码
              │                              │
              │                    ┌─────────┼─────────┐
              │                    ↓         ↓         ↓
              │                [Redis]    [MySQL]   [异步MQ]
              │                 热缓存     持久化    数据同步

读取流程:
客户端 ──→ [API Gateway] ──→ [短链服务] ──→ 查Redis → 302重定向
                                           │
                                           miss → 查MySQL → 回写Redis

Step 4:深入设计


@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(临时重定向,每次经过服务端,可统计点击)。


第2题:消息推送系统

Step 1:澄清需求

Step 2:规模估算

指标值
峰值QPS10万
日消息量5000万条
存储5000万 x 1KB = 50GB/天
在线连接数200万(20%在线)

Step 3:高层设计


业务系统 ──→ [消息API] ──→ [MQ] ──→ [消息路由服务]
                                     │
                    ┌────────────────┼────────────────┐
                    ↓                ↓                ↓
              [APP推送]         [WebSocket]      [短信/邮件]
            (Firebase/APNs)    (Netty集群)     (第三方SDK)
                    │                │                │
                    └────────────────┼────────────────┘
                                     ↓
                              [消息状态存储]
                            (已读/未读/发送状态)

Step 4:深入设计


@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"恰好一次"。至少一次实现简单,业务需要幂等;恰好一次开销大,需要去重表。


第3题:朋友圈/动态流

Step 1:澄清需求

Step 2:规模估算

指标值
写QPS50万/天 = 6/s
读QPS5000万 x 10次 = 5800/s
存储动态50万/天 x 1KB = 500MB/天

Step 3:高层设计


写路径(推模式):
用户发动态 → 写入发件箱 → 推送到粉丝收件箱(Redis List)

读路径(拉模式补充大V):
用户刷新 → 合并[收件箱 + 关注大V的发件箱] → 排序 → 返回

推拉结合策略:
  普通用户(<1000粉丝) → 推模式
  大V(>1000粉丝)     → 拉模式(不推,读时拉取)

Step 4:深入设计


@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:推模式写放大(粉丝多时写入量大)但读快;拉模式写轻但读时需要合并排序。推拉结合是最佳平衡。


第4题:限流器

Step 1:澄清需求

Step 2:规模估算

Step 3:高层设计


客户端 → [网关限流(Guava RateLimiter)] → [分布式限流(Redis+Lua)] → 服务

两层限流:
  第一层:本地令牌桶(快速拒绝,无网络开销)
  第二层:Redis滑动窗口(精确控制总量)

Step 4:深入设计


@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 漏桶(匀速输出)。大多数场景用令牌桶更灵活。


第5题:分布式缓存

Step 1:澄清需求

Step 2:高层设计


客户端 → [本地缓存(Caffeine)] → [Redis集群] → [MySQL]
           L1 (ms级过期)         L2 (min级过期)   持久层

穿透防护: 布隆过滤器 + 空值缓存(TTL 5min)
击穿防护: 互斥锁(Redisson) + 逻辑过期
雪崩防护: 随机过期时间(基准TTL ± 随机偏移)

Step 4:深入设计


@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 最终一致性(异步删缓存+延迟双删)。大多数场景选最终一致性。


第6题:搜索建议(Search Autocomplete)

Step 1:澄清需求

Step 3:高层设计


用户输入"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}

Step 4:深入设计


@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方案更常用。


第7题:定时任务调度

Step 1:澄清需求

Step 3:高层设计


任务管理 → [Redis ZSet延迟队列] → [调度器争抢执行]
                     │
        ┌────────────┼────────────┐
        ↓            ↓            ↓
     节点A          节点B        节点C
   (抢锁执行)    (抢锁执行)    (抢锁执行)

关键:Redis ZREM原子操作保证任务只被一个节点消费

Step 4:深入设计


@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级延迟)。


第8题:通知系统

Step 1:澄清需求

Step 3:高层设计


业务事件 → [事件总线] → [MQ] → [通知路由] → 渠道适配器
                                       │
                    ┌──────────┬───────┼───────┬──────────┐
                    ↓          ↓       ↓       ↓          ↓
                 [站内信]    [短信]  [邮件]  [APP推送]  [WebPush]
                    │          │       │       │          │
                    └──────────┴───────┴───────┴──────────┘
                                       ↓
                               [发送状态记录]

Step 4:深入设计


@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。


第9题:API网关

Step 1:澄清需求

Step 3:高层设计


客户端 ──→ [Nginx(LB)] ──→ [Spring Cloud Gateway集群]
                                    │
                    ┌───────────────┼───────────────┐
                    ↓               ↓               ↓
              [Auth Filter]   [RateLimit]     [LogFilter]
              (JWT校验)       (Redis令牌桶)    (链路追踪)
                    │               │               │
                    └───────────────┼───────────────┘
                                    ↓
                    ┌───────────────┼───────────────┐
                    ↓               ↓               ↓
              [用户服务]       [订单服务]       [商品服务]

Step 4:深入设计


# 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 服务层认证(灵活,但重复)。推荐网关做粗粒度认证,服务做细粒度鉴权。


第10题:秒杀系统

Step 1:澄清需求

Step 2:规模估算

指标值
参与用户100万
商品库存1万件
峰值QPS10万
秒杀窗口10秒

Step 3:高层设计


前端 → [CDN静态化] → [Nginx限流] → [Gateway] → [秒杀服务]
                                                    │
                                            ┌───────┼───────┐
                                            ↓       ↓       ↓
                                         [Redis]  [MQ]   [DB]
                                      (预扣库存) (异步)  (最终落单)

Step 4:深入设计


@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搜索建议前缀匹配 + TopKRedis ZSet
7定时任务延迟队列 + 分布式锁Redis ZSet、Redisson
8通知系统多渠道 + 模板渲染MQ、模板引擎
9API网关路由 + 鉴权 + 限流Gateway、JWT
10秒杀系统防超卖 + 削峰Lua原子扣减、MQ异步

面试回答通用框架


1. 重复问题(确认理解)
   "您是要设计XXX系统对吗?我确认几个关键点..."

2. 给出高层设计(先画大图)
   "整体分N个组件,分别是..."

3. 选择一个关键点深入(展示深度)
   "其中XXX最关键,我来详细说..."

4. 主动讨论trade-off(展示思维广度)
   "这里有两个方案:A的优点是...B相反..."

5. 提出可扩展性思考(展示系统思维)
   "如果量级再增长10倍,我会..."

6. 收尾总结
   "总结一下,核心思路是..."

四、练习篇(10%)

练习1:用四步法答一道新题

选一道未讲过的题(如"设计一个短视频推荐系统"),用四步法写一份答案提纲。

练习2:Trade-off分析

针对秒杀系统,写出以下三个方案的Trade-off分析:

1. 同步扣库存 vs 异步扣库存

2. MySQL悲观锁 vs Redis Lua扣库存

3. 单节点限流 vs 分布式限流

练习3:架构图练习

为"消息推送系统"画一张更详细的ASCII架构图,包含:

练习4:模拟面试

找同学互相面试,从10道题中随机抽2道,每道限时15分钟,用四步法回答。