Java实现优惠券领取：从设计到落地的完整方案

2025年11月6日 互联网

一、系统架构设计

1.1 模块划分

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

1.2 数据库设计

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

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

1.3 接口定义

主要接口包括：

  1. // 优惠券服务接口
  2. public interface CouponService {
  3.     // 领取优惠券
  4.     Result<CouponRecord> acquireCoupon(Long userId, Long couponId);
  5.     // 查询用户优惠券
  6.     List<CouponRecord> queryUserCoupons(Long userId);
  7. }
  9. // 库存服务接口
  10. public interface StockService {
  11.     // 扣减库存
  12.     boolean decreaseStock(Long couponId);
  13. }

二、核心实现方案

2.1 并发控制实现

2.1.1 数据库乐观锁方案

  1. @Transactional
  2. public boolean decreaseStockWithOptimisticLock(Long couponId) {
  3.     CouponStock stock = couponStockMapper.selectById(couponId);
  4.     if (stock.getStock() <= 0) {
  5.         return false;
  6.     }
  7.     int updated = couponStockMapper.updateStock(
  8.         couponId, 
  9.         stock.getVersion(), 
  10.         stock.getStock() - 1
  11.     );
  12.     return updated > 0;
  13. }
  15. // Mapper XML
  16. <update id="updateStock">
  17.     UPDATE coupon_stock 
  18.     SET stock = stock - 1, version = version + 1
  19.     WHERE id = #{id} AND version = #{version} AND stock > 0
  20. </update>

2.1.2 Redis分布式锁方案

  1. public boolean acquireWithRedisLock(Long userId, Long couponId) {
  2.     String lockKey = "coupon:lock:" + couponId;
  3.     String requestId = UUID.randomUUID().toString();
  5.     try {
  6.         // 尝试获取锁，设置10秒过期
  7.         boolean locked = redisTemplate.opsForValue().setIfAbsent(
  8.             lockKey, 
  9.             requestId, 
  10.             10, 
  11.             TimeUnit.SECONDS
  12.         );
  13.         if (!locked) {
  14.             return false;
  15.         }
  17.         // 业务处理
  18.         return stockService.decreaseStock(couponId);
  19.     } finally {
  20.         // 释放锁（需校验requestId防止误删）
  21.         String currentValue = redisTemplate.opsForValue().get(lockKey);
  22.         if (requestId.equals(currentValue)) {
  23.             redisTemplate.delete(lockKey);
  24.         }
  25.     }
  26. }

2.2 业务逻辑实现

2.2.1 完整领取流程

  1. @Service
  2. public class CouponServiceImpl implements CouponService {
  4.     @Autowired
  5.     private StockService stockService;
  7.     @Autowired
  8.     private CouponRecordMapper recordMapper;
  10.     @Override
  11.     @Transactional
  12.     public Result<CouponRecord> acquireCoupon(Long userId, Long couponId) {
  13.         // 1. 参数校验
  14.         if (userId == null || couponId == null) {
  15.             return Result.fail("参数错误");
  16.         }
  18.         // 2. 并发控制（选择方案）
  19.         boolean success = stockService.decreaseStock(couponId);
  20.         if (!success) {
  21.             return Result.fail("优惠券已领完");
  22.         }
  24.         // 3. 创建领取记录
  25.         CouponRecord record = new CouponRecord();
  26.         record.setUserId(userId);
  27.         record.setCouponId(couponId);
  28.         record.setStatus(CouponStatus.UNUSED);
  29.         record.setAcquireTime(new Date());
  30.         recordMapper.insert(record);
  32.         // 4. 返回结果
  33.         return Result.success(record);
  34.     }
  35. }

2.2.2 防重复领取实现

  1. public boolean checkAndAcquire(Long userId, Long couponId) {
  2.     // 查询是否已领取过
  3.     int count = recordMapper.selectCount(
  4.         new QueryWrapper<CouponRecord>()
  5.             .eq("user_id", userId)
  6.             .eq("coupon_id", couponId)
  7.             .eq("status", CouponStatus.UNUSED)
  8.     );
  10.     if (count > 0) {
  11.         return false;
  12.     }
  14.     // 继续领取流程
  15.     return acquireCoupon(userId, couponId).isSuccess();
  16. }

三、高级优化方案

3.1 异步化处理

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

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

3.2 限流策略实现

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

3.3 数据一致性保障

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

  1. public interface TccCouponService {
  2.     // 尝试阶段
  3.     boolean tryAcquire(Long userId, Long couponId);
  5.     // 确认阶段
  6.     boolean confirmAcquire(Long userId, Long couponId);
  8.     // 取消阶段
  9.     boolean cancelAcquire(Long userId, Long couponId);
  10. }
  12. // 实现示例
  13. @Transactional
  14. public boolean tryAcquire(Long userId, Long couponId) {
  15.     // 1. 预扣库存
  16.     boolean stockReserved = stockService.reserveStock(couponId, 1);
  17.     if (!stockReserved) {
  18.         return false;
  19.     }
  21.     // 2. 创建预记录
  22.     CouponRecord record = new CouponRecord();
  23.     record.setUserId(userId);
  24.     record.setCouponId(couponId);
  25.     record.setStatus(CouponStatus.TRYING);
  26.     recordMapper.insert(record);
  28.     return true;
  29. }

四、测试与部署方案

4.1 单元测试示例

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class CouponServiceTest {
  5.     @Autowired
  6.     private CouponService couponService;
  8.     @MockBean
  9.     private StockService stockService;
  11.     @Test
  12.     public void testAcquireSuccess() {
  13.         when(stockService.decreaseStock(1L)).thenReturn(true);
  15.         Result<CouponRecord> result = couponService.acquireCoupon(1001L, 1L);
  17.         assertTrue(result.isSuccess());
  18.         assertNotNull(result.getData());
  19.     }
  21.     @Test
  22.     public void testAcquireFailure() {
  23.         when(stockService.decreaseStock(1L)).thenReturn(false);
  25.         Result<CouponRecord> result = couponService.acquireCoupon(1001L, 1L);
  27.         assertFalse(result.isSuccess());
  28.         assertEquals("优惠券已领完", result.getMessage());
  29.     }
  30. }

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等场景的业务需求。实际开发中需根据具体业务场景调整技术选型和实现细节。

最新文章
热门标签