高并发优惠券系统设计与防超卖方案：从理论到实战

用户请求 -> Redis扣减 -> 发送MQ -> 异步写库

# 优惠券库存
SET coupon:stock:{couponId} 100000

# 用户领取记录（Set，自动去重）
SADD coupon:users:{couponId} userId1 userId2 userId3

# 领取计数（限制每人领取数量）
HSET coupon:limit:{couponId} userId 1

# 分布式锁
SET coupon:lock:{couponId}:{userId} 1 EX 10 NX

-- grab_coupon.lua
local stockKey = KEYS[1]        -- coupon:stock:{couponId}
local userSetKey = KEYS[2]      -- coupon:users:{couponId}
local limitKey = KEYS[3]        -- coupon:limit:{couponId}
local userId = ARGV[1]          -- 用户ID
local limitPerUser = tonumber(ARGV[2])  -- 每人限领数量

-- 1. 检查用户是否已领取
local hasGrabbed = redis.call('SISMEMBER', userSetKey, userId)
if hasGrabbed == 1 then
    return -1  -- 已领取
end

-- 2. 检查领取限制
local currentCount = redis.call('HGET', limitKey, userId)
if currentCount and tonumber(currentCount) >= limitPerUser then
    return -2  -- 超过领取限制
end

-- 3. 检查库存
local stock = redis.call('GET', stockKey)
if not stock or tonumber(stock) <= 0 then
    return -3  -- 库存不足
end

-- 4. 扣减库存
redis.call('DECR', stockKey)

-- 5. 记录用户领取
redis.call('SADD', userSetKey, userId)
redis.call('HINCRBY', limitKey, userId, 1)

-- 6. 设置过期时间（与优惠券有效期一致）
redis.call('EXPIRE', stockKey, 86400)
redis.call('EXPIRE', userSetKey, 86400)
redis.call('EXPIRE', limitKey, 86400)

return 1  -- 领取成功

@Service
public class CouponRedisService {
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    // 预加载Lua脚本
    private DefaultRedisScript<Long> grabScript;
    
    @PostConstruct
    public void init() {
        grabScript = new DefaultRedisScript<>();
        grabScript.setScriptText(loadLuaScript("grab_coupon.lua"));
        grabScript.setResultType(Long.class);
    }
    
    /**
     * 尝试领取优惠券（Redis预扣减）
     * @return 1:成功, -1:已领取, -2:超限制, -3:库存不足
     */
    public Long tryGrabCoupon(Long userId, Long couponId, Integer limitPerUser) {
        String stockKey = "coupon:stock:" + couponId;
        String userSetKey = "coupon:users:" + couponId;
        String limitKey = "coupon:limit:" + couponId;
        
        Long result = redisTemplate.execute(
            grabScript,
            Arrays.asList(stockKey, userSetKey, limitKey),
            userId.toString(),
            limitPerUser.toString()
        );
        
        return result;
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Idempotent {
    String key() default "";  // 幂等Key
    long expire() default 10; // 过期时间（秒）
}

@Aspect
@Component
public class IdempotentAspect {
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    @Around("@annotation(idempotent)")
    public Object around(ProceedingJoinPoint point, Idempotent idempotent) throws Throwable {
        // 生成幂等Key
        String key = generateKey(point, idempotent);
        
        // 尝试获取锁
        Boolean locked = redisTemplate.opsForValue()
            .setIfAbsent(key, "1", idempotent.expire(), TimeUnit.SECONDS);
        
        if (!locked) {
            throw new BusinessException("请勿重复提交");
        }
        
        try {
            return point.proceed();
        } finally {
            // 延迟删除，防止并发问题
            redisTemplate.delete(key);
        }
    }
    
    private String generateKey(ProceedingJoinPoint point, Idempotent idempotent) {
        if (!idempotent.key().isEmpty()) {
            return "idempotent:" + idempotent.key();
        }
        
        // 默认使用类名+方法名+参数MD5
        MethodSignature signature = (MethodSignature) point.getSignature();
        String methodName = signature.getDeclaringTypeName() + "." + signature.getName();
        String params = Arrays.toString(point.getArgs());
        return "idempotent:" + methodName + ":" + DigestUtils.md5DigestAsHex(params.getBytes());
    }
}

@RestController
@RequestMapping("/api/coupon")
public class CouponController {
    
    @Autowired
    private CouponService couponService;
    
    @PostMapping("/grab")
    @Idempotent(key = "coupon:grab", expire = 5)  // 5秒内防重
    public Result<Void> grabCoupon(@RequestParam Long couponId) {
        Long userId = UserContext.getUserId();
        couponService.grabCoupon(userId, couponId);
        return Result.success();
    }
}

@Component
@RocketMQMessageListener(
    topic = "coupon-grab-topic",
    consumerGroup = "coupon-grab-consumer"
)
public class CouponGrabConsumer implements RocketMQListener<CouponGrabMessage> {
    
    @Autowired
    private UserCouponService userCouponService;
    
    @Autowired
    private CouponService couponService;
    
    @Override
    @Transactional
    public void onMessage(CouponGrabMessage message) {
        log.info("处理优惠券领取消息: {}", message);
        
        try {
            // 1. 幂等检查（防止消息重复消费）
            String idempotentKey = "coupon:grab:mq:" + message.getUserId() + ":" + message.getCouponId();
            if (!redisTemplate.opsForValue().setIfAbsent(idempotentKey, "1", 24, TimeUnit.HOURS)) {
                log.warn("消息重复消费，跳过处理");
                return;
            }
            
            // 2. 写入用户优惠券表
            UserCoupon userCoupon = new UserCoupon();
            userCoupon.setUserId(message.getUserId());
            userCoupon.setCouponId(message.getCouponId());
            userCoupon.setStatus(UserCouponStatus.UNUSED);
            userCoupon.setGrabTime(message.getGrabTime());
            userCoupon.setExpireTime(calculateExpireTime(message.getCouponId()));
            userCouponService.save(userCoupon);
            
            // 3. 更新优惠券已领取数量
            couponService.increaseGrabCount(message.getCouponId());
            
            log.info("优惠券领取处理成功");
            
        } catch (Exception e) {
            log.error("处理优惠券领取消息失败", e);
            // 抛出异常，触发消息重试
            throw e;
        }
    }
}

Redis预扣减（强一致性） -> MQ（至少一次投递） -> 数据库（最终一致）

@Component
public class DataConsistencyService {
    
    /**
     * Redis库存回滚
     */
    public void rollbackStock(Long couponId) {
        String stockKey = "coupon:stock:" + couponId;
        redisTemplate.opsForValue().increment(stockKey);
    }
    
    /**
     * 定时对账（每天凌晨执行）
     */
    @Scheduled(cron = "0 0 2 * * ?")
    public void reconcileData() {
        // 1. 查询所有优惠券
        List<Coupon> coupons = couponService.list();
        
        for (Coupon coupon : coupons) {
            String stockKey = "coupon:stock:" + coupon.getId();
            String redisStock = redisTemplate.opsForValue().get(stockKey);
            
            // 2. 计算数据库实际库存
            int dbStock = coupon.getTotalStock() - coupon.getGrabbedCount();
            
            // 3. 对比并修复
            if (redisStock != null && Integer.parseInt(redisStock) != dbStock) {
                log.warn("库存不一致，couponId={}, redis={}, db={}", 
                    coupon.getId(), redisStock, dbStock);
                
                // 以数据库为准，修复Redis
                redisTemplate.opsForValue().set(stockKey, String.valueOf(dbStock));
            }
        }
    }
}

spring:
  redis:
    lettuce:
      pool:
        max-active: 100
        max-idle: 50
        min-idle: 20

// 批量获取库存（Pipeline）
public List<Long> batchGetStock(List<Long> couponIds) {
    return redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
        for (Long couponId : couponIds) {
            connection.get(("coupon:stock:" + couponId).getBytes());
        }
        return null;
    }).stream()
    .map(obj -> obj != null ? Long.parseLong((String) obj) : 0L)
    .collect(Collectors.toList());
}

@Component
public class CouponLocalCache {
    
    private final LoadingCache<Long, CouponRule> cache = Caffeine.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(5, TimeUnit.MINUTES)
        .build(couponRuleService::getById);
    
    public CouponRule getRule(Long couponId) {
        return cache.get(couponId);
    }
}

public void decreaseStock(Long couponId) {
    String key = "coupon:stock:" + couponId;
    
    // 1. 先扣减（写主库）
    Long remain = redisTemplate.opsForValue().decrement(key);
    
    if (remain < 0) {
        // 2. 超卖，回滚
        redisTemplate.opsForValue().increment(key);
        throw new BusinessException("库存不足");
    }
}

// 按用户ID取模分片
public String getUserSetKey(Long couponId, Long userId) {
    int shard = (int) (userId % 10);
    return "coupon:users:" + couponId + ":" + shard;
}

-- 在Lua脚本中设置过期时间
redis.call('EXPIRE', stockKey, 86400)  -- 24小时
redis.call('EXPIRE', userSetKey, 86400)