Spring Boot 整合Redis 实现优惠卷秒杀 一人一单功能

private StringRedisTemplate stringRedisTemplate;

public RedisIdWorker(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}

public long nextId(String keyPrefix) {
// 1.生成时间戳
LocalDateTime now = LocalDateTime.now();
long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
long timestamp = nowSecond – BEGIN_TIMESTAMP;

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

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

private ExecutorService es = Executors.newFixedThreadPool(500);
@Test
public void testWorkerId() throws InterruptedException {
CountDownLatch latch = new CountDownLatch(300);
Runnable task = () -> {
for (int i = 0; i < 100; i++) {
long id = redisIdWorker.nextId(“order”);
System.out.println(“id = ” + id);
}
latch.countDown();
};

long begin = System.currentTimeMillis();
for (int i = 0; i < 300; i++) {
es.submit(task);
}
latch.await();
long end = System.currentTimeMillis();
System.out.println(“times = ” + (end- begin));
}

@Override
public ResultBean<List<Voucher>> queryVoucherOfShop(Long shopId) {
// 查询优惠券信息
List<Voucher> vouchers = getBaseMapper().queryVoucherOfShop(shopId);
// 返回结果
return ResultBean.create(0, “success”, vouchers);
}

@Override
public void addSeckillVoucher(Voucher voucher) {
// 保存优惠券
save(voucher);
// 保存秒杀信息
SeckillVoucher seckillVoucher = new SeckillVoucher();
seckillVoucher.setVoucherId(voucher.getId());
seckillVoucher.setStock(voucher.getStock());
seckillVoucher.setBeginTime(voucher.getBeginTime());
seckillVoucher.setEndTime(voucher.getEndTime());
seckillVoucherService.save(seckillVoucher);
}
}

@Autowired
private IVoucherService voucherService;

/**
* 新增秒杀券
* @param voucher 优惠券信息，包括秒杀信息
* @return 优惠券id
*/
@PostMapping(“seckill”)
public ResultBean addSeckillVoucher(@RequestBody Voucher voucher) {
voucherService.addSeckillVoucher(voucher);
return Result.ok(voucher.getId());
}
}

@Autowired
private ISeckillVoucherService seckillVoucherService;

@Autowired
private RedisIdWorker redisIdWorker;

@Override
@Transactional
public Result seckillVoucher(Long voucherId) {
//1. 查询优惠卷
SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);
//2. 判断秒杀会不会开始 开始时间大于当前时间表示未开始抢购
if (seckillVoucher.getBeginTime().isAfter(LocalDateTime.now())) {
return Result.fail(“秒杀还没有开始！”);
}
//3. 判断秒杀会不会结束
if (seckillVoucher.getEndTime().isBefore(LocalDateTime.now())) {
return Result.fail(“秒杀已结束！”);
}
//4. 判断库存会不会充足
if (seckillVoucher.getStock() < 1) {
return Result.fail(“库存不足！”);
}

Long userId = UserHolder.getUser().getId();
//5. 查询定单
//5.1 查询定单
int count = query().eq(“user_id”, userId).eq(“voucher_id”, voucherId).count();
//5.2 判断并返回
if (count > 0) {
return Result.fail(“用户已租赁过！”);
}

//6. 扣减库存
boolean success = seckillVoucherService.update().setSql(“stock = stock ⑴”)
.eq(“voucher_id”, voucherId).update();
if (!success) {
return Result.fail(“库存不足！”);
}

//7. 创建定单
VoucherOrder voucherOrder = new VoucherOrder();
long orderId = redisIdWorker.nextId(“order”);
voucherOrder.setId(orderId);
voucherOrder.setUserId(userId);
voucherOrder.setVoucherId(voucherId);
save(voucherOrder);
//8. 返回定单id
return Result.ok(orderId);
}
}

@Autowired
private IVoucherOrderService voucherOrderService;

@PostMapping(“seckill/{id}”)
public Result seckillVoucher(@PathVariable(“id”) Long voucherId) {
return voucherOrderService.seckillVoucher(voucherId);
}
}

return var5;

存在问题：现在的问题或者和之前一样，并发过来，查询数据库，都不存在定单，所以我们或者需要加锁，但是乐观锁比较合适更新数据，而现在是插入数据，所以我们需要使用悲观锁操作

注意：在这里提到了非常多的问题，我们需要渐渐的来思考，首先我们的初始方案是封装了一个createVoucherOrder方法，同时为了确保他线程安全，在方法上添加了一把synchronized 锁

加上悲观锁

在启动类加入以下注解，启动AspectJ

以上代码，采取悲观锁解决了高并发下，一人多单的场景，同时，也解决了事务失效。引入了AspectJ解决！

Jmeter 测试

再次测试，查看结果

可见返回的结果异常率如此高，再看要求信息

可见已成功的拦截了毛病要求，JSON断言正确。

查看数据库 信息

优惠卷数量

可见成功的完成了 在高并发要求下 的一人一单功能。

⛵小结

本篇文章到此结束，如果您有相关技术方面疑问可以联系我们技术人员远程解决，感谢大家支持本站！

到此这篇关于Spring Boot 整合Redis 实现优惠卷秒杀 一人一单的文章就介绍到这了,更多相关Spring Boot 整合Redis 优惠卷秒杀内容请搜索之前的文章或继续浏览下面的相关文章希望大家以后多多支持！