OrderWebController提交订单

  1. /**
  2.  * 下单功能，提交订单。   需要去创建订单、验令牌、验价格、锁库存
  3.  * @param vo                    订单提交的数据
  4.  * @param model
  5.  * @param redirectAttributes
  6.  * @return  下单成功来到支付选择页，下单失败回到订单确认页重新确认订单信息
  7.  */
  8. @PostMapping("/submitOrder")
  9. public String submitOrder(OrderSubmitVo vo, Model model, RedirectAttributes redirectAttributes) {
  11.     try {
  12.         SubmitOrderResponseVo responseVo = orderService.submitOrder(vo);
  13.         if (responseVo.getCode() == 0) {
  14.             model.addAttribute("submitOrderResp", responseVo);  // 返回页面数据
  15.             // 下单成功来到支付选择页
  16.             return "pay";
  17.         } else {
  18.             String msg = "下单失败";
  19.             switch (responseVo.getCode()) {
  20.                 case 1:
  21.                     msg += "订单信息过期，请刷新重新提交";
  22.                     break;
  23.                 case 2:
  24.                     msg += "订单商品价格发生变化，请确认后再次提交";
  25.                     break;
  26.                 case 3:
  27.                     msg += "商品库存不足";
  28.             }
  29.             redirectAttributes.addFlashAttribute("msg", msg);   // 返回页面数据
  30.             // 下单失败回到订单确认页重新确认订单信息
  31.             return "redirect:http://order.gulimall.com/toTrade";
  32.         }
  33.     }catch (Exception e){
  34.         if(e instanceof NoStockException){
  35.             String msg = ((NoStockException) e).getMessage();
  36.             redirectAttributes.addFlashAttribute("msg",msg);
  37.         }
  38.         return "redirect:http://order.gulimall.com/toTrade";
  39.     }
  40. }

OrderServiceImpl

  1. @Service("orderService")
  2. public class OrderServiceImpl extends ServiceImpl<OrderDao, OrderEntity> implements OrderService {
  4.     // 将页面传递过来的数据在同一个线程内进行共享
  5.     private ThreadLocal<OrderSubmitVo> submitVoThreadLocal = new ThreadLocal<>();
  7.     @Autowired
  8.     OrderItemService orderItemService;
  10.     @Autowired
  11.     CartFeginService cartFeginService;
  13.     @Autowired
  14.     MemberFeginService memberFeginService;
  16.     @Autowired
  17.     ProductFeignService productFeignService;
  19.     @Autowired
  20.     WmsFeignService wmsFeignService;
  22.     @Autowired
  23.     StringRedisTemplate redisTemplate;
  25.     @Autowired
  26.     RabbitTemplate rabbitTemplate;
  28.     @Autowired
  29.     ThreadPoolExecutor executor;
  31.     @Autowired
  32.     PaymentInfoService paymentInfoService;
  34.     /**
  35.      * 给订单确认页返回需要用的数据
  36.      * @return
  37.      */
  38.     @Override
  39.     public OrderConfirmVo confirmOrder() throws ExecutionException, InterruptedException {
  41.         // 登录拦截器，获取当前登录用户信息
  42.         MemberRespVo memberRespVo = LoginUserInterceptor.loginUser.get();
  44.         OrderConfirmVo orderConfirmVo = new OrderConfirmVo();
  45.         // 获取主线程中的requestAttributes
  46.         RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
  47.         // 异步处理
  48.         CompletableFuture<Void> getAddressFuture = CompletableFuture.runAsync(() -> {
  50.             // 每个子线程共享之前的请求数据
  51.             RequestContextHolder.setRequestAttributes(requestAttributes);
  52.             // 1、远程查询所有的收获地址列表
  53.             List<MemberAddressVo> address = memberFeginService.getAddress(memberRespVo.getId());
  54.             orderConfirmVo.setAddress(address);
  55.         }, executor);
  56.         // 异步处理
  57.         CompletableFuture<Void> getCartItemsFuture = CompletableFuture.runAsync(() -> {
  59.             // 每个子线程共享之前的请求数据
  60.             RequestContextHolder.setRequestAttributes(requestAttributes);
  61.             // 2、远程查询购物车所有选中的购物项，要注意获取最新的商品价格，而不是先前存到redis中的商品价格
  62.             // 利用fegin的RequestInterceptor拦截器功能，远程调用其他服务时，其他服务也能感知当前登录的用户
  63.             List<OrderItemVo> cartItems = cartFeginService.getCurrentUserCartItems();
  64.             orderConfirmVo.setItems(cartItems);
  65.         }, executor).thenRunAsync(() -> {
  67.             // 获取购物项中的商品skuId
  68.             List<OrderItemVo> items = orderConfirmVo.getItems();
  69.             List<Long> collect = items.stream().map(OrderItemVo::getSkuId).collect(Collectors.toList());
  71.             // 远程调用库存服务，获取商品的库存信息
  72.             R skuHasStock = wmsFeignService.getSkuHasStock(collect);
  73.             List<SkuStockVo> stockVos = skuHasStock.getData(new TypeReference<List<SkuStockVo>>() { });
  74.             if(stockVos != null){
  75.                 Map<Long, Boolean> map = stockVos.stream().collect(Collectors.toMap(SkuStockVo::getSkuId, SkuStockVo::getHasStock));
  76.                 // 设置购物车中商品的库存信息
  77.                 orderConfirmVo.setStocks(map);
  78.             }
  79.         },executor);
  81.         // 3、查询用户积分信息
  82.         Integer integration = memberRespVo.getIntegration();
  83.         orderConfirmVo.setIntegration(integration);
  85.         // 4、其他数据，如订单总价，商品总价自动计算
  87.         // TODO 5、防重令牌
  88.         String token = UUID.randomUUID().toString().replace("-", "");
  89.         // 放重令牌保存至服务器
  90.         redisTemplate.opsForValue().set(OrderConstant.USER_ORDER_TOKEN_PREFIX + memberRespVo.getId(), token, 30 , TimeUnit.MINUTES);
  91.         // 放重令牌发送给页面
  92.         orderConfirmVo.setToken(token);
  94.         CompletableFuture.allOf(getAddressFuture,getCartItemsFuture).get();
  96.         return orderConfirmVo;
  97.     }
  99.     /**
  100.      * 下单操作。创建订单、验令牌、验价格、锁库存
  101.      * @param vo
  102.      * @return
  103.      */
  104.     @Transactional
  105.     @Override
  106.     public SubmitOrderResponseVo submitOrder(OrderSubmitVo vo) {
  108.         submitVoThreadLocal.set(vo);
  109.         SubmitOrderResponseVo responseVo = new SubmitOrderResponseVo();
  110.         MemberRespVo memberRespVo = LoginUserInterceptor.loginUser.get();
  111.         responseVo.setCode(0);
  112.         // 1、验证令牌。令牌的对比和删除必须保证原子性
  113.         String orderToken = vo.getOrderToken();
  114.         // 如果调用get方法与传入的val相同，调用del方法，不相同返回0(0失败，1成功)
  115.         String script = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";
  116.         // 使用Lua脚本，原子验证令牌和删除令牌
  117.         Long result = redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class),
  118.                 Arrays.asList(OrderConstant.USER_ORDER_TOKEN_PREFIX + memberRespVo.getId()), orderToken);
  119.         // String redisToken = redisTemplate.opsForValue().get(OrderConstant.USER_ORDER_TOKEN_PREFIX + memberRespVo.getId());
  120.         if (result == 0) {
  121.             // 令牌验证失败
  122.             responseVo.setCode(1);
  123.             return responseVo;
  124.         } else { 
  125.             // 令牌验证成功
  126.             // 2、创建订单，订单项等信息
  127.             OrderCreateTo order = createOrder();
  129.             // 3、验价：根据订单计算的价格与界面提交的价格进行对比（可能因后台修改商品价格出现不一致的情况）
  130.             BigDecimal payAmount = order.getOrder().getPayAmount();
  131.             // 界面提交的价格
  132.             BigDecimal payPrice = vo.getPayPrice();
  133.             // 金额对比：只要差额在0.01就说明对比成功
  134.             if (Math.abs(payAmount.subtract(payPrice).doubleValue()) < 0.01) {
  136.                 // 4、保存订单数据至数据库
  137.                 saveOrder(order);
  139.                 // 5、锁定库存、只要有异常就回滚订单数据
  140.                 // 需要订单号，所有订单项（skuId、skuName、数量）
  141.                 WareSkuLockVo lockVo = new WareSkuLockVo();
  142.                 lockVo.setOrderSn(order.getOrder().getOrderSn());
  144.                 // List<OrderItemEntity>转化为List<OrderItemVo>
  145.                 List<OrderItemVo> locks = order.getItems().stream().map(item -> {
  146.                     OrderItemVo itemVo = new OrderItemVo();
  147.                     itemVo.setSkuId(item.getSkuId());
  148.                     itemVo.setCount(item.getSkuQuantity());
  149.                     itemVo.setTitle(item.getSkuName());
  150.                     return itemVo;
  151.                 }).collect(Collectors.toList());
  152.                 lockVo.setLocks(locks);
  154.                 // 5.1 远程锁库存
  155.                 R r = wmsFeignService.orderLockStock(lockVo);
  156.                 if (r.getCode() == 0) {
  158.                     // 锁定库存成功(rebbitMQ消息通知)
  159.                     responseVo.setOrder(order.getOrder());
  161.                     // 6、远程扣减积分
  162.                     // int i = 10 / 0; // 模拟异常，此时订单回滚，库存不回滚，需要借助RabbitMQ使库存回滚
  164.                     // 7、订单创建成功，将每个订单信息发送给MQ
  165.                     // 通过路由键order.create.order发送给延迟队列order.create.order。
  166.                     // 30分钟后延迟队列将消息通过交换机order-event-exchange、路由键order.release.order
  167.                     // 发送给order.release.order.queue、order.release.coupon.queue等队列
  168.                     // 此时需要查询订单的最新状态，判断当前订单是正常关单还是异常关单，若是异常关单，需要回滚相关数据
  169.                     rabbitTemplate.convertAndSend("order-event-exchange", "order.create.order", order.getOrder());
  171.                     return responseVo;
  172.                 } else {
  173.                     // 锁定库存失败
  174.                     String msg = (String) r.get("msg");
  175.                     throw new NoStockException(1L);
  176.                     // responseVo.setCode(3);
  177.                     // return responseVo;
  178.                 }
  179.             } else {
  180.                 // 金额对比失败
  181.                 responseVo.setCode(2);
  182.                 return responseVo;
  183.             }
  184.         }
  185.     }
  187.     // 保存订单数据
  188.     private void saveOrder(OrderCreateTo order) {
  190.         // 保存订单数据：oms_order
  191.         OrderEntity orderEntity = order.getOrder();
  192.         orderEntity.setModifyTime(new Date());
  193.         this.save(orderEntity);
  195.         // 批量保存订单项数据：oms_order_item
  196.         List<OrderItemEntity> orderItems = order.getItems();
  197.         orderItemService.saveBatch(orderItems);
  198.     }
  200.     // 创建订单
  201.     private OrderCreateTo createOrder() {
  203.         OrderCreateTo orderCreateTo = new OrderCreateTo();
  205.         // 1、构建订单
  206.         String orderSn = IdWorker.getTimeId();
  207.         OrderEntity orderEntity = buildOrder(orderSn);
  208.         // 2、获取所有的订单项
  209.         List<OrderItemEntity> itemEntities = buildOrderItems(orderSn);
  210.         // 3、验价
  211.         computePrice(orderEntity, itemEntities);
  212.         orderCreateTo.setItems(itemEntities);
  213.         orderCreateTo.setOrder(orderEntity);
  214.         return orderCreateTo;
  215.     }
  217.     /**
  218.      * 验价：根据所有订单项的价格计算出订单的价格
  219.      * @param orderEntity   订单内的价格
  220.      * @param itemEntities  所有订单项价格
  221.      */
  222.     private void computePrice(OrderEntity orderEntity, List<OrderItemEntity> itemEntities) {
  224.         // 订单总额，计算各种优惠的总额，计算积分和成长值总额
  225.         BigDecimal total = new BigDecimal("0.0");
  226.         BigDecimal couponAmount = new BigDecimal("0.0");
  227.         BigDecimal promotionAmount = new BigDecimal("0.0");
  228.         BigDecimal integrationAmount = new BigDecimal("0.0");
  229.         Integer integration = 0;
  230.         Integer growth = 0;
  231.         // 遍历所有订单项的价格。计算出订单的相关金额
  232.         for (OrderItemEntity entity : itemEntities) {
  233.             couponAmount = couponAmount.add(entity.getCouponAmount());
  234.             promotionAmount = promotionAmount.add(entity.getPromotionAmount());
  235.             integrationAmount = integrationAmount.add(entity.getIntegrationAmount());
  236.             growth += entity.getGiftGrowth();
  237.             integration += entity.getGiftIntegration();
  238.             total = total.add(entity.getRealAmount());
  239.         }
  240.         // 订单的总额
  241.         orderEntity.setTotalAmount(total);
  242.         // 应付总额 = 订单的总额 + 运费
  243.         orderEntity.setPayAmount(total.add(orderEntity.getFreightAmount()));
  244.         // 各种优惠的总额
  245.         orderEntity.setPromotionAmount(promotionAmount);
  246.         orderEntity.setCouponAmount(couponAmount);
  247.         orderEntity.setIntegrationAmount(integrationAmount);
  248.         // 积分和成长值总额
  249.         orderEntity.setGrowth(growth);
  250.         orderEntity.setIntegration(integration);
  251.     }
  253.     // 构建订单
  254.     private OrderEntity buildOrder(String orderSn) {
  256.         MemberRespVo memberRespVo = LoginUserInterceptor.loginUser.get();
  257.         OrderEntity orderEntity = new OrderEntity();
  258.         orderEntity.setOrderSn(orderSn);
  259.         orderEntity.setMemberId(memberRespVo.getId());  // 设置会员id
  261.         // 获取收货地址信息
  262.         // 想要获取ThreadLocal内的数据，必须先往里面set数据
  263.         OrderSubmitVo orderSubmitVo = submitVoThreadLocal.get();    // 页面传递过来的数据
  264.         R fare = wmsFeignService.getFare(orderSubmitVo.getAddrId());
  265.         FareVo fareData = fare.getData(new TypeReference<FareVo>(){});
  266.         // 设置运费信息
  267.         orderEntity.setFreightAmount(fareData.getFare());
  268.         // 设置收货地址信息、收货地址详情信息、收货人名字、收货人手机号、收货人邮编、省市区信息
  269.         orderEntity.setReceiverCity(fareData.getAddress().getCity());
  270.         orderEntity.setReceiverDetailAddress(fareData.getAddress().getDetailAddress());
  271.         orderEntity.setReceiverName(fareData.getAddress().getName());
  272.         orderEntity.setBillReceiverPhone(fareData.getAddress().getPhone());
  273.         orderEntity.setReceiverPostCode(fareData.getAddress().getPostCode());
  274.         orderEntity.setReceiverProvince(fareData.getAddress().getProvince());
  275.         orderEntity.setReceiverRegion(fareData.getAddress().getRegion());
  277.         // 设置订单状态
  278.         orderEntity.setStatus(OrderStatusEnum.CREATE_NEW.getCode());
  279.         orderEntity.setAutoConfirmDay(7);
  280.         orderEntity.setDeleteStatus(0); // 删除状态,0未删除
  282.         return orderEntity;
  283.     }
  285.     // 构建所有订单项信息
  286.     private List<OrderItemEntity> buildOrderItems(String orderSn) {
  288.         // 最后确定每个购物项的价格
  289.         List<OrderItemVo> cartItems = cartFeginService.getCurrentUserCartItems();
  290.         if(cartItems != null && cartItems.size() > 0){
  291.             List<OrderItemEntity> orderItemEntities = cartItems.stream().map(cartItem -> {
  292.                 // 通过购物车的商品信息返回订单项的详细信息
  293.                 OrderItemEntity orderItemEntity = buildOrderItem(cartItem);
  294.                 orderItemEntity.setOrderSn(orderSn);
  295.                 return orderItemEntity;
  296.             }).collect(Collectors.toList());
  297.             return orderItemEntities;
  298.         }
  299.         return null;
  300.     }
  302.     // 构建指定的某一个订单项
  303.     private OrderItemEntity buildOrderItem(OrderItemVo cartItem) {
  305.         OrderItemEntity itemEntity = new OrderItemEntity();
  306.         // 1、订单信息：订单号
  307.         // 2、商品的spu信息
  308.         Long skuId = cartItem.getSkuId();
  309.         // 远程调用商品服务、根据skuId查询spu信息
  310.         R r = productFeignService.getSpuInfoBySkuId(skuId);
  311.         SpuInfoVo data = r.getData(new TypeReference<SpuInfoVo>() { });
  312.         itemEntity.setSpuId(data.getId());
  313.         itemEntity.setSpuBrand(data.getBrandId().toString());
  314.         itemEntity.setSpuName(data.getSpuName());
  315.         itemEntity.setCategoryId(data.getCatalogId());
  317.         // 3、商品的sku信息
  318.         itemEntity.setSkuId(skuId);
  319.         itemEntity.setSkuName(cartItem.getTitle());
  320.         itemEntity.setSkuPic(cartItem.getImage());
  321.         itemEntity.setSkuPrice(cartItem.getPrice());
  322.         // 将集合按照指定的分隔符转换为字符串数组
  323.         String skuAttr = StringUtils.collectionToDelimitedString(cartItem.getSkuAttr(), ";");
  324.         itemEntity.setSkuAttrsVals(skuAttr);
  325.         itemEntity.setSkuQuantity(cartItem.getCount());
  327.         // 4、优惠信息（不做）
  328.         itemEntity.setPromotionAmount(new BigDecimal("0"));
  329.         itemEntity.setCouponAmount(new BigDecimal("0"));
  330.         itemEntity.setIntegrationAmount(new BigDecimal("0"));
  332.         // 5、积分信息。成长积分和赠送积分
  333.         itemEntity.setGiftGrowth(cartItem.getPrice().intValue() * cartItem.getCount());
  334.         itemEntity.setGiftIntegration(cartItem.getPrice().intValue() * cartItem.getCount());
  336.         // 6.订单项价格信息。总额 - 优惠金额
  337.         // 当前订单项的实际金额
  338.         BigDecimal orgin = itemEntity.getSkuPrice().multiply(new BigDecimal(itemEntity.getSkuQuantity().toString()));
  339.         // 当前订单项优惠后的金额
  340.         BigDecimal subtract = orgin.subtract(itemEntity.getPromotionAmount()).subtract(itemEntity.getCouponAmount()).subtract(itemEntity.getIntegrationAmount());
  341.         itemEntity.setRealAmount(subtract);
  342.         return itemEntity;
  343.     }
  347.     /**
  348.      * 关闭订单（30分钟未支付）
  349.      * @param entity
  350.      */
  351.     @Override
  352.     public void closeOrder(OrderEntity entity) {
  354.         // 查询订单的最新状态（30分钟内容订单状态可能有变化，所以要取最新状态）
  355.         OrderEntity orderEntity = this.getById(entity.getId());
  356.         if (orderEntity.getStatus() == OrderStatusEnum.CREATE_NEW.getCode()) { // 订单状态为待付款
  357.             // 关闭订单，将订单状态修改为已取消
  358.             OrderEntity update = new OrderEntity();
  359.             update.setId(entity.getId());
  360.             update.setStatus(OrderStatusEnum.CANCLED.getCode());
  361.             this.updateById(update);
  363.             OrderTo orderTo = new OrderTo();
  364.             BeanUtils.copyProperties(orderEntity, orderTo);
  365.             try {
  366.                 // 每一条消息进行日志记录(数据库保存每一条消息的详细信息)
  367.                 // 定期扫描数据库将失败的消息（待付款的订单数据）再发送到MQ
  368.                 rabbitTemplate.convertAndSend("order-event-exchange", "order.release.other", orderTo);
  369.             } catch (Exception e) {
  370.                 // 将没法送成功的消息进行重试发送
  371.             }
  372.         }
  373.     }
  375.     /**
  376.      * 根据订单号获取订单实体类
  377.      * @param orderSn
  378.      * @return
  379.      */
  380.     @Override
  381.     public OrderEntity getOrderByOrderSn(String orderSn) {
  382.         OrderEntity entity = this.getOne(new QueryWrapper<OrderEntity>().eq("order_sn", orderSn));
  383.         return entity;
  384.     }
  385. }

WareSkuController锁定库存

  1. /**
  2.  * 为当前订单锁定库存
  3.  */
  4. @PostMapping("/lock/order")
  5. public R orderLockStock(@RequestBody WareSkuLockVo vo) {
  7.     try{
  8.         Boolean stock = wareSkuService.orderLockStock(vo);
  9.         return R.ok();
  10.     }catch (NoStockException e){
  11.         return R.error(BizCodeEnume.NO_STOCK_EXCEPTION.getCode(),BizCodeEnume.NO_STOCK_EXCEPTION.getMsg());
  12.     }
  13. }

WareSkuServiceImpl锁定库存

  1. @RabbitListener(queues = "stock.release.stock.queue")
  2. @Service("wareSkuService")
  3. public class WareSkuServiceImpl extends ServiceImpl<WareSkuDao, WareSkuEntity> implements WareSkuService {
  5.     @Autowired
  6.     private WareSkuDao wareSkuDao;
  8.     @Autowired
  9.     private ProductFeignService productFeignService;
  11.     @Autowired
  12.     WareOrderTaskService orderService;
  14.     @Autowired
  15.     WareOrderTaskDetailService orderDetailService;
  17.     @Autowired
  18.     WareOrderTaskService wareOrderTaskService;
  20.     @Autowired
  21.     OrderFeignService orderFeignService;
  23.     @Autowired
  24.     RabbitTemplate rabbitTemplate;
  26.     /** 为某个订单锁定库存
  27.      * @Transactional(rollbackFor = NoStockException.class)：执行要回滚NoStockException异常。
  28.      * 可以不用加。因为默认只要是运行时异常都会回滚
  29.      *
  30.      * 库存解锁的场景：
  31.      *      1、下订单成功，订单过期没有支付被系统自动取消、被用户手动取消。都要解锁库存
  32.      *      2、下订单成功，库存锁定成功，接下来的业务调用失败，导致订单回滚
  33.      *          之前锁定的库存就要自动解锁
  34.      */
  35.     @Transactional(rollbackFor = NoStockException.class)
  36.     @Override
  37.     public Boolean orderLockStock(WareSkuLockVo vo) {
  39.         // 保存库存工作单详情，方便追溯。
  40.         WareOrderTaskEntity taskEntity = new WareOrderTaskEntity();
  41.         taskEntity.setOrderSn(vo.getOrderSn());     //为哪个订单号锁的库存
  42.         orderService.save(taskEntity);
  44.         // 1、获取每个商品在每个仓库的库存详情：SkuWareHasStock
  45.         List<OrderItemVo> locks = vo.getLocks();
  46.         List<SkuWareHasStock> collect = locks.stream().map(item -> {
  48.             SkuWareHasStock stock = new SkuWareHasStock();
  49.             Long skuId = item.getSkuId();
  50.             stock.setSkuId(skuId);
  51.             stock.setNum(item.getCount());
  52.             // 查询当前商品在哪些仓库有库存
  53.             List<Long> wareIds = wareSkuDao.listWareIdHasSkuStock(skuId);
  54.             stock.setWareId(wareIds);
  55.             return stock;
  56.         }).collect(Collectors.toList());
  58.         // 2、锁定库存
  59.         for (SkuWareHasStock hasStock : collect) {
  61.             Boolean skuStocked = false;
  62.             Long skuId = hasStock.getSkuId();
  63.             List<Long> wareIds = hasStock.getWareId();
  64.             Integer num = hasStock.getNum();
  65.             // 2.1 若仓库为空。即没有任何仓库有这个商品的库存，直接抛异常
  66.             if (wareIds == null || wareIds.size() == 0) {
  67.                 throw new NoStockException(skuId);
  68.             }
  69.             // 2.2 遍历仓库，扣库存（每个仓库依次扣库存）
  70.             // 如果每个商品都锁定成功，将当前商品锁定了几件的工作单记录发给MQ
  71.             // 锁定失败，前面保存的工作单信息就回滚了。发送出去的消息，即使要解锁记录，由于去数据库查不到id，所以就不用解锁
  72.             for (Long wareId : wareIds) {
  74.                 // 2.3 锁定库存。stock_locked加num
  75.                 // 返回1表示成功(库存表1行受影响)，返回0表示失败(0行受影响)
  76.                 Long count = wareSkuDao.lockSkuStock(skuId, wareId, num);
  77.                 if (count == 1) {
  78.                     // 库存锁定成功
  79.                     skuStocked = true;
  81.                     // 将数据保存到数据库wms_ware_order_task_detail表
  82.                     WareOrderTaskDetailEntity detailEntity = new WareOrderTaskDetailEntity(null, skuId, "", hasStock.getNum(), taskEntity.getId(), wareId, 1);
  83.                     orderDetailService.save(detailEntity);
  85.                     StockLockedTo stockLockedTo = new StockLockedTo();
  86.                     stockLockedTo.setId(taskEntity.getId());
  88.                     StockDetailTo detailTo = new StockDetailTo();
  89.                     BeanUtils.copyProperties(detailEntity, detailTo);
  90.                     // 防止回滚之后找不到数据，所以保存完整库存单
  91.                     stockLockedTo.setDetail(detailTo);
  93.                     rabbitTemplate.convertAndSend("stock-event-exchange", "stock.locked", stockLockedTo);
  94.                     break;
  95.                 } else {
  96.                     // 当前仓库库存不足，尝试锁下一个仓库
  97.                 }
  98.             }
  99.             // 当前商品所有仓库都无货(没锁住库存)
  100.             if (skuStocked == false) {
  101.                 throw new NoStockException(skuId);
  102.             }
  103.         }
  104.         // 所有商品的库存都是锁定成功才会返回true
  105.         return true;
  106.     }
  108.     //内部类。商品在每个仓库拥有的库存数据
  109.     @Data
  110.     class SkuWareHasStock {
  112.         private Long skuId;     // 当前商品的ID
  113.         private Integer num;    //
  114.         private List<Long> wareId;  // 有库存的仓库ID
  115.     }
  117.     /**
  118.      * 1、库存自动解锁
  119.      *      下订单成功，库存锁定成功，接下来的业务调用失败，导致订单回滚，之前锁定的库存就要自动解锁
  120.      *      订单失败：锁库存失败
  121.      *
  122.      * 只要解锁库存的消息失败，一定要告诉服务解锁失败，需要手动ACK，回复消息
  123.      *
  124.      * 解锁库存
  125.      * 查询数据库关于这个订单的锁定库存信息wms_ware_order_task、wms_ware_order_task_detail
  126.      * 若有数据，即表示库存锁定成功。此时根据订单情况判断是否需要解锁库存
  127.      *      1、订单不存在，表示订单数据自身已回滚，此时必须解锁库存
  128.      *      2、订单存在，根据订单状态确认是否需要解锁库存
  129.      *          1）订单状态为已取消，此时需要解锁库存
  130.      *          2）订单状态未取消，此时不能解锁库存
  131.      * 若没有数据，表示库存锁定失败，库存已回滚，这种情况就无需解锁库存
  132.      */
  133.     @Override
  134.     public void unlockStock(StockLockedTo stockLockedTo){
  136.         System.out.println("收到解锁库存的消息......");
  137.         StockDetailTo detail = stockLockedTo.getDetail();
  138.         Long detailId = detail.getId();
  139.         // 解锁库存
  140.         // 1.查询关于这个订单的锁定库存信息
  141.         WareOrderTaskDetailEntity orderTaskDetailEntity = orderDetailService.getById(detailId);
  142.         if (orderTaskDetailEntity != null) {
  143.             // 有锁定库存信息，即库存锁定成功，根据订单情况解锁
  144.             Long id = stockLockedTo.getId();    //库存工作单wms_ware_order_task表的Id
  145.             WareOrderTaskEntity taskEntity = wareOrderTaskService.getById(id);
  146.             String orderSn = taskEntity.getOrderSn();
  147.             // 远程调用订单服务，根据订单号获取订单实体
  148.             R r = orderFeignService.getOrderStatus(orderSn);
  149.             if (r.getCode() == 0) {
  150.                 OrderVo data = r.getData(new TypeReference<OrderVo>() { });
  151.                 if (data == null || data.getStatus() == 4) {
  152.                     // 订单不存在（订单数据已经回滚） 或者 有订单但订单状态是已取消，才可以解锁库存
  153.                     // 只有状态是1（已锁定），才能解锁
  154.                     if (orderTaskDetailEntity.getLockStatus() == 1) {
  155.                         unLockStock(detail.getSkuId(), detail.getWareId(), detail.getSkuNum(), detailId);
  156.                         // 手动确认RabbitMQ中order.release.order.queue队列的的消息（即消费这条消息）
  157.                         // channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  158.                     }
  159.                 }
  160.             } else {
  161.                 // 其它状态(包含订单成功)不解锁
  162.                 // 拒绝消息以后重放到队列里面，让其他服务继续消费解锁（防止因自身原因误删RabbitMQ中的消息）
  163.                 // channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
  164.                 throw new RuntimeException("远程服务失败....."); // 需要重新解锁。监听器中已实现
  165.             }
  166.         } else {
  167.             // 若不存在锁定库存信息，即库存锁定失败，库存回滚，这种情况无需解锁
  168.             // 手动确认RabbitMQ中order.release.order.queue队列的的消息（即消费这条消息）
  169.             // channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  170.         }
  171.     }
  173.     /**
  174.      * 防止因为订单服务故障，导致订单状态未改变，从而无法解锁库存
  175.      */
  176.     @Transactional
  177.     @Override
  178.     public void unlockStock(OrderTo orderTo) {
  180.         String orderSn = orderTo.getOrderSn();
  181.         //查询最新库存状态
  182.         WareOrderTaskEntity task = wareOrderTaskService.getOrderTaskByOrderSn(orderSn);
  183.         Long id = task.getId();
  184.         List<WareOrderTaskDetailEntity> list = orderDetailService.list(new QueryWrapper<WareOrderTaskDetailEntity>()
  185.                                                                         .eq("task_id", id)
  186.                                                                         .eq("lock_status", 1));
  187.         for (WareOrderTaskDetailEntity entity : list) {
  188.             unLockStock(entity.getSkuId(), entity.getWareId(), entity.getSkuNum(), entity.getId());
  189.         }
  190.     }
  192.     public void unLockStock(Long skuId, Long wareId, Integer num, Long taskDetailId) {
  194.         // 库存解锁，将锁定库存数stock_locked减去num。即恢复原库存
  195.         wareSkuDao.unlockStock(skuId, wareId, num);
  196.         // 更新库存工作单状态
  197.         WareOrderTaskDetailEntity entity = new WareOrderTaskDetailEntity();
  198.         entity.setId(taskDetailId);
  199.         entity.setLockStatus(2);    // 2-已解锁
  200.         orderDetailService.updateById(entity);
  201.     }
  203. }

一、释放订单

1、流程

图片.png

2、订单服务的MQ配置类MyMQConfig

  1. @Configuration
  2. public class MyMQConfig {
  5. //    @RabbitListener(queues = "order.release.order.queue")
  6. //    public void listener(OrderEntity orderEntity, Channel channel, Message message) throws IOException {
  7. //
  8. //        System.out.println("收到过期的订单信息，准备关闭订单：" + orderEntity);
  9. //        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  10. //    }
  12.     @Bean
  13.     public MessageConverter messageConverter() {
  14.         return new Jackson2JsonMessageConverter();
  15.     }
  17.     /**
  18.      * 注解@Bean注解：可以在容器中自动创建Binding、Queue、Exchange（RabbitMQ没有的情况）
  19.      * RabbitMQ只要存在，@Bean声明的属性发生变化，重启服务后也不会覆盖先前的数据，只有删除队列才行
  20.      * 所有的消息默认会先抵达延迟队列order.delay.queue，延迟一段时间后，才会抵达order.release.order.queue队列。然后才被消费掉
  21.      * @return
  22.      */
  23.     // 创建延迟队列（过了存活时间就会变成死信，然后将信息抛给orderReleaseOrderQueue队列，RabbitMQ监听orderReleaseOrderQueue队列，处理数据）
  24.     @Bean
  25.     public Queue orderDelayQueue() {
  27.         Map<String, Object> arguments = new HashMap<>();
  28.         // 指定死信路由
  29.         arguments.put("x-dead-letter-exchange", "order-event-exchange");
  30.         // 指定死信路由键
  31.         arguments.put("x-dead-letter-routing-key", "order.release.order");
  32.         // 消息过期时间（毫秒）
  33.         arguments.put("x-message-ttl", 60000);
  34.         Queue orderDelayQueue = new Queue("order.delay.queue", true, false, false, arguments);
  35.         return orderDelayQueue;
  36.     }
  38.     // 创建普通队列
  39.     @Bean
  40.     public Queue orderReleaseOrderQueue() {
  41.         return new Queue("order.release.order.queue", true, false, false);
  42.     }
  44.     // 创建topic类型交换机
  45.     @Bean
  46.     public Exchange orderEventExchange() {
  47.         return new TopicExchange("order-event-exchange", true, false);
  48.     }
  50.     // 创建交换机与队列order.delay.queue的绑定关系。Binding(目的地，目的地类型，交换机，路由键，参数)
  51.     @Bean
  52.     public Binding orderCreateBingding() {
  53.         return new Binding("order.delay.queue", Binding.DestinationType.QUEUE, "order-event-exchange", "order.create.order", null);
  54.     }
  56.     // 创建交换机与队列order.release.order.queue的绑定关系
  57.     @Bean
  58.     public Binding orderReleaseBingding() {
  59.         return new Binding("order.release.order.queue", Binding.DestinationType.QUEUE, "order-event-exchange", "order.release.order", null);
  60.     }
  62.     @Bean
  63.     public Binding orderReleaseOtherBingding() {
  64.         return new Binding("stock.release.stock.queue", Binding.DestinationType.QUEUE, "order-event-exchange", "order.release.other.#", null);
  65.     }
  66. }

3、订单服务的监听器OrderCloseListener

  1. // 监听order.release.order.queue队列中的消息（30分钟后（订单30分钟未支付场景）才会到达这个队列）
  2. @Component
  3. @RabbitListener(queues = "order.release.order.queue")
  4. public class OrderCloseListener {
  6.     @Autowired
  7.     OrderService orderService;
  9.     @RabbitHandler
  10.     public void listener(OrderEntity entity, Channel channel, Message msg) throws IOException {
  12.         try {
  13.             System.out.println("收到过期的订单信息，准备关闭订单：" + entity.getOrderSn());
  14.             orderService.closeOrder(entity);
  15.             channel.basicAck(msg.getMessageProperties().getDeliveryTag(), false);
  17.         } catch (Exception e) {
  18.             System.out.println("订单关闭异常，库存解锁异常：" + e.getMessage());
  19.             // 拒绝消息，让其重新回到消息队列
  20.             channel.basicReject(msg.getMessageProperties().getDeliveryTag(), true);
  21.         }
  22.     }
  23. }

4、订单创建成功后发送消息

通过路由键order.create.order发送给延迟队列order.create.order。30分钟后延迟队列将消息通过交换机order-event-exchange、路由键order.release.order发送给order.release.order.queue、order.release.coupon.queue等队列图片.png

5、关闭订单时消费消息

查询订单的最新状态，判断当前订单是正常关单还是异常关单，若是异常关单，需要回滚相关数据图片.png

二、库存自动解锁

1、流程

图片.png

2、库存服务的MQ配置类MyRabbitConfig

  1. @Configuration
  2. public class MyRabbitConfig {
  4.     // 使用JSON序列化机制,进行消息转换
  5.     @Bean
  6.     public MessageConverter messageConverter() {
  7.         return new Jackson2JsonMessageConverter();
  8.     }
  10.     // 创建topic类型交换机。路由键采用模糊匹配。TopicExchange(交换机名称，是否持久化，是否自动删除)
  11.     @Bean
  12.     public Exchange stockEventExchange() {
  13.         return new TopicExchange("stock-event-exchange", true, false);
  14.     }
  16.     // 创建普通队列。Queue(队列名称，是否持久化，是否排他(只允许单个连接它，若支持多个连接，则谁抢到消息算谁的)，是否自动删除)
  17.     @Bean
  18.     public Queue stockReleaseStockQueue() {
  19.         return new Queue("stock.release.stock.queue", true, false, false);
  20.     }
  22.     // 创建延迟队列。库存锁定成功后，消息先发给延迟队列，等待消息过期后，再发给普通队列
  23.     @Bean
  24.     public Queue stockDelayQueue() {
  25.         Map<String, Object> arguments = new HashMap<>();
  26.         // 设置死信路由，表示消息过期后交给哪个交换机
  27.         arguments.put("x-dead-letter-exchange", "stock-event-exchange");
  28.         // 设置死信路由键，表示消息过期后交给哪个路由键
  29.         arguments.put("x-dead-letter-routing-key", "stock.release");
  30.         // 设置消息过期时间
  31.         arguments.put("x-message-ttl", 60000);
  32.         return new Queue("stock.delay.queue", true, false, false, arguments);
  33.     }
  35.     // 创建交换机与普通队列的绑定关系
  36.     @Bean
  37.     public Binding stockReleaseBinding() {
  38.         return new Binding("stock.release.stock.queue", Binding.DestinationType.QUEUE, "stock-event-exchange", "stock.release.#", null);
  39.     }
  41.     // 创建交换机与延迟队列的绑定关系
  42.     @Bean
  43.     public Binding stockLockedBinding() {
  44.         return new Binding("stock.delay.queue", Binding.DestinationType.QUEUE, "stock-event-exchange", "stock.locked", null);
  45.     }
  47.     // 第一次监听消息时，idea会连接RabbitMQ，此时才会创建RabbitMQ中没有的队列、交换机和绑定关系
  48.     // 如果没有监听消息操作，RabbitMQ中就不会创建队列、交换机和绑定关系
  49.     // 如果需要修改rabbitMQ中已存在的队列交换机,需要先删除，然后再次创建
  50. //    @RabbitListener(queues = "stock.release.stock.queue")  // 需要注释掉，否则此时有两个在监听stock.release.stock.queue队列，导致消息消费异常
  51. //    public void listener(WareInfoEntity entity, Channel channel, Message msg) throws IOException, IOException {
  52. //        System.out.println("收到过期的订单信息:准备关闭订单" + entity.getId());
  53. //        channel.basicAck(msg.getMessageProperties().getDeliveryTag(), false);
  54. //    }
  55. }

3、库存服务的监听器StockReleaseListener

  1. @Service
  2. @RabbitListener(queues = "stock.release.stock.queue")
  3. public class StockReleaseListener {
  5.     @Autowired
  6.     WareSkuService wareSkuService;
  8.     /**
  9.      * 监听解锁库存功能
  10.      */
  11.     @RabbitHandler
  12.     public void handleStockLockedRelease(StockLockedTo stockLockedTo, Message message, Channel channel) throws IOException {
  14.         System.out.println("收到接收解锁库存的信息......");
  15.         try {
  16.             wareSkuService.unlockStock(stockLockedTo);
  17.             // 手动确认RabbitMQ中order.release.order.queue队列的的消息（即消费这条消息）
  18.             channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
  20.         }catch (Exception e){
  21.             System.out.println("rabbitMQ错误："+e.getMessage());
  22.             // 只要有任何异常，回退消息。拒绝消息以后重放到队列里面，让其他服务继续消费解锁（防止因自身原因误删RabbitMQ中的消息）
  23.             channel.basicReject(message.getMessageProperties().getDeliveryTag(),true);
  24.         }
  25.     }
  26. }

4、锁定库存后发送消息图片.png

5、解锁库存时消费消息

  1. /**
  2.  * 1、库存自动解锁
  3.  *      下订单成功，库存锁定成功，接下来的业务调用失败，导致订单回滚，之前锁定的库存就要自动解锁
  4.  *      订单失败：锁库存失败
  5.  *
  6.  * 只要解锁库存的消息失败，一定要告诉服务解锁失败，需要手动ACK，回复消息
  7.  *
  8.  * 解锁库存
  9.  * 查询数据库关于这个订单的锁定库存信息wms_ware_order_task、wms_ware_order_task_detail
  10.  * 若有数据，即表示库存锁定成功。此时根据订单情况判断是否需要解锁库存
  11.  *      1、订单不存在，表示订单数据自身已回滚，此时必须解锁库存
  12.  *      2、订单存在，根据订单状态确认是否需要解锁库存
  13.  *          1）订单状态为已取消，此时需要解锁库存
  14.  *          2）订单状态未取消，此时不能解锁库存
  15.  * 若没有数据，表示库存锁定失败，库存已回滚，这种情况就无需解锁库存
  16.  */
  17. @Override
  18. public void unlockStock(StockLockedTo stockLockedTo){
  20.     System.out.println("收到解锁库存的消息......");
  21.     StockDetailTo detail = stockLockedTo.getDetail();
  22.     Long detailId = detail.getId();
  23.     // 解锁库存
  24.     // 1.查询关于这个订单的锁定库存信息
  25.     WareOrderTaskDetailEntity orderTaskDetailEntity = orderDetailService.getById(detailId);
  26.     if (orderTaskDetailEntity != null) {
  27.         // 有锁定库存信息，即库存锁定成功，根据订单情况解锁
  28.         Long id = stockLockedTo.getId();    //库存工作单wms_ware_order_task表的Id
  29.         WareOrderTaskEntity taskEntity = wareOrderTaskService.getById(id);
  30.         String orderSn = taskEntity.getOrderSn();
  31.         // 远程调用订单服务，根据订单号获取订单实体
  32.         R r = orderFeignService.getOrderStatus(orderSn);
  33.         if (r.getCode() == 0) {
  34.             OrderVo data = r.getData(new TypeReference<OrderVo>() { });
  35.             if (data == null || data.getStatus() == 4) {
  36.                 // 订单不存在（订单数据已经回滚） 或者 有订单但订单状态是已取消，才可以解锁库存
  37.                 // 只有状态是1（已锁定），才能解锁
  38.                 if (orderTaskDetailEntity.getLockStatus() == 1) {
  39.                     unLockStock(detail.getSkuId(), detail.getWareId(), detail.getSkuNum(), detailId);
  40.                     // 手动确认RabbitMQ中order.release.order.queue队列的的消息（即消费这条消息）
  41.                     // channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  42.                 }
  43.             }
  44.         } else {
  45.             // 其它状态(包含订单成功)不解锁
  46.             // 拒绝消息以后重放到队列里面，让其他服务继续消费解锁（防止因自身原因误删RabbitMQ中的消息）
  47.             // channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
  48.             throw new RuntimeException("远程服务失败....."); // 需要重新解锁。监听器中已实现
  49.         }
  50.     } else {
  51.         // 若不存在锁定库存信息，即库存锁定失败，库存回滚，这种情况无需解锁
  52.         // 手动确认RabbitMQ中order.release.order.queue队列的的消息（即消费这条消息）
  53.         // channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  54.     }
  55. }

三、订单关闭后主动解锁库存

1、流程

图片.png

2、订单服务的MQ配置类MyMQConfig

创建订单交换机与库存释放队列stock.release.stock.queue的绑定关系图片.png

3、库存服务的MQ监听器StockReleaseListener

监听库存服务的stock.release.stock.queue队列图片.png

4、关闭订单后发送消息

OrderServiceImpl订单关闭后（30分钟未支付），将消息通过订单交换机order-event-exchange、路由键order.release.other发送给库存队列stock.release.stock.queue监听库存队列，收到消息后判断该订单的状态，若为已取消，则主动释放库存图片.png

5、解锁库存时消费消息

监听库存队列stock.release.stock.queue，收到消息后解锁库存，WareSkuServiceImpl判断该订单的状态，若为已取消，则主动释放库存图片.png

下单流程

1、验证令牌。令牌的对比和删除必须保证原子性
2、创建订单，订单项等信息
3、验价：根据订单计算的价格与界面提交的价格进行对比（可能因后台修改商品价格出现不一致的情况）
4、保存订单数据（OrderEntity和OrderItemEntity）至数据库
5、远程锁定库存、只要有异常就回滚订单数据
6、远程扣减积分
7、订单创建成功，将每个订单信息发送给MQ
下单操作总结 - 图12

订单信息（OrderEntity）发送给MQ

1、通过路由键order.create.order发送给延迟队列order.create.order。
2、30分钟后延迟队列将消息通过交换机order-event-exchange、路由键order.release.order发送给order.release.order.queue、order.release.coupon.queue等队列
3、OrderCloseListener监听order.release.order.queue队列数据，调用关闭订单方法orderService.closeOrder(entity)
4、closeOrder首先查询订单的最新状态，若订单状态仍为待付款，主动关闭订单（即回滚数据），即将订单状态更新为已取消；同时将这条订单消息再次发送给MQ，30分钟后再次判断订单状态（正常情况此时应该为已取消，目的是防止关单程序异常导致关单失败）

解锁库存

库存锁定成功后，将锁定库存信息（StockLockedTo：含库存工作单Id和工作的详情表所有信息）发送给MQ。
1、通过路由键stock.locked发送给延迟队列stock.delay.queue
2、2分钟后延迟队列将消息通过交换机stock-event-exchange、路由键stock.release发送给stock.release.stock.queue队列
3、StockReleaseListener监听stock.release.stock.queue队列数据，调用解锁库存方法wareSkuService.unlockStock(stockLockedTo)
4、解锁库存
1）查询关于这个订单的锁定库存信息WareOrderTaskDetailEntity，若有锁定库存信息，即库存锁定成功，根据订单情况解锁
2）远程调用订单服务，根据订单号获取订单实体
3）只有订单不存在（订单数据已经回滚） 或者 有订单但订单状态是已取消，同时锁定库存详情的锁定状态为已锁定，才可以解锁库存。其他状态不需要解锁库存
4）库存解锁，将WareSkuEntity表的锁定库存数stock_locked减去num。即恢复原库存
5）更新库存工作单WareOrderTaskDetailEntity的锁定状态为已解锁

MQ消息记录表

图片.png图片.png图片.png