要设计并实现一个秒杀功能，我们需要解决几个关键的问题，首先来讲秒杀活动通常情况下常伴随着大量用户并发请求，所以要求系统需要具备处理高并发的能力。其次，在设计秒杀系统的时候需要注意必须确保库存不会出现超卖的情况，在用户提交了订单之后，还要确保订单创建的原子性不能因为并发问题导致订单创建重复或失败。另外就是在并发请求的情况下，如何能够保证接口不被攻击，要有防止刷单、限流等策略，并且在一个秒杀功能中，需要引入到一些缓存中间件来减轻数据的压力。

技术选型

基于上面我们分析的内容，给出一个如下的技术选型方案。

• Spring Boot：主框架，用于构建微服务。
• Redis：用于缓存库存数据，减轻数据库压力，快速响应库存查询。
• MySQL：持久化存储订单和商品信息。
• 消息队列（如 RabbitMQ 或 Kafka）：用于异步下单，削峰填谷，缓解数据库压力。
• 分布式锁（如 Redis 分布式锁）：用于防止超卖，确保并发下的库存扣减是安全的。
• 限流（如 RateLimiter、Redis Lua 脚本）：防止恶意刷单或攻击。

下面我们给出一个简单的实现步骤来演示如何实现一个秒杀系统。

具体实现

数据库设计

创建两个基本表：商品表和订单表，如下所示。

商品表

CREATE TABLE `product` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(100) NOT NULL,
  `stock` INT NOT NULL COMMENT '商品库存',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

订单表

CREATE TABLE `order` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT,
  `product_id` BIGINT(20) NOT NULL,
  `user_id` BIGINT(20) NOT NULL,
  `status` TINYINT(1) NOT NULL COMMENT '订单状态',
  `create_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

库表设计完成之后，接下来我们来分析一下需要实现的业务逻辑，主要涉及到的业务流程包括了如下的几个方面的内容。

• 用户请求秒杀，前端发起秒杀请求。
• 通过限流和鉴权确保合法用户请求。
• 使用 Redis 缓存商品库存，并通过 Redis 进行库存的扣减。
• 将秒杀请求放入消息队列，异步处理实际的下单和订单生成操作。
• 返回成功或失败的秒杀结果给用户。

结合上面的需求我们尝试实现这个需求。首先我们先来定义一个秒杀的接口用来接收用户的秒杀请求。如下所示。

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

    @Autowired
    private SeckillService seckillService;

    @PostMapping("/{productId}")
    public ResponseEntity<String> seckill(@PathVariable Long productId) {
        // 获取当前用户 ID，通常在登录状态中获得
        Long userId = getCurrentUserId();
        
        // 调用秒杀业务逻辑
        boolean result = seckillService.executeSeckill(productId, userId);
        
        if (result) {
            return ResponseEntity.ok("秒杀成功");
        } else {
            return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS).body("秒杀失败或库存不足");
        }
    }
}

接下来就是在服务层中对秒杀的业务进行处理，如下所示。

@Service
public class SeckillService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private OrderService orderService;

    // 秒杀核心方法
    public boolean executeSeckill(Long productId, Long userId) {
        // 1. 检查库存是否足够（使用 Redis）
        String stockKey = "product_stock_" + productId;
        Integer stock = (Integer) redisTemplate.opsForValue().get(stockKey);

        if (stock == null || stock <= 0) {
            return false;
        }

        // 2. 扣减库存（原子操作，使用 Redis 的 Decr 命令）
        Long newStock = redisTemplate.opsForValue().decrement(stockKey);
        if (newStock < 0) {
            return false;
        }

        // 3. 将请求放入消息队列（异步下单）
        // 例如使用 RabbitMQ 进行异步下单处理
        orderService.createOrderAsync(productId, userId);

        return true;
    }
}

为了避免数据库的高并发压力，我们将订单的生成放入消息队列进行异步处理，如下所示。

@Service
public class OrderService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private OrderRepository orderRepository;

    // 异步创建订单
    public void createOrderAsync(Long productId, Long userId) {
        // 这里使用消息队列的方式处理订单
        // 可以用 RabbitMQ 或 Kafka

        // 消息处理逻辑
        createOrder(productId, userId);
    }

    // 实际创建订单逻辑
    @Transactional
    public void createOrder(Long productId, Long userId) {
        // 1. 检查库存（从数据库中获取最新库存）
        Product product = productRepository.findById(productId).orElseThrow(() -> new RuntimeException("商品不存在"));
        
        if (product.getStock() <= 0) {
            throw new RuntimeException("库存不足");
        }

        // 2. 扣减库存
        product.setStock(product.getStock() - 1);
        productRepository.save(product);

        // 3. 创建订单
        Order order = new Order();
        order.setProductId(productId);
        order.setUserId(userId);
        order.setStatus(1);  // 状态：已创建
        orderRepository.save(order);
    }
}

Redis的Decr命令是一个原子操作，可以避免高并发下的超卖问题。在实际库存扣减时，我们可以加上分布式锁（Redis 的 setnx 命令），确保多个用户同时扣减库存时的线程安全。

另外我们可以通过Redis来实现限流操作，如下所示。

@Aspect
@Component
public class RateLimiterAspect {

    private final RateLimiter rateLimiter = RateLimiter.create(100); // 每秒最多处理100个请求

    @Around("@annotation(SeckillLimit)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        if (!rateLimiter.tryAcquire()) {
            throw new RuntimeException("请求过多，限流中");
        }
        return joinPoint.proceed();
    }
}

总结

以上就是基于Spring Boot技术栈实现的秒杀系统可以处理高并发场景，为了防止超卖情况，我们通过Redis技术和消息队列技术来保证系统的高性能和高可用性，具体使用场景中可以结合实际的业务需求对相关内容进行调整优化。