分布式秒杀系统设计方案

分布式秒杀系统设计方案

目录

1. 系统架构设计
2. 技术栈选型
3. 核心流程分析
4. 详细代码实现
5. 性能优化策略
6. 监控和降级机制
7. 性能分析

系统架构设计

整体架构图

                    ┌─────────────────┐
                    │   CDN + 静态页面  │
                    └─────────────────┘
                              │
                    ┌─────────────────┐
                    │   Nginx 负载均衡  │
                    └─────────────────┘
                              │
              ┌───────────────┼───────────────┐
              │               │               │
    ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
    │  Gateway 网关    │ │  Gateway 网关    │ │  Gateway 网关    │
    └─────────────────┘ └─────────────────┘ └─────────────────┘
              │               │               │
    ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
    │ 秒杀服务集群      │ │ 秒杀服务集群      │ │ 秒杀服务集群      │
    └─────────────────┘ └─────────────────┘ └─────────────────┘
              │               │               │
              └───────────────┼───────────────┘
                              │
                    ┌─────────────────┐
                    │   Redis 集群     │
                    │  (缓存+分布式锁)  │
                    └─────────────────┘
                              │
                    ┌─────────────────┐
                    │  RocketMQ 集群   │
                    │   (异步处理)     │
                    └─────────────────┘
                              │
                    ┌─────────────────┐
                    │  MySQL 集群      │
                    │  (分库分表)      │
                    └─────────────────┘

核心组件说明

1. 接入层

• CDN: 静态资源缓存，减少服务器压力
• Nginx: 负载均衡，请求分发，限流
• API Gateway: 统一入口，认证，限流，熔断

2. 应用层

• 秒杀服务: 核心业务逻辑处理
• 用户服务: 用户认证和信息管理
• 商品服务: 商品信息管理
• 订单服务: 订单处理和管理
• 支付服务: 支付处理

3. 中间件层

• Redis集群: 缓存热点数据，分布式锁
• RocketMQ: 异步消息处理，削峰填谷
• Elasticsearch: 日志分析和搜索

4. 数据层

• MySQL主从集群: 持久化存储，读写分离
• 分库分表: 水平扩展，提升性能

技术栈选型

后端技术栈

1框架选型:
2  - Spring Boot 2.7.x: 微服务框架
3  - Spring Cloud Alibaba: 微服务治理
4  - Spring Security: 安全框架
5  - MyBatis Plus: ORM框架
6
7中间件选型:
8  - Redis 6.x: 缓存和分布式锁
9  - RocketMQ 4.x: 消息队列
10  - MySQL 8.0: 关系型数据库
11  - Nginx: 负载均衡和反向代理
12  - Sentinel: 流量控制和熔断降级
13
14监控运维:
15  - Prometheus: 监控指标收集
16  - Grafana: 监控大盘
17  - ELK Stack: 日志收集和分析
18  - Docker + K8s: 容器化部署
19

数据库设计

1-- 商品表 (分库分表)
2CREATE TABLE `seckill_product` (
3  [`id`](https://xplanc.org/primers/document/zh/10.Bash/90.%E5%B8%AE%E5%8A%A9%E6%89%8B%E5%86%8C/EX.id.md) bigint NOT NULL AUTO_INCREMENT,
4  `product_id` bigint NOT NULL COMMENT '商品ID',
5  `product_name` varchar(255) NOT NULL COMMENT '商品名称',
6  `original_price` decimal(10,2) NOT NULL COMMENT '原价',
7  `seckill_price` decimal(10,2) NOT NULL COMMENT '秒杀价',
8  `stock_count` int NOT NULL COMMENT '库存数量',
9  `start_time` datetime NOT NULL COMMENT '开始时间',
10  `end_time` datetime NOT NULL COMMENT '结束时间',
11  `status` tinyint DEFAULT '0' COMMENT '状态 0:未开始 1:进行中 2:已结束',
12  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
13  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
14  PRIMARY KEY ([`id`](https://xplanc.org/primers/document/zh/10.Bash/90.%E5%B8%AE%E5%8A%A9%E6%89%8B%E5%86%8C/EX.id.md)),
15  UNIQUE KEY `uk_product_id` (`product_id`),
16  KEY `idx_start_time` (`start_time`),
17  KEY `idx_status` (`status`)
18) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
19
20-- 订单表 (分库分表)
21CREATE TABLE `seckill_order` (
22  [`id`](https://xplanc.org/primers/document/zh/10.Bash/90.%E5%B8%AE%E5%8A%A9%E6%89%8B%E5%86%8C/EX.id.md) bigint NOT NULL AUTO_INCREMENT,
23  `order_id` varchar(64) NOT NULL COMMENT '订单ID',
24  `user_id` bigint NOT NULL COMMENT '用户ID',
25  `product_id` bigint NOT NULL COMMENT '商品ID',
26  `quantity` int NOT NULL DEFAULT '1' COMMENT '购买数量',
27  `amount` decimal(10,2) NOT NULL COMMENT '订单金额',
28  `status` tinyint DEFAULT '0' COMMENT '订单状态 0:待支付 1:已支付 2:已取消',
29  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
30  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
31  PRIMARY KEY ([`id`](https://xplanc.org/primers/document/zh/10.Bash/90.%E5%B8%AE%E5%8A%A9%E6%89%8B%E5%86%8C/EX.id.md)),
32  UNIQUE KEY `uk_order_id` (`order_id`),
33  UNIQUE KEY `uk_user_product` (`user_id`, `product_id`),
34  KEY `idx_user_id` (`user_id`),
35  KEY `idx_product_id` (`product_id`),
36  KEY `idx_create_time` (`create_time`)
37) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
38
39-- 库存流水表
40CREATE TABLE `stock_log` (
41  [`id`](https://xplanc.org/primers/document/zh/10.Bash/90.%E5%B8%AE%E5%8A%A9%E6%89%8B%E5%86%8C/EX.id.md) bigint NOT NULL AUTO_INCREMENT,
42  `product_id` bigint NOT NULL COMMENT '商品ID',
43  `user_id` bigint NOT NULL COMMENT '用户ID',
44  `order_id` varchar(64) NOT NULL COMMENT '订单ID',
45  `stock_count` int NOT NULL COMMENT '扣减库存数',
46  `operation_type` tinyint NOT NULL COMMENT '操作类型 1:扣减 2:回滚',
47  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
48  PRIMARY KEY ([`id`](https://xplanc.org/primers/document/zh/10.Bash/90.%E5%B8%AE%E5%8A%A9%E6%89%8B%E5%86%8C/EX.id.md)),
49  KEY `idx_product_id` (`product_id`),
50  KEY `idx_order_id` (`order_id`)
51) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
52

核心流程分析

1. 秒杀整体流程

用户 CDN Nginx API网关 秒杀服务 Redis RocketMQ 订单服务 MySQL 1. 访问秒杀页面 2. 返回静态页面 3. 发起秒杀请求 4. 负载均衡转发 5. 路由到秒杀服务 6. 检查用户是否已购买 7. 返回检查结果 8. 尝试扣减库存(Lua脚本) 9. 返回扣减结果 10. 发送订单消息 11. 返回秒杀结果 12. 异步处理订单 13. 创建订单记录 用户 CDN Nginx API网关 秒杀服务 Redis RocketMQ 订单服务 MySQL

2. 缓存预热流程

1/**
2 * 缓存预热策略
3 * 1. 定时任务预热热点商品
4 * 2. 分批次预热避免缓存雪崩
5 * 3. 设置合理的过期时间
6 */
7@Component
8public class CacheWarmUpService {
9    
10    @Scheduled(cron = "0 0 8 * * ?") // 每天8点执行
11    public void warmUpCache() {
12        // 预热逻辑
13    }
14}
15

3. 库存扣减流程

1-- Redis Lua脚本保证原子性
2local key = KEYS[1]
3local quantity = tonumber(ARGV[1])
4local stock = redis.call('GET', key)
5
6if stock == false then
7    return -1  -- 商品不存在
8end
9
10stock = tonumber(stock)
11if stock < quantity then
12    return 0   -- 库存不足
13end
14
15redis.call('DECRBY', key, quantity)
16return 1       -- 扣减成功
17

详细代码实现

1. 秒杀核心服务实现

1@RestController
2@RequestMapping("/api/seckill")
3@Slf4j
4public class SeckillController {
5
6    @Autowired
7    private SeckillService seckillService;
8    
9    @Autowired
10    private RedisTemplate<String, Object> redisTemplate;
11    
12    @Autowired
13    private RateLimiter rateLimiter;
14
15    /**
16     * 秒杀接口
17     * @param productId 商品ID
18     * @param userId 用户ID
19     * @return 秒杀结果
20     */
21    @PostMapping("/kill/{productId}")
22    @RateLimiter(key = "seckill", permitsPerSecond = 1000, timeout = 100)
23    public Result<String> seckill(@PathVariable Long productId, 
24                                  @RequestParam Long userId) {
25        try {
26            // 1. 参数校验
27            if (productId == null || userId == null) {
28                return Result.fail("参数错误");
29            }
30
31            // 2. 限流检查
32            if (!rateLimiter.tryAcquire()) {
33                return Result.fail("系统繁忙，请稍后重试");
34            }
35
36            // 3. 重复购买检查
37            String userKey = String.format("seckill:user:%s:%s", userId, productId);
38            if (redisTemplate.hasKey(userKey)) {
39                return Result.fail("您已经参与过此次秒杀");
40            }
41
42            // 4. 执行秒杀
43            String result = seckillService.doSeckill(productId, userId);
44            
45            return Result.success(result);
46            
47        } catch (SeckillException e) {
48            log.error("秒杀异常: productId={}, userId={}, error={}", 
49                     productId, userId, e.getMessage());
50            return Result.fail(e.getMessage());
51        } catch (Exception e) {
52            log.error("系统异常: productId={}, userId={}", productId, userId, e);
53            return Result.fail("系统异常，请稍后重试");
54        }
55    }
56}
57

2. 秒杀服务核心实现

1@Service
2@Slf4j
3public class SeckillServiceImpl implements SeckillService {
4
5    @Autowired
6    private RedisTemplate<String, Object> redisTemplate;
7    
8    @Autowired
9    private RocketMQTemplate rocketMQTemplate;
10    
11    @Autowired
12    private DistributedLock distributedLock;
13
14    private static final String STOCK_KEY_PREFIX = "seckill:stock:";
15    private static final String USER_KEY_PREFIX = "seckill:user:";
16    private static final String LOCK_KEY_PREFIX = "seckill:lock:";
17
18    /**
19     * 执行秒杀
20     */
21    @Override
22    public String doSeckill(Long productId, Long userId) throws SeckillException {
23        
24        // 1. 构建Redis键
25        String stockKey = STOCK_KEY_PREFIX + productId;
26        String userKey = USER_KEY_PREFIX + userId + ":" + productId;
27        String lockKey = LOCK_KEY_PREFIX + productId;
28
29        // 2. 获取分布式锁
30        String lockValue = distributedLock.tryLock(lockKey, 5000, 10000);
31        if (lockValue == null) {
32            throw new SeckillException("系统繁忙，请稍后重试");
33        }
34
35        try {
36            // 3. 检查商品是否存在和活动是否开始
37            if (!checkSeckillActivity(productId)) {
38                throw new SeckillException("秒杀活动未开始或已结束");
39            }
40
41            // 4. 检查用户是否已经购买过
42            if (redisTemplate.hasKey(userKey)) {
43                throw new SeckillException("您已经参与过此次秒杀");
44            }
45
46            // 5. 尝试扣减库存
47            Long stock = decreaseStock(stockKey, 1);
48            if (stock < 0) {
49                throw new SeckillException("商品库存不足");
50            }
51
52            // 6. 标记用户已购买
53            redisTemplate.opsForValue().set(userKey, "1", Duration.ofHours(24));
54
55            // 7. 生成订单ID
56            String orderId = generateOrderId();
57
58            // 8. 发送异步消息创建订单
59            SeckillOrderMessage message = SeckillOrderMessage.builder()
60                    .orderId(orderId)
61                    .userId(userId)
62                    .productId(productId)
63                    .quantity(1)
64                    .build();
65
66            rocketMQTemplate.convertAndSend("seckill-order-topic", message);
67
68            log.info("秒杀成功: orderId={}, userId={}, productId={}", 
69                    orderId, userId, productId);
70
71            return orderId;
72
73        } finally {
74            // 9. 释放分布式锁
75            distributedLock.releaseLock(lockKey, lockValue);
76        }
77    }
78
79    /**
80     * 扣减库存 - 使用Lua脚本保证原子性
81     */
82    private Long decreaseStock(String stockKey, int quantity) {
83        String luaScript = 
84            "local stock = redis.call('GET', KEYS[1]) " +
85            "if stock == false then return -1 end " +
86            "stock = tonumber(stock) " +
87            "if stock < tonumber(ARGV[1]) then return -1 end " +
88            "redis.call('DECRBY', KEYS[1], ARGV[1]) " +
89            "return redis.call('GET', KEYS[1])";
90
91        RedisScript<Long> script = RedisScript.of(luaScript, Long.class);
92        return redisTemplate.execute(script, Collections.singletonList(stockKey), quantity);
93    }
94
95    /**
96     * 检查秒杀活动状态
97     */
98    private boolean checkSeckillActivity(Long productId) {
99        String activityKey = "seckill:activity:" + productId;
100        Object activity = redisTemplate.opsForValue().get(activityKey);
101        
102        if (activity == null) {
103            // 从数据库查询并缓存
104            // 这里省略具体实现
105            return false;
106        }
107        
108        // 检查活动时间等
109        return true;
110    }
111
112    /**
113     * 生成订单ID
114     */
115    private String generateOrderId() {
116        return "SK" + System.currentTimeMillis() + 
117               String.format("%04d", new Random().nextInt(10000));
118    }
119}
120

3. 分布式锁实现

1@Component
2@Slf4j
3public class RedisDistributedLock implements DistributedLock {
4
5    @Autowired
6    private RedisTemplate<String, Object> redisTemplate;
7
8    private static final String LOCK_SUCCESS = "OK";
9    private static final String SET_IF_NOT_EXIST = "NX";
10    private static final String SET_WITH_EXPIRE_TIME = "PX";
11
12    /**
13     * 尝试获取分布式锁
14     * @param lockKey 锁的键
15     * @param requestId 请求标识
16     * @param expireTime 超期时间
17     * @return 是否获取成功
18     */
19    @Override
20    public String tryLock(String lockKey, long waitTime, long expireTime) {
21        String requestId = UUID.randomUUID().toString();
22        long startTime = System.currentTimeMillis();
23        
24        while (System.currentTimeMillis() - startTime < waitTime) {
25            String result = (String) redisTemplate.execute((RedisCallback<String>) connection -> {
26                Jedis jedis = (Jedis) connection.getNativeConnection();
27                return jedis.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);
28            });
29            
30            if (LOCK_SUCCESS.equals(result)) {
31                log.debug("获取锁成功: lockKey={}, requestId={}", lockKey, requestId);
32                return requestId;
33            }
34            
35            try {
36                Thread.sleep(10);
37            } catch (InterruptedException e) {
38                Thread.currentThread().interrupt();
39                break;
40            }
41        }
42        
43        log.warn("获取锁失败: lockKey={}", lockKey);
44        return null;
45    }
46
47    /**
48     * 释放分布式锁
49     * @param lockKey 锁的键
50     * @param requestId 请求标识
51     * @return 是否释放成功
52     */
53    @Override
54    public boolean releaseLock(String lockKey, String requestId) {
55        String luaScript = 
56            "if redis.call('get', KEYS[1]) == ARGV[1] then " +
57            "return redis.call('del', KEYS[1]) " +
58            "else return 0 end";
59
60        RedisScript<Long> script = RedisScript.of(luaScript, Long.class);
61        Long result = redisTemplate.execute(script, 
62                Collections.singletonList(lockKey), requestId);
63
64        boolean success = result != null && result > 0;
65        log.debug("释放锁{}: lockKey={}, requestId={}", 
66                success ? "成功" : "失败", lockKey, requestId);
67        
68        return success;
69    }
70}
71

4. 限流实现

1@Component
2@Slf4j
3public class RedisRateLimiter {
4
5    @Autowired
6    private RedisTemplate<String, Object> redisTemplate;
7
8    /**
9     * 基于滑动窗口的限流算法
10     * @param key 限流键
11     * @param limit 限流数量
12     * @param window 时间窗口(秒)
13     * @return 是否允许通过
14     */
15    public boolean tryAcquire(String key, int limit, int window) {
16        String luaScript = 
17            "local key = KEYS[1] " +
18            "local window = tonumber(ARGV[1]) " +
19            "local limit = tonumber(ARGV[2]) " +
20            "local current = tonumber(ARGV[3]) " +
21            
22            "redis.call('zremrangebyscore', key, 0, current - window * 1000) " +
23            "local count = redis.call('zcard', key) " +
24            
25            "if count < limit then " +
26            "  redis.call('zadd', key, current, current) " +
27            "  redis.call('expire', key, window) " +
28            "  return 1 " +
29            "else " +
30            "  return 0 " +
31            "end";
32
33        RedisScript<Long> script = RedisScript.of(luaScript, Long.class);
34        Long result = redisTemplate.execute(script, 
35                Collections.singletonList(key), 
36                window, limit, System.currentTimeMillis());
37
38        return result != null && result > 0;
39    }
40
41    /**
42     * 令牌桶限流算法
43     */
44    public boolean tryAcquireWithTokenBucket(String key, int capacity, int refillRate) {
45        String luaScript = 
46            "local key = KEYS[1] " +
47            "local capacity = tonumber(ARGV[1]) " +
48            "local tokens = tonumber(ARGV[2]) " +
49            "local interval = tonumber(ARGV[3]) " +
50            "local now = tonumber(ARGV[4]) " +
51            
52            "local bucket = redis.call('hmget', key, 'last_refill_time', 'tokens') " +
53            "local last_refill_time = bucket[1] " +
54            "local current_tokens = bucket[2] " +
55            
56            "if last_refill_time == false then " +
57            "  last_refill_time = now " +
58            "  current_tokens = capacity " +
59            "else " +
60            "  last_refill_time = tonumber(last_refill_time) " +
61            "  current_tokens = tonumber(current_tokens) " +
62            "  " +
63            "  local elapsed = math.max(0, now - last_refill_time) " +
64            "  local tokens_to_add = math.floor(elapsed / interval * tokens) " +
65            "  current_tokens = math.min(capacity, current_tokens + tokens_to_add) " +
66            "end " +
67            
68            "if current_tokens < 1 then " +
69            "  redis.call('hmset', key, 'last_refill_time', now, 'tokens', current_tokens) " +
70            "  redis.call('expire', key, 3600) " +
71            "  return 0 " +
72            "else " +
73            "  current_tokens = current_tokens - 1 " +
74            "  redis.call('hmset', key, 'last_refill_time', now, 'tokens', current_tokens) " +
75            "  redis.call('expire', key, 3600) " +
76            "  return 1 " +
77            "end";
78
79        RedisScript<Long> script = RedisScript.of(luaScript, Long.class);
80        Long result = redisTemplate.execute(script, 
81                Collections.singletonList(key), 
82                capacity, refillRate, 1000, System.currentTimeMillis());
83
84        return result != null && result > 0;
85    }
86}
87

5. 消息队列处理

1@Component
2@RocketMQMessageListener(
3    topic = "seckill-order-topic",
4    consumerGroup = "seckill-order-consumer"
5)
6@Slf4j
7public class SeckillOrderConsumer implements RocketMQListener<SeckillOrderMessage> {
8
9    @Autowired
10    private OrderService orderService;
11    
12    @Autowired
13    private StockService stockService;
14
15    @Override
16    public void onMessage(SeckillOrderMessage message) {
17        log.info("收到秒杀订单消息: {}", message);
18        
19        try {
20            // 1. 创建订单
21            createOrder(message);
22            
23            // 2. 记录库存流水
24            recordStockLog(message);
25            
26            log.info("处理秒杀订单成功: orderId={}", message.getOrderId());
27            
28        } catch (Exception e) {
29            log.error("处理秒杀订单失败: orderId={}, error={}", 
30                     message.getOrderId(), e.getMessage(), e);
31            
32            // 回滚库存
33            rollbackStock(message);
34            throw e;
35        }
36    }
37
38    private void createOrder(SeckillOrderMessage message) {
39        SeckillOrder order = SeckillOrder.builder()
40                .orderId(message.getOrderId())
41                .userId(message.getUserId())
42                .productId(message.getProductId())
43                .quantity(message.getQuantity())
44                .status(OrderStatus.PENDING_PAYMENT.getCode())
45                .createTime(new Date())
46                .build();
47
48        orderService.createOrder(order);
49    }
50
51    private void recordStockLog(SeckillOrderMessage message) {
52        StockLog stockLog = StockLog.builder()
53                .productId(message.getProductId())
54                .userId(message.getUserId())
55                .orderId(message.getOrderId())
56                .stockCount(message.getQuantity())
57                .operationType(StockOperationType.DECREASE.getCode())
58                .createTime(new Date())
59                .build();
60
61        stockService.recordStockLog(stockLog);
62    }
63
64    private void rollbackStock(SeckillOrderMessage message) {
65        try {
66            stockService.rollbackStock(message.getProductId(), message.getQuantity());
67            log.info("回滚库存成功: productId={}, quantity={}", 
68                    message.getProductId(), message.getQuantity());
69        } catch (Exception e) {
70            log.error("回滚库存失败: productId={}, quantity={}", 
71                     message.getProductId(), message.getQuantity(), e);
72        }
73    }
74}
75