简介

订单中心

电商系统涉及到3流，分别时信息流，资金流，物流，而订单系统作为中枢将三者有机的集合起来。订单模块是电商系统的枢纽，在订单这个环节上需求获取多个模块的数据和信息，同时对这些信息进行加工处理后流向下个环节，这一系列就构成了订单的信息流通。

订单构成

订单服务 - 图1

流程

订单服务 - 图2

拦截器

订单模块需要用户登录后操作

步骤：

  • 添加拦截器
  1. @Component
  2. public class LoginUserInterceptor implements HandlerInterceptor {
  4.     public static ThreadLocal<MemberRespVo> threadLocal = new ThreadLocal<>();
  6.     @Override
  7.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  8.         HttpSession session = request.getSession();
  9.         MemberRespVo memberRespVo = (MemberRespVo) session.getAttribute(AuthConstant.LOGIN_USER);
  10.         if (memberRespVo != null) {
  11.             // 保存到ThreadLocal中
  12.             threadLocal.set(memberRespVo);
  13.             return true;
  14.         }else {
  15.             // 设置提示
  16.             request.getSession().setAttribute("msg", "请先登录!");
  17.             // 重定向去登录
  18.             response.sendRedirect("http://auth.gulimalls.com/login.html");
  19.             return false;
  20.         }
  21.     }
  22. }
  • 添加配置使拦截器生效
  1. @Configuration
  2. public class MyWebConfig implements WebMvcConfigurer {
  4.     @Override
  5.     public void addInterceptors(InterceptorRegistry registry) {
  6.         registry.addInterceptor(new LoginUserInterceptor()).addPathPatterns("/**");
  7.     }
  9. }

确认订单页流程

订单模型抽取

  1. /**
  2.  * 结算页VO（confirm.html需要的页面数据）
  3.  *
  4.  * @author: wan
  5.  */
  6. public class OrderConfirmVO {
  8.     /**
  9.      * 会员收获地址列表，ums_member_receive_address
  10.      **/
  11.     @Getter
  12.     @Setter
  13.     List<MemberAddressVO> memberAddressVos;
  15.     /**
  16.      * 所有选中的购物项【购物车中的选中项】
  17.      **/
  18.     @Getter
  19.     @Setter
  20.     List<OrderItemVO> items;
  22.     /**
  23.      * 优惠券（会员积分）
  24.      **/
  25.     @Getter
  26.     @Setter
  27.     private Integer integration;
  29.     /**
  30.      * TODO 防止重复提交的令牌 幂等性
  31.      **/
  32.     @Getter
  33.     @Setter
  34.     private String uniqueToken;
  36.     /**
  37.      * 库存
  38.      * 有货/无货，不放在item里面
  39.      */
  40.     @Getter
  41.     @Setter
  42.     Map<Long, Boolean> stocks;
  44.     /**
  45.      * 总商品金额
  46.      **/
  47.     //BigDecimal total;
  48.     //计算订单总额
  49.     public BigDecimal getTotal() {
  50.         BigDecimal totalNum = BigDecimal.ZERO;
  51.         if (!CollectionUtils.isEmpty(items)) {
  52.             for (OrderItemVO item : items) {
  53.                 // 计算当前商品总价格
  54.                 BigDecimal itemPrice = item.getPrice().multiply(new BigDecimal(item.getCount()));
  55.                 // 累加全部商品总价格
  56.                 totalNum = totalNum.add(itemPrice);
  57.             }
  58.         }
  59.         return totalNum;
  60.     }
  62.     /**
  63.      * 应付总额
  64.      **/
  65.     //BigDecimal payPrice;
  66.     public BigDecimal getPayPrice() {
  67.         return getTotal();
  68.     }
  70.     /**
  71.      * 商品总数
  72.      */
  73.     public Integer getCount() {
  74.         Integer count = 0;
  75.         if (!CollectionUtils.isEmpty(items)) {
  76.             for (OrderItemVO item : items) {
  77.                 count += item.getCount();
  78.             }
  79.         }
  80.         return count;
  81.     }
  83. }

用户地址

  1. /**
  2.  * 收获地址，结算页VO
  3.  * @author: wan
  4.  */
  5. @Data
  6. public class MemberAddressVO {
  8.     private Long id;
  9.     /**
  10.      * member_id
  11.      */
  12.     private Long memberId;
  13.     /**
  14.      * 收货人姓名
  15.      */
  16.     private String name;
  17.     /**
  18.      * 电话
  19.      */
  20.     private String phone;
  21.     /**
  22.      * 邮政编码
  23.      */
  24.     private String postCode;
  25.     /**
  26.      * 省份/直辖市
  27.      */
  28.     private String province;
  29.     /**
  30.      * 城市
  31.      */
  32.     private String city;
  33.     /**
  34.      * 区
  35.      */
  36.     private String region;
  37.     /**
  38.      * 详细地址(街道)
  39.      */
  40.     private String detailAddress;
  41.     /**
  42.      * 省市区代码
  43.      */
  44.     private String areacode;
  45.     /**
  46.      * 是否默认
  47.      */
  48.     private Integer defaultStatus;
  50. }

勾选了的购物项

  1. /**
  2.  * @Description: 购物车所有购物项
  3.  */
  4. @Data
  5. public class OrderItemVO {
  6.     private Long skuId;             // skuId
  7.     private Boolean check = true;   // 是否选中
  8.     private String title;           // 标题
  9.     private String image;           // 图片
  10.     private List<String> skuAttrValues;// 商品销售属性  ["颜色:星河银","版本:8GB+256GB"]
  11.     private BigDecimal price;       // 单价
  12.     private Integer count;          // 当前商品数量
  13.     private BigDecimal totalPrice;  // 总价
  14.     private BigDecimal weight = new BigDecimal("0.085");// 商品重量
  15. }

业务逻辑

Controller

  1. @Controller
  2. public class OrderWebController {
  4.     @Autowired
  5.     private OrderService orderService;
  7.     @GetMapping("/toTrade")
  8.     public String toTrade(Model model) {
  9.         OrderConfirmVO orderConfirmVO = orderService.getOrderConfirm();
  10.         model.addAttribute("confirmOrderData", orderConfirmVO);
  11.         return "confirm";
  12.     }
  13. }

接口实现类

  1. @Override
  2. public OrderConfirmVO getOrderConfirm() {
  3.     OrderConfirmVO orderConfirmVO = new OrderConfirmVO();
  4.     MemberRespVo member = LoginUserInterceptor.threadLocal.get();
  6.     // 远程调用查用户的地址
  7.     List<MemberAddressVO> memberAddress = memberServiceClient.getMemberAddress(member.getId());
  8.     orderConfirmVO.setMemberAddressVos(memberAddress);
  10.     // 远程调用查用户选中了的购物项
  11.     List<OrderItemVO> cartItems = cartServiceClient.getCartItems();
  12.     orderConfirmVO.setItems(cartItems);
  14.     // 优惠信息在用户信息中已经保存
  15.     orderConfirmVO.setIntegration(member.getIntegration());
  17.     // 其他数据计算
  19.     // TODO 放重令牌
  21.     return orderConfirmVO;
  22. }

注意此时调用远程调用了购物车模块查询购物项

  1. @Override
  2. public List<CartItemVo> getCartItems() {
  3.     UserInfoTo userInfoTo = CartInterceptor.threadLocal.get();
  4.     if (userInfoTo.getUserId() == null) {
  5.         return null;
  6.     } else {
  7.         // 从redis中查出
  8.         List<CartItemVo> cartItems = getCartItems(CartConstant.CART_PREFIX + userInfoTo.getUserId());
  9.         // 过滤出选中的，且更新最新的价格
  10.         List<CartItemVo> collect = cartItems.stream().filter(CartItemVo::getCheck).map((item) -> {
  11.             // 远程调用查询
  12.             BigDecimal skuPrice = productFeignService.getSkuPrice(item.getSkuId());
  13.             item.setPrice(skuPrice);
  14.             return item;
  15.         }).collect(Collectors.toList());
  16.         return collect;
  17.     }
  18. }

此时会从threadLocal中取出user-key，但是此时在cart服务的拦截器会先对feign请求进行拦截，但此时请求却没有cookie信息。这就是feign调用不携带请求头的问题。

Feign远程调用丢失请求头问题

原因

主要原因还是feign调用时，会创建一个新请求来调用。

订单服务 - 图3

此时配置拦截器，注入到容器中，feign创建的新请求会被拦截器拦截。

Feign底层

feign底层可以注册多个拦截器处理请求

订单服务 - 图4

这个方法会遍历注册的拦截器，并调用拦截器的apply方法执行

订单服务 - 图5

拦截器接口

订单服务 - 图6

所以我们要返回这个接口的实例，注入到容器中。

配置拦截器

  1. @Configuration
  2. public class GuliFeignConfig {
  4.     @Bean("requestInterceptor")
  5.     public RequestInterceptor requestInterceptor() {
  6.         return new RequestInterceptor() {
  7.             /**
  8.              * 重写apply方法
  9.              * @param requestTemplate 新请求
  10.              */
  11.             @Override
  12.             public void apply(RequestTemplate requestTemplate) {
  13.                 // 获取原来的请求
  14.                 // 拿到刚进来的请求RequestContextHolder
  15.                 // ServletRequestAttributes是spring封装的，AbstractRequestAttributes（RequestContextHolder返回类型）子类
  16.                 // 如果不使用的化，也可以通过在controller中接收request，并通过ThreadLocal也可以共享，只是这里spring提供了可以直接获取的类
  17.                 ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
  18.                 HttpServletRequest request = servletRequestAttributes.getRequest();
  19.                 // 同步请求cookie，老请求放到新请求中
  20.                 // 所有Cookie被封装在请求头中，所以吧Cookie放到新请求即可
  21.                 String cookie = request.getHeader("Cookie");
  22.                 requestTemplate.header("Cookie", cookie);
  23.             }
  24.         };
  25.     }
  27. }

异步优化

使用异步编排优化业务执行，线程池的配置在其他服务已经配置过，复制配置即可。

  1. @Override
  2. public OrderConfirmVO getOrderConfirm() throws ExecutionException, InterruptedException {
  3.     OrderConfirmVO orderConfirmVO = new OrderConfirmVO();
  4.     MemberRespVo member = LoginUserInterceptor.threadLocal.get();
  6.     // 先从父线程获取原请求
  7.     RequestAttributes request = RequestContextHolder.getRequestAttributes();
  9.     CompletableFuture<Void> getAddress = CompletableFuture.runAsync(() -> {
  10.         // 在子线程调用时先共享请求为父线程的请求
  11.         RequestContextHolder.setRequestAttributes(request);
  12.         // 远程调用查用户的地址
  13.         List<MemberAddressVO> memberAddress = memberServiceClient.getMemberAddress(member.getId());
  14.         orderConfirmVO.setMemberAddressVos(memberAddress);
  15.     }, threadPoolExecutor);
  17.     CompletableFuture<Void> getItem = CompletableFuture.runAsync(() -> {
  18.         // 在子线程调用时先共享请求为父线程的请求
  19.         RequestContextHolder.setRequestAttributes(request);
  20.         // 远程调用查用户选中了的购物项
  21.         List<OrderItemVO> cartItems = cartServiceClient.getCartItems();
  22.         orderConfirmVO.setItems(cartItems);
  23.     }, threadPoolExecutor).thenRunAsync(() -> {
  24.         // 远程调用查询库存信息
  25.         // 先收集skuId
  26.         List<OrderItemVO> items = orderConfirmVO.getItems();
  27.         List<Long> skuIdList = items.stream().map(orderItemVo -> orderItemVo.getSkuId()).collect(Collectors.toList());
  28.         R r = wmsServiceClient.getSkuHasStock(skuIdList);
  29.         List<SkuHasStockTo> data = r.getData(new TypeReference<List<SkuHasStockTo>>() {
  30.         });
  32.         // 封装库存信息
  33.         if (data != null) {
  34.             Map<Long, Boolean> collect = data.stream().collect(Collectors.toMap(SkuHasStockTo::getSkuId, SkuHasStockTo::getHasStock));
  35.             orderConfirmVO.setStocks(collect);
  36.         }
  37.     });
  39.     // 优惠信息在用户信息中已经保存
  40.     orderConfirmVO.setIntegration(member.getIntegration());
  42.     // 其他数据计算
  43.     // TODO 放重令牌
  45.     // 等待2个异步任务
  46.     CompletableFuture.allOf(getAddress, getItem).get();
  48.     return orderConfirmVO;
  49. }

此时又会遇到问题，就是在两个线程中的请求不共享，2个线程分别调用远程服务，此时也就是没有携带cookie调用，所以会调用失败。

也就是threadLocal作用只是在父线程，而没有在子线程。

异步编排feign调用不丢失请求问题

此时解决方法就是子线程需要共享父线程的请求。此时请求就携带了cookie。

原因：

使用异步编排时，非同一线程无法取到RequestContextHolder（上下文环境保持器）
ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = requestAttributes.getRequest();// 获取controller请求对象空指针异常

解决：获取主线程ServletRequestAttributes，给每个异步线程复制一份

  1. // 先从父线程获取原请求
  2. RequestAttributes request = RequestContextHolder.getRequestAttributes();
  4. CompletableFuture<Void> getAddress = CompletableFuture.runAsync(() -> {
  5.     // 在子线程调用时先共享请求为父线程的请求
  6.     RequestContextHolder.setRequestAttributes(request);
  7.     ...
  8. }, threadPoolExecutor);
  10. CompletableFuture<Void> getItem = CompletableFuture.runAsync(() -> {
  11.     // 在子线程调用时先共享请求为父线程的请求
  12.     RequestContextHolder.setRequestAttributes(request);
  13.     ...
  14. }, threadPoolExecutor).thenRunAsync(() -> {
  15.     ...
  16.     List<SkuHasStockTo> data = r.getData(new TypeReference<List<SkuHasStockTo>>() {
  17.     });

计算运费

  1. @Override
  2. public FareVo getFare(Long addrId) {
  3.     FareVo fareVo = new FareVo();
  4.     // 远程调用
  5.     R r = memberFeignService.info(addrId);
  6.     MemberAddressVo memberAddressVo = r.getData("memberReceiveAddress", new TypeReference<MemberAddressVo>() {
  7.     });
  8.     if (memberAddressVo != null) {
  9.         String phone = memberAddressVo.getPhone();
  10.         //截取用户手机号码最后一位作为我们的运费计算
  11.         //1558022051
  12.         String fare = phone.substring(phone.length() - 1);
  13.         BigDecimal bigDecimal = new BigDecimal(fare);
  14.         fareVo.setFare(bigDecimal);
  15.         fareVo.setAddress(memberAddressVo);
  16.         return fareVo;
  17.     }
  18.     return null;
  19. }

创建订单流程

接口幂等性问题

具体问题见文档，使用token保证接口幂等性，注意保证查询token和删除token是原子的。

订单服务 - 图7

流程

加上接口幂等性校验流程图

订单服务 - 图8

  1. @Override
  2. public SubmitOrderResponseVo getSubmitOrderResponseVo(OrderSubmitVo orderSubmitVo) {
  3.     SubmitOrderResponseVo submitOrderResponseVo = new SubmitOrderResponseVo();
  5.     // 获取用户信息
  6.     MemberRespVo member = LoginUserInterceptor.threadLocal.get();
  7.     String submitToken = orderSubmitVo.getUniqueToken();
  8.     orderSubmitThreadLocal.set(orderSubmitVo);
  10.     // Lua脚本含义：
  11.     //  查找KEYS[1]的值，如果等于ARGV[1]，就进行删除，删除成功返回1，删除失败返回0，如果没找到返回0
  12.     String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
  13.     // 使用Lua脚本保证令牌的验证和删除是原子性的
  14.     Long flag = redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList(OrderConstant.USER_ORDER_TOKEN_PREFIX + member.getId()), submitToken);
  16.     if (flag == 1L) {
  17.         // 创建订单
  18.         OrderCreateTo order = createOrder();
  19.         // 验价
  20.         BigDecimal totalAmount = order.getOrder().getPayAmount();
  21.         BigDecimal payPrice = orderSubmitVo.getPayPrice();
  22.         if (Math.abs(totalAmount.subtract(payPrice).doubleValue()) < 0.01) {
  23.             // 金额对比成功
  24.             // 保存订单
  25.             saveOrder(order);
  26.             // 锁定库存
  27.             WareSkuLockVo wareSkuLockVo = new WareSkuLockVo();
  28.             wareSkuLockVo.setOrderSn(order.getOrder().getOrderSn());
  29.             List<OrderItemEntity> orderItems = order.getOrderItems();
  30.             // 封装一个类
  31.             List<OrderItemVo> orderItemVoList = orderItems.stream().map(entity -> {
  32.                 OrderItemVo orderItemVo = new OrderItemVo();
  33.                 orderItemVo.setSkuId(entity.getSkuId());
  34.                 orderItemVo.setTitle(entity.getSkuName());
  35.                 orderItemVo.setCount(entity.getSkuQuantity());
  36.                 return orderItemVo;
  37.             }).collect(Collectors.toList());
  38.             wareSkuLockVo.setLocks(orderItemVoList);
  39.             // 远程调用
  40.             R r = wmsServiceClient.lockOrderStock(wareSkuLockVo);
  41.             if (r.getCode() == 0) {
  42.                 // 锁住库存成功
  43.                 submitOrderResponseVo.setOrder(order.getOrder());
  44.                 submitOrderResponseVo.setCode(0);
  45.                 // TODO 远程扣减积分
  46.                 return submitOrderResponseVo;
  47.             } else {
  48.                 submitOrderResponseVo.setCode(3);
  49.                 throw new NoStockException((String)r.get("msg"));
  50.             }
  51.         } else {
  52.             // 金额对比失败
  53.             submitOrderResponseVo.setCode(2);
  54.             return submitOrderResponseVo;
  55.         }
  56.     } else {
  57.         // 令牌校验失败
  58.         submitOrderResponseVo.setCode(1);
  59.         return submitOrderResponseVo;
  60.     }
  62. }

创建订单流程图

订单服务 - 图9

创建订单TO对象方法

  1. private OrderCreateTo createOrder() {
  2.     OrderCreateTo orderCreateTo = new OrderCreateTo();
  4.     // 创建订单
  5.     String orderSn = IdWorker.getTimeId();
  6.     OrderEntity orderEntity = buildOrder(orderSn);
  8.     // 生成订单项实体对象
  9.     List<OrderItemEntity> orderItemEntities = buildOrderItems(orderSn);
  11.     // 计算价格
  12.     summaryFillOrder(orderEntity, orderItemEntities);
  14.     orderCreateTo.setOrder(orderEntity);
  15.     orderCreateTo.setOrderItems(orderItemEntities);
  17.     return orderCreateTo;
  18. }

创建订单方法，和生成订单项集合封装方法

  1.    /**
  2.      * 创建订单方法
  3.      *
  4.      * @param orderSn
  5.      * @return
  6.      */
  7.     private OrderEntity buildOrder(String orderSn) {
  8.         // 设置订单号
  9.         OrderEntity orderEntity = new OrderEntity();
  10.         orderEntity.setOrderSn(orderSn);
  12.         // 设置memberId
  13.         MemberRespVo member = LoginUserInterceptor.threadLocal.get();
  14.         orderEntity.setMemberId(member.getId());
  16.         // 查找发送地址
  17.         OrderSubmitVo orderSubmitVo = orderSubmitThreadLocal.get();
  18.         R r = wmsServiceClient.getFare(orderSubmitVo.getAddrId());
  19.         FareVo fareVo = r.getData(new TypeReference<FareVo>() {
  20.         });
  22.         orderEntity.setFreightAmount(fareVo.getFare());
  23.         // 4.封装收货地址信息
  24.         orderEntity.setReceiverName(fareVo.getAddress().getName());// 收货人名字
  25.         orderEntity.setReceiverPhone(fareVo.getAddress().getPhone());// 收货人电话
  26.         orderEntity.setReceiverProvince(fareVo.getAddress().getProvince());// 省
  27.         orderEntity.setReceiverCity(fareVo.getAddress().getCity());// 市
  28.         orderEntity.setReceiverRegion(fareVo.getAddress().getRegion());// 区
  29.         orderEntity.setReceiverDetailAddress(fareVo.getAddress().getDetailAddress());// 详细地址
  30.         orderEntity.setReceiverPostCode(fareVo.getAddress().getPostCode());// 收货人邮编
  31.         // 5.封装订单状态信息
  32.         orderEntity.setStatus(OrderConstant.OrderStatusEnum.CREATE_NEW.getCode());
  33.         // 6.设置自动确认时间
  34.         orderEntity.setAutoConfirmDay(OrderConstant.autoConfirmDay);// 7天
  35.         // 7.设置未删除状态
  36.         orderEntity.setDeleteStatus(OrderConstant.OrderIsDeleteEnum.NOT_DELETE.getIsDelete());
  37.         // 8.设置时间
  38.         Date now = new Date();
  39.         orderEntity.setCreateTime(now);
  40.         orderEntity.setModifyTime(now);
  42.         return orderEntity;
  43.     }
  45.     /**
  46.      * 生成订单项实体对象集合
  47.      *
  48.      * @param orderSn
  49.      * @return
  50.      */
  51.     private List<OrderItemEntity> buildOrderItems(String orderSn) {
  52.         List<OrderItemVo> cartItems = cartServiceClient.getCartItems();
  53.         List<OrderItemEntity> orderItemEntityList = new ArrayList<>();
  54.         if (!CollectionUtils.isEmpty(cartItems)) {
  55.             orderItemEntityList = cartItems.stream()
  56.                     .filter(OrderItemVo::getCheck)
  57.                     .map(item -> buildOrderItem(orderSn, item))
  58.                     .collect(Collectors.toList());
  59.         }
  60.         return orderItemEntityList;
  61.     }
  63.     /**
  64.      * 封装每一个购物项
  65.      *
  66.      * @param orderSn
  67.      * @param cartItem
  68.      * @return
  69.      */
  70.     private OrderItemEntity buildOrderItem(String orderSn, OrderItemVo cartItem) {
  71.         OrderItemEntity itemEntity = new OrderItemEntity();
  72.         // 1.封装订单号
  73.         itemEntity.setOrderSn(orderSn);
  74.         // 2.封装SPU信息
  75.         R spuInfo = productServiceClient.getSpuBySkuId(cartItem.getSkuId());// 查询SPU信息
  76.         SpuInfoTo spuInfoTO = spuInfo.getData(new TypeReference<SpuInfoTo>() {
  77.         });
  78.         itemEntity.setSpuId(spuInfoTO.getId());
  79.         itemEntity.setSpuName(spuInfoTO.getSpuName());
  80.         itemEntity.setSpuBrand(spuInfoTO.getSpuName());
  81.         itemEntity.setCategoryId(spuInfoTO.getCatalogId());
  82.         // 3.封装SKU信息
  83.         itemEntity.setSkuId(cartItem.getSkuId());
  84.         itemEntity.setSkuName(cartItem.getTitle());
  85.         itemEntity.setSkuPic(cartItem.getImage());// 商品sku图片
  86.         itemEntity.setSkuPrice(cartItem.getPrice());// 这个是最新价格，购物车模块查询数据库得到
  87.         itemEntity.setSkuQuantity(cartItem.getCount());// 当前商品数量
  88.         String skuAttrsVals = String.join(";", cartItem.getSkuAttrValues());
  89.         itemEntity.setSkuAttrsVals(skuAttrsVals);// 商品销售属性组合["颜色:星河银","版本:8GB+256GB"]
  90.         // 4.优惠信息【不做】
  92.         // 5.积分信息
  93.         int num = cartItem.getPrice().multiply(new BigDecimal(cartItem.getCount())).intValue();// 分值=单价*数量
  94.         itemEntity.setGiftGrowth(num);// 成长值
  95.         itemEntity.setGiftIntegration(num);// 积分
  97.         // 6.价格信息
  98.         itemEntity.setPromotionAmount(BigDecimal.ZERO);// 促销金额
  99.         itemEntity.setCouponAmount(BigDecimal.ZERO);// 优惠券金额
  100.         itemEntity.setIntegrationAmount(BigDecimal.ZERO);// 积分优惠金额
  101.         BigDecimal realAmount = itemEntity.getSkuPrice().multiply(new BigDecimal(itemEntity.getSkuQuantity()))
  102.                 .subtract(itemEntity.getPromotionAmount())
  103.                 .subtract(itemEntity.getCouponAmount())
  104.                 .subtract(itemEntity.getIntegrationAmount());
  105.         itemEntity.setRealAmount(realAmount);// 实际金额，减去所有优惠金额
  107.         return itemEntity;
  108.     }

验价之后保存订单，保存订单后锁定库存

  1. /**
  2.  * 保存订单
  3.  *
  4.  * @param orderCreateTo
  5.  */
  6. @Transactional
  7. void saveOrder(OrderCreateTo orderCreateTo) {
  8.     OrderEntity order = orderCreateTo.getOrder();
  9.     this.save(order);
  10.     List<OrderItemEntity> orderItems = orderCreateTo.getOrderItems();
  11.     orderItemService.saveBatch(orderItems);
  12. }

锁定库存

订单服务 - 图10

  1. if (r.getCode() == 0) {
  2.     // 锁住库存成功
  3.     submitOrderResponseVo.setOrder(order.getOrder());
  4.     submitOrderResponseVo.setCode(0);
  5.     // TODO 远程扣减积分
  6.     return submitOrderResponseVo;
  7. }

锁定库存如果在远程扣减积分出现异常，那么就会库存不会回滚，此时就有分布式异常的问题。

远程调用库存扣减的方法：

主要就是对lock_stock字段进行操作。

  1. /**
  2.  * 锁定库存,sql执行锁定锁定
  3.  *
  4.  * @param wareSkuLockVo
  5.  * @return
  6.  */
  7. @Transactional(rollbackFor = NoStockException.class)
  8. @Override
  9. public Boolean lockOrderStock(WareSkuLockVo wareSkuLockVo) {
  10.     // 按照收货地址找到就近仓库，锁定库存（暂未实现）
  11.     // 采用方案：获取每项商品在哪些仓库有库存，轮询尝试锁定，任一商品锁定失败回滚
  13.     // 找到这个商品在哪里有库存，封装成一个对象
  14.     List<OrderItemVo> locks = wareSkuLockVo.getLocks();
  15.     List<SkuWareHasStock> skuWareHasStockList = locks.stream().map(item -> {
  16.         SkuWareHasStock skuWareHasStock = new SkuWareHasStock();
  17.         Long skuId = item.getSkuId();
  18.         List<Long> wareIds = wareSkuDao.getSkuStockWareIds(skuId, item.getCount());
  19.         // 没有仓库
  20.         if (wareIds == null && wareIds.size() == 0) {
  21.             throw new NoStockException(skuId);
  22.         }
  23.         skuWareHasStock.setLockNum(item.getCount());
  24.         skuWareHasStock.setSkuId(skuId);
  25.         skuWareHasStock.setWareIds(wareIds);
  26.         return skuWareHasStock;
  27.     }).collect(Collectors.toList());
  29.     for (SkuWareHasStock skuWareHasStock : skuWareHasStockList) {
  30.         // 是否锁定成功的标志
  31.         Boolean skuStockLock = false;
  32.         Long skuId = skuWareHasStock.getSkuId();
  33.         List<Long> wareIds = skuWareHasStock.getWareIds();
  35.         if (CollectionUtils.isEmpty(wareIds)) {
  36.             // 只要有一个货物没有仓库有他库存，直接抛出异常，锁定库存失败，回滚
  37.             throw new NoStockException(skuId);
  38.         } else {
  39.             // 有多个仓库有库存，此时需要判断哪个仓库够
  40.             for (Long wareId : wareIds) {
  41.                 // 锁定成功就返回1，不成功返回0（代表影响的行数）
  42.                 Long count = wareSkuDao.lockSkuStock(skuId, wareId, skuWareHasStock.getLockNum());
  43.                 if (count == 1) {
  44.                     // 表示已经有一个仓库锁住了
  45.                     // 标志置为true，停止锁下一个仓库
  46.                     skuStockLock = true;
  47.                     break;
  48.                 }
  50.                 // 当前仓库失败，重试下一个仓库
  52.                 // 所有仓库都没成功锁住，抛出异常
  53.                 if (skuStockLock == false) {
  54.                     throw new NoStockException(skuId);
  55.                 }
  56.             }
  57.         }
  58.     }
  59.     return true;
  60. }

分布式事务的解决

参照分布式事务的文档。

后台保存商品分布式方案

Seata的使用参照官网：https://seata.io/zh-cn/docs/user/quickstart.html

前台订单分布式方案

本项目订单并没有使用Seata来解决库存的分布式事务问题，Seata在解决分布式事务的过程中会加锁一系列操作，出现异常直接回滚。并发程度并不是特别高，但后台保存商品可以使用Seata，此时并发并不是特别高，所以本项目分布式事务为了高并发，只保持最终一致性即可，可以使用消息队列。（延时队列）

保存库存锁定成功的消息在延时队列中，30分钟后把消息发送给解锁库存服务，解锁服务如果此时没有查看到订单，也就是可能被人取消了，此时就需要执行库存回滚，也就是定时任务的效果。

image.png

延时队列场景

订单服务 - 图12

为什么不使用Spring提供的定时任务？

订单服务 - 图13

定时任务的时效性问题：如果在下单之前开启定时任务，订单在1才下好单，那么订单在30分钟也就是31的时候才会算过期，而定时任务在30的时候检测没有过期，所以不回滚，在下一个定时任务才可以检测到。时差很大。不采用，而采用延时对了

订单服务 - 图14

死信队列和死信交换机

订单服务 - 图15

延时队列的实现

方法一：设置队列过期时间

订单服务 - 图16

方法二：设置消息过期时间

订单服务 - 图17

延时队列模拟关单

使用2个交换机

订单服务 - 图18

但可以优化一下，复用同一个交换机，根据routing-key不同进行转发

订单服务 - 图19

设计建议规范：(基于事件模型的交换机设计)

1、交换机命名:业务+exchange;交换机为Topic

2、路由键:事件.需要感知的业务(可以不写)

3、队列命名:事件+想要监听服务名+queue

4、绑定关系:事件.感知的业务(#)

  1. @Bean
  2. public Queue orderDelayQueue() {
  3.     Map<String, Object> arguments = new HashMap<>();
  4.     // 延时队列的死信交换机和routing-key
  5.     arguments.put("x-dead-letter-exchange", "order-event-exchange");
  6.     arguments.put("x-dead-letter-routing-key", "order.release.order");
  7.     arguments.put("x-message-ttl", 60000);
  8.     return new Queue("order.delay.queue", true, false, false, arguments);
  9. }
  11. @Bean
  12. public Queue orderReleaseOrderQueue() {
  13.     return new Queue("order.release.order.queue", true, false, false, null);
  14. }
  16. @Bean
  17. public Exchange orderEventExchange() {
  18.     return new TopicExchange("order-event-exchange", true, false);
  19. }
  21. @Bean
  22. public Binding orderCreateOrderBinding() {
  23.     return new Binding("order.delay.queue",
  24.             Binding.DestinationType.QUEUE,
  25.             "order-event-exchange",
  26.             "order.create.order",
  27.             null);
  28. }
  30. @Bean
  31. public Binding orderReleaseOrderBinding() {
  32.     return new Binding("order.release.order.queue",
  33.             Binding.DestinationType.QUEUE,
  34.             "order-event-exchange",
  35.             "order.release.order",
  36.             null);
  37. }

利用消息队列就解决库存问题

库存问题解决流程图

订单服务 - 图20

根据图示创建相应的队列和交换机

根据模拟关单可以是由一个交换机代替两个交换机

  1. @Configuration
  2. public class RabbitMqConfig {
  5.     /**
  6.      * 配置发送对象到消息队列为Json格式
  7.      *
  8.      * @return
  9.      */
  10.     @Bean
  11.     public MessageConverter messageConverter() {
  12.         return new Jackson2JsonMessageConverter();
  13.     }
  16.     @Bean
  17.     public Queue stockDelayQueue() {
  18.         Map<String, Object> arguments = new HashMap<>();
  19.         // 延时队列的死信交换机和routing-key
  20.         arguments.put("x-dead-letter-exchange", "stock-event-exchange");
  21.         arguments.put("x-dead-letter-routing-key", "stock.release");
  22.         arguments.put("x-message-ttl", 120000);
  23.         return new Queue("stock.delay.queue", true, false, false, arguments);
  24.     }
  26.     @Bean
  27.     public Queue stockReleaseOrderQueue() {
  28.         return new Queue("stock.release.stock.queue", true, false, false, null);
  29.     }
  31.     @Bean
  32.     public Exchange stockEventExchange() {
  33.         return new TopicExchange("stock-event-exchange", true, false);
  34.     }
  36.     @Bean
  37.     public Binding orderCreateOrderBinding() {
  38.         return new Binding("stock.delay.queue",
  39.                 Binding.DestinationType.QUEUE,
  40.                 "stock-event-exchange",
  41.                 "stock.locked",
  42.                 null);
  43.     }
  45.     @Bean
  46.     public Binding stockReleaseOrderBinding() {
  47.         return new Binding("stock.release.stock.queue",
  48.                 Binding.DestinationType.QUEUE,
  49.                 "stock-event-exchange",
  50.                 "stock.release.#",
  51.                 null);
  52.     }
  53. }

进行库存回滚的操作

注意先开启消息手动确认：

防止消息解锁库存出现异常之后，不重新处理，此时库存就未解锁，有很大问题。

  1. spring:
  2.     listener:
  3.       simple:
  4.         acknowledge-mode: manual  # 配置ack为手动应答

回滚的情况判断：

  1. /**
  2.  * 回滚消息的逻辑：
  3.  *  一.先在任务详情表中查询消息:
  4.  *    1.如果没有，那么说明在锁定库存的时候已经出现了错误，在本地事务已经进行了回滚，所以所以此时不需要回滚
  5.  *    2.如果有：
  6.  *      解锁需要判断订单情况：
  7.  *          如果没有这个订单，必须解锁。
  8.  *          如果有这个订单：1.订单未取消，不解锁 2.订单取消了，解锁
  9.  */
  1. public void handleStockLockedRelease(StockLockedTo stockLockedTo, Message message, Channel channel) throws IOException {
  2.     log.info("收到回滚消息");
  3.     Long id = stockLockedTo.getId();
  4.     WareOrderTaskDetailEntity byId = wareOrderTaskDetailService.getById(id);
  5.     if (byId != null) {
  6.         // 此时远程调用查询订单情况
  7.         WareOrderTaskEntity taskEntity = wareOrderTaskService.getById(id);
  8.         R r = orderFeignService.getOrderStatus(taskEntity.getOrderSn());
  9.         if (r.getCode() == 0) {
  10.             OrderVo data = r.getData(new TypeReference<OrderVo>() {
  11.             });
  12.             // 只有不存在订单和订单一已经关闭才解锁
  13.             if (data == null || data.getStatus() == 4) {
  14.                 // 调用解锁方法
  15.                 unLockStock(byId.getSkuId(), byId.getWareId(), byId.getSkuNum());
  16.                 // 手动应答
  17.                 channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  18.             }
  19.         } else {
  20.             // 如果远程调用失败，不应答，再次放入队列中，下一次应答
  21.             channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
  22.         }
  23.     } else {
  24.         // 没有任务详情表，说明已经回滚，不解锁
  25.         // 手动应答
  26.         channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  27.     }
  28. }
  30. private void unLockStock(Long skuId, Long wareId, Integer num) {
  31.     wareSkuDao.unLockStock(skuId, wareId, num);
  32. }

优化

（封装成一个方法）接收消息的listener

  1. @Service
  2. @Slf4j
  3. @RabbitListener(queues = {"stock.release.stock.queue"})
  4. public class RabbitMQListener {
  6.     @Autowired
  7.     private WareSkuService wareSkuService;
  9.     @RabbitHandler
  10.     public void handleStockLockedRelease(StockLockedTo stockLockedTo, Message message, Channel channel) throws IOException {
  11.         log.info("收到自动回滚消息，开始处理回滚操作");
  12.         try {
  13.             wareSkuService.handleStockLockedRelease(stockLockedTo);
  14.             // 只要没有异常，就确认收到消息
  15.             channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  16.         } catch (Exception exception) {
  17.             channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
  18.         }
  19.     }
  20. }

调用方法：此时只有异常，也就是远程调用查询订单出现了异常抛出异常，进行手动的ack拒接。其他不解锁的情况也就不会滚库存数量。

  1. public void handleStockLockedRelease(StockLockedTo stockLockedTo) throws Exception {
  2.     /**
  3.      * 回滚消息的逻辑：
  4.      *  一.先在任务详情表中查询消息:
  5.      *    1.如果没有，那么说明在锁定库存的时候已经出现了错误，在本地事务已经进行了回滚，所以所以此时不需要回滚
  6.      *    2.如果有：
  7.      *      解锁需要判断订单情况：
  8.      *          如果没有这个订单，必须解锁。
  9.      *          如果有这个订单：1.订单未取消，不解锁 2.订单取消了，解锁
  10.      */
  11.     Long id = stockLockedTo.getId();
  12.     StockDetailTo stockDetailTo = stockLockedTo.getDetail();
  13.     WareOrderTaskDetailEntity taskDetail = wareOrderTaskDetailService.getById(stockDetailTo.getId());
  14.     if (taskDetail != null) {
  15.         // 此时远程调用查询订单情况
  16.         WareOrderTaskEntity taskEntity = wareOrderTaskService.getById(id);
  17.         R r = orderFeignService.getOrderStatus(taskEntity.getOrderSn());
  18.         if (r.getCode() == 0) {
  19.             OrderVo data = r.getData(new TypeReference<OrderVo>() {
  20.             });
  21.             // 只有不存在订单和订单一已经关闭才解锁
  22.             if (data == null || data.getStatus() == 4) {
  23.                 // 当任务详情表中的状态为1，也就是未解锁的时候才进行解锁
  24.                 if (taskDetail.getLockStatus() == 1) {
  25.                     // 调用解锁方法
  26.                     unLockStock(taskDetail.getSkuId(), taskDetail.getWareId(), taskDetail.getSkuNum(), taskDetail.getId());
  27.                 } else {
  28.                     // 订单其他状态，不可解锁（消息确认）
  29.                 }
  30.             }
  31.         } else {
  32.             // 订单远程调用失败（消息重新入队）
  33.             throw new RuntimeException("解锁异常");
  34.         }
  35.     } else {
  36.         // 无库存锁定工作单记录，已回滚，无需解锁（消息确认）
  37.     }
  38. }
  40. /**
  41.      * 解锁库存
  42.      *
  43.      * @param skuId
  44.      * @param wareId
  45.      * @param num
  46.      * @param taskId
  47.      */
  48. @Transactional
  49. public void unLockStock(Long skuId, Long wareId, Integer num, Long taskId) {
  50.     // 仓库解锁
  51.     wareSkuDao.unLockStock(skuId, wareId, num);
  52.     // 更新解锁任务单详情表的解锁状态
  53.     WareOrderTaskDetailEntity detail = new WareOrderTaskDetailEntity();
  54.     detail.setId(taskId);
  55.     detail.setLockStatus(2);
  56.     wareOrderTaskDetailService.updateById(detail);
  57. }

发送消息

在订单模块库存调用成功后发送消息

  1. if (r.getCode() == 0) {
  2.     // 锁住库存成功
  3.     submitOrderResponseVo.setOrder(order.getOrder());
  4.     submitOrderResponseVo.setCode(0);
  6.     // TODO 远程扣减积分
  8.     // 发送消息到订单队列中，以后进行关单操作
  9.     rabbitTemplate.convertAndSend("order-event-exchange", "order.create.order", order.getOrder());
  11.     return submitOrderResponseVo;
  12. } else {
  13.     submitOrderResponseVo.setCode(3);
  14.     throw new NoStockException((String) r.get("msg"));
  15. }

关单操作详情

如果订单在规定时间未进行支付，那么此时就要进行关单的功能，在关单模拟已经创建了队列和交换机，此时就是在创建订单后发送消息，在一定时间后，监听并关单即可。

关单流程图

订单服务 - 图21

监听消息

  1. @Slf4j
  2. @Service
  3. @RabbitListener(queues = {"order.release.order.queue"})
  4. public class RabbitMQListener {
  6.     @Autowired
  7.     private OrderService orderService;
  9.     @RabbitHandler
  10.     public void closeOrder(OrderEntity orderEntity, Message message, Channel channel) throws IOException {
  11.         log.info("订单超过未支付时间，开始关闭订单操作...");
  12.         try {
  13.             orderService.closeOrder(orderEntity);
  14.             channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  15.         } catch (Exception exception) {
  16.             channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
  17.         }
  18.     }
  20. }

修改订单状态为关单状态

  1. /**
  2.  * 修改订单状态为关单
  3.  *
  4.  * @param orderEntity
  5.  */
  6. @Override
  7. public void closeOrder(OrderEntity orderEntity) {
  8.     // 修改订单状态，表示未支付
  9.     OrderEntity entity = getById(orderEntity.getId());
  10.     // 时间过了还未付款，关单
  11.     if (entity.getStatus() == 0) {
  12.         OrderEntity updateEntity = new OrderEntity();
  13.         updateEntity.setId(entity.getId());
  14.         updateEntity.setStatus(4);
  15.         updateById(updateEntity);
  16.     }
  17. }

关单操作和库存解锁的问题

问题引入和解决方法

订单服务 - 图22

一般情况库存锁定在关单操作之后，如果有网络卡顿，那么关单在解锁库存之后，此时库存的解锁的逻辑：如果有这个订单：1.订单未取消，不解锁 2.订单取消了，解锁，所以此时库存是不会解锁的，因为订单还是在新建状态，并没有关单。

为了解决这个问题：可以在订单创建之后主动发送一次库存解锁操作，此时可以保证库存在订单关单之后一定被解锁，但是如果关单在解锁库存之前，那么正常解锁库存（不是订单主动发送的解锁）应该如何判断是否解锁呢？

此时在关单主动解锁库存的时候，一定需要将任务详情单的lock_status设置未2表示已经解锁，第二次被动解锁就再次解锁库存了。

流程

此时关单的交换机需要绑定库存的死信队列，注意一定不要绑到了库存的延时队列

订单服务 - 图23

  1. @Bean
  2. public Binding orderReleaseOtherBinding() {
  3.     return new Binding("stock.release.stock.queue",
  4.             Binding.DestinationType.QUEUE,
  5.             "order-event-exchange",
  6.             "order.release.other.#",
  7.             null);
  8. }

下单之后主动发送库存解锁消息

  1. /**
  2.  * 修改订单状态为关单
  3.  *
  4.  * @param orderEntity
  5.  */
  6. @Override
  7. public void closeOrder(OrderEntity orderEntity) {
  8.     // 修改订单状态，表示未支付
  9.     OrderEntity entity = getById(orderEntity.getId());
  10.     // 时间过了还未付款，关单
  11.     if (entity.getStatus() == 0) {
  12.         OrderEntity updateEntity = new OrderEntity();
  13.         updateEntity.setId(entity.getId());
  14.         updateEntity.setStatus(4);
  15.         updateById(updateEntity);
  16.     }
  17.     // 主动发起解锁库存消息，防止有延时导致库存未解锁，却又修改了订单
  18.     OrderTo orderTo = new OrderTo();
  19.     BeanUtils.copyProperties(entity, orderTo);
  20.     rabbitTemplate.convertAndSend("order-event-exchange", "order.release.other", orderTo);
  21. }

库存监听器监听OrderTo的消息

  1. @RabbitHandler
  2. public void handleStockLockedReleaseByOrderSend(OrderTo orderTo, Message message, Channel channel) throws IOException {
  3.     log.info("收到订单发送关单后的回滚消息，开始处理回滚操作");
  4.     try {
  5.         wareSkuService.handleStockLockedReleaseByOrderSend(orderTo);
  6.         // 只要没有异常，就确认收到消息
  7.         channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
  8.     } catch (Exception exception) {
  9.         channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
  10.     }
  11. }

接口

此时需要先查询taskId，根据任务详情单进行回滚

  1. @Override
  2. @Transactional
  3. public void handleStockLockedReleaseByOrderSend(OrderTo orderTo) {
  4.     // 通过任务表查询任务id
  5.     String orderSn = orderTo.getOrderSn();
  6.     Long taskId = orderTaskService.getTaskIdByOrderSn(orderSn);
  8.     // 查询所有任务详情的信息，注意找的是没有解锁的任务详情
  9.     List<WareOrderTaskDetailEntity> list = wareOrderTaskDetailService.list(new QueryWrapper<WareOrderTaskDetailEntity>()
  10.             .eq("task_id", taskId)
  11.             .eq("lock_status", 1));
  13.     // 遍历解锁库存
  14.     for (WareOrderTaskDetailEntity entity : list) {
  15.         unLockStock(entity.getSkuId(), entity.getWareId(), entity.getSkuNum(), entity.getId());
  16.     }
  17. }

如何保证消息的可靠性

消息丢失（三种情况）

消息丢失一消息发送出去，由于网络问题没有抵达服务器

  • 做好容错方法(try-catch)，发送消息可能会网络失败，失败后要有重试机制，可记录到数据库，采用定期扫描重发的方式
  • 做好日志记录，每个消息状态是否都被服务器收到都应该记录
  • 做好定期重发，如果消息没有发送成功，定期去数据库扫描未成功的消息进行重发一

消息抵达Broker，Broker要将消息写入磁盘(持久化)才算成功。此时Broker尚未持久化完成，宕机。

  • publishe地必须加入确认回调机制，确认成功的消息，修改数据库消息状态。

自动ACK的状态下。消费者收到消息，但没来得及消息然后宕机

  • 一定开启手动ACK，消费成功才移除，失败或者没来得及处理就noAck并重新入队

消息重复(三种情况)

消息消费成功，事务已经提交，ack时，机器宕机。导致没有ack成功，Broker的消息重新由unack变为ready，并发送给其他消费者

消息消费失败，由于重试机制，自动又将消息发送出去

成功消费，ack时宕机，消息由unack变为ready,Broker又重新发送

  • 消费者的业务消费接口应该设计为幂等性的。比如扣库存有工作单的状态标志
  • 使用防重表(redis/mysql)，发送消息每一个都有业务的唯一标识，处理过就不用处理
  • rabbitMQ的每一个消息都有redelivered字段，可以获取是否是被重新投递过来的，而不是第一次投递过来的

消息重复很好解决，库存服务在业务逻辑上也就放置了幂等性。

消息积压

消费者宕机积压

消费者消费能力不足积压

发送者发送流量太大。

  • 上线更多的消费者，进行正常消费
  • 上线专门的队列消费服务，将消息先批量取出来，记录数据库，离线慢慢处理

项目也可以使用解锁库存的服务专为为一个微服务，可以解决消息挤压。