优惠券秒杀

1
@Component
2
public class RedisIdWorker {
3
    /**
4
     * 开始时间戳
5
     */
6
    private static final long BEGIN_TIMESTAMP = 1640995200L;
7
    /**
8
     * 序列号的位数
9
     */
10
    private static final int COUNT_BITS = 32;
11

12
    private StringRedisTemplate stringRedisTemplate;
13

14
    public RedisIdWorker(StringRedisTemplate stringRedisTemplate) {
15
        this.stringRedisTemplate = stringRedisTemplate;
16
    }
17

18
    public long nextId(String keyPrefix) {
19
        // 1.生成时间戳
20
        LocalDateTime now = LocalDateTime.now();
21
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
22
        long timestamp = nowSecond - BEGIN_TIMESTAMP;
23

24
        // 2.生成序列号
25
        // 2.1.获取当前日期，精确到天
26
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
27
        // 2.2.自增长
28
        long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);
29

30
        // 3.拼接并返回
31
        return timestamp << COUNT_BITS | count;
32
    }
33
}

1
@RestController
2
@RequestMapping("/voucher")
3
public class VoucherController {
4

5
    @Resource
6
    private IVoucherService voucherService;
7
     //新增普通券
8
    @PostMapping
9
    public Result addVoucher(@RequestBody Voucher voucher) {
10
        voucherService.save(voucher);
11
        return Result.ok(voucher.getId());
12
    }
13
    //新增秒杀券
14
    @PostMapping("seckill")
15
    public Result addSeckillVoucher(@RequestBody Voucher voucher) {
16
        voucherService.addSeckillVoucher(voucher);
17
        return Result.ok(voucher.getId());
18
    }
19
    //查询店铺的优惠券列表
20
    @GetMapping("/list/{shopId}")
21
    public Result queryVoucherOfShop(@PathVariable("shopId") Long shopId) {
22
       return voucherService.queryVoucherOfShop(shopId);
23
    }
24
}

1
@Service
2
public class VoucherServiceImpl extends ServiceImpl<VoucherMapper, Voucher> implements IVoucherService {
3
    @Resource
4
    private ISeckillVoucherService seckillVoucherService;
5
    @Override
6
    public Result queryVoucherOfShop(Long shopId) {
7
        // 查询优惠券信息
8
        List<Voucher> vouchers = getBaseMapper().queryVoucherOfShop(shopId);
9
        // 返回结果
10
        return Result.ok(vouchers);
11
    }
12

13

14
    @Override
15
    @Transactional
16
    public void addSeckillVoucher(Voucher voucher) {
17
        // 保存优惠券
18
        save(voucher);
19
        // 保存秒杀信息
20
       //补充tb_voucher表中没有的属性
21
        SeckillVoucher seckillVoucher = new SeckillVoucher();
22
        seckillVoucher.setVoucherId(voucher.getId());
23
        seckillVoucher.setStock(voucher.getStock());
24
        seckillVoucher.setBeginTime(voucher.getBeginTime());
25
        seckillVoucher.setEndTime(voucher.getEndTime());
26
        seckillVoucherService.save(seckillVoucher);
27

28
        // 保存秒杀库存到Redis中
29
    stringRedisTemplate.opsForValue().set(SECKILL_STOCK_KEY + voucher.getId(), voucher.getStock().toString());
30
    }
31
}

1
@Service
2
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
3
     @Resource
4
     private ISeckillVoucherService seckillVoucherService;
5
     //全局唯一id引入
6
    @Resource
7
    private RedisIdWorker redisIdWorker;
8
    @Override
9
    public Result seckillVoucher(Long voucherId) {
10
        //拿到优惠券信息
11
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
12
        //判断优惠券在抢购时间之前
13
       if(voucher.getBeginTime().isAfter(LocalDateTime.now())) {
14
           return Result.fail("秒杀尚未开始");
15
       }
16
       //判断秒杀是否结束
17
        if(voucher.getEndTime().isBefore(LocalDateTime.now())){
18
            return Result.fail("秒杀已经结束");
19
        }
20
        //判断库存是否充足
21
            if(voucher.getStock()<1){
22
                return Result.fail("库存不足");
23
            }
24

25
       // 一人一单
26
        Long Userid = UserHolder.getUser().getId();
27
        //  查询订单
28
        int count = query().eq("user_id", userId)
29
                .eq("voucher_id", voucherId)
30
                .count();
31
        //判断是否存在
32
        if(count>0){
33
            //用户已经购买过了
34
            return Result.fail("用户已经购买了一次");
35
        }
36

37
        //存在减库存
38
        boolean success=  seckillVoucherService.update()
39
                .setSql("stock=stock -1")
40
                .eq("voucher_id",voucherId)//where条件
41
                .gt("stock",0)
42
                .update();
43

44
        if(!success){
45
            Result.fail("库存不足");
46
        }
47
        //创建订单
48
        VoucherOrder voucherOrder =new VoucherOrder();
49
        //订单id
50
        long orderId = redisIdWorker.nextId("order");
51
        voucherOrder.setId(orderId);
52
        //用户ID
53
        voucherOrder.setUserId(Userid);
54
        //代金券ID
55
        voucherOrder.setVoucherId(voucherId);
56
        save(voucherOrder);
57
        //返回订单id
58
        return Result.ok(orderId);
59
    }

1
@Transactional
2
public synchronized Result createVoucherOrder(Long voucherId) {
3

4
  Long userId = UserHolder.getUser().getId();
5
         // 5.1.查询订单
6
        int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
7
        // 5.2.判断是否存在
8
        if (count > 0) {
9
            // 用户已经购买过了
10
            return Result.fail("用户已经购买过一次！");
11
        }
12

13
        // 6.扣减库存
14
        boolean success = seckillVoucherService.update()
15
                .setSql("stock = stock - 1") // set stock = stock - 1
16
                .eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0
17
                .update();
18
        if (!success) {
19
            // 扣减失败
20
            return Result.fail("库存不足！");
21
        }
22

23
        // 7.创建订单
24
        VoucherOrder voucherOrder = new VoucherOrder();
25
        // 7.1.订单id
26
        long orderId = redisIdWorker.nextId("order");
27
        voucherOrder.setId(orderId);
28
        // 7.2.用户id
29
        voucherOrder.setUserId(userId);
30
        // 7.3.代金券id
31
        voucherOrder.setVoucherId(voucherId);
32
        save(voucherOrder);
33

34
        // 7.返回订单id
35
        return Result.ok(orderId);
36
}

1
@Transactional
2
public  Result createVoucherOrder(Long voucherId) {
3
  Long userId = UserHolder.getUser().getId();
4
  synchronized(userId.toString().intern()){
5
         // 5.1.查询订单
6
        int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
7
        // 5.2.判断是否存在
8
        if (count > 0) {
9
            // 用户已经购买过了
10
            return Result.fail("用户已经购买过一次！");
11
        }
12

13
        // 6.扣减库存
14
        boolean success = seckillVoucherService.update()
15
                .setSql("stock = stock - 1") // set stock = stock - 1
16
                .eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0
17
                .update();
18
        if (!success) {
19
            // 扣减失败
20
            return Result.fail("库存不足！");
21
        }
22

23
        // 7.创建订单
24
        VoucherOrder voucherOrder = new VoucherOrder();
25
        // 7.1.订单id
26
        long orderId = redisIdWorker.nextId("order");
27
        voucherOrder.setId(orderId);
28
        // 7.2.用户id
29
        voucherOrder.setUserId(userId);
30
        // 7.3.代金券id
31
        voucherOrder.setVoucherId(voucherId);
32
        save(voucherOrder);
33

34
        // 7.返回订单id
35
        return Result.ok(orderId);
36
    }
37
}

1
@Service
2
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
3

4
    @Resource
5
    private ISeckillVoucherService seckillVoucherService;
6

7
    @Resource
8
    private RedisIdWorker redisIdWorker;
9

10
    @Override
11
    public Result seckillVoucher(Long voucherId) {
12
        //1.查询优惠券
13
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
14

15
        //2.判断秒杀是否开始
16
        if(voucher.getBeginTime().isAfter(LocalDateTime.now())){
17
            return Result.fail("秒杀尚未开始!");
18
        }
19

20
        //3.判断秒杀是否结束
21
        if(voucher.getEndTime().isBefore(LocalDateTime.now())){
22
            return Result.fail("秒杀已经结束!");
23
        }
24

25
        //4.判断库存是否充足
26
        if (voucher.getStock()<1) {
27
            return Result.fail("库存不足!");
28
        }
29

30
        Long userId = UserHolder.getUser().getId();
31
        synchronized(userId.toString().intern()){
32
        获取到代理对象
33
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
34
            return proxy.createVoucherOrder(voucherId);
35
        }
36
    }
37

38
    @Transactional
39
    public  Result createVoucherOrder(Long voucherId) {
40

41
        Long userId = UserHolder.getUser().getId();
42
        // 5.1.查询订单
43
        int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
44
        // 5.2.判断是否存在
45
        if (count > 0) {
46
            // 用户已经购买过了
47
            return Result.fail("用户已经购买过一次！");
48
        }
49

50
        // 6.扣减库存
51
        boolean success = seckillVoucherService.update()
52
                .setSql("stock = stock - 1") // set stock = stock - 1
53
                .eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0
54
                .update();
55
        if (!success) {
56
            // 扣减失败
57
            return Result.fail("库存不足！");
58
        }
59

60
        // 7.创建订单
61
        VoucherOrder voucherOrder = new VoucherOrder();
62
        // 7.1.订单id
63
        long orderId = redisIdWorker.nextId("order");
64
        voucherOrder.setId(orderId);
65
        // 7.2.用户id
66
        voucherOrder.setUserId(userId);
67
        // 7.3.代金券id
68
        voucherOrder.setVoucherId(voucherId);
69
        save(voucherOrder);
70

71
        // 7.返回订单id
72
        return Result.ok(orderId);
73
    }
74
}

1
//分布式锁
2
public class SimpleRedisLock implements ILock {
3
        //锁的名称
4
        private  String name;
5
        //引入Redis
6
        private StringRedisTemplate stringRedisTemplate;
7

8

9
    //有参构造传入key的统一锁前缀 + 具体业务锁名称
10
    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
11
        this.name = name;
12
        this.stringRedisTemplate = stringRedisTemplate;
13
    }
14
    //Redis中的key设计（统一的key前缀）
15
    private static final String KEY_PREFIX ="lock:";
16
    //锁的名称不能写死
17
    //任何业务需要有不同的锁（name） value为线程id
18
    @Override
19
    public boolean tryLock(long timeoutSec) {
20
        // 获取线程标示
21
        String threadId = Thread.currentThread().getId() + "";
22
        // 获取锁
23
        Boolean success = stringRedisTemplate.opsForValue()
24
                .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
25
        return Boolean.TRUE.equals(success);
26
    }
27
   //释放锁
28
    @Override
29
    public void unlock() {
30
        stringRedisTemplate.delete(KEY_PREFIX + name);
31
    }

1
@Override
2
    public Result seckillVoucher(Long voucherId) {
3
        //1.查询优惠券
4
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
5

6
        //2.判断秒杀是否开始
7
        if(voucher.getBeginTime().isAfter(LocalDateTime.now())){
8
            return Result.fail("秒杀尚未开始!");
9
        }
10

11
        //3.判断秒杀是否结束
12
        if(voucher.getEndTime().isBefore(LocalDateTime.now())){
13
            return Result.fail("秒杀已经结束!");
14
        }
15

16
        //4.判断库存是否充足
17
        if (voucher.getStock()<1) {
18
            return Result.fail("库存不足!");
19
        }
20

21
        Long userId = UserHolder.getUser().getId();
22
        //获取锁对象,有参构造Key
23
        SimpleRedisLock Lock = new SimpleRedisLock("order" + userId, stringRedisTemplate);
24

25
        //获取锁
26
        boolean isLock = Lock.tryLock(1200);//设置过期时间
27
            //判断是否获取锁成功
28
        if(!isLock){
29
            //获取锁失败
30
            return Result.fail("不予许重复下单");
31
        }
32
        try {
33
            //代理对象执行事务逻辑Transactional
34
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
35
            return proxy.createVoucherOrder(voucherId);
36
        } finally {
37
            //释放锁
38
            Lock.unlock();
39
        }

1
  //Redis中的key设计
2
    private static final String KEY_PREFIX ="lock:";
3
    private static final String ID_PREFIX
4
    =UUID.randomUUID().toString();
5
    //锁的名称不能写死
6
    //任何业务需要有不同的锁
7
    @Override
8
    public boolean tryLock(long timeoutSec) {
9
        // 获取线程标示
10
        String threadId = ID_PREFIX+Thread.currentThread().getId() + "";
11
        // 获取锁
12
        Boolean success = stringRedisTemplate.opsForValue()
13
                .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
14
        return Boolean.TRUE.equals(success);
15
    }
16

17
  //释放锁
18
    @Override
19
    public void unlock() {
20
        //获取线程标示
21
        String threadId = ID_PREFIX+Thread.currentThread().getId() + "";
22
        //锁中的标示
23
        String id= StringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
24
        if(threadId.equals(id)){
25
            stringRedisTemplate.delete(KEY_PREFIX + name);
26
        }
27
    }

1
//静态代码块，类加载时执行一次
2
private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
3
    static {
4
    //创建 Spring Redis 的 Lua 脚本对象
5
        UNLOCK_SCRIPT = new DefaultRedisScript<>();
6
       //Lua脚本放置的位置
7
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
8
        UNLOCK_SCRIPT.setResultType(Long.class);
9
    }
10

11
public void unlock() {
12
    // 调用lua脚本
13
    stringRedisTemplate.execute(
14
            UNLOCK_SCRIPT,
15
//Collections.singletonList 创建一个只包含一个元素的 List
16
            Collections.singletonList(KEY_PREFIX + name),
17
            ID_PREFIX + Thread.currentThread().getId());
18
}

1
@Override
2
@Transactional
3
public void addSeckillVoucher(Voucher voucher) {
4
    // 保存优惠券
5
    save(voucher);
6
    // 保存秒杀信息
7
    SeckillVoucher seckillVoucher = new SeckillVoucher();
8
    seckillVoucher.setVoucherId(voucher.getId());
9
    seckillVoucher.setStock(voucher.getStock());
10
    seckillVoucher.setBeginTime(voucher.getBeginTime());
11
    seckillVoucher.setEndTime(voucher.getEndTime());
12
    seckillVoucherService.save(seckillVoucher);
13
    // 保存秒杀库存到Redis中
14
    //SECKILL_STOCK_KEY 这个变量定义在RedisConstans中
15
    //private static final String SECKILL_STOCK_KEY ="seckill:stock:"
16
    stringRedisTemplate.opsForValue().set(SECKILL_STOCK_KEY + voucher.getId(), voucher.getStock().toString());
17
}

1
-- 1.参数列表
2
-- 1.1.优惠券id
3
local voucherId = ARGV[1]
4
-- 1.2.用户id
5
local userId = ARGV[2]
6
-- 1.3.订单id
7
local orderId = ARGV[3]
8

9
-- 2.数据key
10
-- 2.1.库存key
11
local stockKey = 'seckill:stock:' .. voucherId
12
-- 2.2.订单key
13
local orderKey = 'seckill:order:' .. voucherId
14

15
-- 3.脚本业务
16
-- 3.1.判断库存是否充足 get stockKey
17
if(tonumber(redis.call('get', stockKey)) <= 0) then
18
    -- 3.2.库存不足，返回1
19
    return 1
20
end
21
-- 3.2.判断用户是否下单 SISMEMBER orderKey userId
22
if(redis.call('sismember', orderKey, userId) == 1) then
23
    -- 3.3.存在，说明是重复下单，返回2
24
    return 2
25
end
26
-- 3.4.扣库存 incrby stockKey -1
27
redis.call('incrby', stockKey, -1)
28
-- 3.5.下单（保存用户）sadd orderKey userId 创建seckill:order:
29
redis.call('sadd', orderKey, userId)
30
-- 3.6.发送消息到队列中， XADD stream.orders * k1 v1 k2 v2 ...
31
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)
32
return 0

1
@Override
2
public Result seckillVoucher(Long voucherId) {
3
    //获取用户
4
    Long userId = UserHolder.getUser().getId();
5
    long orderId = redisIdWorker.nextId("order");
6
    // 1.执行lua脚本
7
    Long result = stringRedisTemplate.execute(
8
            SECKILL_SCRIPT,
9
            Collections.emptyList(),
10
            voucherId.toString(), userId.toString(), String.valueOf(orderId)
11
    );
12
    int r = result.intValue();
13
    // 2.判断结果是否为0
14
    if (r != 0) {
15
        // 2.1.不为0 ，代表没有购买资格
16
        return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
17
    }
18
    //TODO 保存阻塞队列
19
    // 3.返回订单id
20
    return Result.ok(orderId);
21
}

1
 //创建队列消费消息完成下单
2
  private BlockingQueue<VoucherOrder> orderTasks =new  ArrayBlockingQueue<>(1024 * 1024);
3
    @Override
4
    public Result seckillVoucher(Long voucherId) {
5
        Long userId = UserHolder.getUser().getId();
6
        long orderId = redisIdWorker.nextId("order");
7
        // 1.执行lua脚本
8
        Long result = stringRedisTemplate.execute(
9
                SECKILL_SCRIPT,
10
                Collections.emptyList(),
11
                voucherId.toString(), userId.toString(), String.valueOf(orderId)
12
        );
13
        int r = result.intValue();
14
        // 2.判断结果是否为0
15
        if (r != 0) {
16
            // 2.1.不为0 ，代表没有购买资格
17
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
18
        }
19
        VoucherOrder voucherOrder = new VoucherOrder();
20
        voucherOrder.setId(orderId);
21
        // 2.4.用户id
22
        voucherOrder.setUserId(userId);
23
        // 2.5.代金券id
24
        voucherOrder.setVoucherId(voucherId);
25
        // 2.6.放入阻塞队列
26
        orderTasks.add(voucherOrder);
27
        //3.获取代理对象
28
         proxy = (IVoucherOrderService)AopContext.currentProxy();
29
        //4.返回订单id
30
        return Result.ok(orderId);
31
    }

1
//异步处理线程池
2
private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();
3

4
//在类初始化之后执行，因为当这个类初始化好了之后，随时都是有可能要执行的
5
@PostConstruct
6
private void init() {
7
   SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
8
}
9

10
// 用于线程池处理的任务
11
// 当初始化完毕后，就会去从对列中去拿信息
12
 private class VoucherOrderHandler implements Runnable{
13

14
        @Override
15
        public void run() {
16
            while (true){
17
                try {
18
                    // 1.获取队列中的订单信息
19
                    VoucherOrder voucherOrder = orderTasks.take();
20
                    // 2.创建订单
21
                    handleVoucherOrder(voucherOrder);
22
                } catch (Exception e) {
23
                    log.error("处理订单异常", e);
24
                }
25
             }
26
        }
27

28
       private void handleVoucherOrder(VoucherOrder voucherOrder) {
29
            //1.获取用户
30
            Long userId = voucherOrder.getUserId();
31
            // 2.创建锁对象
32
            RLock redisLock = redissonClient.getLock("lock:order:" + userId);
33
            // 3.尝试获取锁
34
            boolean isLock = redisLock.lock();
35
            // 4.判断是否获得锁成功
36
            if (!isLock) {
37
                // 获取锁失败，直接返回失败或者重试
38
                log.error("不允许重复下单！");
39
                return;
40
            }
41
            try {
42
        //注意：由于是spring的事务是放在threadLocal中，此时的是多线程，事务会失效
43
                proxy.createVoucherOrder(voucherOrder);
44
            } finally {
45
                // 释放锁
46
                redisLock.unlock();
47
            }
48
    }
49

50

51
      @Transactional
52
    public  void createVoucherOrder(VoucherOrder voucherOrder) {
53
        Long userId = voucherOrder.getUserId();
54
        // 5.1.查询订单
55
        int count = query().eq("user_id", userId).eq("voucher_id", voucherOrder.getVoucherId()).count();
56
        // 5.2.判断是否存在
57
        if (count > 0) {
58
            // 用户已经购买过了
59
           log.error("用户已经购买过了");
60
           return ;
61
        }
62

63
        // 6.扣减库存
64
        boolean success = seckillVoucherService.update()
65
                .setSql("stock = stock - 1") // set stock = stock - 1
66
                .eq("voucher_id", voucherOrder.getVoucherId()).gt("stock", 0) // where id = ? and stock > 0
67
                .update();
68
        if (!success) {
69
            // 扣减失败
70
            log.error("库存不足");
71
            return ;
72
        }
73
        save(voucherOrder);
74
    }

1
private class VoucherOrderHandler implements Runnable {
2

3
    @Override
4
    public void run() {
5
        while (true) {
6
            try {
7
                // 1.获取消息队列中的订单信息 XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS s1 >
8
                List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
9
                    Consumer.from("g1", "c1"),
10
                    StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
11
                    StreamOffset.create("stream.orders", ReadOffset.lastConsumed())
12
                );
13
                // 2.判断订单信息是否为空
14
                if (list == null || list.isEmpty()) {
15
                    // 如果为null，说明没有消息，继续下一次循环
16
                    continue;
17
                }
18
                // 解析数据
19
                MapRecord<String, Object, Object> record = list.get(0);
20
                Map<Object, Object> value = record.getValue();
21
                VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
22
                // 3.创建订单
23
                createVoucherOrder(voucherOrder);
24
                // 4.确认消息 XACK
25
                stringRedisTemplate.opsForStream().acknowledge("s1", "g1", record.getId());
26
            } catch (Exception e) {
27
                log.error("处理订单异常", e);
28
                //处理异常消息
29
                handlePendingList();
30
            }
31
        }
32
    }
33

34
    private void handlePendingList() {
35
        while (true) {
36
            try {
37
                // 1.获取pending-list中的订单信息 XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS s1 0
38
                List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
39
                    Consumer.from("g1", "c1"),
40
                    StreamReadOptions.empty().count(1),
41
                    StreamOffset.create("stream.orders", ReadOffset.from("0"))
42
                );
43
                // 2.判断订单信息是否为空
44
                if (list == null || list.isEmpty()) {
45
                    // 如果为null，说明没有异常消息，结束循环
46
                    break;
47
                }
48
                // 解析数据
49
                MapRecord<String, Object, Object> record = list.get(0);
50
                Map<Object, Object> value = record.getValue();
51
                VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
52
                // 3.创建订单
53
                createVoucherOrder(voucherOrder);
54
                // 4.确认消息 XACK
55
                stringRedisTemplate.opsForStream().acknowledge("s1", "g1", record.getId());
56
            } catch (Exception e) {
57
                log.error("处理pendding订单异常", e);
58
                try{
59
                    Thread.sleep(20);
60
                }catch(Exception e){
61
                    e.printStackTrace();
62
                }
63
            }
64
        }
65
    }
66
}