Java优惠券系统设计：从核心模型到高并发实践

作者：半吊子全栈工匠2025.11.04 22:08浏览量：0

简介：本文详细探讨Java环境下优惠券系统的设计要点，涵盖数据库建模、业务规则实现、分布式锁应用及高并发场景优化，提供可落地的技术方案。

一、优惠券系统核心业务模型设计

1.1 实体关系建模

优惠券系统需包含四大核心实体：优惠券模板（CouponTemplate）、优惠券实例（Coupon）、用户优惠券（UserCoupon）和订单关联（OrderCoupon）。采用JPA实现时，可设计如下实体类：

  1. @Entity
  2. public class CouponTemplate {
  3.     @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
  4.     private Long id;
  5.     private String name;
  6.     private String logo;
  7.     private String intro;
  8.     @Enumerated(EnumType.STRING)
  9.     private CouponType type; // 折扣券/满减券/现金券
  10.     private BigDecimal ruleValue; // 折扣值或金额
  11.     private BigDecimal conditionAmount; // 满减条件
  12.     private LocalDateTime startTime;
  13.     private LocalDateTime endTime;
  14.     private Integer total; // 发行总量
  15.     private Integer remaining; // 剩余数量
  16.     // 适用范围
  17.     @ElementCollection
  18.     private Set<Long> applicableCategories;
  19.     @ElementCollection
  20.     private Set<Long> applicableProducts;
  21. }
  23. @Entity
  24. public class UserCoupon {
  25.     @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
  26.     private Long id;
  27.     @ManyToOne
  28.     private CouponTemplate template;
  29.     private String code; // 唯一券码
  30.     private LocalDateTime getTime;
  31.     private LocalDateTime usedTime;
  32.     @Enumerated(EnumType.STRING)
  33.     private CouponStatus status; // 未使用/已使用/已过期
  34.     @ManyToOne
  35.     private User user;
  36. }

1.2 业务规则引擎实现

优惠券使用需满足多重条件校验，建议采用策略模式实现规则引擎：

  1. public interface CouponRule {
  2.     boolean validate(UserCoupon coupon, OrderContext context);
  3. }
  5. @Component
  6. public class TimeValidityRule implements CouponRule {
  7.     @Override
  8.     public boolean validate(UserCoupon coupon, OrderContext context) {
  9.         LocalDateTime now = LocalDateTime.now();
  10.         return !now.isBefore(coupon.getTemplate().getStartTime()) 
  11.                && !now.isAfter(coupon.getTemplate().getEndTime());
  12.     }
  13. }
  15. @Service
  16. public class CouponValidator {
  17.     @Autowired
  18.     private List<CouponRule> rules;
  20.     public boolean validate(UserCoupon coupon, OrderContext context) {
  21.         return rules.stream()
  22.                    .allMatch(rule -> rule.validate(coupon, context));
  23.     }
  24. }

二、高并发场景下的关键技术实现

2.1 优惠券发放的原子性控制

在秒杀场景下，需使用Redis分布式锁保证库存扣减的原子性：

  1. @Service
  2. public class CouponDistributionService {
  3.     @Autowired
  4.     private RedisTemplate<String, String> redisTemplate;
  6.     public boolean acquireCoupon(Long templateId, Long userId) {
  7.         String lockKey = "coupon_lock_" + templateId;
  8.         try {
  9.             boolean locked = redisTemplate.opsForValue()
  10.                 .setIfAbsent(lockKey, "locked", 10, TimeUnit.SECONDS);
  11.             if (!locked) {
  12.                 throw new RuntimeException("操作太频繁，请稍后再试");
  13.             }
  15.             // 双重检查库存
  16.             CouponTemplate template = couponTemplateRepo.findById(templateId)
  17.                 .orElseThrow(() -> new RuntimeException("优惠券不存在"));
  18.             if (template.getRemaining() <= 0) {
  19.                 throw new RuntimeException("优惠券已领完");
  20.             }
  22.             // 扣减库存
  23.             int updated = couponTemplateRepo.decreaseRemaining(templateId);
  24.             if (updated == 0) {
  25.                 throw new RuntimeException("库存不足");
  26.             }
  28.             // 创建用户券
  29.             UserCoupon coupon = new UserCoupon();
  30.             coupon.setTemplate(template);
  31.             coupon.setCode(generateCouponCode());
  32.             coupon.setUser(userRepo.findById(userId).get());
  33.             userCouponRepo.save(coupon);
  35.             return true;
  36.         } finally {
  37.             redisTemplate.delete(lockKey);
  38.         }
  39.     }
  40. }

2.2 优惠券核销的幂等性设计

核销接口需处理重复调用问题，可采用Token机制：

  1. @RestController
  2. @RequestMapping("/api/coupons")
  3. public class CouponController {
  4.     @PostMapping("/use")
  5.     public ResponseEntity<?> useCoupon(@RequestHeader("X-Request-Token") String token,
  6.                                       @RequestParam String couponCode) {
  7.         // 验证Token唯一性
  8.         String usedToken = redisTemplate.opsForValue().get("used_token_" + token);
  9.         if (usedToken != null) {
  10.             return ResponseEntity.badRequest().body("请求已处理");
  11.         }
  13.         try {
  14.             couponService.useCoupon(couponCode);
  15.             redisTemplate.opsForValue().set("used_token_" + token, "1", 24, TimeUnit.HOURS);
  16.             return ResponseEntity.ok().build();
  17.         } catch (Exception e) {
  18.             return ResponseEntity.status(500).body(e.getMessage());
  19.         }
  20.     }
  21. }

三、系统优化与扩展设计

3.1 优惠券分片存储策略

当数据量超过单表500万条时，建议按模板ID进行分库分表：

  1. @Table(name = "user_coupon")
  2. @ShardingSphereTable(
  3.     shardingAlgorithmName = "coupon-mod",
  4.     databaseStrategy = "standard",
  5.     databaseShardingColumn = "template_id",
  6.     tableStrategy = "standard",
  7.     tableShardingColumn = "template_id"
  8. )
  9. public class UserCoupon {
  10.     // 实体定义同上
  11. }
  13. // 自定义分片算法
  14. public class CouponModShardingAlgorithm implements PreciseShardingAlgorithm<Long> {
  15.     @Override
  16.     public String doSharding(Collection<String> availableTargetNames, 
  17.                             PreciseShardingValue<Long> shardingValue) {
  18.         long templateId = shardingValue.getValue();
  19.         int tableIndex = (int)(templateId % 4); // 4个分表
  20.         return "user_coupon_" + tableIndex;
  21.     }
  22. }

3.2 异步任务处理架构

优惠券过期检查适合使用Spring Batch+Quartz实现：

  1. @Configuration
  2. public class BatchConfig {
  3.     @Bean
  4.     public Job couponExpiryJob(JobRepository jobRepository,
  5.                               Step couponExpiryStep) {
  6.         return new JobBuilder("couponExpiryJob", jobRepository)
  7.                 .start(couponExpiryStep)
  8.                 .build();
  9.     }
  11.     @Bean
  12.     public Step couponExpiryStep(StepBuilderFactory stepBuilderFactory,
  13.                                 ItemReader<UserCoupon> reader,
  14.                                 ItemProcessor<UserCoupon, ExpiryResult> processor,
  15.                                 ItemWriter<ExpiryResult> writer) {
  16.         return stepBuilderFactory.get("couponExpiryStep")
  17.                 .<UserCoupon, ExpiryResult>chunk(100)
  18.                 .reader(reader)
  19.                 .processor(processor)
  20.                 .writer(writer)
  21.                 .build();
  22.     }
  23. }
  25. // Quartz调度配置
  26. @Configuration
  27. public class QuartzConfig {
  28.     @Bean
  29.     public JobDetail couponExpiryJobDetail() {
  30.         return JobBuilder.newJob(CouponExpiryJob.class)
  31.                 .withIdentity("couponExpiryJob")
  32.                 .storeDurably()
  33.                 .build();
  34.     }
  36.     @Bean
  37.     public Trigger couponExpiryTrigger() {
  38.         SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder
  39.                 .simpleSchedule()
  40.                 .withIntervalInHours(1) // 每小时执行
  41.                 .repeatForever();
  43.         return TriggerBuilder.newTrigger()
  44.                 .forJob(couponExpiryJobDetail())
  45.                 .withIdentity("couponExpiryTrigger")
  46.                 .withSchedule(scheduleBuilder)
  47.                 .build();
  48.     }
  49. }

四、最佳实践与经验总结

  1. 券码生成策略：采用雪花算法+业务前缀组合，如”DISC_”+snowflakeId，保证全局唯一且可读
  2. 防刷机制：
    • 用户维度：同一用户10分钟内限领3张
    • IP维度：同一IP每小时限领20张
    • 设备维度：同一设备每天限领5张
  3. 数据一致性方案：
    • 最终一致性：通过消息队列实现异步更新
    • 强一致性：使用Seata等分布式事务框架
  4. 监控指标：
    • 发放成功率：成功数/请求数
    • 核销率：已使用数/发放总数
    • 库存预警：剩余量<10%时告警

实际项目实施中，建议采用渐进式架构演进：初期单库单表+缓存，中期引入分库分表，后期考虑服务化拆分。测试环境需模拟10万级QPS压力测试，重点关注锁竞争、数据库连接池耗尽等典型问题。

最热文章