-- 秒杀库存扣减 LUA 脚本
-- KEYS[1]: 库存key
-- KEYS[2]: 用户限购key
-- ARGV[1]: 商品ID
-- ARGV[2]: 用户ID
-- ARGV[3]: 扣减数量
-- ARGV[4]: 限购数量

local stock_key = KEYS[1]
local user_limit_key = KEYS[2]
local product_id = ARGV[1]
local user_id = ARGV[2]
local quantity = tonumber(ARGV[3])
local limit_qty = tonumber(ARGV[4])

-- 1. 检查用户是否已抢购（防重复下单）
local user_bought = redis.call('GET', user_limit_key)
if user_bought and tonumber(user_bought) >= limit_qty then
    return {0, "您已达到购买上限"}
end

-- 2. 检查库存
local stock = redis.call('GET', stock_key)
if not stock or tonumber(stock) < quantity then
    return {0, "库存不足"}
end

-- 3. 扣减库存（原子操作）
local new_stock = redis.call('DECRBY', stock_key, quantity)

-- 4. 记录用户购买记录
redis.call('INCRBY', user_limit_key, quantity)
redis.call('EXPIRE', user_limit_key, 3600)  -- 1小时过期

-- 5. 返回成功
return {1, new_stock}

@Component
public class SeckillStockService {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    private DefaultRedisScript<Long> stockLuaScript;
    
    @PostConstruct
    public void init() {
        stockLuaScript = new DefaultRedisScript<>();
        stockLuaScript.setScriptText(SECKILL_LUA_SCRIPT);
        stockLuaScript.setResultType(Long.class);
    }
    
    public SeckillResult deductStock(String productId, String userId, int quantity, int limitQty) {
        String stockKey = "seckill:stock:" + productId;
        String userKey = "seckill:user:" + productId + ":" + userId;
        
        List<String> keys = Arrays.asList(stockKey, userKey);
        
        // 执行LUA脚本
        Long result = redisTemplate.execute(
            stockLuaScript, 
            keys, 
            productId, userId, String.valueOf(quantity), String.valueOf(limitQty)
        );
        
        if (result == 1L) {
            // 扣减成功，发送MQ消息异步创建订单
            sendOrderCreateMessage(productId, userId, quantity);
            return SeckillResult.success();
        } else {
            return SeckillResult.fail("抢购失败，库存不足或已达上限");
        }
    }
}

@Component
public class SeckillOrderService {
    
    @Autowired
    private RocketMQTemplate mqTemplate;
    
    @Autowired
    private OrderService orderService;
    
    // 接收抢购请求，异步处理
    public void handleSeckill(SeckillRequest request) {
        // 1. 先进行库存扣减（Redis）
        SeckillResult result = stockService.deductStock(
            request.getProductId(), 
            request.getUserId(), 
            1, 
            1
        );
        
        if (!result.isSuccess()) {
            return;
        }
        
        // 2. 扣减成功后，发送MQ消息
        SeckillOrderMessage message = SeckillOrderMessage.builder()
            .productId(request.getProductId())
            .userId(request.getUserId())
            .seckillTime(System.currentTimeMillis())
            .build();
        
        mqTemplate.sendAsync("seckill_order_topic", message);
        
        // 3. 立即返回"排队中"，告知用户稍后查询结果
    }
    
    // MQ消费者：异步创建订单
    @RocketMQMessageListener(topic = "seckill_order_topic", consumerGroup = "order_consumer")
    public class OrderConsumer implements RocketMQListener<SeckillOrderMessage> {
        
        @Override
        public void onMessage(SeckillOrderMessage message) {
            try {
                // 创建订单（写入数据库）
                Order order = orderService.createSeckillOrder(
                    message.getProductId(),
                    message.getUserId()
                );
                
                // 发送通知给用户（WebSocket/推送）
                notifyService.notifyUser(message.getUserId(), order);
                
            } catch (Exception e) {
                log.error("创建订单失败", e);
                // 失败补偿：回滚Redis库存
                stockService.rollbackStock(message.getProductId(), message.getUserId());
            }
        }
    }
}

# nginx.conf

# 限制单个IP的请求速率（10r/s）
limit_req_zone $binary_remote_addr zone=seckill_ip:10m rate=10r/s;

# 限制单个IP的连接数（20个）
limit_conn_zone $binary_remote_addr zone=conn_ip:10m;

server {
    listen 80;
    server_name seckill.example.com;
    
    location /seckill {
        # 应用限流
        limit_req zone=seckill_ip burst=20 nodelay;
        limit_conn conn_ip 20;
        
        # 只允许内网访问秒杀接口（通过网关转发）
        allow 10.0.0.0/8;
        deny all;
        
        proxy_pass http://seckill_gateway;
    }
}

@Component
public class TokenBucketLimiter {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    /**
     * 令牌桶限流
     * @param key 限流key（如用户ID、IP）
     * @param capacity 桶容量
     * @param rate 令牌生成速率（个/秒）
     */
    public boolean tryAcquire(String key, int capacity, int rate) {
        String tokenKey = "rate_limiter:" + key;
        String lastRefillKey = "rate_limiter_last:" + key;
        
        long now = System.currentTimeMillis();
        
        // 获取当前令牌数
        String tokenStr = redisTemplate.opsForValue().get(tokenKey);
        long tokens = tokenStr == null ? capacity : Long.parseLong(tokenStr);
        
        // 获取上次填充时间
        String lastStr = redisTemplate.opsForValue().get(lastRefillKey);
        long lastRefill = lastStr == null ? now : Long.parseLong(lastStr);
        
        // 计算需要补充的令牌数
        long interval = now - lastRefill;
        long newTokens = Math.min(capacity, tokens + interval * rate / 1000);
        
        if (newTokens < 1) {
            return false;
        }
        
        // 消耗一个令牌
        newTokens--;
        
        // 更新Redis
        redisTemplate.opsForValue().set(tokenKey, String.valueOf(newTokens));
        redisTemplate.opsForValue().set(lastRefillKey, String.valueOf(now));
        
        return true;
    }
}

@Component
public class UserRateLimiter {
    
    // 每秒最多请求数
    private static final int MAX_REQUESTS_PER_SECOND = 5;
    // 每分钟最多请求数
    private static final int MAX_REQUESTS_PER_MINUTE = 50;
    
    public boolean checkUserRateLimit(String userId) {
        String secondKey = "rate:user:second:" + userId;
        String minuteKey = "rate:user:minute:" + userId;
        
        // 秒级限流
        Long secondCount = redisTemplate.opsForValue().increment(secondKey);
        if (secondCount == 1) {
            redisTemplate.expire(secondKey, 1, TimeUnit.SECONDS);
        }
        if (secondCount > MAX_REQUESTS_PER_SECOND) {
            log.warn("用户 {} 触发秒级限流", userId);
            return false;
        }
        
        // 分钟级限流
        Long minuteCount = redisTemplate.opsForValue().increment(minuteKey);
        if (minuteCount == 1) {
            redisTemplate.expire(minuteKey, 60, TimeUnit.SECONDS);
        }
        if (minuteCount > MAX_REQUESTS_PER_MINUTE) {
            log.warn("用户 {} 触发分钟级限流", userId);
            return false;
        }
        
        return true;
    }
}

<!-- 秒杀页面：静态HTML框架 -->
<!DOCTYPE html>
<html>
<head>
    <link rel="stylesheet" href="//cdn.example.com/seckill/main.css">
    <script src="//cdn.example.com/seckill/main.js"></script>
</head>
<body>
    <div class="product-info">
        <img src="//cdn.example.com/images/product_123.jpg">
        <h1>秒杀商品：XXX手机</h1>
        <div class="price">秒杀价: ¥999</div>
    </div>
    
    <div class="seckill-info">
        <div id="countdown">距离开始: 00:00:00</div>
        <button id="seckill-btn" disabled>即将开始</button>
    </div>
    
    <script>
    // 轮询获取动态数据
    setInterval(function() {
        $.get('/api/seckill/status?productId=123', function(data) {
            updateCountdown(data.timeLeft);
            updateButtonStatus(data.status);
        });
    }, 1000);
    </script>
</body>
</html>

@RestController
@RequestMapping("/api/seckill")
public class SeckillController {
    
    @Autowired
    private SeckillService seckillService;
    
    @Autowired
    private UserRateLimiter rateLimiter;
    
    @Autowired
    private SeckillStockService stockService;
    
    @Autowired
    private RocketMQTemplate mqTemplate;
    
    /**
     * 秒杀接口
     */
    @PostMapping("/do")
    public Result doSeckill(@RequestBody SeckillRequest request) {
        String userId = request.getUserId();
        String productId = request.getProductId();
        
        // 1. 基础校验
        // 1.1 活动时间校验
        if (!seckillService.isInSeckillPeriod(productId)) {
            return Result.error("秒杀活动未开始或已结束");
        }
        
        // 1.2 用户登录校验（从Token获取）
        if (!isLogin(userId)) {
            return Result.error("请先登录");
        }
        
        // 1.3 重复提交校验（防重令牌）
        String token = request.getToken();
        if (!validateToken(userId, token)) {
            return Result.error("请勿重复提交");
        }
        
        // 2. 限流检查
        if (!rateLimiter.checkUserRateLimit(userId)) {
            return Result.error("请求过于频繁，请稍后再试");
        }
        
        // 3. 库存预检（快速失败）
        Long stock = stockService.getStock(productId);
        if (stock == null || stock <= 0) {
            return Result.error("商品已抢光");
        }
        
        // 4. 核心：库存扣减（Redis LUA）
        SeckillResult result = stockService.deductStock(productId, userId, 1, 1);
        if (!result.isSuccess()) {
            return Result.error(result.getMessage());
        }
        
        // 5. 发送MQ消息，异步创建订单
        SeckillOrderMessage message = SeckillOrderMessage.builder()
            .productId(productId)
            .userId(userId)
            .seckillTime(System.currentTimeMillis())
            .build();
        
        String orderId = generateOrderId();
        message.setOrderId(orderId);
        
        // 将订单状态存入Redis（用于轮询）
        redisTemplate.opsForValue().set(
            "seckill:order_status:" + orderId,
            "pending",
            10, TimeUnit.MINUTES
        );
        
        mqTemplate.sendAsync("seckill_order_topic", message);
        
        // 6. 返回排队中，给用户orderId用于轮询
        return Result.success(Map.of(
            "orderId", orderId,
            "status", "pending",
            "message", "正在排队处理中，请稍后查询结果"
        ));
    }
    
    /**
     * 轮询查询秒杀结果
     */
    @GetMapping("/result")
    public Result queryResult(@RequestParam String orderId) {
        // 1. 先查Redis中的状态
        String status = redisTemplate.opsForValue().get("seckill:order_status:" + orderId);
        
        if ("pending".equals(status)) {
            return Result.success(Map.of("status", "pending"));
        }
        
        if ("success".equals(status)) {
            // 获取订单详情
            Order order = orderService.getOrder(orderId);
            return Result.success(Map.of("status", "success", "order", order));
        }
        
        if ("failed".equals(status)) {
            return Result.success(Map.of("status", "failed"));
        }
        
        // 2. Redis中没有，查数据库
        Order order = orderService.getOrder(orderId);
        if (order != null) {
            return Result.success(Map.of("status", "success", "order", order));
        }
        
        return Result.success(Map.of("status", "pending"));
    }
}

@Component
public class SeckillOrderConsumer {
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    @Autowired
    private NotifyService notifyService;
    
    @RocketMQMessageListener(
        topic = "seckill_order_topic",
        consumerGroup = "seckill_order_consumer",
        consumeThreadMax = 64,
        maxReconsumeTimes = 3
    )
    public void onMessage(SeckillOrderMessage message) {
        String orderId = message.getOrderId();
        String userId = message.getUserId();
        String productId = message.getProductId();
        
        try {
            // 1. 幂等性检查（防止重复消费）
            Boolean consumed = redisTemplate.opsForValue()
                .setIfAbsent("seckill:consumed:" + orderId, "1", 1, TimeUnit.DAYS);
            if (Boolean.FALSE.equals(consumed)) {
                log.warn("订单已处理过，跳过: {}", orderId);
                return;
            }
            
            // 2. 创建订单（写入数据库）
            Order order = orderService.createSeckillOrder(
                orderId, productId, userId
            );
            
            // 3. 更新订单状态
            redisTemplate.opsForValue().set(
                "seckill:order_status:" + orderId,
                "success",
                10, TimeUnit.MINUTES
            );
            
            // 4. 发送通知（WebSocket/消息推送）
            notifyService.notifyUser(userId, "恭喜您抢购成功！订单号：" + orderId);
            
            // 5. 更新统计数据
            metricsCollector.recordSuccess();
            
        } catch (Exception e) {
            log.error("创建订单失败: orderId={}", orderId, e);
            
            // 失败：更新状态
            redisTemplate.opsForValue().set(
                "seckill:order_status:" + orderId,
                "failed",
                10, TimeUnit.MINUTES
            );
            
            // 回滚库存
            rollbackStock(productId, userId);
            
            // 发送失败通知
            notifyService.notifyUser(userId, "抢购失败，库存不足");
            
            metricsCollector.recordFailure();
            
            // 抛出异常触发MQ重试
            throw new RuntimeException("订单创建失败", e);
        }
    }
    
    private void rollbackStock(String productId, String userId) {
        String stockKey = "seckill:stock:" + productId;
        String userKey = "seckill:user:" + productId + ":" + userId;
        
        redisTemplate.opsForValue().increment(stockKey, 1);
        redisTemplate.delete(userKey);
    }
}

@Component
public class SeckillCacheWarmer {
    
    @EventListener(ApplicationReadyEvent.class)
    public void warmUp() {
        // 获取即将开始的秒杀活动
        List<SeckillActivity> activities = activityService.getUpcomingActivities();
        
        for (SeckillActivity activity : activities) {
            // 预热商品信息
            warmProductCache(activity.getProductId());
            
            // 预热库存到Redis
            String stockKey = "seckill:stock:" + activity.getProductId();
            redisTemplate.opsForValue().set(
                stockKey,
                String.valueOf(activity.getStock()),
                24, TimeUnit.HOURS
            );
            
            // 预热活动信息
            String activityKey = "seckill:activity:" + activity.getProductId();
            redisTemplate.opsForHash().putAll(activityKey, Map.of(
                "startTime", String.valueOf(activity.getStartTime()),
                "endTime", String.valueOf(activity.getEndTime()),
                "price", String.valueOf(activity.getPrice()),
                "status", "1"
            ));
        }
    }
    
    private void warmProductCache(String productId) {
        // 将商品详情从DB加载到Redis
        Product product = productService.getProduct(productId);
        String productKey = "seckill:product:" + productId;
        redisTemplate.opsForHash().putAll(productKey, Map.of(
            "name", product.getName(),
            "image", product.getImage(),
            "seckillPrice", String.valueOf(product.getSeckillPrice())
        ));
    }
}

@Component
public class HotspotDetector {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    // 每秒统计窗口
    private final LoadingCache<String, AtomicLong> qpsCounter = Caffeine.newBuilder()
        .expireAfterWrite(2, TimeUnit.SECONDS)
        .build(key -> new AtomicLong(0));
    
    // 热点阈值
    private static final int HOTSPOT_THRESHOLD = 10000;
    
    public void recordRequest(String productId) {
        AtomicLong counter = qpsCounter.get(productId);
        long qps = counter.incrementAndGet();
        
        if (qps > HOTSPOT_THRESHOLD) {
            // 触发热点保护
            String hotspotKey = "seckill:hotspot:" + productId;
            Boolean isHot = redisTemplate.opsForValue().setIfAbsent(hotspotKey, "1", 10, TimeUnit.SECONDS);
            
            if (Boolean.TRUE.equals(isHot)) {
                log.warn("商品 {} 成为热点，触发保护机制", productId);
                // 动态扩容该商品的处理节点
                scaleUpForHotspot(productId);
            }
        }
    }
    
    private void scaleUpForHotspot(String productId) {
        // 方案1: 增加该商品的缓存副本
        String stockKey = "seckill:stock:" + productId;
        for (int i = 1; i <= 5; i++) {
            String replicaKey = stockKey + ":replica:" + i;
            redisTemplate.opsForValue().set(replicaKey, 
                redisTemplate.opsForValue().get(stockKey));
        }
        
        // 方案2: 通知K8s增加Pod副本
        k8sClient.scaleDeployment("seckill-service", 10);
    }
}

@Component
public class SeckillCircuitBreaker {
    
    @Autowired
    private HealthIndicator healthIndicator;
    
    // 降级开关
    private volatile boolean degradeEnabled = false;
    
    // 熔断器状态
    private enum CircuitState { CLOSED, OPEN, HALF_OPEN }
    private volatile CircuitState state = CircuitState.CLOSED;
    private AtomicInteger failureCount = new AtomicInteger(0);
    private AtomicInteger successCount = new AtomicInteger(0);
    
    private static final int FAILURE_THRESHOLD = 50;
    private static final int SUCCESS_THRESHOLD = 10;
    private static final long OPEN_TIMEOUT = 30000; // 30秒
    
    private volatile long openTime = 0;
    
    @Scheduled(fixedDelay = 1000)
    public void checkHealth() {
        switch (state) {
            case CLOSED:
                if (failureCount.get() > FAILURE_THRESHOLD) {
                    state = CircuitState.OPEN;
                    openTime = System.currentTimeMillis();
                    log.warn("熔断器开启，秒杀服务降级");
                    degradeEnabled = true;
                }
                break;
                
            case OPEN:
                if (System.currentTimeMillis() - openTime > OPEN_TIMEOUT) {
                    state = CircuitState.HALF_OPEN;
                    successCount.set(0);
                    log.info("熔断器半开，尝试恢复");
                }
                break;
                
            case HALF_OPEN:
                if (successCount.get() > SUCCESS_THRESHOLD) {
                    state = CircuitState.CLOSED;
                    failureCount.set(0);
                    degradeEnabled = false;
                    log.info("熔断器关闭，服务恢复");
                }
                break;
        }
    }
    
    public void recordSuccess() {
        if (state == CircuitState.HALF_OPEN) {
            successCount.incrementAndGet();
        } else if (state == CircuitState.CLOSED) {
            failureCount.set(0);
        }
    }
    
    public void recordFailure() {
        if (state == CircuitState.CLOSED) {
            failureCount.incrementAndGet();
        } else if (state == CircuitState.HALF_OPEN) {
            state = CircuitState.OPEN;
            openTime = System.currentTimeMillis();
        }
    }
    
    public boolean isDegradeEnabled() {
        return degradeEnabled;
    }
}

-- 秒杀订单表（分库分表）
CREATE TABLE `seckill_order` (
    `id` bigint NOT NULL AUTO_INCREMENT,
    `order_id` varchar(32) NOT NULL COMMENT '订单号',
    `product_id` varchar(32) NOT NULL COMMENT '商品ID',
    `user_id` bigint NOT NULL COMMENT '用户ID',
    `price` decimal(10,2) NOT NULL COMMENT '秒杀价',
    `status` tinyint DEFAULT '0' COMMENT '0-待支付 1-已支付 2-已取消',
    `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
    `pay_time` datetime DEFAULT NULL,
    PRIMARY KEY (`id`),
    UNIQUE KEY `uk_order_id` (`order_id`),
    KEY `idx_user_id` (`user_id`),
    KEY `idx_product_id` (`product_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='秒杀订单表';

-- 建议：
-- 1. 按 user_id 分片，方便查询用户订单
-- 2. 订单号使用雪花算法，保证全局唯一
-- 3. 历史订单定期归档到冷存储

压测工具: JMeter / wrk / Locust

压测场景:
  - 正常流量: 模拟真实用户行为
  - 突发流量: 瞬间大量请求
  - 超卖测试: 并发请求超过库存数
  - 异常测试: 网络延迟、服务超时

压测指标:
  - 吞吐量: 最大 QPS
  - 响应时间: P50/P99/P999
  - 错误率: 4xx/5xx 比例
  - 资源占用: CPU/内存/网络

压测数据准备:
  - 100万用户账号
  - 10个秒杀商品
  - 库存设置: 1000/商品