优惠券秒杀

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

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
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
33
            return proxy.createVoucherOrder(voucherId);
34
        }
35
    }
36

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

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

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

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

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

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

8
    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
9
        this.name = name;
10
        this.stringRedisTemplate = stringRedisTemplate;
11
    }
12
    //Redis中的key设计
13
    private static final String KEY_PREFIX ="lock:";
14
    //锁的名称不能写死
15
    //任何业务需要有不同的锁
16
    @Override
17
    public boolean tryLock(long timeoutSec) {
18
        // 获取线程标示
19
        String threadId = Thread.currentThread().getId() + "";
20
        // 获取锁
21
        Boolean success = stringRedisTemplate.opsForValue()
22
                .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
23
        return Boolean.TRUE.equals(success);
24
    }

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

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 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
 private class VoucherOrderHandler implements Runnable{
12

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

27
       private void handleVoucherOrder(VoucherOrder voucherOrder) {
28
            //1.获取用户
29
            Long userId = voucherOrder.getUserId();
30
            // 2.创建锁对象
31
            RLock redisLock = redissonClient.getLock("lock:order:" + userId);
32
            // 3.尝试获取锁
33
            boolean isLock = redisLock.lock();
34
            // 4.判断是否获得锁成功
35
            if (!isLock) {
36
                // 获取锁失败，直接返回失败或者重试
37
                log.error("不允许重复下单！");
38
                return;
39
            }
40
            try {
41
        //注意：由于是spring的事务是放在threadLocal中，此时的是多线程，事务会失效
42
                proxy.createVoucherOrder(voucherOrder);
43
            } finally {
44
                // 释放锁
45
                redisLock.unlock();
46
            }
47
    }
48
  private BlockingQueue<VoucherOrder> orderTasks =new  ArrayBlockingQueue<>(1024 * 1024);
49
    @Override
50
    public Result seckillVoucher(Long voucherId) {
51
        Long userId = UserHolder.getUser().getId();
52
        long orderId = redisIdWorker.nextId("order");
53
        // 1.执行lua脚本
54
        Long result = stringRedisTemplate.execute(
55
                SECKILL_SCRIPT,
56
                Collections.emptyList(),
57
                voucherId.toString(), userId.toString(), String.valueOf(orderId)
58
        );
59
        int r = result.intValue();
60
        // 2.判断结果是否为0
61
        if (r != 0) {
62
            // 2.1.不为0 ，代表没有购买资格
63
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
64
        }
65
        VoucherOrder voucherOrder = new VoucherOrder();
66
        voucherOrder.setId(orderId);
67
        // 2.4.用户id
68
        voucherOrder.setUserId(userId);
69
        // 2.5.代金券id
70
        voucherOrder.setVoucherId(voucherId);
71
        // 2.6.放入阻塞队列
72
        orderTasks.add(voucherOrder);
73
        //3.获取代理对象
74
         proxy = (IVoucherOrderService)AopContext.currentProxy();
75
        //4.返回订单id
76
        return Result.ok(orderId);
77
    }
78

79
      @Transactional
80
    public  void createVoucherOrder(VoucherOrder voucherOrder) {
81
        Long userId = voucherOrder.getUserId();
82
        // 5.1.查询订单
83
        int count = query().eq("user_id", userId).eq("voucher_id", voucherOrder.getVoucherId()).count();
84
        // 5.2.判断是否存在
85
        if (count > 0) {
86
            // 用户已经购买过了
87
           log.error("用户已经购买过了");
88
           return ;
89
        }
90

91
        // 6.扣减库存
92
        boolean success = seckillVoucherService.update()
93
                .setSql("stock = stock - 1") // set stock = stock - 1
94
                .eq("voucher_id", voucherOrder.getVoucherId()).gt("stock", 0) // where id = ? and stock > 0
95
                .update();
96
        if (!success) {
97
            // 扣减失败
98
            log.error("库存不足");
99
            return ;
100
        }
101
        save(voucherOrder);
102
    }