• Redis实战——优惠券秒杀（一人一单业务）

    需求：修改秒杀业务，要求同一个优惠券，一个用户只能下一单

    我们只需要在增加订单之前，拿用户id和优惠券id判断订单是否已经存在，如果存在，说明用户已经购买。

    代码实现：

    1. package com.hmdp.service.impl;
    2.  
    3. import com.hmdp.dto.Result;
    4. import com.hmdp.entity.SeckillVoucher;
    5. import com.hmdp.entity.VoucherOrder;
    6. import com.hmdp.mapper.VoucherOrderMapper;
    7. import com.hmdp.service.ISeckillVoucherService;
    8. import com.hmdp.service.IVoucherOrderService;
    9. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    10. import com.hmdp.utils.RedisIdWorker;
    11. import com.hmdp.utils.UserHolder;
    12. import org.springframework.stereotype.Service;
    13. import org.springframework.transaction.annotation.Transactional;
    14.  
    15. import javax.annotation.Resource;
    16. import java.time.LocalDateTime;
    17.  
    18. /**
    19.  * 
    20.  *  服务实现类
    21.  * 
    22.  *
    23.  * @author 虎哥
    24.  * @since 2021-12-22
    25.  */
    26. @Service
    27. public class VoucherOrderServiceImpl extends ServiceImpl implements IVoucherOrderService {
    28.  
    29.     @Resource
    30.     private ISeckillVoucherService iSeckillVoucherService;
    31.  
    32.     @Resource
    33.     private RedisIdWorker redisIdWorker;
    34.  
    35.     @Override
    36.     public Result seckillVoucher(Long voucherId) {
    37.         //1.获取优惠券信息
    38.         SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);
    39.  
    40.         //2.判断是否已经开始
    41.         if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
    42.             Result.fail("秒杀尚未开始!");
    43.         }
    44.         //3.判断是否已经结束
    45.         if (voucher.getEndTime().isBefore(LocalDateTime.now())){
    46.             Result.fail("秒杀已经结束了!");
    47.         }
    48.         //4.判断库存是否充足
    49.         if (voucher.getStock() < 1) {
    50.             Result.fail("库存不充足!");
    51.         }
    52.         //5.扣减库存
    53.         boolean success = iSeckillVoucherService.update()
    54.                 .setSql("stock = stock-1").eq("voucher_id",voucherId).gt("stock",0)
    55.                 .update();
    56.         if (!success){
    57.             Result.fail("库存不充足!");
    58.         }
    59.          Long userId = UserHolder.getUser().getId();
    60.         //6.根据优惠券id和用户id判断订单是否已经存在
    61.         //如果存在，则返回错误信息
    62.         int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
    63.         if (count > 0) {
    64.             return Result.fail("用户已经购买！");
    65.         }
    66.         //7. 创建订单
    67.         VoucherOrder voucherOrder = new VoucherOrder();
    68.         //7.1添加订单id
    69.         Long orderId = redisIdWorker.nextId("order");
    70.         voucherOrder.setId(orderId);
    71.         //7.2添加用户id
    72.         voucherOrder.setUserId(userId);
    73.         //7.3添加优惠券id
    74.         voucherOrder.setVoucherId(voucherId);
    75.         save(voucherOrder);
    76.         //8.返回订单id
    77.         return Result.ok(orderId);
    78.     }
    79. }

     但是，还没完，这种代码逻辑，在高并发的情况下还是会出现一个人购买购买多个的情况：

    就是同一时间，多个线程来查询数据，都没有查到订单，都去创建了订单（高并发的情况下）

    类似超卖问题，所以我们要进行上锁。

    这次就用悲观锁。

    最简单的实现方法，就是把从查询订单是否存在到保存订单返回订单id这一段代码块进行封装成一个方法，然后在这个方法上加上synchronized关键字和spring事务。

    如下：

    1. package com.hmdp.service.impl;
    2.  
    3. import com.hmdp.dto.Result;
    4. import com.hmdp.entity.SeckillVoucher;
    5. import com.hmdp.entity.VoucherOrder;
    6. import com.hmdp.mapper.VoucherOrderMapper;
    7. import com.hmdp.service.ISeckillVoucherService;
    8. import com.hmdp.service.IVoucherOrderService;
    9. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    10. import com.hmdp.utils.RedisIdWorker;
    11. import com.hmdp.utils.UserHolder;
    12. import org.springframework.stereotype.Service;
    13. import org.springframework.transaction.annotation.Transactional;
    14.  
    15. import javax.annotation.Resource;
    16. import java.time.LocalDateTime;
    17.  
    18. /**
    19.  * 
    20.  *  服务实现类
    21.  * 
    22.  *
    23.  * @author 虎哥
    24.  * @since 2021-12-22
    25.  */
    26. @Service
    27. public class VoucherOrderServiceImpl extends ServiceImpl implements IVoucherOrderService {
    28.  
    29.     @Resource
    30.     private ISeckillVoucherService iSeckillVoucherService;
    31.  
    32.     @Resource
    33.     private RedisIdWorker redisIdWorker;
    34.  
    35.     @Override
    36.     public Result seckillVoucher(Long voucherId) {
    37.         //1.获取优惠券信息
    38.         SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);
    39.  
    40.         //2.判断是否已经开始
    41.         if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
    42.             Result.fail("秒杀尚未开始!");
    43.         }
    44.         //3.判断是否已经结束
    45.         if (voucher.getEndTime().isBefore(LocalDateTime.now())){
    46.             Result.fail("秒杀已经结束了!");
    47.         }
    48.         //4.判断库存是否充足
    49.         if (voucher.getStock() < 1) {
    50.             Result.fail("库存不充足!");
    51.         }
    52.         //5.扣减库存
    53.         boolean success = iSeckillVoucherService.update()
    54.                 .setSql("stock = stock-1").eq("voucher_id",voucherId).gt("stock",0)
    55.                 .update();
    56.         if (!success){
    57.             Result.fail("库存不充足!");
    58.         }
    59.        
    60.         return createVoucherOrder(voucherId);
    61.         
    62.     }
    63.  
    64.     @Transactional
    65.     public synchronized Result createVoucherOrder(Long voucherId) {
    66.         Long userId = UserHolder.getUser().getId();
    67.         //6.根据优惠券id和用户id判断订单是否已经存在
    68.         //如果存在，则返回错误信息
    69.         int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
    70.         if (count > 0) {
    71.             return Result.fail("用户已经购买！");
    72.         }
    73.         //7. 创建订单
    74.         VoucherOrder voucherOrder = new VoucherOrder();
    75.         //7.1添加订单id
    76.         Long orderId = redisIdWorker.nextId("order");
    77.         voucherOrder.setId(orderId);
    78.         //7.2添加用户id
    79.         voucherOrder.setUserId(userId);
    80.         //7.3添加优惠券id
    81.         voucherOrder.setVoucherId(voucherId);
    82.         save(voucherOrder);
    83.         //8.返回订单id
    84.         return Result.ok(orderId);
    85.     }
    86. }

    但是，这个方法就是使用了悲观锁，锁的对象是整个类对象，所有用户公用一把锁，就会导致串行执行，从而性能大大降低。

    我们可以只锁上用户id，让他每个用户获得一把锁。

    1. package com.hmdp.service.impl;
    2.  
    3. import com.hmdp.dto.Result;
    4. import com.hmdp.entity.SeckillVoucher;
    5. import com.hmdp.entity.VoucherOrder;
    6. import com.hmdp.mapper.VoucherOrderMapper;
    7. import com.hmdp.service.ISeckillVoucherService;
    8. import com.hmdp.service.IVoucherOrderService;
    9. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    10. import com.hmdp.utils.RedisIdWorker;
    11. import com.hmdp.utils.UserHolder;
    12. import org.springframework.stereotype.Service;
    13. import org.springframework.transaction.annotation.Transactional;
    14.  
    15. import javax.annotation.Resource;
    16. import java.time.LocalDateTime;
    17.  
    18. /**
    19.  * 
    20.  *  服务实现类
    21.  * 
    22.  *
    23.  * @author 虎哥
    24.  * @since 2021-12-22
    25.  */
    26. @Service
    27. public class VoucherOrderServiceImpl extends ServiceImpl implements IVoucherOrderService {
    28.  
    29.     @Resource
    30.     private ISeckillVoucherService iSeckillVoucherService;
    31.  
    32.     @Resource
    33.     private RedisIdWorker redisIdWorker;
    34.  
    35.     @Override
    36.     public Result seckillVoucher(Long voucherId) {
    37.         //1.获取优惠券信息
    38.         SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);
    39.  
    40.         //2.判断是否已经开始
    41.         if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
    42.             Result.fail("秒杀尚未开始!");
    43.         }
    44.         //3.判断是否已经结束
    45.         if (voucher.getEndTime().isBefore(LocalDateTime.now())){
    46.             Result.fail("秒杀已经结束了!");
    47.         }
    48.         //4.判断库存是否充足
    49.         if (voucher.getStock() < 1) {
    50.             Result.fail("库存不充足!");
    51.         }
    52.         //5.扣减库存
    53.         boolean success = iSeckillVoucherService.update()
    54.                 .setSql("stock = stock-1").eq("voucher_id",voucherId).gt("stock",0)
    55.                 .update();
    56.         if (!success){
    57.             Result.fail("库存不充足!");
    58.         }
    59.         Long userId = UserHolder.getUser().getId();
    60.         
    61.         return createVoucherOrder(voucherId);
    62.        
    63.     }
    64.  
    65.     @Transactional
    66.     public Result createVoucherOrder(Long voucherId) {
    67.         Long userId = UserHolder.getUser().getId();
    68.         //6.根据优惠券id和用户id判断订单是否已经存在
    69.         synchronized (userId.toString().intern()){
    70.             //如果存在，则返回错误信息
    71.             int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
    72.             if (count > 0) {
    73.                 return Result.fail("用户已经购买！");
    74.             }
    75.             //7. 创建订单
    76.             VoucherOrder voucherOrder = new VoucherOrder();
    77.             //7.1添加订单id
    78.             Long orderId = redisIdWorker.nextId("order");
    79.             voucherOrder.setId(orderId);
    80.             //7.2添加用户id
    81.             voucherOrder.setUserId(userId);
    82.             //7.3添加优惠券id
    83.             voucherOrder.setVoucherId(voucherId);
    84.             save(voucherOrder);
    85.             //8.返回订单id
    86.             return Result.ok(orderId);
    87.         } 
    88.     }
    89. }

     这里锁上userid时，除了用toString方法转成字符串，还使用intern方法的原因是：

    toString方法的底层原理其实是new一个String对象，然后将其变成字符串，如果只锁上了加toString方法的userid，就有可能出现相同的userid，但是toString底层new出来的String对象不同，而多分了锁。所以使用intern方法来直接判断常量池中的string值是否一致，值一样的共用一把锁，这样就不会导致多分锁了。

    但是但是，还没完因为这里我们是加了锁和事务，但是因为这个事务时Spring进行管理的，它会在我们代码块结束后才会去执行事务，也就是我们释放锁的时候，才会执行事务。这个时候，锁放开了，就会有其他线程进来，就很有可能出现事务提交带上了其他线程。

    我们可以这样进行改进：在本个方法上进行加锁。

    1. package com.hmdp.service.impl;
    2.  
    3. import com.hmdp.dto.Result;
    4. import com.hmdp.entity.SeckillVoucher;
    5. import com.hmdp.entity.VoucherOrder;
    6. import com.hmdp.mapper.VoucherOrderMapper;
    7. import com.hmdp.service.ISeckillVoucherService;
    8. import com.hmdp.service.IVoucherOrderService;
    9. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    10. import com.hmdp.utils.RedisIdWorker;
    11. import com.hmdp.utils.UserHolder;
    12. import org.springframework.stereotype.Service;
    13. import org.springframework.transaction.annotation.Transactional;
    14.  
    15. import javax.annotation.Resource;
    16. import java.time.LocalDateTime;
    17.  
    18. /**
    19.  * 
    20.  *  服务实现类
    21.  * 
    22.  *
    23.  * @author 虎哥
    24.  * @since 2021-12-22
    25.  */
    26. @Service
    27. public class VoucherOrderServiceImpl extends ServiceImpl implements IVoucherOrderService {
    28.  
    29.     @Resource
    30.     private ISeckillVoucherService iSeckillVoucherService;
    31.  
    32.     @Resource
    33.     private RedisIdWorker redisIdWorker;
    34.  
    35.     @Override
    36.     public Result seckillVoucher(Long voucherId) {
    37.         //1.获取优惠券信息
    38.         SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);
    39.  
    40.         //2.判断是否已经开始
    41.         if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
    42.             Result.fail("秒杀尚未开始!");
    43.         }
    44.         //3.判断是否已经结束
    45.         if (voucher.getEndTime().isBefore(LocalDateTime.now())){
    46.             Result.fail("秒杀已经结束了!");
    47.         }
    48.         //4.判断库存是否充足
    49.         if (voucher.getStock() < 1) {
    50.             Result.fail("库存不充足!");
    51.         }
    52.         //5.扣减库存
    53.         boolean success = iSeckillVoucherService.update()
    54.                 .setSql("stock = stock-1").eq("voucher_id",voucherId).gt("stock",0)
    55.                 .update();
    56.         if (!success){
    57.             Result.fail("库存不充足!");
    58.         }
    59.         Long userId = UserHolder.getUser().getId();
    60.         synchronized (userId.toString().intern()){
    61.             return createVoucherOrder(voucherId);
    62.         }
    63.     }
    64.  
    65.     @Transactional
    66.     public Result createVoucherOrder(Long voucherId) {
    67.         Long userId = UserHolder.getUser().getId();
    68.         //6.根据优惠券id和用户id判断订单是否已经存在
    69.         //如果存在，则返回错误信息
    70.         int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
    71.         if (count > 0) {
    72.             return Result.fail("用户已经购买！");
    73.         }
    74.         //7. 创建订单
    75.         VoucherOrder voucherOrder = new VoucherOrder();
    76.         //7.1添加订单id
    77.         Long orderId = redisIdWorker.nextId("order");
    78.         voucherOrder.setId(orderId);
    79.         //7.2添加用户id
    80.         voucherOrder.setUserId(userId);
    81.         //7.3添加优惠券id
    82.         voucherOrder.setVoucherId(voucherId);
    83.         save(voucherOrder);
    84.         //8.返回订单id
    85.         return Result.ok(orderId);
    86.     }
    87. }

    但是但是但是，还没完。哈哈

    我们只给创建订单这个方法（createVoucherOrder）加了事务，但是没给上面判断条件的方法加上事务，而我们锁代码块里执行的方法，其实是this.createVoucherOrder()方法，是没有加事务的方法调用的createVoucherOrder（）方法，这个this可不是spring的事务代理对象，这就会导致事务失效。

    解决方法就是，我们只需要拿到代理对象，然后通过代理对象调用我们这个加了事务的方法，也就是createVoucherOrder（）方法。

    使用 AopContext.currentProxy();方法来拿到代理对象

    温馨提示 ：使用这个方法前要先做两件事~

    1. 记得在配置类似加上@EnableAspectJAutoProxy(exposeProxy = true)注解来暴露这个代理对象

    2. 加上依赖：

    1.         <dependency>
    2.             <groupId>org.aspectjgroupId>
    3.             <artifactId>aspectjweaverartifactId>
    4.         dependency>

    完整代码；： 

    1. package com.hmdp.service.impl;
    2.  
    3. import com.hmdp.dto.Result;
    4. import com.hmdp.entity.SeckillVoucher;
    5. import com.hmdp.entity.VoucherOrder;
    6. import com.hmdp.mapper.VoucherOrderMapper;
    7. import com.hmdp.service.ISeckillVoucherService;
    8. import com.hmdp.service.IVoucherOrderService;
    9. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    10. import com.hmdp.utils.RedisIdWorker;
    11. import com.hmdp.utils.UserHolder;
    12. import org.springframework.aop.framework.AopContext;
    13. import org.springframework.stereotype.Service;
    14. import org.springframework.transaction.annotation.Transactional;
    15.  
    16. import javax.annotation.Resource;
    17. import java.time.LocalDateTime;
    18.  
    19. /**
    20.  * 
    21.  *  服务实现类
    22.  * 
    23.  *
    24.  * @author 虎哥
    25.  * @since 2021-12-22
    26.  */
    27. @Service
    28. public class VoucherOrderServiceImpl extends ServiceImpl implements IVoucherOrderService {
    29.  
    30.     @Resource
    31.     private ISeckillVoucherService iSeckillVoucherService;
    32.  
    33.     @Resource
    34.     private RedisIdWorker redisIdWorker;
    35.  
    36.     @Override
    37.     public Result seckillVoucher(Long voucherId) {
    38.         //1.获取优惠券信息
    39.         SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);
    40.  
    41.         //2.判断是否已经开始
    42.         if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
    43.             Result.fail("秒杀尚未开始!");
    44.         }
    45.         //3.判断是否已经结束
    46.         if (voucher.getEndTime().isBefore(LocalDateTime.now())){
    47.             Result.fail("秒杀已经结束了!");
    48.         }
    49.         //4.判断库存是否充足
    50.         if (voucher.getStock() < 1) {
    51.             Result.fail("库存不充足!");
    52.         }
    53.         //5.扣减库存
    54.         boolean success = iSeckillVoucherService.update()
    55.                 .setSql("stock = stock-1").eq("voucher_id",voucherId).gt("stock",0)
    56.                 .update();
    57.         if (!success){
    58.             Result.fail("库存不充足!");
    59.         }
    60.         Long userId = UserHolder.getUser().getId();
    61.         synchronized (userId.toString().intern()){
    62.             IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
    63.             return proxy.createVoucherOrder(voucherId);
    64.         }
    65.     }
    66.  
    67.     @Transactional
    68.     public Result createVoucherOrder(Long voucherId) {
    69.         Long userId = UserHolder.getUser().getId();
    70.         //6.根据优惠券id和用户id判断订单是否已经存在
    71.         //如果存在，则返回错误信息
    72.         int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
    73.         if (count > 0) {
    74.             return Result.fail("用户已经购买！");
    75.         }
    76.         //7. 创建订单
    77.         VoucherOrder voucherOrder = new VoucherOrder();
    78.         //7.1添加订单id
    79.         Long orderId = redisIdWorker.nextId("order");
    80.         voucherOrder.setId(orderId);
    81.         //7.2添加用户id
    82.         voucherOrder.setUserId(userId);
    83.         //7.3添加优惠券id
    84.         voucherOrder.setVoucherId(voucherId);
    85.         save(voucherOrder);
    86.         //8.返回订单id
    87.         return Result.ok(orderId);
    88.     }
    89. }

  • 相关阅读:
    网络原理——HTTP
    02 请求默认值
    JAVA学习第十一课：java绘图
    基于AM5708开发板——开箱初探＋环境搭建、源码编译
    pandas DataFrame内存优化技巧：让数据处理更高效
    k8s的安装部署，详细过程展示（保姆级安装教程）
    解读TCP协议和UDP协议的区别
    LightMap 设置参数的介绍
    【HarmonyOS】低代码平台组件拖拽使用技巧之页签容器
    CSDN每日一练 |『买苹果』『最长回文串』『查找整数』2023-10-20
  • 原文地址：https://blog.csdn.net/qq_59212867/article/details/128121316