← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
一、理论篇:秒杀系统架构设计(30%)二、实战篇:完整代码实现(40%)三、面试模拟篇(20%)四、练习篇(10%)架构要点速查表

P4-02 秒杀系统完整实现

适用对象:5年经验Java开发者,目标薪资18-22K
课时:约4小时 | 理论30% + 实战40% + 面试20% + 练习10%

一、理论篇:秒杀系统架构设计(30%)

1.1 秒杀的核心难点

秒杀场景的三大核心问题:

1.2 六层防护架构


┌─────────────────────────────────────────────────────────┐
│  Layer 1: 客户端层                                       │
│  ├── 页面静态化(CDN缓存)                                │
│  ├── 按钮置灰 + 倒计时                                    │
│  └── 答题/验证码防机器                                    │
├─────────────────────────────────────────────────────────┤
│  Layer 2: Nginx层                                        │
│  ├── 限流(limit_req)                                    │
│  ├── IP黑名单                                            │
│  └── 静态资源缓存                                         │
├─────────────────────────────────────────────────────────┤
│  Layer 3: 网关层(Gateway)                               │
│  ├── 全局限流(Sentinel)                                  │
│  ├── 用户维度的请求频率限制                                 │
│  └── 秒杀活动状态校验(是否开始/结束)                       │
├─────────────────────────────────────────────────────────┤
│  Layer 4: 应用层                                         │
│  ├── 幂等Token校验                                        │
│  ├── Redis Lua原子扣库存                                  │
│  └── MQ异步下单                                           │
├─────────────────────────────────────────────────────────┤
│  Layer 5: 消息队列层                                      │
│  ├── 流量削峰                                             │
│  ├── 顺序消费保证                                         │
│  └── 消费失败重试 + 死信队列                                │
├─────────────────────────────────────────────────────────┤
│  Layer 6: 数据层                                         │
│  ├── 数据库乐观锁/悲观锁                                   │
│  ├── Redis集群(缓存 + 分布式锁)                           │
│  └── 最终库存对账                                         │
└─────────────────────────────────────────────────────────┘

1.3 核心流程时序


用户 → CDN(静态页) → Nginx(限流) → Gateway(鉴权+限流)
    → App(幂等校验) → Redis Lua(原子扣库存)
    → RocketMQ(异步下单) → Consumer(创建订单+扣DB库存)
    → WebSocket(推送结果)

二、实战篇:完整代码实现(40%)

2.1 Redis Lua原子扣库存脚本


-- seckill_deduct_stock.lua
-- KEYS[1] = 秒杀库存key      seckill:stock:{activityId}
-- KEYS[2] = 已购买用户集合key  seckill:bought:{activityId}
-- ARGV[1] = 用户ID
-- ARGV[2] = 活动ID

local stockKey = KEYS[1]
local boughtKey = KEYS[2]
local userId = ARGV[1]
local activityId = ARGV[2]

-- 1. 检查用户是否已购买(防重复购买)
local isBought = redis.call('SISMEMBER', boughtKey, userId)
if isBought == 1 then
    return -2  -- 已购买过
end

-- 2. 获取当前库存
local stock = tonumber(redis.call('GET', stockKey))
if stock == nil then
    return -3  -- 活动不存在
end

-- 3. 判断库存是否充足
if stock <= 0 then
    return 0   -- 库存不足
end

-- 4. 原子操作:扣库存 + 记录用户
redis.call('DECR', stockKey)
redis.call('SADD', boughtKey, userId)

-- 5. 设置过期时间(活动结束后自动清理)
redis.call('EXPIRE', boughtKey, 86400)

return 1  -- 扣减成功

2.2 秒杀服务核心实现


@Service
@Slf4j
public class SeckillService {

    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    private static final String STOCK_KEY = "seckill:stock:";
    private static final String BOUGHT_KEY = "seckill:bought:";
    private static final String ACTIVITY_KEY = "seckill:activity:";

    // Lua脚本(项目启动时加载)
    private DefaultRedisScript<Long> deductStockScript;

    @PostConstruct
    public void init() {
        deductStockScript = new DefaultRedisScript<>();
        deductStockScript.setLocation(
            new ClassPathResource("lua/seckill_deduct_stock.lua"));
        deductStockScript.setResultType(Long.class);
    }

    /**
     * 秒杀核心接口
     */
    @SentinelResource(value = "seckill.execute",
        blockHandler = "seckillBlockHandler",
        fallback = "seckillFallback")
    public SeckillResult execute(Long userId, Long activityId, String token) {
        // ====== 第一关:活动状态校验 ======
        String activityInfo = redisTemplate.opsForValue()
            .get(ACTIVITY_KEY + activityId);
        if (activityInfo == null) {
            return SeckillResult.fail("活动不存在");
        }

        SeckillActivity activity = JSON.parseObject(activityInfo, 
            SeckillActivity.class);
        long now = System.currentTimeMillis();
        if (now < activity.getStartTime().getTime()) {
            return SeckillResult.fail("活动未开始");
        }
        if (now > activity.getEndTime().getTime()) {
            return SeckillResult.fail("活动已结束");
        }

        // ====== 第二关:幂等Token校验 ======
        String tokenKey = "seckill:token:" + userId + ":" + activityId;
        Boolean valid = redisTemplate.delete(tokenKey);
        if (valid == null || !valid) {
            return SeckillResult.fail("请勿重复提交");
        }

        // ====== 第三关:Redis Lua原子扣库存 ======
        Long result = redisTemplate.execute(
            deductStockScript,
            Arrays.asList(STOCK_KEY + activityId, BOUGHT_KEY + activityId),
            userId.toString(),
            activityId.toString()
        );

        if (result == null) {
            return SeckillResult.fail("系统异常");
        }
        if (result == -2) {
            return SeckillResult.fail("您已购买过该商品");
        }
        if (result == -3) {
            return SeckillResult.fail("活动不存在");
        }
        if (result == 0) {
            return SeckillResult.fail("商品已售罄");
        }

        // ====== 第四关:发送MQ消息异步创建订单 ======
        SeckillMessage message = new SeckillMessage();
        message.setUserId(userId);
        message.setActivityId(activityId);
        message.setProductId(activity.getProductId());
        message.setPrice(activity.getSeckillPrice());
        message.setOrderNo(generateOrderNo());
        message.setTimestamp(now);

        try {
            rocketMQTemplate.syncSend(
                "seckill-order-topic",
                MessageBuilder.withPayload(message)
                    .setKeys(message.getOrderNo())
                    .build(),
                3000, // 超时3秒
                0     // 延迟级别0=不延迟
            );
        } catch (Exception e) {
            // MQ发送失败,回滚Redis库存
            redisTemplate.opsForValue().increment(STOCK_KEY + activityId);
            redisTemplate.opsForSet().remove(BOUGHT_KEY + activityId, 
                userId.toString());
            log.error("MQ发送失败,库存已回滚: userId={}, activityId={}", 
                userId, activityId, e);
            return SeckillResult.fail("系统繁忙,请稍后重试");
        }

        log.info("秒杀成功,等待订单创建: userId={}, activityId={}, orderNo={}",
            userId, activityId, message.getOrderNo());
        return SeckillResult.success(message.getOrderNo());
    }

    private String generateOrderNo() {
        return "SK" + IdWorker.getIdStr();
    }

    // Sentinel限流处理
    public SeckillResult seckillBlockHandler(Long userId, Long activityId, 
            String token, BlockException ex) {
        return SeckillResult.fail("当前参与人数过多,请稍后重试");
    }

    // 业务异常降级
    public SeckillResult seckillFallback(Long userId, Long activityId, 
            String token, Throwable t) {
        log.error("秒杀异常: userId={}", userId, t);
        return SeckillResult.fail("系统异常,请稍后重试");
    }
}

2.3 MQ消费者:异步创建订单


@Component
@RocketMQMessageListener(
    topic = "seckill-order-topic",
    consumerGroup = "seckill-order-consumer-group",
    selectorExpression = "*"
)
@Slf4j
public class SeckillOrderConsumer implements RocketMQListener<SeckillMessage> {

    @Autowired
    private OrderService orderService;
    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private StringRedisTemplate redisTemplate;

    @Override
    public void onMessage(SeckillMessage message) {
        log.info("收到秒杀订单消息: {}", message);

        // 分布式锁防止重复消费
        String lockKey = "seckill:lock:" + message.getOrderNo();
        RLock lock = redissonClient.getLock(lockKey);

        try {
            boolean locked = lock.tryLock(5, 30, TimeUnit.SECONDS);
            if (!locked) {
                log.warn("获取分布式锁失败,可能重复消费: {}", 
                    message.getOrderNo());
                return;
            }

            // 幂等校验:检查订单是否已创建
            Boolean orderExists = redisTemplate.hasKey(
                "seckill:order:" + message.getOrderNo());
            if (Boolean.TRUE.equals(orderExists)) {
                log.info("订单已创建,跳过: {}", message.getOrderNo());
                return;
            }

            // 创建订单(数据库操作)
            Order order = orderService.createSeckillOrder(
                message.getUserId(),
                message.getProductId(),
                message.getPrice(),
                message.getOrderNo()
            );

            // 标记订单已创建
            redisTemplate.opsForValue().set(
                "seckill:order:" + message.getOrderNo(),
                JSON.toJSONString(order),
                24, TimeUnit.HOURS
            );

            // TODO: 通过WebSocket通知用户订单创建成功
            log.info("秒杀订单创建成功: orderNo={}", message.getOrderNo());

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

2.4 分布式锁工具类(Redisson)


@Component
public class DistributedLockHelper {

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 执行带分布式锁的操作
     * @param lockKey  锁的key
     * @param waitTime 等待时间(秒)
     * @param leaseTime 持有时间(秒)
     * @param action   要执行的操作
     */
    public <T> T executeWithLock(String lockKey, long waitTime, 
            long leaseTime, Supplier<T> action) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            boolean locked = lock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
            if (!locked) {
                throw new BusinessException("获取锁失败,请稍后重试");
            }
            return action.get();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new BusinessException("操作被中断");
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

2.5 数据库层:乐观锁保证最终一致性


@Mapper
public interface SeckillStockMapper {

    /**
     * 乐观锁扣减库存
     * 利用stock > 0作为条件,防止超卖
     */
    @Update("UPDATE seckill_stock SET stock = stock - #{quantity}, " +
            "version = version + 1 " +
            "WHERE activity_id = #{activityId} " +
            "AND stock >= #{quantity}")
    int deductStock(@Param("activityId") Long activityId,
                    @Param("quantity") Integer quantity);
}

2.6 秒杀活动预热(库存预热到Redis)


@Service
@Slf4j
public class SeckillPreheatService {

    @Autowired
    private SeckillActivityMapper activityMapper;
    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 活动开始前预热库存到Redis
     */
    @Scheduled(cron = "0 */5 * * * ?") // 每5分钟检查
    public void preheatStock() {
        List<SeckillActivity> activities = activityMapper
            .selectUpcoming(LocalDateTime.now().plusHours(1));

        for (SeckillActivity activity : activities) {
            String stockKey = "seckill:stock:" + activity.getId();
            String activityKey = "seckill:activity:" + activity.getId();

            // 缓存库存
            redisTemplate.opsForValue().setIfAbsent(
                stockKey, 
                String.valueOf(activity.getTotalStock()),
                24, TimeUnit.HOURS
            );

            // 缓存活动信息
            redisTemplate.opsForValue().set(
                activityKey,
                JSON.toJSONString(activity),
                24, TimeUnit.HOURS
            );

            log.info("活动预热完成: activityId={}, stock={}", 
                activity.getId(), activity.getTotalStock());
        }
    }
}

2.7 幂等Token发放接口


@RestController
@RequestMapping("/api/seckill")
public class SeckillController {

    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private SeckillService seckillService;

    /**
     * 获取秒杀Token(前端在秒杀开始前调用)
     */
    @GetMapping("/token/{activityId}")
    public Result<String> getToken(
            @PathVariable Long activityId,
            @RequestParam Long userId) {
        // 校验活动状态
        String activityJson = redisTemplate.opsForValue()
            .get("seckill:activity:" + activityId);
        if (activityJson == null) {
            return Result.fail("活动不存在");
        }

        // 生成Token
        String token = IdWorker.getIdStr();
        String tokenKey = "seckill:token:" + userId + ":" + activityId;
        // 每人每活动只能获取一个Token,有效期5分钟
        Boolean set = redisTemplate.opsForValue()
            .setIfAbsent(tokenKey, token, 5, TimeUnit.MINUTES);
        if (Boolean.FALSE.equals(set)) {
            return Result.fail("请勿频繁获取Token");
        }
        return Result.success(token);
    }

    /**
     * 执行秒杀
     */
    @PostMapping("/execute")
    public Result<SeckillResult> execute(
            @RequestBody SeckillRequest request) {
        SeckillResult result = seckillService.execute(
            request.getUserId(),
            request.getActivityId(),
            request.getToken()
        );
        return Result.success(result);
    }
}

三、面试模拟篇(20%)

Q1:如何防止超卖?

面试官:秒杀场景下如何绝对防止超卖?

分层回答:

Redis层(第一道防线):

数据库层(最终防线):

对账机制(兜底):

关键代码:


-- 这条SQL就是防超卖的根本保证
UPDATE seckill_stock SET stock = stock - 1
WHERE activity_id = 100 AND stock > 0;
-- 影响行数为0 → 库存已空,不超卖

Q2:如何应对瞬时流量洪峰?

面试官:秒杀开始的瞬间有100万用户同时点击,你怎么扛住?

回答结构:

1. CDN层:秒杀页面全部静态化,JS/CSS/图片走CDN,请求根本不到后端

2. 按钮策略:前端按钮点击后置灰3秒 + 随机散列(加入随机延迟1-3秒),打散请求

3. Nginx限流:limit_req zone=seckill burst=100 nodelay;,直接丢弃超限请求

4. 网关层:Sentinel集群限流,多节点共享配额

5. Redis预扣:Lua脚本微秒级处理,不经过任何数据库

6. MQ削峰:扣完库存后直接返回"排队中",实际订单创建走MQ异步

核心思想:层层过滤,最终到达数据库的请求只是库存数量的量级。

Q3:Redis扣完库存后MQ发送失败怎么办?

这是一个典型的分布式一致性问题。

方案:

1. MQ发送失败时立即回滚Redis库存(increment + sadd移除)

2. 引入本地消息表:扣库存成功后先写本地消息表,定时任务补偿发送

3. RocketMQ事务消息:先发半消息,扣库存成功后提交,失败则回滚


四、练习篇(10%)

练习1:库存预热+秒杀完整流程

请补充以下缺失代码:实现一个完整的秒杀活动从创建到结束的流程。


要求:
1. 管理后台创建秒杀活动 → 写DB + 预热Redis
2. 用户获取Token → 执行秒杀 → 查询结果
3. 活动结束 → 库存对账 → 清理Redis缓存

练习2:防刷策略

实现基于IP + 用户ID + 设备指纹的三维防刷机制。


// 提示:使用Redis HyperLogLog统计唯一访问
// IP维度:同一IP每秒最多5次
// 用户维度:同一用户每秒最多3次
// 设备维度:同一设备每分钟最多10次

练习3:压测方案设计

为秒杀系统设计一个JMeter压测方案。


要求:
1. 模拟10000并发用户
2. 思考时间(随机延迟0-5秒)
3. 断言:成功率>99%、RT<500ms
4. 监控指标:CPU、内存、Redis命中率、MQ堆积

架构要点速查表

层级技术作用
CDN静态资源隔离99%的读流量
Nginxlimit_req第一道限流
GatewaySentinel集群限流 + 鉴权
应用层Lua脚本原子扣库存
MQRocketMQ异步削峰
DB乐观锁最终防超卖

上一篇:P4-01-高并发系统设计方法论
下一篇:P4-03-分布式事务实战