206｜秒杀系统设计：库存预热、削峰、限流、防刷、扣减一致性和兜底

// 兜底逻辑：从 MySQL 加载并预热
public int preheatStock(String productId) {
    String redisKey = "seckill:stock:" + productId;
    Integer stock = (Integer) redisTemplate.opsForValue().get(redisKey);
    if (stock == null) {
        // Redis 中无数据，从 DB 加载
        stock = productMapper.selectStock(productId);
        if (stock == null) {
            throw new BizException("商品不存在或未配置秒杀");
        }
        redisTemplate.opsForValue().set(redisKey, stock, 2, TimeUnit.HOURS);
    }
    return stock;
}

// 秒杀按钮防抖：点击后立即置灰，3 秒内不可重复点击
const btn = document.getElementById('seckill-btn');
btn.addEventListener('click', () => {
    btn.disabled = true;
    btn.textContent = '排队中...';
    fetch('/api/seckill/submit', { method: 'POST' })
        .then(res => res.json())
        .then(data => {
            if (data.code === 'QUEUED') {
                btn.textContent = '已加入排队';
            }
        });
    setTimeout(() => { btn.disabled = false; }, 3000);
});

// 基于 Redis 的令牌桶
public boolean tryAcquireToken(String userId, String productId) {
    String tokenKey = "seckill:token:" + productId;
    Long remaining = redisTemplate.opsForValue().decrement(tokenKey);
    if (remaining == null || remaining < 0) {
        // 令牌已耗尽，直接返回"已抢完"
        return false;
    }
    // 记录用户拿到令牌
    redisTemplate.opsForSet().add("seckill:token:users:" + productId, userId);
    return true;
}

// 生产者：快速写入 MQ
public SeckillResult submitOrder(SeckillRequest req) {
    // 1. 令牌校验
    if (!tokenService.tryAcquireToken(req.getUserId(), req.getProductId())) {
        return SeckillResult.SOLD_OUT;
    }
    // 2. 发送到消息队列，快速返回
    rocketMQTemplate.send("seckill-order-topic", req);
    return SeckillResult.QUEUED;
}

// 消费者：匀速消费，操作数据库
@RocketMQMessageListener(topic = "seckill-order-topic", consumerGroup = "seckill-order")
public class OrderConsumer implements RocketMQListener<SeckillRequest> {
    @Override
    public void onMessage(SeckillRequest req) {
        // 扣减库存、创建订单
        seckillService.createOrder(req);
    }
}

public boolean isAllowed(String userId, int maxRequests, int windowSeconds) {
    String key = "rate:user:" + userId;
    long now = System.currentTimeMillis();
    long windowStart = now - windowSeconds * 1000L;

    // 移除窗口外的记录
    redisTemplate.opsForZSet().removeRangeByScore(key, 0, windowStart);
    // 统计窗口内的请求数
    Long count = redisTemplate.opsForZSet().count(key, windowStart, now);

    if (count != null && count >= maxRequests) {
        return false; // 超过限制
    }
    // 记录本次请求
    redisTemplate.opsForZSet().add(key, String.valueOf(now), now);
    redisTemplate.expire(key, windowSeconds, TimeUnit.SECONDS);
    return true;
}

@PostMapping("/seckill/submit")
public Result submit(@RequestBody SeckillReq req) {
    // 验证滑块验证码
    if (!captchaService.verify(req.getCaptchaId(), req.getCaptchaAnswer())) {
        return Result.fail("验证码错误");
    }
    // 后续业务逻辑...
}

// 秒杀开始前，后端生成动态 URL 并下发
public String getSeckillUrl(String productId) {
    String token = UUID.randomUUID().toString().replace("-", "");
    String url = "/seckill/" + productId + "?token=" + token;
    // 缓存 token，有效期 5 分钟
    redisTemplate.opsForValue().set("seckill:url:" + token, productId, 5, TimeUnit.MINUTES);
    return url;
}

// 每人限购 1 件
public boolean checkUserLimit(String userId, String productId) {
    String key = "seckill:user:limit:" + productId + ":" + userId;
    // SETNX 保证原子性
    Boolean success = redisTemplate.opsForValue()
        .setIfAbsent(key, "1", 24, TimeUnit.HOURS);
    return Boolean.TRUE.equals(success);
}

-- seckill.lua
-- KEYS[1]: 库存 key (seckill:stock:123)
-- KEYS[2]: 已购买用户 set (seckill:users:123)
-- ARGV[1]: 用户 ID
-- ARGV[2]: 限购数量

local stock = tonumber(redis.call('GET', KEYS[1]))
if stock == nil or stock <= 0 then
    return -1  -- 库存不足
end

-- 检查用户是否已购买
local exists = redis.call('SISMEMBER', KEYS[2], ARGV[1])
if exists == 1 then
    return -2  -- 已购买
end

-- 扣减库存
redis.call('DECR', KEYS[1])
-- 记录用户
redis.call('SADD', KEYS[2], ARGV[1])

return 1  -- 成功

public int deductStock(String productId, String userId) {
    String stockKey = "seckill:stock:" + productId;
    String usersKey = "seckill:users:" + productId;
    Long result = redisTemplate.execute(
        seckillScript,
        Arrays.asList(stockKey, usersKey),
        userId, "1"
    );
    return result != null ? result.intValue() : -1;
}

-- 乐观锁方案
UPDATE product 
SET stock = stock - 1 
WHERE id = 123 AND stock > 0;

@Component
public class SeckillDegradeManager {
    
    @Value("${seckill.degrade.level:0}")
    private int degradeLevel; // 0=正常, 1=部分降级, 2=全面降级
    
    public boolean isRedisAvailable() {
        if (degradeLevel >= 1) return false;
        try {
            redisTemplate.opsForValue().get("health:check");
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    
    public int deductStock(String productId) {
        if (isRedisAvailable()) {
            return deductWithRedis(productId);
        }
        // 降级到 MySQL
        log.warn("Redis unavailable, fallback to MySQL");
        return deductWithMySQL(productId);
    }
}

<!-- 降级静态页：即使后端全挂，用户也能看到有意义的提示 -->
<div class="seckill-degrade">
    <h2>活动太火爆了</h2>
    <p>当前参与人数过多，请稍后再试</p>
    <p>您也可以<a href="/">返回首页</a>浏览其他商品</p>
</div>

@Scheduled(cron = "0 0 3 * * ?")
public void reconcile() {
    // 1. 查询所有秒杀活动
    List<SeckillActivity> activities = activityMapper.selectFinished();
    
    for (SeckillActivity activity : activities) {
        // 2. Redis 中的库存扣减量
        Long redisDeducted = activity.getTotalStock() - 
            redisTemplate.opsForValue().get("seckill:stock:" + activity.getProductId());
        
        // 3. MySQL 中的实际订单数
        Long orderCount = orderMapper.countByActivity(activity.getId());
        
        // 4. 对比
        if (!redisDeducted.equals(orderCount)) {
            alertService.send("秒杀对账异常", 
                String.format("活动 %s: Redis扣减 %d, 订单数 %d", 
                    activity.getId(), redisDeducted, orderCount));
        }
    }
}