Java实现简单秒杀功能

        在商城项目中，秒杀功能可以说是必不可少的，下面我将使用Spring Boot集成Redis、RabbitMQ、MyBatis-Plus和MySQL来实现一个简单的秒杀系统，系统将包含以下核心功能：

1. 使用Redis进行库存预减和用户限流；

2. 使用RabbitMQ进行异步下单，提高系统吞吐量；

3. 使用MyBatis-Plus操作MySQL数据库；

4. 利用Redis执行Lua脚本的原子性防止商品超卖；

5. 接口限流（使用Redis或网关限流，这里使用gateway实现简单限流）；

一、系统架构

二、数据库设计 

1. 秒杀商品表 (seckill_goods)

CREATE TABLE `seckill_goods` (
  `id` BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '秒杀商品ID',
  `origin_id` BIGINT(20) NOT NULL COMMENT '原始商品ID',
  `name` VARCHAR(100) NOT NULL COMMENT '商品名称',
  `price` DECIMAL(10,2) NOT NULL DEFAULT '0.00' COMMENT '原价',
  `seckill_price` DECIMAL(10,2) NOT NULL COMMENT '秒杀价',
  `stock` INT(11) NOT NULL COMMENT '库存数量',
  `start_time` DATETIME NOT NULL COMMENT '开始时间',
  `end_time` DATETIME NOT NULL COMMENT '结束时间',
  `is_active` TINYINT(1) NOT NULL DEFAULT '1' COMMENT '是否启用',
  `version` INT(11) NOT NULL DEFAULT '0' COMMENT '乐观锁版本',
  `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  KEY `idx_time` (`start_time`,`end_time`),
  KEY `idx_origin` (`origin_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='秒杀商品表';

2. 订单表 (seckill_order)

CREATE TABLE `seckill_order` (
  `id` VARCHAR(32) NOT NULL COMMENT '订单ID(时间戳+用户ID哈希)',
  `user_id` BIGINT(20) UNSIGNED NOT NULL COMMENT '用户ID',
  `goods_id` BIGINT(20) UNSIGNED NOT NULL COMMENT '秒杀商品ID',
  `quantity` INT(11) NOT NULL DEFAULT '1' COMMENT '购买数量',
  `price` DECIMAL(10,2) NOT NULL COMMENT '实际支付价格',
  `status` TINYINT(4) NOT NULL DEFAULT '0' COMMENT '0-未支付 1-已支付 2-已取消',
  `create_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `update_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  KEY `idx_user_goods` (`user_id`,`goods_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='秒杀订单表';

三、网关层实现（Spring Cloud Gateway）

1.Gateway配置类

@Configuration
public class GatewayConfig {
    
    private static final Logger log = LoggerFactory.getLogger(GatewayConfig.class);
    
    // 限流过滤器
    @Bean
    @Order(-1)
    public GlobalFilter rateLimitFilter() {
        return (exchange, chain) -> {
            ServerHttpRequest request = exchange.getRequest();
            String ip = Objects.requireNonNull(request.getRemoteAddress()).getAddress().getHostAddress();
            String path = request.getPath().value();
            
            // 秒杀接口特殊限流
            if (path.startsWith("/api/seckill")) {
                if (!rateLimiter.tryAcquire(ip, 1, 5, TimeUnit.SECONDS)) {
                    log.warn("IP限流触发: {}", ip);
                    exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
                    return exchange.getResponse().setComplete();
                }
            }
            return chain.filter(exchange);
        };
    }
    
    // 路由配置
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("seckill_route", r -> r.path("/api/seckill/**")
                .filters(f -> f.stripPrefix(2)
                    // 添加请求头
                    .addRequestHeader("X-Seckill-Token", "secure_token")
                    .circuitBreaker(config -> config
                        .setName("seckillCircuitBreaker")
                        // 设置回调方法请求地址（失败时）
                        .setFallbackUri("forward:/fallback")))
                // 为秒杀请求配置负载均衡
                .uri("lb://seckill-service"))
            .route("order_route", r -> r.path("/api/order/**")
                .filters(f -> f.stripPrefix(2))
                .uri("lb://order-service"))
            .build();
    }
    
    // 断路器降级处理
    @RequestMapping("/fallback")
    public Mono> fallback() {
        return Mono.just(ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
            .body("{\"code\":503,\"message\":\"服务不可用，请稍后重试\"}"));
    }
}

2.Redis限流器

@Service
public class RedisRateLimiter {
    
    private final RedisTemplate redisTemplate;
    
    public RedisRateLimiter(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    
    // 参数含义：redis的key、窗口期内可请求的最大次数、周期、时间单位
    public boolean tryAcquire(String key, int permits, int period, TimeUnit timeUnit) {
        String redisKey = "rate_limit:" + key;
        long current = System.currentTimeMillis();
        long windowStart = current - timeUnit.toMillis(period);
        
        return redisTemplate.execute(new SessionCallback() {
            @Override
            @SuppressWarnings("unchecked")
            public Boolean execute(RedisOperations operations) {
                operations.multi();
                // 创建一条记录
                operations.opsForZSet().add(redisKey, current, current);
                // 删除不在窗口期的请求记录
                operations.opsForZSet().removeRangeByScore(redisKey, 0, windowStart);
                // 计算窗口期内请求的次数
                operations.opsForZSet().zCard(redisKey);
                // 设置过期时间，提高内存利用率
                operations.expire(redisKey, period + 1, timeUnit);
                
                List