如何设计一个秒杀系统？⭐⭐⭐

@Service
@Slf4j
public class SeckillService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    // 秒杀 Redis Key
    private static final String STOCK_KEY = "seckill:stock:";
    private static final String USER_KEY = "seckill:user:";

    /**
     * 秒杀接口：Redis 预减库存 + MQ 异步下单
     */
    public Result<Long> doSeckill(SeckillRequest request) {
        Long skuId = request.getSkuId();
        Long userId = request.getUserId();

        // 1. 用户维度限流：每人每秒最多请求 1 次
        String userRateKey = "seckill:rate:user:" + userId;
        Long count = stringRedisTemplate.opsForValue().increment(userRateKey);
        if (count != null && count > 1) {
            return Result.error("请求过于频繁，请稍后再试");
        }
        stringRedisTemplate.expire(userRateKey, 1, TimeUnit.SECONDS);

        // 2. 检查用户是否已购买过
        String userBoughtKey = USER_KEY + skuId + ":" + userId;
        if (Boolean.TRUE.equals(stringRedisTemplate.hasKey(userBoughtKey))) {
            return Result.error("您已购买过该秒杀商品");
        }

        // 3. Lua 脚本原子扣减库存
        String stockKey = STOCK_KEY + skuId;
        DefaultRedisScript<Long> script = new DefaultRedisScript<>();
        script.setScriptText(
            "local stock = redis.call('GET', KEYS[1]) " +
            "if stock == false then return -1 end " +
            "stock = tonumber(stock) " +
            "if stock < 1 then return 0 end " +
            "stock = stock - 1 " +
            "redis.call('SET', KEYS[1], stock) " +
            "return stock"
        );
        script.setResultType(Long.class);

        Long remainStock = stringRedisTemplate.execute(script, List.of(stockKey));

        if (remainStock == null || remainStock < 0) {
            return Result.error("商品不存在");
        }
        if (remainStock == 0) {
            return Result.error("已售罄");
        }

        // 4. 库存扣减成功，发送 MQ 消息异步创建订单
        SeckillMessage message = new SeckillMessage(skuId, userId, remainStock);
        rocketMQTemplate.asyncSend("seckill-order-topic", message, new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                log.info("秒杀消息发送成功: {}", sendResult);
            }
            @Override
            public void onException(Throwable e) {
                log.error("秒杀消息发送失败，回补库存: skuId={}", skuId, e);
                // 发送失败，回补 Redis 库存
                stringRedisTemplate.opsForValue().increment(stockKey);
            }
        });

        // 5. 记录用户购买标记
        stringRedisTemplate.opsForValue().set(userBoughtKey, "1", 24, TimeUnit.HOURS);

        return Result.success("抢购成功，请稍后刷新订单页面", remainStock);
    }
}

@Service
@Slf4j
public class SeckillOrderConsumer {

    @Autowired
    private OrderService orderService;

    @Autowired
    private StockService stockService;

    @RocketMQMessageListener(
        topic = "seckill-order-topic",
        consumerGroup = "seckill-order-consumer-group",
        maxReconsumeTimes = 3  // 最多重试 3 次
    )
    public void handleSeckillOrder(SeckillMessage message, Acknowledgment ack) {
        Long skuId = message.getSkuId();
        Long userId = message.getUserId();

        try {
            // 1. 幂等检查：防止消息重复消费
            String dedupKey = "seckill:order:dedup:" + skuId + ":" + userId;
            Boolean success = redisTemplate.opsForValue()
                .setIfAbsent(dedupKey, "1", Duration.ofHours(1));

            if (!Boolean.TRUE.equals(success)) {
                log.info("订单已存在，跳过: skuId={}, userId={}", skuId, userId);
                ack.acknowledge();
                return;
            }

            // 2. MySQL 乐观锁扣减库存（最终一致性保障）
            boolean stockOk = stockService.deductStockWithVersion(skuId);
            if (!stockOk) {
                log.error("MySQL 库存不足: skuId={}", skuId);
                throw new BizException("库存不足");
            }

            // 3. 创建订单
            Order order = orderService.createSeckillOrder(skuId, userId);

            // 4. 发消息通知用户
            notifyService.sendOrderSuccessNotification(userId, order.getOrderId());

            // 5. 手动 ACK
            ack.acknowledge();
            log.info("秒杀订单创建成功: orderId={}", order.getOrderId());

        } catch (Exception e) {
            log.error("秒杀订单创建失败: skuId={}, userId={}", skuId, userId, e);
            // 不 ACK，消息会进入重试队列
            throw e;
        }
    }
}

@Service
public class StockService {

    @Autowired
    private StockMapper stockMapper;

    /**
     * 乐观锁扣减库存：防止超卖
     * SQL: UPDATE stock SET stock = stock - #{count}, version = version + 1
     *      WHERE sku_id = #{skuId} AND stock >= #{count} AND version = #{version}
     */
    @Transactional(rollbackFor = Exception.class)
    public boolean deductStockWithVersion(Long skuId) {
        // 1. 查询当前库存和版本号
        Stock stock = stockMapper.selectBySkuId(skuId);
        if (stock == null || stock.getStock() <= 0) {
            return false;
        }

        // 2. 乐观锁扣减：where 条件包含 version，只有版本匹配才更新
        int affected = stockMapper.deductWithOptimisticLock(
            skuId, 1, stock.getVersion()
        );

        if (affected == 0) {
            log.warn("乐观锁冲突，库存扣减失败: skuId={}", skuId);
            return false;
        }

        return true;
    }
}

// 秒杀商品详情页：多级缓存
public ItemVO getItemDetail(Long skuId) {
    String cacheKey = "item:detail:" + skuId;

    // L1: 本地缓存（Caffeine），扛热点读
    ItemVO cached = localCache.getIfPresent(cacheKey);
    if (cached != null) return cached;

    // L2: Redis 缓存
    String redisValue = redisTemplate.opsForValue().get(cacheKey);
    if (redisValue != null) {
        ItemVO vo = JSON.parseObject(redisValue, ItemVO.class);
        localCache.put(cacheKey, vo);
        return vo;
    }

    // L3: MySQL
    ItemVO vo = itemMapper.selectBySkuId(skuId);
    redisTemplate.opsForValue().set(cacheKey, JSON.toJSONString(vo), 1, TimeUnit.HOURS);
    localCache.put(cacheKey, vo);
    return vo;
}

// 订单超时未支付，自动回补库存
@Scheduled(cron = "0/10 * * * * ?")
public void rollbackExpiredOrders() {
    List<Order> expiredOrders = orderMapper.selectExpiredUnpaidOrders();

    for (Order order : expiredOrders) {
        try {
            // 1. 取消订单
            orderMapper.updateStatus(order.getOrderId(), OrderStatus.CANCELLED);

            // 2. 回补 Redis 库存
            String stockKey = "seckill:stock:" + order.getSkuId();
            stringRedisTemplate.opsForValue().increment(stockKey);

            // 3. 回补 MySQL 库存
            stockMapper.incrementStock(order.getSkuId(), 1);

            log.info("订单超时取消，库存回补: orderId={}, skuId={}",
                order.getOrderId(), order.getSkuId());
        } catch (Exception e) {
            log.error("库存回补失败: orderId={}", order.getOrderId(), e);
        }
    }
}