一、系统架构设计

1.1 模块划分

优惠券领取系统可分为四个核心模块：用户服务、优惠券服务、库存服务、日志服务。用户服务负责用户身份验证与权限控制，优惠券服务管理优惠券类型与规则，库存服务处理并发领取的原子性操作，日志服务记录操作轨迹。采用微服务架构时，各模块可通过REST API或RPC进行通信，建议使用Spring Cloud实现服务发现与熔断机制。

1.2 数据库设计

表结构包含四张核心表：用户表(user)、优惠券表(coupon)、库存表(coupon_stock)、领取记录表(coupon_record)。关键设计点包括：

• 库存表采用状态字段(status)标记优惠券是否可用
• 领取记录表记录用户ID、优惠券ID、领取时间、使用状态等字段
• 索引设计：用户ID+优惠券ID的复合索引加速查询

1.3 接口定义

主要接口包括：

// 优惠券服务接口
public interface CouponService {
    // 领取优惠券
    Result<CouponRecord> acquireCoupon(Long userId, Long couponId);
    // 查询用户优惠券
    List<CouponRecord> queryUserCoupons(Long userId);
}
// 库存服务接口
public interface StockService {
    // 扣减库存
    boolean decreaseStock(Long couponId);
}

二、核心实现方案

2.1 并发控制实现

2.1.1 数据库乐观锁方案

@Transactional
public boolean decreaseStockWithOptimisticLock(Long couponId) {
    CouponStock stock = couponStockMapper.selectById(couponId);
    if (stock.getStock() <= 0) {
        return false;
    }
    int updated = couponStockMapper.updateStock(
        couponId, 
        stock.getVersion(), 
        stock.getStock() - 1
    );
    return updated > 0;
}
// Mapper XML
<update id="updateStock">
    UPDATE coupon_stock 
    SET stock = stock - 1, version = version + 1
    WHERE id = #{id} AND version = #{version} AND stock > 0
</update>

2.1.2 Redis分布式锁方案

public boolean acquireWithRedisLock(Long userId, Long couponId) {
    String lockKey = "coupon:lock:" + couponId;
    String requestId = UUID.randomUUID().toString();
    try {
        // 尝试获取锁，设置10秒过期
        boolean locked = redisTemplate.opsForValue().setIfAbsent(
            lockKey, 
            requestId, 
            10, 
            TimeUnit.SECONDS
        );
        if (!locked) {
            return false;
        }
        // 业务处理
        return stockService.decreaseStock(couponId);
    } finally {
        // 释放锁（需校验requestId防止误删）
        String currentValue = redisTemplate.opsForValue().get(lockKey);
        if (requestId.equals(currentValue)) {
            redisTemplate.delete(lockKey);
        }
    }
}

2.2 业务逻辑实现

2.2.1 完整领取流程

@Service
public class CouponServiceImpl implements CouponService {
    @Autowired
    private StockService stockService;
    @Autowired
    private CouponRecordMapper recordMapper;
    @Override
    @Transactional
    public Result<CouponRecord> acquireCoupon(Long userId, Long couponId) {
        // 1. 参数校验
        if (userId == null || couponId == null) {
            return Result.fail("参数错误");
        }
        // 2. 并发控制（选择方案）
        boolean success = stockService.decreaseStock(couponId);
        if (!success) {
            return Result.fail("优惠券已领完");
        }
        // 3. 创建领取记录
        CouponRecord record = new CouponRecord();
        record.setUserId(userId);
        record.setCouponId(couponId);
        record.setStatus(CouponStatus.UNUSED);
        record.setAcquireTime(new Date());
        recordMapper.insert(record);
        // 4. 返回结果
        return Result.success(record);
    }
}

2.2.2 防重复领取实现

public boolean checkAndAcquire(Long userId, Long couponId) {
    // 查询是否已领取过
    int count = recordMapper.selectCount(
        new QueryWrapper<CouponRecord>()
            .eq("user_id", userId)
            .eq("coupon_id", couponId)
            .eq("status", CouponStatus.UNUSED)
    );
    if (count > 0) {
        return false;
    }
    // 继续领取流程
    return acquireCoupon(userId, couponId).isSuccess();
}

三、高级优化方案

3.1 异步化处理

采用消息队列解耦领取操作与后续处理：

@Async
public void asyncProcessCoupon(CouponRecord record) {
    // 1. 发送通知
    notificationService.sendCouponNotice(record);
    // 2. 更新统计信息
    statsService.incrementAcquireCount(record.getCouponId());
    // 3. 记录操作日志
    logService.recordCouponOperation(record);
}

3.2 限流策略实现

public class RateLimiter {
    private final RateLimiter limiter = RateLimiter.create(100); // 每秒100个请求
    public boolean tryAcquire() {
        return limiter.tryAcquire();
    }
}
// 在Controller中使用
@GetMapping("/acquire")
public Result<?> acquire(@RequestParam Long couponId, HttpServletRequest request) {
    String token = request.getHeader("Authorization");
    Long userId = jwtUtil.getUserId(token);
    if (!rateLimiter.tryAcquire()) {
        return Result.fail("系统繁忙，请稍后再试");
    }
    return couponService.acquireCoupon(userId, couponId);
}

3.3 数据一致性保障

采用TCC（Try-Confirm-Cancel）模式处理分布式事务：

public interface TccCouponService {
    // 尝试阶段
    boolean tryAcquire(Long userId, Long couponId);
    // 确认阶段
    boolean confirmAcquire(Long userId, Long couponId);
    // 取消阶段
    boolean cancelAcquire(Long userId, Long couponId);
}
// 实现示例
@Transactional
public boolean tryAcquire(Long userId, Long couponId) {
    // 1. 预扣库存
    boolean stockReserved = stockService.reserveStock(couponId, 1);
    if (!stockReserved) {
        return false;
    }
    // 2. 创建预记录
    CouponRecord record = new CouponRecord();
    record.setUserId(userId);
    record.setCouponId(couponId);
    record.setStatus(CouponStatus.TRYING);
    recordMapper.insert(record);
    return true;
}

四、测试与部署方案

4.1 单元测试示例

@RunWith(SpringRunner.class)
@SpringBootTest
public class CouponServiceTest {
    @Autowired
    private CouponService couponService;
    @MockBean
    private StockService stockService;
    @Test
    public void testAcquireSuccess() {
        when(stockService.decreaseStock(1L)).thenReturn(true);
        Result<CouponRecord> result = couponService.acquireCoupon(1001L, 1L);
        assertTrue(result.isSuccess());
        assertNotNull(result.getData());
    }
    @Test
    public void testAcquireFailure() {
        when(stockService.decreaseStock(1L)).thenReturn(false);
        Result<CouponRecord> result = couponService.acquireCoupon(1001L, 1L);
        assertFalse(result.isSuccess());
        assertEquals("优惠券已领完", result.getMessage());
    }
}

4.2 压力测试方案

使用JMeter进行压力测试：

1. 线程组设置：1000个线程，循环10次
2. HTTP请求配置：/coupon/acquire接口
3. 监听器配置：聚合报告、响应时间图
4. 预期指标：QPS≥500，平均响应时间≤200ms，错误率≤0.1%

4.3 部署建议

1. 容器化部署：使用Docker打包服务，Kubernetes管理集群
2. 配置管理：通过Spring Cloud Config实现环境差异化配置
3. 监控告警：集成Prometheus+Grafana监控系统指标，设置库存阈值告警

五、最佳实践总结

1. 并发控制选择：优先使用数据库乐观锁，高并发场景下结合Redis分布式锁
2. 幂等性设计：所有写入操作必须保证幂等，防止重复提交
3. 数据一致性：重要业务采用TCC模式，普通业务采用最终一致性
4. 性能优化：热点数据缓存，异步处理非核心业务
5. 安全防护：接口限流、防刷机制、数据脱敏处理

通过以上方案，可构建一个高可用、高并发的优惠券领取系统，满足电商、O2O等场景的业务需求。实际开发中需根据具体业务场景调整技术选型和实现细节。