Spring Cloud 秒杀系统设计全解析：从 0 到百万 QPS 的架构实践

/**
 * 秒杀网关限流规则配置
 * 在 Gateway 服务启动时注册 Sentinel 规则
 */
@Configuration
public class SentinelGatewayConfig {

    @PostConstruct
    public void initGatewayRules() {
        Set<GatewayFlowRule> rules = new HashSet<>();

        // 规则1：秒杀接口整体 QPS 限制为 5000/s
        GatewayFlowRule seckillRule = new GatewayFlowRule("seckill-route")
                .setCount(5000)                    // 阈值：5000 QPS
                .setIntervalSec(1)                 // 统计窗口：1秒
                .setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT); // 快速失败

        // 规则2：单个 IP 每秒最多 10 次秒杀请求（防刷）
        GatewayFlowRule ipRule = new GatewayFlowRule("seckill-route")
                .setCount(10)
                .setIntervalSec(1)
                .setParamItem(
                    new GatewayParamFlowItem()
                        .setParseStrategy(SentinelGatewayConstants.PARAM_PARSE_STRATEGY_CLIENT_IP)
                );

        rules.add(seckillRule);
        rules.add(ipRule);

        // 注册规则到 Sentinel
        GatewayRuleManager.loadRules(rules);
    }
}

// ❌ 错误示例：非原子操作，高并发下必超卖
public boolean deductStock(Long skuId) {
    Integer stock = stockMapper.getStock(skuId);  // 步骤1：读库存
    if (stock > 0) {
        stockMapper.deductStock(skuId, 1);         // 步骤2：扣库存
        return true;                               // 步骤1和2之间存在竞态条件！
    }
    return false;
}

/**
 * Redis Lua 脚本预扣库存
 * Lua 脚本在 Redis 服务端原子执行，不会被其他命令插入
 */
@Service
public class StockRedisService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * Lua 脚本：原子扣减库存
     * 返回值：1 表示扣减成功，0 表示库存不足，-1 表示商品不存在
     */
    private static final String DEDUCT_STOCK_LUA =
            "local stock = tonumber(redis.call('HGET', KEYS[1], 'stock')) \n" +
            "if stock == nil then return -1 end \n" +           // 商品不存在
            "if stock <= 0 then return 0 end \n" +              // 库存不足
            "redis.call('HINCRBY', KEYS[1], 'stock', -1) \n" + // 原子扣减 1
            "return 1";                                         // 扣减成功

    private final RedisScript<Long> deductScript =
            new DefaultRedisScript<>(DEDUCT_STOCK_LUA, Long.class);

    /**
     * 预扣 Redis 库存
     * @param skuId 商品 ID
     * @return 1 扣减成功，0 库存不足，-1 商品不存在
     */
    public Long preDeductStock(Long skuId) {
        String key = "seckill:stock:" + skuId;
        return redisTemplate.execute(
            deductScript,
            Collections.singletonList(key)
        );
    }

    /**
     * 秒杀活动开始前预热库存到 Redis
     * 通常由定时任务在活动开始前 5 分钟执行
     */
    public void warmUpStock(Long skuId, int stock) {
        String key = "seckill:stock:" + skuId;
        Map<String, String> stockInfo = new HashMap<>();
        stockInfo.put("stock", String.valueOf(stock));
        stockInfo.put("skuId", String.valueOf(skuId));
        // 设置 2 小时过期，避免活动结束后 Redis 数据残留
        redisTemplate.opsForHash().putAll(key, stockInfo);
        redisTemplate.expire(key, 2, TimeUnit.HOURS);
    }

    /**
     * 回滚 Redis 库存（MQ 发送失败时调用）
     */
    public void rollbackStock(Long skuId) {
        String key = "seckill:stock:" + skuId;
        redisTemplate.opsForHash().increment(key, "stock", 1);
    }

    /**
     * 获取 Redis 当前库存
     */
    public int getStock(Long skuId) {
        String key = "seckill:stock:" + skuId;
        Object val = redisTemplate.opsForHash().get(key, "stock");
        return val == null ? 0 : Integer.parseInt(val.toString());
    }

    /**
     * 重置 Redis 库存（以 MySQL 为准，用于定时校对）
     */
    public void resetStock(Long skuId, int stock) {
        String key = "seckill:stock:" + skuId;
        redisTemplate.opsForHash().put(key, "stock", String.valueOf(stock));
    }
}

/**
 * MySQL 乐观锁扣减库存（降级兜底方案）
 * 使用 WHERE stock > 0 条件防止超卖，无需显式加锁
 */
@Mapper
public interface StockMapper {

    /**
     * SQL: UPDATE seckill_stock
     *      SET stock = stock - #{count}
     *      WHERE sku_id = #{skuId} AND stock >= #{count}
     * 返回受影响行数：1 = 扣减成功，0 = 库存不足
     */
    @Update("UPDATE seckill_stock SET stock = stock - #{count} " +
            "WHERE sku_id = #{skuId} AND stock >= #{count}")
    int deductStockWithOptimisticLock(
        @Param("skuId") Long skuId,
        @Param("count") int count
    );
}

/**
 * 秒杀核心服务
 * 职责：校验 → 预扣库存 → 发送 MQ 消息
 */
@Service
@Slf4j
public class SeckillService {

    @Autowired
    private StockRedisService stockRedisService;

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 执行秒杀操作
     * @param userId  用户 ID
     * @param skuId   商品 ID
     * @return 秒杀结果（排队 requestId 或失败原因）
     */
    @SentinelResource(value = "seckill", blockHandler = "seckillBlockHandler")
    public SeckillResult doSeckill(Long userId, Long skuId) {

        // ① 幂等性检查：同一用户同一商品只能秒杀一次
        String userKey = "seckill:user:" + userId + ":" + skuId;
        Boolean isFirst = redisTemplate.opsForValue()
            .setIfAbsent(userKey, "1", 24, TimeUnit.HOURS);
        if (Boolean.FALSE.equals(isFirst)) {
            return SeckillResult.fail("您已参与过该活动");
        }

        // ② Redis Lua 脚本原子预扣库存
        Long deducted = stockRedisService.preDeductStock(skuId);
        if (deducted == null || deducted == -1L) {
            // 扣减失败说明商品不存在或未预热，回滚幂等标记
            redisTemplate.delete(userKey);
            return SeckillResult.fail("商品不存在或未预热");
        } else if (deducted == 0L) {
            // 扣减失败说明库存不足，回滚幂等标记
            redisTemplate.delete(userKey);
            return SeckillResult.fail("商品已售罄");
        }

        // ③ 生成唯一请求 ID，异步追踪订单结果
        String requestId = UUID.randomUUID().toString().replace("-", "");

        // ④ 发送 MQ 消息，异步创建订单
        SeckillOrderMessage msg = SeckillOrderMessage.builder()
            .requestId(requestId)
            .userId(userId)
            .skuId(skuId)
            .createTime(System.currentTimeMillis())
            .build();

        rocketMQTemplate.asyncSendOrderly(
            "seckill-order-topic",
            msg,
            String.valueOf(skuId),
            new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    log.info("MQ 发送成功，requestId={}", requestId);
                }
                @Override
                public void onException(Throwable e) {
                    // MQ 发送失败，需要回滚 Redis 库存！
                    log.error("MQ 发送失败，回滚库存 skuId={}", skuId, e);
                    stockRedisService.rollbackStock(skuId);
                    redisTemplate.delete(userKey);
                }
            }
        );

        return SeckillResult.queuing(requestId);
    }

    /**
     * Sentinel 限流降级处理
     * 当 QPS 超限时触发，返回友好提示
     */
    public SeckillResult seckillBlockHandler(Long userId, Long skuId, BlockException ex) {
        log.warn("秒杀接口被限流, userId={}, skuId={}", userId, skuId);
        return SeckillResult.fail("系统繁忙，请稍后重试");
    }
}

/**
 * 秒杀结果返回对象
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SeckillResult {
    // 状态：SUCCESS(成功) / FAIL(失败) / QUEUING(排队中)
    private String status;
    private String message;
    // 排队时的请求 ID，用于轮询订单结果
    private String requestId;

    public static SeckillResult queuing(String requestId) {
        return SeckillResult.builder()
            .status("QUEUING")
            .message("秒杀成功，正在创建订单...")
            .requestId(requestId)
            .build();
    }

    public static SeckillResult fail(String message) {
        return SeckillResult.builder()
            .status("FAIL")
            .message(message)
            .build();
    }
}

/**
 * MQ 异步下单消息体
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SeckillOrderMessage implements Serializable {
    private String requestId;   // 唯一请求 ID（用于幂等消费）
    private Long userId;
    private Long skuId;
    private long createTime;

    public static SeckillOrderMessage fromRecord(SeckillRecord record) {
        return SeckillOrderMessage.builder()
            .requestId(record.getRequestId())
            .userId(record.getUserId())
            .skuId(record.getSkuId())
            .createTime(record.getCreateTime())
            .build();
    }
}

/**
 * 秒杀订单消费者
 * 监听 seckill-order-topic，异步创建订单并更新 MySQL 库存
 */
@RocketMQMessageListener(
    topic = "seckill-order-topic",
    consumerGroup = "seckill-order-consumer-group",
    // 顺序消费（保证同一 skuId 的订单按顺序处理）
    consumeMode = ConsumeMode.ORDERLY,
    messageModel = MessageModel.CLUSTERING
)
@Service
@Slf4j
public class SeckillOrderConsumer implements RocketMQListener<SeckillOrderMessage> {

    @Autowired
    private OrderService orderService;

    @Autowired
    private StockMapper stockMapper;

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void onMessage(SeckillOrderMessage msg) {
        log.info("收到秒杀订单消息, requestId={}", msg.getRequestId());

        // ① 幂等性检查：防止 MQ 重复投递（消费者宕机重启后可能重投）
        String consumeKey = "seckill:consumed:" + msg.getRequestId();
        Boolean isFirst = redisTemplate.opsForValue()
            .setIfAbsent(consumeKey, "1", 24, TimeUnit.HOURS);
        if (Boolean.FALSE.equals(isFirst)) {
            log.warn("重复消费，跳过 requestId={}", msg.getRequestId());
            return;
        }

        try {
            // ② 扣减 MySQL 实际库存（最终持久化）
            int affected = stockMapper.deductStockWithOptimisticLock(msg.getSkuId(), 1);
            if (affected == 0) {
                // MySQL 扣减失败（极端情况下 Redis 放行但 DB 无库存），抛出异常让消息进入重试/死信队列，人工排查不一致原因
                log.error("MySQL 库存扣减失败, skuId={}", msg.getSkuId());
                throw new RuntimeException("库存扣减失败");
            }

            // ③ 创建订单并持久化
            Order order = orderService.createSeckillOrder(
                msg.getUserId(),
                msg.getSkuId(),
                msg.getRequestId()
            );

            // ④ 更新请求状态到 Redis，供前端轮询
            redisTemplate.opsForValue().set(
                "seckill:result:" + msg.getRequestId(),
                "ORDER_CREATED:" + order.getOrderNo(),
                1, TimeUnit.HOURS
            );

            log.info("订单创建成功, orderId={}", order.getOrderNo());

        } catch (Exception e) {
            // 消费失败时删除幂等标记，让 MQ 重试
            redisTemplate.delete(consumeKey);
            throw e;
        }
    }
}

/**
 * 查询秒杀结果接口
 * 前端每隔 1 秒轮询一次，直到获取到订单 ID 或超时
 */
@GetMapping("/seckill/result/{requestId}")
public ResponseEntity<SeckillResult> querySeckillResult(@PathVariable String requestId) {
    String key = "seckill:result:" + requestId;
    String result = redisTemplate.opsForValue().get(key);

    if (result == null) {
        // 订单还在处理中
        return ResponseEntity.ok(SeckillResult.builder()
            .status("PROCESSING").message("订单处理中...").build());
    }

    if (result.startsWith("ORDER_CREATED:")) {
        // 订单创建成功
        String orderNo = result.substring("ORDER_CREATED:".length());
        return ResponseEntity.ok(SeckillResult.builder()
            .status("SUCCESS").message("下单成功，订单号：" + orderNo).build());
    }

    return ResponseEntity.ok(SeckillResult.fail(result));
}

/**
 * 库存校对定时任务
 * 每 5 分钟检查 Redis 库存与 MySQL 库存是否一致
 * 兜底保障，应对极端情况下的数据不一致
 */
@Component
@Slf4j
public class StockSyncTask {

    @Autowired
    private StockMapper stockMapper;

    @Autowired
    private StockRedisService stockRedisService;

    @Scheduled(fixedDelay = 5 * 60 * 1000)  // 每 5 分钟执行一次
    public void syncStock() {
        // 获取所有进行中的秒杀活动商品
        List<Long> activeSkuIds = stockMapper.findActiveSeckillSkuIds();

        for (Long skuId : activeSkuIds) {
            // 查询 MySQL 实际库存
            int dbStock = stockMapper.getStock(skuId);
            // 查询 Redis 缓存库存
            int redisStock = stockRedisService.getStock(skuId);

            if (dbStock != redisStock) {
                log.warn("库存不一致 skuId={}, DB={}, Redis={}", skuId, dbStock, redisStock);
                // 以 MySQL 为准，修复 Redis
                stockRedisService.resetStock(skuId, dbStock);
            }
        }
    }
}

/**
 * 消息补偿任务
 * 扫描超过 30 分钟未完成的秒杀请求，重新发送 MQ
 */
@Slf4j
@Component
public class SeckillCompensationTask {

    @Autowired
    private SeckillRecordMapper seckillRecordMapper;

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @Scheduled(fixedDelay = 10 * 60 * 1000) // 每 10 分钟执行
    public void compensate() {
        // 查询超时未完成的秒杀记录（状态 = PROCESSING 且创建时间 > 30min）
        List<SeckillRecord> pendingList = seckillRecordMapper
            .findPendingTimeout(30);

        for (SeckillRecord record : pendingList) {
            // 检查 Redis 结果是否存在
            String result = redisTemplate.opsForValue()
                .get("seckill:result:" + record.getRequestId());

            if (result == null) {
                // 结果不存在，重新投递 MQ
                log.info("补偿发送 MQ requestId={}", record.getRequestId());
                rocketMQTemplate.syncSendOrderly(
                    "seckill-order-topic",
                    SeckillOrderMessage.fromRecord(record),
                    String.valueOf(record.getSkuId())  // 与生产者保持一致
                );
            }
        }
    }
}

/**
 * 秒杀商品库存预热
 * 在活动开始前 5 分钟，由 Spring Scheduler 触发
 */
@Component
@Slf4j
public class SeckillStockWarmUpTask {

    @Autowired
    private ActivityMapper activityMapper;

    @Autowired
    private StockRedisService stockRedisService;

    @Scheduled(cron = "0 55 * * * *")  // 每小时第 55 分钟执行（提前 5 分钟）
    public void preheatSeckillStock() {
        List<SeckillActivity> activities = activityMapper
            .findActivitiesStartingIn(5); // 5分钟内开始的活动

        for (SeckillActivity activity : activities) {
            // 将库存写入 Redis，有效期设为活动时长 + 1小时
            stockRedisService.warmUpStock(
                activity.getSkuId(),
                activity.getStock()
            );
            log.info("库存预热完成 skuId={}, stock={}",
                activity.getSkuId(), activity.getStock());
        }
    }
}

// 秒杀 URL 动态 Token 校验
// 在活动开始时，才把正确 Token 下发到前端页面
@GetMapping("/seckill/token/{activityId}")
public String getSeckillToken(@PathVariable Long activityId,
                               @RequestParam Long userId) {
    // 验证活动状态和用户资格
    validateUserQualification(userId, activityId);

    // 生成随机 Token 并存入 Redis（5分钟有效期）
    String token = UUID.randomUUID().toString();
    redisTemplate.opsForValue().set(
        "seckill:token:" + activityId + ":" + userId,
        token, 5, TimeUnit.MINUTES
    );
    return token;
}