1. 优惠券秒杀活动概述

优惠券秒杀活动是电商平台的重要营销手段，通过限时优惠吸引用户参与，提升平台活跃度和销量。在高并发场景下，需要处理大量用户同时抢购的情况。本文将详细介绍优惠券系统、秒杀活动、库存管理、限流控制和订单处理的高并发解决方案。

1.1 核心功能

  1. 优惠券系统: 优惠券创建、发放、使用
  2. 秒杀活动: 限时抢购、库存控制
  3. 高并发处理: 限流控制、队列处理
  4. 库存管理: 预扣库存、回滚机制
  5. 订单处理: 异步下单、状态跟踪

1.2 技术架构

1
2
3
4
5
用户请求 → 限流控制 → 库存预扣 → 异步下单 → 订单处理
   ↓         ↓         ↓         ↓         ↓
高并发 → 令牌桶 → Redis扣减 → 消息队列 → 数据库
   ↓         ↓         ↓         ↓         ↓
秒杀活动 → 防刷机制 → 库存回滚 → 状态通知 → 结果返回

2. 优惠券秒杀配置

2.1 Maven依赖配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<!-- pom.xml -->
<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring Boot Data Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <!-- Spring Boot Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <!-- RabbitMQ -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    
    <!-- Guava限流 -->
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>31.1-jre</version>
    </dependency>
    
    <!-- Redisson分布式锁 -->
    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson-spring-boot-starter</artifactId>
        <version>3.17.7</version>
    </dependency>
</dependencies>

2.2 优惠券秒杀配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
/**
 * 优惠券秒杀配置类
 */
@Configuration
public class CouponSeckillConfig {
    
    @Value("${seckill.rate-limit.permits-per-second:100}")
    private int permitsPerSecond;
    
    @Value("${seckill.rate-limit.burst-capacity:200}")
    private int burstCapacity;
    
    @Value("${seckill.stock.prefix:seckill:stock}")
    private String stockPrefix;
    
    @Value("${seckill.user.prefix:seckill:user}")
    private String userPrefix;
    
    /**
     * 优惠券秒杀配置属性
     */
    @Bean
    public SeckillProperties seckillProperties() {
        return SeckillProperties.builder()
            .permitsPerSecond(permitsPerSecond)
            .burstCapacity(burstCapacity)
            .stockPrefix(stockPrefix)
            .userPrefix(userPrefix)
            .build();
    }
    
    /**
     * 限流器
     */
    @Bean
    public RateLimiter rateLimiter() {
        return RateLimiter.create(permitsPerSecond);
    }
    
    /**
     * 优惠券服务
     */
    @Bean
    public CouponService couponService() {
        return new CouponService(seckillProperties());
    }
    
    /**
     * 秒杀服务
     */
    @Bean
    public SeckillService seckillService() {
        return new SeckillService(seckillProperties());
    }
    
    /**
     * 库存服务
     */
    @Bean
    public StockService stockService() {
        return new StockService(seckillProperties());
    }
}

/**
 * 秒杀配置属性
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SeckillProperties {
    private int permitsPerSecond;
    private int burstCapacity;
    private String stockPrefix;
    private String userPrefix;
    
    // 限流配置
    private boolean enableRateLimit = true;
    private int maxRequestsPerUser = 10;
    private int maxRequestsPerIp = 100;
    
    // 库存配置
    private boolean enablePreReduce = true;
    private int preReduceTimeout = 30; // 秒
    private boolean enableStockRollback = true;
    
    // 活动配置
    private int maxSeckillDuration = 3600; // 秒
    private boolean enableAntiBrush = true;
    private int antiBrushThreshold = 5;
}

3. 数据模型定义

3.1 优惠券秒杀数据模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
/**
 * 优惠券模型
 */
@Entity
@Table(name = "coupon")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Coupon {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "name", nullable = false)
    private String name;
    
    @Column(name = "type", nullable = false)
    private String type; // DISCOUNT, CASH, GIFT
    
    @Column(name = "discount_amount", precision = 15, scale = 2)
    private BigDecimal discountAmount;
    
    @Column(name = "discount_rate", precision = 5, scale = 2)
    private BigDecimal discountRate;
    
    @Column(name = "min_order_amount", precision = 15, scale = 2)
    private BigDecimal minOrderAmount;
    
    @Column(name = "max_discount_amount", precision = 15, scale = 2)
    private BigDecimal maxDiscountAmount;
    
    @Column(name = "total_count", nullable = false)
    private Integer totalCount;
    
    @Column(name = "used_count", nullable = false)
    private Integer usedCount;
    
    @Column(name = "status", nullable = false)
    private String status; // ACTIVE, INACTIVE, EXPIRED
    
    @Column(name = "start_time", nullable = false)
    private LocalDateTime startTime;
    
    @Column(name = "end_time", nullable = false)
    private LocalDateTime endTime;
    
    @Column(name = "create_time", nullable = false)
    private LocalDateTime createTime;
}

/**
 * 秒杀活动模型
 */
@Entity
@Table(name = "seckill_activity")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SeckillActivity {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "name", nullable = false)
    private String name;
    
    @Column(name = "coupon_id", nullable = false)
    private Long couponId;
    
    @Column(name = "stock_count", nullable = false)
    private Integer stockCount;
    
    @Column(name = "sold_count", nullable = false)
    private Integer soldCount;
    
    @Column(name = "start_time", nullable = false)
    private LocalDateTime startTime;
    
    @Column(name = "end_time", nullable = false)
    private LocalDateTime endTime;
    
    @Column(name = "status", nullable = false)
    private String status; // PENDING, ACTIVE, ENDED, CANCELLED
    
    @Column(name = "create_time", nullable = false)
    private LocalDateTime createTime;
    
    @Column(name = "update_time", nullable = false)
    private LocalDateTime updateTime;
}

/**
 * 秒杀订单模型
 */
@Entity
@Table(name = "seckill_order")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SeckillOrder {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "order_no", nullable = false, unique = true)
    private String orderNo;
    
    @Column(name = "user_id", nullable = false)
    private Long userId;
    
    @Column(name = "activity_id", nullable = false)
    private Long activityId;
    
    @Column(name = "coupon_id", nullable = false)
    private Long couponId;
    
    @Column(name = "status", nullable = false)
    private String status; // PENDING, SUCCESS, FAILED, CANCELLED
    
    @Column(name = "seckill_time", nullable = false)
    private LocalDateTime seckillTime;
    
    @Column(name = "create_time", nullable = false)
    private LocalDateTime createTime;
    
    @Column(name = "update_time", nullable = false)
    private LocalDateTime updateTime;
}

/**
 * 秒杀结果模型
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SeckillResult {
    private boolean success;
    private String message;
    private String orderNo;
    private Long userId;
    private Long activityId;
    private LocalDateTime seckillTime;
    private String status;
}

4. 限流控制服务

4.1 限流控制服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
/**
 * 限流控制服务
 */
@Service
public class RateLimitService {
    
    private final RateLimiter rateLimiter;
    private final RedisTemplate<String, Object> redisTemplate;
    private final SeckillProperties properties;
    
    public RateLimitService(RateLimiter rateLimiter, RedisTemplate<String, Object> redisTemplate, 
                           SeckillProperties properties) {
        this.rateLimiter = rateLimiter;
        this.redisTemplate = redisTemplate;
        this.properties = properties;
    }
    
    /**
     * 检查是否允许请求
     * @param userId 用户ID
     * @param activityId 活动ID
     * @return 是否允许
     */
    public boolean isAllowed(Long userId, Long activityId) {
        try {
            // 1. 全局限流
            if (!rateLimiter.tryAcquire(1, TimeUnit.SECONDS)) {
                log.warn("全局限流触发: userId={}, activityId={}", userId, activityId);
                return false;
            }
            
            // 2. 用户限流
            if (!checkUserRateLimit(userId, activityId)) {
                log.warn("用户限流触发: userId={}, activityId={}", userId, activityId);
                return false;
            }
            
            // 3. 防刷检查
            if (!checkAntiBrush(userId, activityId)) {
                log.warn("防刷检查失败: userId={}, activityId={}", userId, activityId);
                return false;
            }
            
            return true;
            
        } catch (Exception e) {
            log.error("限流检查失败: userId={}, activityId={}", userId, activityId, e);
            return false;
        }
    }
    
    /**
     * 检查用户限流
     * @param userId 用户ID
     * @param activityId 活动ID
     * @return 是否允许
     */
    private boolean checkUserRateLimit(Long userId, Long activityId) {
        String key = properties.getUserPrefix() + ":" + activityId + ":" + userId;
        
        try {
            String count = (String) redisTemplate.opsForValue().get(key);
            int currentCount = count != null ? Integer.parseInt(count) : 0;
            
            if (currentCount >= properties.getMaxRequestsPerUser()) {
                return false;
            }
            
            // 增加计数
            redisTemplate.opsForValue().increment(key);
            redisTemplate.expire(key, Duration.ofMinutes(1));
            
            return true;
            
        } catch (Exception e) {
            log.error("用户限流检查失败: userId={}, activityId={}", userId, activityId, e);
            return false;
        }
    }
    
    /**
     * 防刷检查
     * @param userId 用户ID
     * @param activityId 活动ID
     * @return 是否允许
     */
    private boolean checkAntiBrush(Long userId, Long activityId) {
        if (!properties.isEnableAntiBrush()) {
            return true;
        }
        
        String key = "anti_brush:" + activityId + ":" + userId;
        
        try {
            String count = (String) redisTemplate.opsForValue().get(key);
            int currentCount = count != null ? Integer.parseInt(count) : 0;
            
            if (currentCount >= properties.getAntiBrushThreshold()) {
                return false;
            }
            
            // 增加计数
            redisTemplate.opsForValue().increment(key);
            redisTemplate.expire(key, Duration.ofSeconds(10));
            
            return true;
            
        } catch (Exception e) {
            log.error("防刷检查失败: userId={}, activityId={}", userId, activityId, e);
            return false;
        }
    }
}

5. 库存管理服务

5.1 库存管理服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
/**
 * 库存管理服务
 */
@Service
public class StockService {
    
    private final RedisTemplate<String, Object> redisTemplate;
    private final SeckillProperties properties;
    private final RedissonClient redissonClient;
    
    public StockService(SeckillProperties properties) {
        this.properties = properties;
        this.redisTemplate = new RedisTemplate<>();
        this.redissonClient = null; // 注入
    }
    
    /**
     * 预扣库存
     * @param activityId 活动ID
     * @param userId 用户ID
     * @return 是否成功
     */
    public boolean preReduceStock(Long activityId, Long userId) {
        String lockKey = "stock_lock:" + activityId;
        RLock lock = redissonClient.getLock(lockKey);
        
        try {
            // 获取分布式锁
            if (lock.tryLock(3, TimeUnit.SECONDS)) {
                try {
                    String stockKey = properties.getStockPrefix() + ":" + activityId;
                    
                    // 检查库存
                    String stockStr = (String) redisTemplate.opsForValue().get(stockKey);
                    int stock = stockStr != null ? Integer.parseInt(stockStr) : 0;
                    
                    if (stock <= 0) {
                        return false;
                    }
                    
                    // 预扣库存
                    redisTemplate.opsForValue().decrement(stockKey);
                    
                    // 设置用户预扣记录
                    String userStockKey = "user_stock:" + activityId + ":" + userId;
                    redisTemplate.opsForValue().set(userStockKey, "1", 
                        Duration.ofSeconds(properties.getPreReduceTimeout()));
                    
                    log.info("预扣库存成功: activityId={}, userId={}, remainingStock={}", 
                        activityId, userId, stock - 1);
                    
                    return true;
                    
                } finally {
                    lock.unlock();
                }
            } else {
                log.warn("获取库存锁失败: activityId={}, userId={}", activityId, userId);
                return false;
            }
            
        } catch (Exception e) {
            log.error("预扣库存失败: activityId={}, userId={}", activityId, userId, e);
            return false;
        }
    }
    
    /**
     * 确认扣减库存
     * @param activityId 活动ID
     * @param userId 用户ID
     * @return 是否成功
     */
    public boolean confirmReduceStock(Long activityId, Long userId) {
        String userStockKey = "user_stock:" + activityId + ":" + userId;
        
        try {
            // 检查用户预扣记录
            String userStock = (String) redisTemplate.opsForValue().get(userStockKey);
            if (userStock == null) {
                return false;
            }
            
            // 删除预扣记录
            redisTemplate.delete(userStockKey);
            
            log.info("确认扣减库存成功: activityId={}, userId={}", activityId, userId);
            
            return true;
            
        } catch (Exception e) {
            log.error("确认扣减库存失败: activityId={}, userId={}", activityId, userId, e);
            return false;
        }
    }
    
    /**
     * 回滚库存
     * @param activityId 活动ID
     * @param userId 用户ID
     * @return 是否成功
     */
    public boolean rollbackStock(Long activityId, Long userId) {
        if (!properties.isEnableStockRollback()) {
            return true;
        }
        
        String lockKey = "stock_lock:" + activityId;
        RLock lock = redissonClient.getLock(lockKey);
        
        try {
            if (lock.tryLock(3, TimeUnit.SECONDS)) {
                try {
                    String stockKey = properties.getStockPrefix() + ":" + activityId;
                    String userStockKey = "user_stock:" + activityId + ":" + userId;
                    
                    // 检查用户预扣记录
                    String userStock = (String) redisTemplate.opsForValue().get(userStockKey);
                    if (userStock != null) {
                        // 回滚库存
                        redisTemplate.opsForValue().increment(stockKey);
                        
                        // 删除预扣记录
                        redisTemplate.delete(userStockKey);
                        
                        log.info("回滚库存成功: activityId={}, userId={}", activityId, userId);
                    }
                    
                    return true;
                    
                } finally {
                    lock.unlock();
                }
            } else {
                log.warn("获取库存锁失败: activityId={}, userId={}", activityId, userId);
                return false;
            }
            
        } catch (Exception e) {
            log.error("回滚库存失败: activityId={}, userId={}", activityId, userId, e);
            return false;
        }
    }
    
    /**
     * 获取库存数量
     * @param activityId 活动ID
     * @return 库存数量
     */
    public int getStock(Long activityId) {
        try {
            String stockKey = properties.getStockPrefix() + ":" + activityId;
            String stockStr = (String) redisTemplate.opsForValue().get(stockKey);
            return stockStr != null ? Integer.parseInt(stockStr) : 0;
        } catch (Exception e) {
            log.error("获取库存失败: activityId={}", activityId, e);
            return 0;
        }
    }
}

6. 秒杀服务

6.1 秒杀服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
/**
 * 秒杀服务
 */
@Service
public class SeckillService {
    
    private final SeckillProperties properties;
    private final RateLimitService rateLimitService;
    private final StockService stockService;
    private final SeckillOrderRepository orderRepository;
    private final RabbitTemplate rabbitTemplate;
    
    public SeckillService(SeckillProperties properties) {
        this.properties = properties;
        this.rateLimitService = null; // 注入
        this.stockService = null; // 注入
        this.orderRepository = null; // 注入
        this.rabbitTemplate = null; // 注入
    }
    
    /**
     * 执行秒杀
     * @param userId 用户ID
     * @param activityId 活动ID
     * @return 秒杀结果
     */
    public SeckillResult executeSeckill(Long userId, Long activityId) {
        try {
            // 1. 限流检查
            if (!rateLimitService.isAllowed(userId, activityId)) {
                return SeckillResult.builder()
                    .success(false)
                    .message("请求过于频繁，请稍后再试")
                    .userId(userId)
                    .activityId(activityId)
                    .seckillTime(LocalDateTime.now())
                    .status("RATE_LIMITED")
                    .build();
            }
            
            // 2. 预扣库存
            if (!stockService.preReduceStock(activityId, userId)) {
                return SeckillResult.builder()
                    .success(false)
                    .message("库存不足")
                    .userId(userId)
                    .activityId(activityId)
                    .seckillTime(LocalDateTime.now())
                    .status("OUT_OF_STOCK")
                    .build();
            }
            
            // 3. 异步处理订单
            String orderNo = generateOrderNo();
            SeckillOrderMessage message = SeckillOrderMessage.builder()
                .orderNo(orderNo)
                .userId(userId)
                .activityId(activityId)
                .seckillTime(LocalDateTime.now())
                .build();
            
            rabbitTemplate.convertAndSend("seckill.order.queue", message);
            
            return SeckillResult.builder()
                .success(true)
                .message("秒杀成功，订单处理中")
                .orderNo(orderNo)
                .userId(userId)
                .activityId(activityId)
                .seckillTime(LocalDateTime.now())
                .status("PROCESSING")
                .build();
            
        } catch (Exception e) {
            log.error("秒杀执行失败: userId={}, activityId={}", userId, activityId, e);
            
            // 回滚库存
            stockService.rollbackStock(activityId, userId);
            
            return SeckillResult.builder()
                .success(false)
                .message("秒杀失败: " + e.getMessage())
                .userId(userId)
                .activityId(activityId)
                .seckillTime(LocalDateTime.now())
                .status("FAILED")
                .build();
        }
    }
    
    /**
     * 处理秒杀订单
     * @param message 订单消息
     */
    @RabbitListener(queues = "seckill.order.queue")
    public void processSeckillOrder(SeckillOrderMessage message) {
        try {
            // 1. 确认扣减库存
            if (!stockService.confirmReduceStock(message.getActivityId(), message.getUserId())) {
                log.warn("确认扣减库存失败: orderNo={}", message.getOrderNo());
                return;
            }
            
            // 2. 创建订单
            SeckillOrder order = SeckillOrder.builder()
                .orderNo(message.getOrderNo())
                .userId(message.getUserId())
                .activityId(message.getActivityId())
                .couponId(getCouponIdByActivity(message.getActivityId()))
                .status("SUCCESS")
                .seckillTime(message.getSeckillTime())
                .createTime(LocalDateTime.now())
                .updateTime(LocalDateTime.now())
                .build();
            
            orderRepository.save(order);
            
            log.info("秒杀订单处理成功: orderNo={}, userId={}, activityId={}", 
                message.getOrderNo(), message.getUserId(), message.getActivityId());
            
        } catch (Exception e) {
            log.error("处理秒杀订单失败: orderNo={}", message.getOrderNo(), e);
            
            // 回滚库存
            stockService.rollbackStock(message.getActivityId(), message.getUserId());
        }
    }
    
    /**
     * 生成订单号
     * @return 订单号
     */
    private String generateOrderNo() {
        return "SK" + System.currentTimeMillis() + RandomUtils.nextInt(1000, 9999);
    }
    
    /**
     * 根据活动ID获取优惠券ID
     * @param activityId 活动ID
     * @return 优惠券ID
     */
    private Long getCouponIdByActivity(Long activityId) {
        // 实现根据活动ID获取优惠券ID的逻辑
        return 1L;
    }
}

/**
 * 秒杀订单消息模型
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SeckillOrderMessage {
    private String orderNo;
    private Long userId;
    private Long activityId;
    private LocalDateTime seckillTime;
}

7. 优惠券秒杀控制器

7.1 优惠券秒杀控制器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/**
 * 优惠券秒杀控制器
 */
@RestController
@RequestMapping("/seckill")
public class CouponSeckillController {
    
    @Autowired
    private SeckillService seckillService;
    
    @Autowired
    private StockService stockService;
    
    /**
     * 执行秒杀
     */
    @PostMapping("/execute")
    public ResponseEntity<Map<String, Object>> executeSeckill(
            @RequestParam Long userId,
            @RequestParam Long activityId) {
        try {
            SeckillResult result = seckillService.executeSeckill(userId, activityId);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", result.isSuccess());
            response.put("message", result.getMessage());
            response.put("orderNo", result.getOrderNo());
            response.put("status", result.getStatus());
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("秒杀执行失败: userId={}, activityId={}", userId, activityId, e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "秒杀失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    /**
     * 获取库存
     */
    @GetMapping("/stock/{activityId}")
    public ResponseEntity<Map<String, Object>> getStock(@PathVariable Long activityId) {
        try {
            int stock = stockService.getStock(activityId);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", true);
            response.put("stock", stock);
            response.put("activityId", activityId);
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            log.error("获取库存失败: activityId={}", activityId, e);
            
            Map<String, Object> response = new HashMap<>();
            response.put("success", false);
            response.put("message", "获取库存失败: " + e.getMessage());
            
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
}

8. 总结

通过优惠券秒杀活动的实现，我们成功构建了一个高并发的秒杀系统。关键特性包括：

8.1 核心优势

  1. 优惠券系统: 优惠券创建、发放、使用
  2. 秒杀活动: 限时抢购、库存控制
  3. 高并发处理: 限流控制、队列处理
  4. 库存管理: 预扣库存、回滚机制
  5. 订单处理: 异步下单、状态跟踪

8.2 最佳实践

  1. 限流控制: 多层级限流和防刷机制
  2. 库存管理: 预扣库存和回滚机制
  3. 异步处理: 消息队列异步处理订单
  4. 分布式锁: 保证库存扣减的原子性
  5. 监控告警: 全面的监控和异常处理

这套优惠券秒杀方案不仅能够处理高并发场景，还包含了完整的限流控制、库存管理、订单处理等核心功能，是电商平台的重要营销工具。