1
# engine 模块 shardingsphere-config.yaml
2
t_coupon_template:  ds_${0..1}.t_coupon_template_${0..15}    # 2 库 16 表，按 shop_number
3
t_user_coupon:      ds_${0..1}.t_user_coupon_${0..31}        # 2 库 32 表，按 user_id
4
t_coupon_settlement: ds_${0..1}.t_coupon_settlement_${0..15} # 2 库 16 表，按 user_id

1
用户请求领券
2
    │
3
    ▼
4
┌─────────────── 查券链路（findCouponTemplate）───────────────┐
5
│ Hash 命中? ──是──► 返回（99% 流量止步于此，一条 HGETALL）        │
6
│   │否                                                        │
7
│ 布隆说不存在? ──是──► 抛异常（DB 零压力）                       │
8
│   │说存在(可能误报)                                            │
9
│ 空值缓存存在? ──是──► 抛异常                                   │
10
│   │否                                                        │
11
│ 拿锁 → 锁内再查空值缓存、再查 Hash（双重判定）→ 都落空才查 DB    │
12
│   DB 有 → Lua 原子写 Hash 缓存（TTL=活动结束）                  │
13
│   DB 无 → 写空值缓存 30 分钟                                   │
14
└──────────────────────────┬─────────────────────────────────┘
15
                           │ 返回模板数据
16
                           ▼
17
┌─────────────── 领券链路 ───────────────────────────────────┐
18
│ 时间校验（不在活动期抛异常）                                    │
19
│ Lua 原子四件事：判库存+扣库存(HINCRBY)+判上限+计数(INCR)        │
20
│   失败 → 抛异常（事务未开启，DB 零压力）                        │
21
│   成功 → 返回位压缩值（Lua 按 ×2^16 打包，Java 按 2^14 解码，缺陷 #18）│
22
│                                                              │
23
│ ── 分叉点：Lua 成功之后的那一行 ──                              │
24
│ 同步版: TransactionTemplate 编程式事务                          │
25
│   ⑤a 条件UPDATE扣DB库存 → ⑤b INSERT用户券 → ⑤c ZADD卡包        │
26
│   → ⑤d 发延迟关闭消息 → 提交 → 用户拿到真实结果                 │
27
│ MQ 版: 发 UserCouponRedeemEvent → 立即返回"受理成功"            │
28
│   消费者: 幂等切面(SET NX GET PX) → @Transactional 事务         │
29
│   → 条件UPDATE → INSERT → ZADD → 发延迟消息 → 标记CONSUMED      │
30
└────────────────────────────────────────────────────────────┘

1
Lua 打包：  返回值 = firstField × 2^16 + secondField            ← Lua 脚本 SECOND_FIELD_BITS = 16
2
Java 解码：firstField = 返回值 >> 14 & 0b11                     ← Java 工具类 SECOND_FIELD_BITS = 14
3
           secondField = 返回值 & 16383
4
0=成功 / 1=库存不足 / 2=已达限领

1
┌─ 事务圈外（占时间不占事务）─────┐   ┌─ 事务圈内 ─────────────────┐
2
│ ① 查模板缓存（Redis 读）         │   │ ⑤a 扣 DB 库存   ←可回滚 ✓  │
3
│ ③ Lua 预扣（Redis 写）           │   │ ⑤b 插用户券     ←可回滚 ✓  │
4
│ ④ 解码返回值                     │   │ ⑤c 写 ZSet      ←❌回滚不了 │
5
│                                  │   │ ⑤d 发延迟消息    ←❌回滚不了 │
6
└──────────────────────────────────┘   └─────────────────────────────┘

1
UPDATE t_coupon_template SET stock = stock - 1
2
WHERE shop_number = #{shopNumber} AND id = #{couponTemplateId}
3
  AND stock >= 1        -- 扣减条件写进 WHERE，防 check-then-act 竞态

1
@Override
2
public void redeemUserCouponByMQ(CouponTemplateRedeemReqDTO requestParam) {
3
    // ① ~ ④ 与同步版完全相同：查模板缓存 → 时间校验 → Lua 懒加载 → 执行 Lua + 解码
4
    // ......
5
    // ⑤ 分叉点：组装事件发 MQ（不碰 DB、不开事务）
6
    UserCouponRedeemEvent userCouponRedeemEvent = UserCouponRedeemEvent.builder()
7
            .requestParam(requestParam)
8
            .receiveCount((int) StockDecrementReturnCombinedUtil.extractSecondField(stockDecrementLuaResult))  // Lua 第二字段
9
            .couponTemplate(couponTemplate)   // 整个模板塞进消息（快照）
10
            .userId(UserContext.getUserId())
11
            .build();
12
    SendResult sendResult = userCouponRedeemProducer.sendMessage(userCouponRedeemEvent);
13
    // 发送消息失败：打印日志并报警，通过日志搜集并重新投递（不抛异常）
14
    if (ObjectUtil.notEqual(sendResult.getSendStatus().name(), "SEND_OK")) {
15
        log.warn("[生产者] 用户兑换优惠券 - 发送优惠券兑换消息失败，消息参数：{}", JSON.toJSONString(userCouponRedeemEvent));
16
    }
17
    // 方法正常返回 → 用户看到"受理成功"
18
}

1
t1 消息到达 → 切面先执行：SET NX 抢"消费许可证"
2
t2 三分支：抢到(nil) → 进业务；旧值"1"已消费 → 跳过 + ACK；旧值"0"别人在消费 → 抛异常等重投
3
t3 业务（事务内）：条件 UPDATE 扣库存 → 插用户券 → 写卡包 ZSet → 发延迟关券消息
4
t4 三个出口：全部成功 / 任意异常 / DB 没货（见下节）

1
@NoMQDuplicateConsume(
2
        keyPrefix = "user-coupon-redeem:",
3
        key = "#messageWrapper.keys",
4
        keyTimeout = 600
5
)
6
@Transactional(rollbackFor = Exception.class)
7
@Override
8
public void onMessage(MessageWrapper<UserCouponRedeemEvent> messageWrapper) {
9
    log.info("[消费者] 用户兑换优惠券 - 执行消费逻辑，消息体：{}", JSON.toJSONString(messageWrapper));
10

11
    // 全部来自消息体（快照），不依赖线程上下文、不查缓存
12
    CouponTemplateRedeemReqDTO requestParam = messageWrapper.getMessage().getRequestParam();
13
    CouponTemplateQueryRespDTO couponTemplate = messageWrapper.getMessage().getCouponTemplate();
14
    String userId = messageWrapper.getMessage().getUserId();
15

16
    // 条件 UPDATE 扣 DB 库存
17
    int decremented = couponTemplateMapper.decrementCouponTemplateStock(
18
            Long.parseLong(requestParam.getShopNumber()), Long.parseLong(requestParam.getCouponTemplateId()), 1L);
19
    if (!SqlHelper.retBool(decremented)) {
20
        // 0 行：静默 return（DB stock=0 是永久状态，抛异常只会无限重试进死信）
21
        log.warn("[消费者] 用户兑换优惠券 - 执行消费逻辑，扣减优惠券数据库库存失败，消息体：{}", JSON.toJSONString(messageWrapper));
22
        return;
23
    }
24

25
    // 插入用户券（receiveCount 用消息里那个）
26
    Date now = new Date();
27
    DateTime validEndTime = DateUtil.offsetHour(now, JSON.parseObject(couponTemplate.getConsumeRule()).getInteger("validityPeriod"));
28
    UserCouponDO userCouponDO = UserCouponDO.builder()
29
            .couponTemplateId(Long.parseLong(requestParam.getCouponTemplateId()))
30
            .userId(Long.parseLong(userId))
31
            .source(requestParam.getSource())
32
            .receiveCount(messageWrapper.getMessage().getReceiveCount())
33
            .status(UserCouponStatusEnum.UNUSED.getCode())
34
            .receiveTime(now)
35
            .validStartTime(now)
36
            .validEndTime(validEndTime)
37
            .build();
38
    userCouponMapper.insert(userCouponDO);
39

40
    if (ObjectUtil.notEqual(userCouponListSaveCacheType, "binlog")) {
41
        // 写 ZSet 卡包
42
        String userCouponListCacheKey = String.format(EngineRedisConstant.USER_COUPON_TEMPLATE_LIST_KEY, userId);
43
        String userCouponItemCacheKey = StrUtil.builder()
44
                .append(requestParam.getCouponTemplateId()).append("_").append(userCouponDO.getId())
45
                .toString();
46
        stringRedisTemplate.opsForZSet().add(userCouponListCacheKey, userCouponItemCacheKey, now.getTime());
47

48
        // 写后查询：防主从异步复制静默丢失
49
        Double scored;
50
        try {
51
            scored = stringRedisTemplate.opsForZSet().score(userCouponListCacheKey, userCouponItemCacheKey);
52
            if (scored == null) {
53
                stringRedisTemplate.opsForZSet().add(userCouponListCacheKey, userCouponItemCacheKey, now.getTime());
54
            }
55
        } catch (Throwable ex) {
56
            log.warn("[消费者] ... 可能Redis宕机或主从复制数据丢失，基础错误信息：{}", ex.getMessage());
57
            stringRedisTemplate.opsForZSet().add(userCouponListCacheKey, userCouponItemCacheKey, now.getTime());
58
        }
59
    }
60

61
    // 发延迟关券消息
62
    UserCouponDelayCloseEvent userCouponDelayCloseEvent = UserCouponDelayCloseEvent.builder()
63
            .couponTemplateId(requestParam.getCouponTemplateId())
64
            .userCouponId(String.valueOf(userCouponDO.getId()))
65
            .userId(userId)
66
            .delayTime(validEndTime.getTime())
67
            .build();
68
    SendResult sendResult = couponDelayCloseProducer.sendMessage(userCouponDelayCloseEvent);
69
    if (ObjectUtil.notEqual(sendResult.getSendStatus().name(), "SEND_OK")) {
70
        log.warn("[消费者] 用户兑换优惠券 - 发送优惠券关闭延时队列失败，消息参数：{}", JSON.toJSONString(userCouponDelayCloseEvent));
71
    }
72
}

1
@Aspect
2
@RequiredArgsConstructor
3
public final class NoMQDuplicateConsumeAspect {
4

5
    private final StringRedisTemplate stringRedisTemplate;
6

7
    // 一条命令完成"抢占 + 读旧值 + 设 TTL"（NX + GET + PX）
8
    private static final String LUA_SCRIPT = """
9
            local key = KEYS[1]
10
            local value = ARGV[1]
11
            local expire_time_ms = ARGV[2]
12
            return redis.call('SET', key, value, 'NX', 'GET', 'PX', expire_time_ms)
13
            """;
14

15
    @Around("@annotation(com.nageoffer.onecoupon.framework.idempotent.NoMQDuplicateConsume)")
16
    public Object noMQRepeatConsume(ProceedingJoinPoint joinPoint) throws Throwable {
17
        NoMQDuplicateConsume noMQDuplicateConsume = getNoMQDuplicateConsumeAnnotation(joinPoint);
18
        // SpEL 从消息体取 key（如 #messageWrapper.keys）
19
        String uniqueKey = noMQDuplicateConsume.keyPrefix() + SpELUtil.parseKey(noMQDuplicateConsume.key(), ((MethodSignature) joinPoint.getSignature()).getMethod(), joinPoint.getArgs());
20

21
        // 抢占：返回 nil = 抢到；返回旧值 = 已被占用（"0" 消费中 / "1" 已消费）
22
        String absentAndGet = stringRedisTemplate.execute(
23
                RedisScript.of(LUA_SCRIPT, String.class),
24
                List.of(uniqueKey),
25
                IdempotentMQConsumeStatusEnum.CONSUMING.getCode(),
26
                String.valueOf(TimeUnit.SECONDS.toMillis(noMQDuplicateConsume.keyTimeout()))
27
        );
28

29
        if (Objects.nonNull(absentAndGet)) {
30
            boolean errorFlag = IdempotentMQConsumeStatusEnum.isError(absentAndGet);  // 只认 "0"
31
            if (errorFlag) {
32
                // CONSUMING：别人正在消费 → 抛异常让 MQ 延迟重投（不能替别人 ACK）
33
                throw new ServiceException(String.format("消息消费者幂等异常，幂等标识：%s", uniqueKey));
34
            }
35
            // CONSUMED：已消费完 → 静默跳过（return null = ACK）
36
            return null;
37
        }
38

39
        Object result;
40
        try {
41
            result = joinPoint.proceed();   // 执行业务
42
            // 成功 → 置 "1"（CONSUMED），TTL 同 keyTimeout
43
            stringRedisTemplate.opsForValue().set(uniqueKey, IdempotentMQConsumeStatusEnum.CONSUMED.getCode(), noMQDuplicateConsume.keyTimeout(), TimeUnit.SECONDS);
44
        } catch (Throwable ex) {
45
            // 失败 → 删 Key（归还许可证）+ 重抛 → MQ 重投可重新抢
46
            stringRedisTemplate.delete(uniqueKey);
47
            throw ex;
48
        }
49
        return result;
50
    }
51
}

1
                    Lua: SET NX "0"
2
   Key 不存在 ────────────────────────► [CONSUMING "0"] 消费中
3
      ▲                                      │
4
      │                    proceed() 成功      │ proceed() 抛异常
5
      │                    SET "1"            │ DELETE
6
      │                                      ▼
7
      │                              [CONSUMED "1"] 已消费
8
      │                                      │
9
      └────────────── TTL 到期自动蒸发 ◄──────┘

1
redis.call('SET', key, value, 'NX', 'GET', 'PX', expire_time_ms)

1
实际实现（删 Key）：失败 → DELETE → 重抛 → t=10s 重投 → 成功 ✅ 恢复 10 秒
2
假如不删：Key 卡 "0" 600s，重投全被弹回烧重试额度 → t≈9 分钟才恢复，
3
         连续失败两个窗口 → 耗尽 16 次 → 进死信

1
@Transactional(rollbackFor = Exception.class)
2
@Override
3
public void createCouponTask(CouponTaskCreateReqDTO requestParam) {
4
    // 校验模板是否存在
5
    CouponTemplateQueryRespDTO couponTemplate = couponTemplateService
6
            .findCouponTemplateById(requestParam.getCouponTemplateId());
7
    if (couponTemplate == null) {
8
        throw new ClientException("优惠券模板不存在");
9
    }
10

11
    // ───── 事件A：构建任务记录，落库 ─────
12
    CouponTaskDO couponTaskDO = BeanUtil.copyProperties(requestParam, CouponTaskDO.class);
13
    couponTaskDO.setBatchId(IdUtil.getSnowflakeNextId());           // 雪花批次号，失败表关联用
14
    couponTaskDO.setOperatorId(Long.parseLong(UserContext.getUserId()));
15
    couponTaskDO.setShopNumber(UserContext.getShopNumber());
16
    couponTaskDO.setStatus(
17
            Objects.equals(requestParam.getSendType(), CouponTaskSendTypeEnum.IMMEDIATE.getType())
18
                    ? CouponTaskStatusEnum.IN_PROGRESS.getStatus()   // 立即→执行中
19
                    : CouponTaskStatusEnum.PENDING.getStatus()       // 定时→待执行
20
    );
21
    couponTaskMapper.insert(couponTaskDO);  // 入 MySQL: t_coupon_task
22

23
    // ───── 事件B：异步统计 Excel 行数，用于事后对账 ─────
24
    // 为什么异步？100万行同步数要4秒，用户不能干等
25
    JSONObject delayJsonObject = JSONObject
26
            .of("fileAddress", requestParam.getFileAddress(), "couponTaskId", couponTaskDO.getId());
27
    executorService.execute(() -> refreshCouponTaskSendNum(delayJsonObject));
28

29
    // ───── 事件B的兜底：Redisson延迟队列20秒后补数 ─────
30
    // 假设刚提交异步任务就宕机，线程池任务丢了 → 20秒后守护线程检查
31
    // 如果 sendNum 还是 NULL，就补数一次
32
    RBlockingDeque<Object> blockingDeque = redissonClient
33
            .getBlockingDeque("COUPON_TASK_SEND_NUM_DELAY_QUEUE");
34
    RDelayedQueue<Object> delayedQueue = redissonClient.getDelayedQueue(blockingDeque);
35
    delayedQueue.offer(delayJsonObject, 20, TimeUnit.SECONDS);
36

37
    // ───── 事件C：发MQ触发真正的发券流程 ─────
38
    // 事件B（数行数）和事件C（发MQ）是并行的，互不依赖
39
    if (Objects.equals(requestParam.getSendType(), CouponTaskSendTypeEnum.IMMEDIATE.getType())) {
40
        CouponTaskExecuteEvent couponTaskExecuteEvent = CouponTaskExecuteEvent.builder()
41
                .couponTaskId(couponTaskDO.getId())
42
                .build();
43
        couponTaskActualExecuteProducer.sendMessage(couponTaskExecuteEvent);
44
    }
45
}

1
事件B（异步数行数）→ 统计"Excel里一共多少行"，回填 sendNum，方便事后对账
2
事件C（发MQ）      → 通知下游消费者开始读Excel、扣库存、落库，这才是真正的发券

1
@NoMQDuplicateConsume(                          // ← 第一层：幂等保护（切面细节见第二部分 2.4）
2
        keyPrefix = "coupon_task_execute:idempotent:",
3
        key = "#messageWrapper.message.couponTaskId",  // 幂等键 = 任务ID（业务级）
4
        keyTimeout = 120                                // 120秒过期
5
)
6
@Override
7
public void onMessage(MessageWrapper<CouponTaskExecuteEvent> messageWrapper) {
8
    var couponTaskId = messageWrapper.getMessage().getCouponTaskId();
9
    var couponTaskDO = couponTaskMapper.selectById(couponTaskId);
10

11
    // 第二层：任务状态校验 → 必须是执行中才放行
12
    if (ObjectUtil.notEqual(couponTaskDO.getStatus(), CouponTaskStatusEnum.IN_PROGRESS.getStatus())) {
13
        log.warn("任务状态异常：{}，已终止推送", couponTaskDO.getStatus());
14
        return;  // ❌ 已完成/已取消/待执行都拦掉
15
    }
16

17
    // 第三层：模板状态校验 → 必须是生效中才放行
18
    var couponTemplateDO = couponTemplateMapper.selectOne(queryWrapper);
19
    if (ObjectUtil.notEqual(couponTemplateDO.getStatus(), CouponTemplateStatusEnum.ACTIVE.getStatus())) {
20
        log.error("优惠券模板状态：{}，已终止推送", status);
21
        return;  // ❌ 下架/过期模板拦掉
22
    }
23

24
    // 全部校验通过 → 创建监听器，开始流式读 Excel
25
    ReadExcelDistributionListener listener = new ReadExcelDistributionListener(
26
            couponTaskDO, couponTemplateDO, couponTaskFailMapper,
27
            stringRedisTemplate, couponExecuteDistributionProducer
28
    );
29
    EasyExcel.read(couponTaskDO.getFileAddress(), CouponTaskExcelObject.class, listener)
30
            .sheet().doRead();  // 流式读，不加载全部数据到内存
31
}

1
coupon_template:2026082811 (Hash)
2
└─ stock: 10000 → 9999          ← 扣 1 张
3

4
distribution:batch_user_set:9527 (Set，攒人用)
5
└─ SADD {"userId":"10001","rowNum":2}
6

7
one-coupon_distribution:template-task-execute-progress:9527 = "1"    ← 进度 Key，支持宕机断点续传

1
local stock = tonumber(redis.call('HGET', key, 'stock'))  -- 读库存
2
if stock == nil or stock <= 0 then
3
    -- 库存没了：返回 (false, Set当前大小)，Java侧记失败表
4
    return combineFields(false, redis.call('SCARD', userSetKey))
5
end
6
redis.call('HINCRBY', key, 'stock', -1)      -- 原子扣 1
7
redis.call('SADD', userSetKey, userIdAndRowNum)  -- 用户进待落库集合
8
return combineFields(true, redis.call('SCARD', userSetKey))

1
① DB扣库存: UPDATE t_coupon_template SET stock = stock - 5000
2
           WHERE id=2026082811 AND stock >= 5000   -- 10000→5000
3
   失败(DB只剩3000)→ 查实际值，按3000递归重试 → 以DB为准裁剪本批
4
② SPOP 弹出5000人（弹出的才落库，弹多少=DB实扣多少）
5
③ 构建5000个UserCouponDO批量insert到 t_user_coupon
6
   (雪花ID, validEndTime = now + 72h 领到那刻才起算, source=平台分发)
7
④ 假设10333之前抢过这张券 → 唯一索引冲突 → 整批失败
8
   → 降级逐条insert → 4999成功 + 1失败记表
9
⑤ 执行第二个Lua: 每个用户 ZADD 券记录到 user:{userId} + INCR 限领Key
10
⑥ 差额回滚: 5000-4999=1 → Redis和DB各加回1张
11
   (10333没拿到券，这1张不回滚就永久蒸发了)

1
private Integer decrementCouponTemplateStock(CouponTemplateDistributionEvent event, Integer decrementStockSize) {
2
    Long couponTemplateId = event.getCouponTemplateId();
3
    int decremented = couponTemplateMapper.decrementCouponTemplateStock(
4
        event.getShopNumber(), couponTemplateId, decrementStockSize);
5

6
    // 如果修改记录失败，意味着优惠券库存已不足，需要重试获取到可自减的库存数值
7
    if (!SqlHelper.retBool(decremented)) {
8
        LambdaQueryWrapper<CouponTemplateDO> queryWrapper = Wrappers.lambdaQuery(CouponTemplateDO.class)
9
                .eq(CouponTemplateDO::getShopNumber, event.getShopNumber())
10
                .eq(CouponTemplateDO::getId, couponTemplateId);
11
        CouponTemplateDO couponTemplateDO = couponTemplateMapper.selectOne(queryWrapper);
12
        // 递归重试，按 DB 实际库存裁剪本批
13
        return decrementCouponTemplateStock(event, couponTemplateDO.getStock());
14
    }
15
    return decrementStockSize;
16
}

1
String batchUserSetKey = String.format(DistributionRedisConstant.TEMPLATE_TASK_EXECUTE_BATCH_USER_KEY, event.getCouponTaskId());
2
List<String> batchUserMaps = stringRedisTemplate.opsForSet().pop(batchUserSetKey, couponTemplateStock);

1
for (String each : batchUserMaps) {
2
    JSONObject userIdAndRowNumJsonObject = JSON.parseObject(each);
3
    DateTime validEndTime = DateUtil.offsetHour(now, JSON.parseObject(event.getCouponTemplateConsumeRule()).getInteger("validityPeriod"));
4
    UserCouponDO userCouponDO = UserCouponDO.builder()
5
            .id(IdUtil.getSnowflakeNextId())         // 雪花 ID 作为主键
6
            .couponTemplateId(event.getCouponTemplateId())
7
            .rowNum(userIdAndRowNumJsonObject.getInteger("rowNum"))
8
            .userId(userIdAndRowNumJsonObject.getLong("userId"))
9
            .receiveTime(now)
10
            .receiveCount(1) // 第一次领取该优惠券
11
            .validStartTime(now)
12
            .validEndTime(validEndTime)  // 有效期从"领到这一刻"开始算
13
            .source(CouponSourceEnum.PLATFORM.getType())  // 平台分发
14
            .status(CouponStatusEnum.EFFECTIVE.getType())  // 生效中（值=0，与 engine 的 UNUSED 同义）
15
            .build();
16
    userCouponDOList.add(userCouponDO);
17
}

1
try {
2
    userCouponMapper.insert(userCouponDOList, userCouponDOList.size()); // 尝试批量插入
3
} catch (Exception ex) {
4
    if (cause instanceof BatchExecutorException) { // 唯一索引冲突 → 整批失败
5
        // 降级：逐条插入
6
        userCouponDOList.forEach(each -> {
7
            try {
8
                userCouponMapper.insert(each);
9
            } catch (Exception ignored) {
10
                // 查到用户已领取 → 记失败表，从列表移除
11
                couponTaskFailDOList.add(CouponTaskFailDO.builder()
12
                        .batchId(couponTaskBatchId)
13
                        .jsonObject(JSON.toJSONString(MapUtil.builder()
14
                                .put("rowNum", each.getRowNum())
15
                                .put("cause", "用户已领取该优惠券")
16
                                .build()))
17
                        .build());
18
                toRemove.add(each);
19
            }
20
        });
21
        couponTaskFailMapper.insert(couponTaskFailDOList, couponTaskFailDOList.size()); // 批量记失败表
22
        userCouponDOList.removeAll(toRemove); // 移除重复的，剩下成功的
23
    }
24
}

1
local userIds = cjson.decode(ARGV[1])      -- 用户ID集合
2
local couponIds = cjson.decode(ARGV[2])  -- 优惠券ID集合（模板ID_雪花ID）
3
local userIdPrefix = KEYS[1]              -- 用户前缀
4
local limitKeyPrefix = KEYS[2]           -- 限领前缀
5
local couponTemplateId = KEYS[3]         -- 模板ID
6
local currentTime = tonumber(ARGV[3])    -- 当前时间戳
7
local couponTemplateValidEndTime = tonumber(ARGV[4]) -- 过期时间
8

9
for i, userId in ipairs(userIds) do
10
    local key = userIdPrefix .. userId         -- user:10001
11
    local couponId = couponIds[i]
12
    redis.call('ZADD', key, currentTime, couponId)  -- ZADD 到用户券包
13

14
    local limitKey = limitKeyPrefix .. userId .. '_' .. couponTemplateId
15
    redis.call('INCR', limitKey)               -- INCR 限领次数
16
    redis.call('EXPIRE', limitKey, couponTemplateValidEndTime)
17
end