• 订单服务-----功能实现逻辑

    订单服务的实现流程（确认订单->提交订单->支付）

    1、整合SpringSession

    使用SpringSession的目的是来解决分布式session不同步不共享的问题，其实就是为了让登录信息在订单微服务里共享

    注意：由于这里使用springsession的用的类型是redis，所以这springsession和redis都要一起加入依赖和配置

    （1）导入依赖

    1. <!-- 整合springsession 来解决分布式session不同步不共享的问题-->
    2. <dependency>
    3.   <groupId>org.springframework.session</groupId>
    4.   <artifactId>spring-session-data-redis</artifactId>
    5. </dependency>
    6. <!-- 整合redis-->
    7. <dependency>
    8.   <groupId>org.springframework.boot</groupId>
    9.   <artifactId>spring-boot-starter-data-redis</artifactId>
    10. </dependency>

    （2）在application.properties配置文件里配置springsession

    1. #配置springsession
    2. spring.session.store-type=redis
    3. server.servlet.session.timeout=30m
    4. #配置redis的ip地址
    5. spring.redis.host=192.168.241.128

    （3）在config配置中加入springSession配置类

    1. package com.saodai.saodaimall.order.config;
    2.  
    3. import org.springframework.context.annotation.Bean;
    4. import org.springframework.context.annotation.Configuration;
    5. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    6. import org.springframework.data.redis.serializer.RedisSerializer;
    7. import org.springframework.session.web.http.CookieSerializer;
    8. import org.springframework.session.web.http.DefaultCookieSerializer;
    9.  
    10.  
    11. /**
    12. * springSession配置类（所有要使用session的服务的session配置要一致）
    13. */
    14.  
    15. @Configuration
    16. public class GulimallSessionConfig {
    17.     
    18.     /**
    19.     * 配置session（主要是为了放大session作用域）
    20.     * @return
    21.     */
    22.     @Bean
    23.     public CookieSerializer cookieSerializer() {
    24.         
    25.         DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();
    26.         
    27.         //放大作用域
    28.         cookieSerializer.setDomainName("saodaimall.com");
    29.         cookieSerializer.setCookieName("SAODAISESSION");
    30.         
    31.         return cookieSerializer;
    32.     }
    33.     
    34.     
    35.     /**
    36.     * 配置Session放到redis存储的格式为json（其实就是json序列化）
    37.     * @return
    38.     */
    39.     @Bean
    40.     public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
    41.         return new GenericJackson2JsonRedisSerializer();
    42.     }
    43.     
    44. }

    （4）在启动类上添加@EnableRedisHttpSession注解

    1. package com.saodai.saodaimall.order;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    6. import org.springframework.cloud.openfeign.EnableFeignClients;
    7. import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;
    8.  
    9. /**
    10.  * 订单服务启动类
    11.  */
    12. @EnableFeignClients
    13. @EnableRedisHttpSession
    14. @EnableDiscoveryClient
    15. @SpringBootApplication
    16. public class SaodaimallOrderApplication {
    17.  
    18.     public static void main(String[] args) {
    19.         SpringApplication.run(SaodaimallOrderApplication.class, args);
    20.     }
    21.  
    22. }

    2、增加登录拦截器

    （1）点击去结算后会去订单详情确认页面，这个时候需要用户登录才可以去结算

    1. package com.saodai.saodaimall.order.interceptor;
    2.  
    3.  
    4. import com.saodai.common.vo.MemberResponseVo;
    5. import org.springframework.stereotype.Component;
    6. import org.springframework.util.AntPathMatcher;
    7. import org.springframework.web.servlet.HandlerInterceptor;
    8. import org.springframework.web.servlet.ModelAndView;
    9.  
    10. import javax.servlet.http.HttpServletRequest;
    11. import javax.servlet.http.HttpServletResponse;
    12.  
    13. import static com.saodai.common.constant.AuthServerConstant.LOGIN_USER;
    14.  
    15. /**
    16.  * 登录拦截器
    17.  */
    18. @Component
    19. public class LoginUserInterceptor implements HandlerInterceptor {
    20.  
    21.     public static ThreadLocal<MemberResponseVo> loginUser = new ThreadLocal<>();
    22.  
    23.     @Override
    24.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    25.  
    26.         /**
    27.          *直接放行的路径（也就是下面的两个路径不需要登录用于库存解锁）
    28.          */
    29.         String uri = request.getRequestURI();
    30.         AntPathMatcher antPathMatcher = new AntPathMatcher();
    31.         //根据订单号查询订单实体类
    32.         boolean match = antPathMatcher.match("/order/order/status/**", uri);
    33.         //支付宝支付成功后的异步回调
    34.         boolean match1 = antPathMatcher.match("/payed/notify", uri);
    35.         if (match || match1) {
    36.             return true;
    37.         }
    38.  
    39.         //获取登录的用户信息
    40.         MemberResponseVo attribute = (MemberResponseVo) request.getSession().getAttribute(LOGIN_USER);
    41.  
    42.         if (attribute != null) {
    43.             //把登录后用户的信息放在ThreadLocal里面进行保存
    44.             loginUser.set(attribute);
    45.  
    46.             return true;
    47.         } else {
    48.             //未登录，返回登录页面
    49.              request.getSession().setAttribute("msg", "请先进行登录");
    50.              response.sendRedirect("http://auth.saodaimall.com/login.html");
    51.             return false;
    52.         }
    53.     }
    54.  
    55.     @Override
    56.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    57.  
    58.     }
    59.  
    60.     @Override
    61.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    62.  
    63.     }
    64. }

    （2）一定要记得在SpringMVC的配置文件里注册拦截器，不然拦截器不会生效

    1. package com.saodai.saodaimall.order.config;
    2.  
    3.  
    4. import com.saodai.saodaimall.order.interceptor.LoginUserInterceptor;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.context.annotation.Configuration;
    7. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    8. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    9.  
    10. /**
    11.  * springmvc配置类
    12.  **/
    13.  
    14. @Configuration
    15. public class OrderWebConfig implements WebMvcConfigurer {
    16.  
    17.     @Autowired
    18.     private LoginUserInterceptor loginUserInterceptor;
    19.  
    20.     @Override
    21.     public void addInterceptors(InterceptorRegistry registry) {
    22.         registry.addInterceptor(loginUserInterceptor).addPathPatterns("/**");
    23.     }
    24. }

    3、根据订单业务需求抽取模型

    （1）订单确认页类OrderConfirmVo（也就是订单确认页需要用的数据）

    1. package com.saodai.saodaimall.order.vo;
    2.  
    3. import lombok.Getter;
    4. import lombok.Setter;
    5.  
    6. import java.math.BigDecimal;
    7. import java.util.List;
    8. import java.util.Map;
    9.  
    10. /**
    11.  * 订单确认页类（订单确认页需要用的数据）
    12.  **/
    14. public class OrderConfirmVo {
    15.  
    16.     @Getter @Setter
    17.     /** 会员收获地址列表 **/
    18.     List<MemberAddressVo> memberAddressVos;
    19.  
    20.     @Getter @Setter
    21.     /** 所有选中的购物项 **/
    22.     List<OrderItemVo> items;
    23.  
    24.     /** 发票记录 **/
    25.     @Getter @Setter
    26.     /** 优惠券（会员积分） **/
    27.     private Integer integration;
    28.  
    29.     /** 防止重复提交的令牌 **/
    30.     @Getter @Setter
    31.     private String orderToken;
    32.  
    33.     @Getter @Setter
    34.     Map<Long,Boolean> stocks;
    35.  
    36.     public Integer getCount() {
    37.         Integer count = 0;
    38.         if (items != null && items.size() > 0) {
    39.             for (OrderItemVo item : items) {
    40.                 count += item.getCount();
    41.             }
    42.         }
    43.         return count;
    44.     }
    45.  
    46.     /** 订单总额 **/
    47.     //BigDecimal total;
    48.     //计算订单总额
    49.     public BigDecimal getTotal() {
    50.         BigDecimal totalNum = BigDecimal.ZERO;
    51.         if (items != null && items.size() > 0) {
    52.             for (OrderItemVo item : items) {
    53.                 //计算当前商品的总价格
    54.                 BigDecimal itemPrice = item.getPrice().multiply(new BigDecimal(item.getCount().toString()));
    55.                 //再计算全部商品的总价格
    56.                 totalNum = totalNum.add(itemPrice);
    57.             }
    58.         }
    59.         return totalNum;
    60.     }
    61.  
    62.  
    63.  
    64.     /** 应付价格 **/
    65.     //BigDecimal payPrice;
    66.     public BigDecimal getPayPrice() {
    67.         return getTotal();
    68.     }
    69. }

    （2）订单项类OrderItemVo

    1. package com.saodai.saodaimall.order.vo;
    2.  
    3. import lombok.Data;
    4.  
    5. import java.math.BigDecimal;
    6. import java.util.List;
    7.  
    8. /**
    9.  * 订单项类（其实就是购物项）
    10.  **/
    12. @Data
    13. public class OrderItemVo {
    14.  
    15.     private Long skuId;
    16.  
    17.     //
    18.     private Boolean check;
    19.  
    20.     private String title;
    21.  
    22.     private String image;
    23.  
    24.     /**
    25.      * 商品套餐属性
    26.      */
    27.     private List<String> skuAttrValues;
    28.  
    29.     private BigDecimal price;
    30.  
    31.     private Integer count;
    32.  
    33.     private BigDecimal totalPrice;
    34.  
    35.     private Boolean hasStock;
    36.  
    37.     /** 商品重量 **/
    38.     private BigDecimal weight = new BigDecimal("0.085");
    39. }

    （3）用户收货信息类MemberAddressVo

    1. package com.saodai.saodaimall.order.vo;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6.  * 用户订单的地址
    7.  **/
    9. @Data
    10. public class MemberAddressVo {
    11.  
    12.     /**
    13.      * 地址id
    14.      */
    15.     private Long id;
    16.     /**
    17.      * member_id
    18.      */
    19.     private Long memberId;
    20.     /**
    21.      * 收货人姓名
    22.      */
    23.     private String name;
    24.     /**
    25.      * 电话
    26.      */
    27.     private String phone;
    28.     /**
    29.      * 邮政编码
    30.      */
    31.     private String postCode;
    32.     /**
    33.      * 省份/直辖市
    34.      */
    35.     private String province;
    36.     /**
    37.      * 城市
    38.      */
    39.     private String city;
    40.     /**
    41.      * 区
    42.      */
    43.     private String region;
    44.     /**
    45.      * 详细地址(街道)
    46.      */
    47.     private String detailAddress;
    48.     /**
    49.      * 省市区代码
    50.      */
    51.     private String areacode;
    52.     /**
    53.      * 是否默认
    54.      */
    55.     private Integer defaultStatus;
    56.  
    57. }

    4、点击去结算按钮（确认订单）

    （1）订单服务的web的OrderWebController控制器来处理/toTrade请求

    1. @Autowired
    2.     private OrderService orderService;
    3.  
    4.     /**
    5.      * 去结算确认页
    6.      * @param model
    7.      * @param request
    8.      * @return
    9.      * @throws ExecutionException
    10.      * @throws InterruptedException
    11.      */
    12.     @GetMapping(value = "/toTrade")
    13.     public String toTrade(Model model, HttpServletRequest request) throws ExecutionException, InterruptedException {
    14.  
    15.         OrderConfirmVo confirmVo = orderService.confirmOrder();
    16.  
    17.         model.addAttribute("confirmOrderData",confirmVo);
    18.         //展示订单确认的数据
    19.  
    20.         return "confirm";
    21.     }

    （2）处理/toTrade请求的confirmOrder方法具体实现

    流程：

    1、远程调用会员服务来查询所有的收获地址列表

    2、远程调用购物车服务来查询购物车所有选中的购物项

    3、远程调用库存服务来批量查询所有商品的库存是否有货

    4、查询用户积分

    5、生成一个防重令牌并放到redis中(防止表单重复提交),这格令牌是会过期的，过期时间为30分钟（注意是结算的时候服务器生成一个防重令牌，然后把这个令牌隐藏在订单页面，点击去结算只是生成这个令牌并存到redis中和订单页面上，下面的点击提交订单按钮才会做校验令牌，保证原子性，防刷这些操作）

    格式为key:order:token：+用户id，value:防重令牌

    1.   /**
    2.      * 去结算确认页时封装订单确认页返回需要用的数据
    3.      * @return
    4.      * @throws ExecutionException
    5.      * @throws InterruptedException
    6.      */
    7.     @Override
    8.     public OrderConfirmVo confirmOrder() throws ExecutionException, InterruptedException {
    9.  
    10.         //构建OrderConfirmVo
    11.         OrderConfirmVo confirmVo = new OrderConfirmVo();
    12.  
    13.         //获取当前用户登录的信息(直接获取)
    14.         MemberResponseVo memberResponseVo = LoginUserInterceptor.loginUser.get();
    15.  
    16.         //获取当前线程请求头信息(用于解决Feign异步调用丢失上下文的问题)
    17.         RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
    18.  
    19.         /**开启第一个异步任务来远程查询所有的收获地址列表**/
    20.         CompletableFuture<Void> addressFuture = CompletableFuture.runAsync(() -> {
    21.  
    22.             //每一个线程都来共享之前的请求数据(用于解决Feign异步调用丢失上下文的问题)
    23.             RequestContextHolder.setRequestAttributes(requestAttributes);
    24.  
    25.             //1、远程查询所有的收获地址列表
    26.             List<MemberAddressVo> address = memberFeignService.getAddress(memberResponseVo.getId());
    27.             confirmVo.setMemberAddressVos(address);
    28.         }, threadPoolExecutor);
    29.  
    30.         /**开启第二个异步任务来远程查询购物车所有选中的购物项**/
    31.         CompletableFuture<Void> cartInfoFuture = CompletableFuture.runAsync(() -> {
    32.  
    33.             //每一个线程都来共享之前的请求数据(用于解决Feign异步调用丢失上下文的问题)
    34.             RequestContextHolder.setRequestAttributes(requestAttributes);
    35.  
    36.             //2、远程查询购物车所有选中的购物项
    37.             List<OrderItemVo> currentCartItems = cartFeignService.getCurrentCartItems();
    38.             confirmVo.setItems(currentCartItems);
    39.             //feign在远程调用之前要构造请求，调用很多的拦截器
    40.         }, threadPoolExecutor).thenRunAsync(() -> {
    41.             /** 开启第三个异步任务来远程批量查询所有商品的库存是否有货**/
    42.             List<OrderItemVo> items = confirmVo.getItems();
    43.             //获取全部商品的id
    44.             List<Long> skuIds = items.stream().map((itemVo -> itemVo.getSkuId())).collect(Collectors.toList());
    45.  
    46.             //远程查询商品库存信息
    47.             R skuHasStock = wmsFeignService.getSkuHasStock(skuIds);
    48.            //SkuStockVo就是下面的SkuHasStockVo类
    49.             List<SkuStockVo> skuStockVos = skuHasStock.getData("data", new TypeReference<List<SkuStockVo>>() {});
    51.             if (skuStockVos != null && skuStockVos.size() > 0) {
    52.                 //将skuStockVos集合转换为map
    53.                 Map<Long, Boolean> skuHasStockMap = skuStockVos.stream().collect(Collectors.toMap(SkuStockVo::getSkuId, SkuStockVo::getHasStock));
    54.                 confirmVo.setStocks(skuHasStockMap);
    55.             }
    56.         },threadPoolExecutor);
    57.  
    58.         //3、查询用户积分
    59.         Integer integration = memberResponseVo.getIntegration();
    60.         confirmVo.setIntegration(integration);
    61.  
    62.         //4、价格数据由OrderConfirmVo的getTotal方法自动计算
    63.  
    64.         //TODO 5、防重令牌(防止表单重复提交)
    65.         //为用户设置一个token，三十分钟过期时间（存在redis）
    66.         String token = UUID.randomUUID().toString().replace("-", "");
    67.         //防重令牌一个放到redis里  USER_ORDER_TOKEN_PREFIX = "order:token"
    68.         redisTemplate.opsForValue().set(USER_ORDER_TOKEN_PREFIX+memberResponseVo.getId(),token,30, TimeUnit.MINUTES);
    69.         //防重令牌一个放到前台页面（不过隐藏了）
    70.         confirmVo.setOrderToken(token);
    71.  
    72.         //阻塞异步线程，只有两个异步都完成了才可以进行下一步
    73.         CompletableFuture.allOf(addressFuture,cartInfoFuture).get();
    74.  
    75.         return confirmVo;
    76.     }
    1. package com.saodai.common.vo;
    2.  
    3. import lombok.Data;
    4. import lombok.ToString;
    5.  
    6. import java.io.Serializable;
    7. import java.util.Date;
    8.  
    9. /**
    10.  *会员信息
    11.  **/
    13. @ToString
    14. @Data
    15. public class MemberResponseVo implements Serializable {
    16.  
    17.     private static final long serialVersionUID = 5573669251256409786L;
    18.  
    19.     private Long id;
    20.     /**
    21.      * 会员等级id
    22.      */
    23.     private Long levelId;
    24.     /**
    25.      * 用户名
    26.      */
    27.     private String username;
    28.     /**
    29.      * 密码
    30.      */
    31.     private String password;
    32.     /**
    33.      * 昵称
    34.      */
    35.     private String nickname;
    36.     /**
    37.      * 手机号码
    38.      */
    39.     private String mobile;
    40.     /**
    41.      * 邮箱
    42.      */
    43.     private String email;
    44.     /**
    45.      * 头像
    46.      */
    47.     private String header;
    48.     /**
    49.      * 性别
    50.      */
    51.     private Integer gender;
    52.     /**
    53.      * 生日
    54.      */
    55.     private Date birth;
    56.     /**
    57.      * 所在城市
    58.      */
    59.     private String city;
    60.     /**
    61.      * 职业
    62.      */
    63.     private String job;
    64.     /**
    65.      * 个性签名
    66.      */
    67.     private String sign;
    68.     /**
    69.      * 用户来源
    70.      */
    71.     private Integer sourceType;
    72.     /**
    73.      * 积分
    74.      */
    75.     private Integer integration;
    76.     /**
    77.      * 成长值
    78.      */
    79.     private Integer growth;
    80.     /**
    81.      * 启用状态
    82.      */
    83.     private Integer status;
    84.     /**
    85.      * 注册时间
    86.      */
    87.     private Date createTime;
    88.     /**
    89.      * 社交登录用户的ID
    90.      */
    91.     private String socialId;
    92.     /**
    93.      * 社交登录用户的名称
    94.      */
    95.     private String socialName;
    96.  
    97.     /**
    98.      * 社交登录用户的自我介绍
    99.      */
    100.     private String socialBio;
    101.  
    102.  
    103. }

    1>远程调用会员服务来查询所有的收获地址列表

    1.   @Autowired
    2.     private MemberReceiveAddressService memberReceiveAddressService;
    3.  
    4.     /**
    5.      * 根据会员id查询会员的所有地址（用于获取订单时远程的查询地址）
    6.      * @param memberId
    7.      * @return
    8.      */
    9.     @GetMapping(value = "/{memberId}/address")
    10.     public List<MemberReceiveAddressEntity> getAddress(@PathVariable("memberId") Long memberId) {
    11.  
    12.         List<MemberReceiveAddressEntity> addressList = memberReceiveAddressService.getAddress(memberId);
    13.  
    14.         return addressList;
    15.     }
    16. //根据会员id查询会员的所有地址（用于获取订单时远程的查询地址）
    17.     @Override
    18.     public List<MemberReceiveAddressEntity> getAddress(Long memberId) {
    19.          //MemberReceiveAddressEntity对象就是上面的用户收货信息类MemberAddressVo
    20.         List<MemberReceiveAddressEntity> addressList = this.baseMapper.selectList
    21.                 (new QueryWrapper<MemberReceiveAddressEntity>().eq("member_id", memberId));
    22.  
    23.         return addressList;
    24.     }

    2>远程调用购物车服务来查询购物车所有选中的购物项

    1. package com.saodai.saodaimall.order.feign;
    2.  
    3.  
    4. import com.saodai.saodaimall.order.vo.OrderItemVo;
    5. import org.springframework.cloud.openfeign.FeignClient;
    6. import org.springframework.web.bind.annotation.GetMapping;
    7.  
    8. import java.util.List;
    9.  
    10. /**
    11.  * 远程调用购物车服务
    12.  **/
    14. @FeignClient("saodaimall-cart")
    15. public interface CartFeignService {
    16.  
    17.     /**
    18.      * 查询当前用户购物车选中的商品项
    19.      * @return
    20.      */
    21.     @GetMapping(value = "/currentUserCartItems")
    22.     List<OrderItemVo> getCurrentCartItems();
    23.  
    24. }
    25.     @Resource
    26.     private CartService cartService;
    27.  
    28.     /**
    29.      * 获取当前用户的购物车商品项（订单生成需要查询用户购物车中选择的购物项）
    30.      * @return
    31.      */
    32.     @GetMapping(value = "/currentUserCartItems")
    33.     @ResponseBody
    34.     public List<CartItemVo> getCurrentCartItems() {
    35.  
    36.         List<CartItemVo> cartItemVoList = cartService.getUserCartItems();
    37.  
    38.         return cartItemVoList;
    39.     }

    查询购物车所有选中的购物项分流程：

    1、获取当前用户登录的信息来判断登录没

    2、组装Redis中的HashMap结构的Hash值，用来绑定Hash操作（这里的购物车和购物项的数据都是存到Reids缓存里的，格式为Hash值：saodaimall:cart:10290038，key：39，value：CartItemVo对象的String类型，其中10290038是用户id，39是skuId）

    3、调用getCartItems方法来把所有的value值取出来并都封装成CartItemVo对象（注意每一个Hash值对应一个用户的购物车，所以其中的key和value合在一起表示每个购物项）

    4、远程调用商品服务来查询每个商品的最新价格（由于redis缓存中的数据可能不是最新的数据）

    1.    /**
    2.      * 获取当前用户的购物车商品项（订单生成需要查询用户购物车中选择的购物项）
    3.      * @return
    4.      */
    5.     @Override
    6.     public List<CartItemVo> getUserCartItems() {
    7.  
    8.         List<CartItemVo> cartItemVoList = new ArrayList<>();
    9.         //获取当前用户登录的信息
    10.         UserInfoTo userInfoTo = CartInterceptor.toThreadLocal.get();
    11.         //如果用户未登录直接返回null
    12.         // userInfoTo.getUserId()== null是因为拦截器判断用户登录了就设置其userId
    13.         // 没有登录就设置userKey，所以不能像以前那样直接就用userInfoTo==null来判断
    14.         if (userInfoTo.getUserId() == null) {
    15.             return null;
    16.         } else {
    17.             //获取购物车项  String CART_PREFIX = "saodaimall:cart:"是Hash值
    18.             String cartKey = CART_PREFIX + userInfoTo.getUserId();
    19.             //把Hash值传给getCartItems来获取购物车的所有购物项
    20.             List<CartItemVo> cartItems = getCartItems(cartKey);
    21.             if (cartItems == null) {
    22.                 throw new CartExceptionHandler();
    23.             }
    24.             //由于redis缓存中的数据可能不是最新的数据，所以要远程在查一次价格
    25.             cartItemVoList = cartItems.stream()
    26.                     .filter(items -> items.getCheck())
    27.                     .map(item -> {
    28.                         //更新为最新的价格（远程调用商品服务来查询数据库）
    29.                         BigDecimal price = productFeignService.getPrice(item.getSkuId());
    30.                         item.setPrice(price);
    31.                         return item;
    32.                     })
    33.                     .collect(Collectors.toList());
    34.         }
    35.  
    36.         return cartItemVoList;
    37.     }
    38.  
    39.     /**
    40.      * 获取购物车里面的数据
    41.      * @param cartKey redis中的外围map的key值
    42.      * @return
    43.      */
    44.     private List<CartItemVo> getCartItems(String cartKey) {
    45.         //获取购物车里面的所有商品
    46.         BoundHashOperations<String, Object, Object> operations = redisTemplate.boundHashOps(cartKey);
    47.         //注意这里从Reids中取出来的是Object类型
    48.         List<Object> values = operations.values();
    49.         if (values != null && values.size() > 0) {
    50.             List<CartItemVo> cartItemVoStream = values.stream().map((obj) -> {
    51.                 //这里要转为String类型是因为reids中取出来的是Obhect类型
    52.                 String str = (String) obj;
    53.                 //在把String转为CartItemVo对象
    54.                 CartItemVo cartItem = JSON.parseObject(str, CartItemVo.class);
    55.                 return cartItem;
    56.             }).collect(Collectors.toList());
    57.             return cartItemVoStream;
    58.         }
    59.         return null;
    60.  
    61.     }
    62.     @Autowired
    63.     private SkuInfoService skuInfoService;
    64.  
    65.     /**
    66.      * 根据skuId查询当前商品的价格（订单生成需要查询用户购物车中选择的购物项时的最新价格）
    67.      * @param skuId
    68.      * @return
    69.      */
    70.     @GetMapping(value = "/{skuId}/price")
    71.     public BigDecimal getPrice(@PathVariable("skuId") Long skuId) {
    72.  
    73.         //获取当前商品的信息(skuInfoService.getById()这个方法是代码构造器自动生成的代码里有的)
    74.         SkuInfoEntity skuInfo = skuInfoService.getById(skuId);
    75.  
    76.         //获取商品的价格
    77.         BigDecimal price = skuInfo.getPrice();
    78.  
    79.         return price;
    80.     }

    3>远程调用库存服务来批量查询所有商品的库存是否有货

    1. /**
    2.      * 查询sku是否有库存（商品服务的saveSpuInfoImpl中up方法要用到的，去结算确认页时批量查询有货没也要用到）
    3.      * @return
    4.      */
    5.     @PostMapping("/hasstock")
    6.     public R getSkusHasStock(@RequestBody List<Long> skuIds){
    7.         List<SkuHasStockVo> vos = wareSkuService.getSkusHasStock(skuIds);
    8.         return R.ok().setData(vos);
    9.     }
    10.     //查询sku是否有库存（saveSpuInfo中up方法要用到的）
    11.     @Override
    12.     public List<SkuHasStockVo> getSkusHasStock(List<Long> skuIds) {
    13.         List<SkuHasStockVo> skuHasStockVos = skuIds.stream().map(skuId -> {
    14.             SkuHasStockVo vo = new SkuHasStockVo();
    15.             //查询当前sku的总库存量
    16.             Long count = baseMapper.getSkuStock(skuId);
    17.             vo.setSkuId(skuId);
    18.             vo.setHasStock(count==null?false:true);
    19.             return vo;
    20.         }).collect(Collectors.toList());
    21.         return skuHasStockVos;
    22.     }
    23. <!--    查询当前sku的总库存量-->
    24. <select id="getSkuStock" resultType="java.lang.Long">
    25.   SELECT SUM(stock - stock_locked) FROM wms_ware_sku WHERE sku_id = #{skuId}
    26. </select>
    1. package com.saodai.saodaimall.ware.vo;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6. *查询sku是否有库存的封装类
    7. **/
    8.  
    9. @Data
    10. public class SkuHasStockVo {
    11.     
    12.     private Long skuId;
    13.     //有没有库存
    14.     private Boolean hasStock;
    15.     
    16. }

    5、订单确认页面的渲染

    （1）收货人信息渲染

    1. <p class="p1">填写并核对订单信息 <span style="color: red" th:if="${msg}!=null" > <b>提交订单失败!失败原因是：[[${msg}]]</b></span> </p>
    2. <div class="section">
    3.   <!--收货人信息-->
    4.   <div class="top-2">
    5.     <span>收货人信息</span>
    6.     <span>新增收货地址</span>
    7.   </div>
    8.   
    9.   <!--地址-->
    10.   <div class="top-3 addr-item" th:each="addr:${confirmOrderData.memberAddressVos}">
    11.     <p th:attr="def=${addr.defaultStatus},addrId=${addr.id}">[[${addr.name}]]</p><span>[[${addr.name}]]  [[${addr.province}]]  [[${addr.city}]] [[${addr.region}]] [[${addr.detailAddress}]]  [[${addr.phone}]]</span>
    12.   </div>
    13.   <p class="p2">更多地址︾</p>
    14.   <div class="hh1"/>
    15. </div>

    （2）购物项信息的渲染

    1. <!--图片-->
    2. <div class="yun1" th:each="item:${confirmOrderData.items}">
    3.   <img th:src="${item.image}" class="yun"/>
    4.   <div class="mi">
    5.     <p>[[${item.title}]]<span style="color: red;" th:text="'￥' + ${#numbers.formatDecimal(item.price,3,2)}"> ￥ 499.00</span>
    6.       <span> [[${item.count}]] </span> <span> [[${confirmOrderData.stocks[item.skuId]?"有货":"无货"}]]</span>
    7.     </p>
    8.     <p><span>[[${item.weight}]]kg</span></p>
    9.     <p class="tui-1"><img src="/static/order/confirm/img/i_07.png"/>支持7天无理由退货</p>
    10.   </div>
    11. </div>

    （3）结算区域的渲染

    1. <div class="xia">
    2.     <div class="qian">
    3.         <p class="qian_y">
    4.             <span>[[${confirmOrderData.count}]]</span>
    5.             <span>件商品，总商品金额：</span>
    6.             <span class="rmb">￥[[${#numbers.formatDecimal(confirmOrderData.total, 1, 2)}]]</span>
    7.         </p>
    8.         <p class="qian_y">
    9.             <span>返现：</span>
    10.             <span class="rmb">  -￥0.00</span>
    11.         </p>
    12.         <p class="qian_y">
    13.             <span>运费： </span>
    14.             <span class="rmb"> &nbsp ￥<b id="fare"></b></span>
    15.         </p>
    16.         <p class="qian_y">
    17.             <span>服务费： </span>
    18.             <span class="rmb"> &nbsp ￥0.00</span>
    19.         </p>
    20.         <p class="qian_y">
    21.             <span>退换无忧： </span>
    22.             <span class="rmb"> &nbsp ￥0.00</span>
    23.         </p>
    24.  
    25.     </div>
    26.  
    27.     <div class="yfze">
    28.         <p class="yfze_a"><span class="z">应付总额：</span><span class="hq">￥<b id="payPrice">[[${#numbers.formatDecimal(confirmOrderData.payPrice, 1, 2)}]]</b></span>
    29.         </p>
    30.         <p class="yfze_b">寄送至： <span id="receiveAddress"></span> 收货人：<span id="receiver"></span></p>
    31.     </div>
    32.     <form action="http://order.saodaimall.com/submitOrder" method="post">
    33.         <input id="addrInput" type="hidden" name="addrId" />
    34.         <input id="payPriceInput" type="hidden" name="payPrice">
    35.         <input name="orderToken" th:value="${confirmOrderData.orderToken}" type="hidden"/>
    36.         <button class="tijiao" type="submit" >提交订单</button>
    37.     </form>
    38. </div>

    6、运费的模拟

    （1）直接从confirm.html页面的js代码发的请求去查运费

    1. //查运费
    2. function getFare(addrId) {
    3.     //给表单回填选择的地址
    4.     $("#addrInput").val(addrId);
    5.     $.get("http://saodaimall.com/api/ware/wareinfo/fare?addrId=" + addrId, function (resp) {
    6.         console.log(resp);
    7.         $("#fare").text(resp.data.fare);
    8.         var total = [[${confirmOrderData.total}]];
    9.         
    10.         var payPrice = total * 1 + resp.data.fare * 1;
    11.         //设置运费
    12.         $("#payPrice").text(payPrice);
    13.         $("#payPriceInput").val(payPrice);
    14.         
    15.         //设置收获地址人信息
    16.         $("#receiveAddress").text(resp.data.address.province + " " + resp.data.address.city + " " + " " + resp.data.address.region + resp.data.address.detailAddress);
    17.         $("#receiver").text(resp.data.address.name);
    18.     })
    19.     }

    （2）这个请求由库存服务的WareInfoController控制器来处理

    1.   /**
    2.      * 获取运费信息（订单结算界面时）
    3.      * @return
    4.      */
    5.     @GetMapping(value = "/fare")
    6.     public R getFare(@RequestParam("addrId") Long addrId) {
    7.  
    8.         FareVo fare = wareInfoService.getFare(addrId);
    9.  
    10.         return R.ok().setData(fare);
    11.     }

    分流程：

    1、远程调用会员服务的MemberReceiveAddressController控制器来查找用户收货信息MemberAddressVo对象

    2、截取用户手机号码最后一位作运费计算

    1.  /**
    2.      * 获取运费信息（订单结算界面时）
    3.      * @param addrId
    4.      * @return
    5.      */
    6.     @Override
    7.     public FareVo getFare(Long addrId) {
    8.  
    9.         FareVo fareVo = new FareVo();
    10.  
    11.         //收获地址的详细信息
    12.         R addrInfo = memberFeignService.info(addrId);
    13.  
    14.         MemberAddressVo memberAddressVo = addrInfo.getData("memberReceiveAddress",new TypeReference<MemberAddressVo>() {});
    15.  
    16.         if (memberAddressVo != null) {
    17.             String phone = memberAddressVo.getPhone();
    18.             //截取用户手机号码最后一位作为我们的运费计算
    19.             //1558022051
    20.             String fare = phone.substring(phone.length() - 1, phone.length());
    21.             BigDecimal bigDecimal = new BigDecimal(fare);
    22.  
    23.             fareVo.setFare(bigDecimal);
    24.             fareVo.setAddress(memberAddressVo);
    25.  
    26.             return fareVo;
    27.         }
    28.         return null;
    29.     }
    1. package com.saodai.saodaimall.ware.vo;
    2.  
    3. import lombok.Data;
    4.  
    5. import java.math.BigDecimal;
    6.  
    7. /**
    8.  *运费vo类
    9.  **/
    10.  
    11. @Data
    12. public class FareVo {
    13.  
    14.     //用户信息
    15.     private MemberAddressVo address;
    16.     //运费
    17.     private BigDecimal fare;
    18.  
    19. }
    1. package com.saodai.saodaimall.ware.vo;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6.  * 会员信息
    7.  **/
    9. @Data
    10. public class MemberAddressVo {
    11.  
    12.     private Long id;
    13.     /**
    14.      * member_id
    15.      */
    16.     private Long memberId;
    17.     /**
    18.      * 收货人姓名
    19.      */
    20.     private String name;
    21.     /**
    22.      * 电话
    23.      */
    24.     private String phone;
    25.     /**
    26.      * 邮政编码
    27.      */
    28.     private String postCode;
    29.     /**
    30.      * 省份/直辖市
    31.      */
    32.     private String province;
    33.     /**
    34.      * 城市
    35.      */
    36.     private String city;
    37.     /**
    38.      * 区
    39.      */
    40.     private String region;
    41.     /**
    42.      * 详细地址(街道)
    43.      */
    44.     private String detailAddress;
    45.     /**
    46.      * 省市区代码
    47.      */
    48.     private String areacode;
    49.     /**
    50.      * 是否默认
    51.      */
    52.     private Integer defaultStatus;
    53.  
    54. }
    55.    /**
    56.      * 根据地址id找到地址信息
    57.      */
    58.     @RequestMapping("/info/{id}")
    59.     //@RequiresPermissions("member:memberreceiveaddress:info")
    60.     public R info(@PathVariable("id") Long id){
    61. 		MemberReceiveAddressEntity memberReceiveAddress = memberReceiveAddressService.getById(id);
    62.  
    63.         return R.ok().put("memberReceiveAddress", memberReceiveAddress);
    64.     }

    7、提交订单（点击提交订单按钮，下单）

    （1）订单服务的web的OrderWebController控制器来处理/submitOrder请求

    1.    /**
    2.      * 下单功能（提交订单）
    3.      * @param vo 
    4.      * OrderSubmitVo对象是确认订单页面的部分数据，自动封装好的，因为后面提交订单需要这些数据
    5.      * @return
    6.      */
    7.     @PostMapping(value = "/submitOrder")
    8.     public String submitOrder(OrderSubmitVo vo, Model model, RedirectAttributes attributes) {
    9.  
    10.         //这里进行异常处理是为了防止出错导致系统奔溃，即使出错了也可以保证跳转到提交订单的界面
    11.         try {
    12.             SubmitOrderResponseVo responseVo = orderService.submitOrder(vo);
    13.             //下单成功来到支付选择页
    14.             //下单失败回到订单确认页重新确定订单信息
    15.             if (responseVo.getCode() == 0) {
    16.                 //成功
    17.                 model.addAttribute("submitOrderResp",responseVo);
    18.                 return "pay";
    19.             } else {
    20.                 String msg = "下单失败";
    21.                 switch (responseVo.getCode()) {
    22.                     case 1: msg += "令牌订单信息过期，请刷新再次提交"; break;
    23.                     case 2: msg += "订单商品价格发生变化，请确认后再次提交"; break;
    24.                     case 3: msg += "商品库存不足"; break;
    25.                 }
    26.                 attributes.addFlashAttribute("msg",msg);
    27.                 return "redirect:http://order.saodaimall.com/toTrade";
    28.             }
    29.         } catch (Exception e) {
    30.  
    31.             if (e instanceof NoStockException) {
    32.                 String message = ((NoStockException)e).getMessage();
    33.                 attributes.addFlashAttribute("msg",message);
    34.             }
    35.             return "redirect:http://order.saodaimall.com/toTrade";
    36.         }
    37.     }

    OrderSubmitVo对象是确认订单页面的部分数据，自动封装好的，因为后面提交订单需要这些数据

    1. package com.saodai.saodaimall.order.vo;
    2.  
    3. import lombok.Data;
    4.  
    5. import java.math.BigDecimal;
    6.  
    7. /**
    8.  * 封装订单提交数据的vo
    9.  **/
    11. @Data
    12. public class OrderSubmitVo {
    13.  
    14.     /** 收获地址的id **/
    15.     private Long addrId;
    16.  
    17.     /** 支付方式 **/
    18.     private Integer payType;
    19.     //无需提交要购买的商品，去购物车再获取一遍
    20.     //优惠、发票
    21.  
    22.     /** 防重令牌 **/
    23.     private String orderToken;
    24.  
    25.     /** 应付价格 **/
    26.     private BigDecimal payPrice;
    27.  
    28.     /** 订单备注 **/
    29.     private String remarks;
    30.  
    31.     //用户相关的信息，直接去session中取出即可
    32. }

    （2）OrderServiceImpl的submitOrder方法的具体实现

    注意：这个submitOrder方法方法非常复杂，可以从对象的封装来一步步理解

    1.  /**
    2.      * 获取运费信息（订单结算界面时）
    3.      * @return
    4.      */
    5.     @GetMapping(value = "/fare")
    6.     public R getFare(@RequestParam("addrId") Long addrId) {
    7.  
    8.         FareVo fare = wareInfoService.getFare(addrId);
    9.  
    10.         return R.ok().setData(fare);
    11.     }
    12.    
    13.    private ThreadLocal<OrderSubmitVo> confirmVoThreadLocal = new ThreadLocal<>();
    14.  
    15.     @Autowired
    16.     private MemberFeignService memberFeignService;
    17.  
    18.     @Autowired
    19.     private CartFeignService cartFeignService;
    20.  
    21.     @Autowired
    22.     private WmsFeignService wmsFeignService;
    23.  
    24.     @Autowired
    25.     private ProductFeignService productFeignService;
    26.  
    27.     @Autowired
    28.     private OrderItemService orderItemService;
    29.  
    30.     @Autowired
    31.     private StringRedisTemplate redisTemplate;
    32.  
    33.     @Autowired
    34.     private RabbitTemplate rabbitTemplate; 
    35.  
    36.     /**
    37.      *  创建订单（下单）
    38.      * // @Transactional(isolation = Isolation.READ_COMMITTED) 设置事务的隔离级别
    39.      * // @Transactional(propagation = Propagation.REQUIRED)   设置事务的传播级别
    40.      *
    41.      */
    42.     @Transactional(rollbackFor = Exception.class)
    43.     @Override
    44.     public SubmitOrderResponseVo submitOrder(OrderSubmitVo vo) {
    45.         //把OrderSubmitVo对象放到本地线程，方便后面共享
    46.         confirmVoThreadLocal.set(vo);
    47.  
    48.         SubmitOrderResponseVo responseVo = new SubmitOrderResponseVo();
    49.         //去创建、下订单、验令牌、验价格、锁定库存...
    50.  
    51.         //获取当前用户登录的信息
    52.         MemberResponseVo memberResponseVo = LoginUserInterceptor.loginUser.get();
    53.         //所在默认状态码为0表示没有异常
    54.         responseVo.setCode(0);
    55.  
    56.         /**1、验证令牌是否合法【令牌的对比和删除必须保证原子性】**/
    57.         String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
    58.         String orderToken = vo.getOrderToken();
    59.  
    60.         //通过lure脚本原子验证令牌和删除令牌（执行脚本后返回long类型的0或1，0表示令牌验证失败，1表示成功）
    61.         //Arrays.asList(USER_ORDER_TOKEN_PREFIX + memberResponseVo.getId())表示存到redis里的值
    62.         //   orderToken是页面传过来的令牌（表示当前需要验证的值）
    63.         Long result = redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class),
    64.                 Arrays.asList(USER_ORDER_TOKEN_PREFIX + memberResponseVo.getId()),
    65.                 orderToken);
    66.  
    67.         if (result == 0L) {
    68.             //令牌验证失败
    69.             responseVo.setCode(1);
    70.             return responseVo;
    71.         } else {
    72.             //令牌验证成功
    73.             /**2、创建订单、订单项等信息（抽取成createOrder方法）**/
    74.             OrderCreateTo order = createOrder();
    75.  
    76.             //后端计算出的价格
    77.             BigDecimal payAmount = order.getOrder().getPayAmount();
    78.             //前端界面传来的价格
    79.             BigDecimal payPrice = vo.getPayPrice();
    80.             //只要这两个的差值小于0.01都是可以接受的
    81.             /**3、验证前端界面传来的价格和计算后的价格是否相同（验价）**/
    82.             if (Math.abs(payAmount.subtract(payPrice).doubleValue()) < 0.01) {
    83.                 //金额对比
    84.                /**4、保存订单信息**/
    85.                 saveOrder(order);
    86.  
    87.                 //4、库存锁定,只要有异常，回滚订单数据
    88.                 //订单号、所有订单项信息(skuId,skuNum,skuName)
    89.                 WareSkuLockVo lockVo = new WareSkuLockVo();
    90.                 lockVo.setOrderSn(order.getOrder().getOrderSn());
    91.  
    92.                 //获取出要锁定的商品数据信息
    93.                 List<OrderItemVo> orderItemVos = order.getOrderItems().stream().map((item) -> {
    94.                     OrderItemVo orderItemVo = new OrderItemVo();
    95.                     orderItemVo.setSkuId(item.getSkuId());
    96.                     orderItemVo.setCount(item.getSkuQuantity());
    97.                     orderItemVo.setTitle(item.getSkuName());
    98.                     return orderItemVo;
    99.                 }).collect(Collectors.toList());
    100.                 lockVo.setLocks(orderItemVos);
    101.  
    102.                 //TODO 调用远程锁定库存的方法
    103.                 //出现的问题：扣减库存成功了，但是由于网络原因超时，出现异常，导致订单事务回滚，库存事务不回滚(解决方案：seata)
    104.                 //为了保证高并发，不推荐使用seata，因为是加锁，并行化，提升不了效率,可以发消息给库存服务
    105.                 R r = wmsFeignService.orderLockStock(lockVo);
    106.  
    107.  
    108.                 if (r.getCode() == 0) {
    109.                     //锁定成功
    110.                     responseVo.setOrder(order.getOrder());
    111. //                     int i = 10/0;
    112.  
    113.                     //这里使用消息队列是用于处理超过指定时间还未支付的订单（也就是把这些订单给取消）
    114.                     /**
    115.                      * 订单创建成功，发送消息给MQ交换机order-event-exchange，交换机根据路由键order.create.order把消息放到延时队列order.delay.queue
    116.                      * 当消息在延时队列里等待了指定的时间后还没有被消费就会再次由交换机路由到队列order.release.order
    117.                      * 这个设置是在MyRabbitMQConfig中指定的 arguments.put("x-dead-letter-routing-key", "order.release.order");
    118.                      */
    119.                     rabbitTemplate.convertAndSend("order-event-exchange","order.create.order",order.getOrder());
    120.  
    121.                     //删除购物车里的数据
    122. //                    redisTemplate.delete(CART_PREFIX+memberResponseVo.getId());
    123.                     return responseVo;
    124.                 } else {
    125.                     //锁定失败
    126. //                    String msg = (String) r.get("msg");
    127. //                    throw new NoStockException(msg);
    128.                     /**
    129.                      *        Code 1: "令牌订单信息过期，请刷新再次提交";
    130.                      *        Code 2: "订单商品价格发生变化，请确认后再次提交";
    131.                      *        Code 3: "商品库存不足";
    132.                      */
    133.                      responseVo.setCode(3);
    134.                      return responseVo;
    135.                 }
    136.  
    137.             } else {
    138.                 responseVo.setCode(2);
    139.                 return responseVo;
    140.             }
    141.         }
    142.     }
    143.  
    144.     /**
    145.      * 创建订单
    146.      */
    147.     private OrderCreateTo createOrder() {
    148.  
    149.         OrderCreateTo createTo = new OrderCreateTo();
    150.  
    151.         //1、生成订单号（IdWorker.getTimeId()是jdk提供的生成订单订单号的方法）
    152.         String orderSn = IdWorker.getTimeId();
    153.          //订单构造（将订单构造抽取为builderOrder方法）
    154.         OrderEntity orderEntity = builderOrder(orderSn);
    155.  
    156.         //2、获取到所有的订单项（将所有订单项构造抽取为builderOrderItems方法）
    157.         List<OrderItemEntity> orderItemEntities = builderOrderItems(orderSn);
    158.  
    159.         //3、计算订单各种价格(总价，优惠价，积分价等等)
    160.         computePrice(orderEntity,orderItemEntities);
    161.  
    162.         createTo.setOrder(orderEntity);
    163.         createTo.setOrderItems(orderItemEntities);
    164.  
    165.         return createTo;
    166.     }
    167.  
    168.     /**
    169.      *   构建订单数据
    170.      * @param orderSn 订单号
    171.      * @return
    172.      */
    173.     private OrderEntity builderOrder(String orderSn) {
    174.         
    175.         /**通过拦截器中线程共享数据来获取当前用户登录信息**/
    176.         MemberResponseVo memberResponseVo = LoginUserInterceptor.loginUser.get();
    177.  
    178.         OrderEntity orderEntity = new OrderEntity();
    179.         orderEntity.setMemberId(memberResponseVo.getId());
    180.         orderEntity.setOrderSn(orderSn);
    181.         orderEntity.setMemberUsername(memberResponseVo.getUsername());
    182.  
    183.         /**通过线程共享数据来获取地址id信息**/
    184.         OrderSubmitVo orderSubmitVo = confirmVoThreadLocal.get();
    185.  
    186.  
    187.         /**通过远程获取收货地址和运费信息来**/
    188.         R fareAddressVo = wmsFeignService.getFare(orderSubmitVo.getAddrId());
    189.         FareVo fareResp = fareAddressVo.getData("data", new TypeReference<FareVo>() {});
    190.  
    191.         //获取到运费信息
    192.         BigDecimal fare = fareResp.getFare();
    193.         orderEntity.setFreightAmount(fare);
    194.  
    195.         //获取到收货地址信息
    196.         MemberAddressVo address = fareResp.getAddress();
    197.         //设置收货人信息
    198.         orderEntity.setReceiverName(address.getName());
    199.         orderEntity.setReceiverPhone(address.getPhone());
    200.         //设置收货人邮编
    201.         orderEntity.setReceiverPostCode(address.getPostCode());
    202.         orderEntity.setReceiverProvince(address.getProvince());
    203.         orderEntity.setReceiverCity(address.getCity());
    204.         //设置地区
    205.         orderEntity.setReceiverRegion(address.getRegion());
    206.         //设置详细地址
    207.         orderEntity.setReceiverDetailAddress(address.getDetailAddress());
    208.  
    209.         //设置订单相关的状态信息  CREATE_NEW(0,"待付款")
    210.         orderEntity.setStatus(OrderStatusEnum.CREATE_NEW.getCode());
    211.          //设置自动确认时间（天）
    212.         orderEntity.setAutoConfirmDay(7);
    213.         //设置确认收货状态[0->未确认；1->已确认]
    214.         orderEntity.setConfirmStatus(0);
    215.         return orderEntity;
    216.     }
    217.  
    218.  
    219.     /**
    220.      * 构建所有订单项数据
    221.      * @param orderSn 订单号
    222.      * @return
    223.      */
    224.     public List<OrderItemEntity> builderOrderItems(String orderSn) {
    225.         List<OrderItemEntity> orderItemEntityList = new ArrayList<>();
    226.  
    227.         //最后确定每个购物项的价格
    228.         List<OrderItemVo> currentCartItems = cartFeignService.getCurrentCartItems();
    229.         if (currentCartItems != null && currentCartItems.size() > 0) {
    230.             orderItemEntityList = currentCartItems.stream().map((items) -> {
    231.                 //构建订单项数据
    232.                 OrderItemEntity orderItemEntity = builderOrderItem(items);
    233.                 orderItemEntity.setOrderSn(orderSn);
    234.  
    235.                 return orderItemEntity;
    236.             }).collect(Collectors.toList());
    237.         }
    238.         return orderItemEntityList;
    239.     }
    240.     /**
    241.      * 构建某一个订单项的数据
    242.      * @param items 购物项
    243.      * @return
    244.      */
    245.     private OrderItemEntity builderOrderItem(OrderItemVo items) {
    246.  
    247.         OrderItemEntity orderItemEntity = new OrderItemEntity();
    248.  
    249.         //1、商品的spu信息
    250.         Long skuId = items.getSkuId();
    251.  
    252.         /**远程调用商品服务来获取spu的信息**/
    253.         R spuInfo = productFeignService.getSpuInfoBySkuId(skuId);
    254.         SpuInfoVo spuInfoData = spuInfo.getData("data", new TypeReference<SpuInfoVo>() {
    255.         });
    256.         orderItemEntity.setSpuId(spuInfoData.getId());
    257.         orderItemEntity.setSpuName(spuInfoData.getSpuName());
    258.         orderItemEntity.setSpuBrand(spuInfoData.getBrandName());
    259.         orderItemEntity.setCategoryId(spuInfoData.getCatalogId());
    260.  
    261.         //2、商品的sku信息
    262.         orderItemEntity.setSkuId(skuId);
    263.         orderItemEntity.setSkuName(items.getTitle());
    264.         //设置商品sku图片
    265.         orderItemEntity.setSkuPic(items.getImage());
    266.          //设置商品sku价格
    267.         orderItemEntity.setSkuPrice(items.getPrice());
    268.          //商品购买的数量
    269.         orderItemEntity.setSkuQuantity(items.getCount());
    270.  
    271.         //使用StringUtils.collectionToDelimitedString将list集合转换为String
    272.         String skuAttrValues = StringUtils.collectionToDelimitedString(items.getSkuAttrValues(), ";");
    273.         //设置商品销售属性组合（JSON）
    274.         orderItemEntity.setSkuAttrsVals(skuAttrValues);
    275.  
    276.         //3、商品的优惠信息
    277.  
    278.         //4、商品的积分信息
    279.          //设置赠送成长值
    280.         orderItemEntity.setGiftGrowth(items.getPrice().multiply(new BigDecimal(items.getCount())).intValue());
    281.          //设置赠送积分
    282.         orderItemEntity.setGiftIntegration(items.getPrice().multiply(new BigDecimal(items.getCount())).intValue());
    283.  
    284.         //5、订单项的价格信息
    285.         //设置商品促销分解金额
    286.         orderItemEntity.setPromotionAmount(BigDecimal.ZERO);
    287.         //设置优惠券优惠分解金额
    288.         orderItemEntity.setCouponAmount(BigDecimal.ZERO);
    289.         //设置积分优惠分解金额
    290.         orderItemEntity.setIntegrationAmount(BigDecimal.ZERO);
    291.  
    292.         //当前订单项的实际金额.总额 - 各种优惠价格
    293.         //原来的价格    orderItemEntity.getSkuQuantity()是获取商品购买的数量
    294.         BigDecimal origin = orderItemEntity.getSkuPrice().multiply(new BigDecimal(orderItemEntity.getSkuQuantity().toString()));
    295.         //原价减去优惠价得到最终的价格
    296.         BigDecimal subtract = origin.subtract(orderItemEntity.getCouponAmount())
    297.                 .subtract(orderItemEntity.getPromotionAmount())
    298.                 .subtract(orderItemEntity.getIntegrationAmount());
    299.         orderItemEntity.setRealAmount(subtract);
    300.  
    301.         return orderItemEntity;
    302.     }
    303.  
    304.  
    305.     /**
    306.      * 保存订单所有数据
    307.      * @param orderCreateTo
    308.      */
    309.     private void saveOrder(OrderCreateTo orderCreateTo) {
    310.  
    311.         //获取订单信息
    312.         OrderEntity order = orderCreateTo.getOrder();
    313.         order.setModifyTime(new Date());
    314.         order.setCreateTime(new Date());
    315.         //保存订单
    316.         this.baseMapper.insert(order);
    317.  
    318.         //获取订单项信息
    319.         List<OrderItemEntity> orderItems = orderCreateTo.getOrderItems();
    320.         //批量保存订单项数据（代码构造器自动生成的方法）
    321.         orderItemService.saveBatch(orderItems);
    322.     }
    323.     /**
    324.      *  计算价格的方法
    325.      */
    326.     private void computePrice(OrderEntity orderEntity, List<OrderItemEntity> orderItemEntities) {
    327.  
    328.         //总价
    329.         BigDecimal total = new BigDecimal("0.0");
    330.         //优惠券优惠分解金额
    331.         BigDecimal coupon = new BigDecimal("0.0");
    332.         //积分优惠分解金额
    333.         BigDecimal intergration = new BigDecimal("0.0");
    334.         //商品促销分解金额
    335.         BigDecimal promotion = new BigDecimal("0.0");
    336.  
    337.         //积分、成长值
    338.         Integer integrationTotal = 0;
    339.         Integer growthTotal = 0;
    340.  
    341.         //订单总额，叠加每一个订单项的总额信息
    342.         for (OrderItemEntity orderItem : orderItemEntities) {
    343.             //优惠券优惠总金额
    344.             coupon = coupon.add(orderItem.getCouponAmount());
    345.             //商品促销总金额
    346.             promotion = promotion.add(orderItem.getPromotionAmount());
    347.             //积分优惠总金额
    348.             intergration = intergration.add(orderItem.getIntegrationAmount());
    349.  
    350.             //总价
    351.             total = total.add(orderItem.getRealAmount());
    352.  
    353.             //赠送总积分
    354.             integrationTotal += orderItem.getGiftIntegration();
    355.             //赠送总成长值
    356.             growthTotal += orderItem.getGiftGrowth();
    357.  
    358.         }
    359.         //1、订单价格相关的
    360.         orderEntity.setTotalAmount(total);
    361.         //设置应付总额(总额+运费)
    362.         orderEntity.setPayAmount(total.add(orderEntity.getFreightAmount()));
    363.         //设置优惠总价
    364.         orderEntity.setCouponAmount(coupon);
    365.         //设置商品促销总价
    366.         orderEntity.setPromotionAmount(promotion);
    367.         //设置积分优惠总价
    368.         orderEntity.setIntegrationAmount(intergration);
    369.  
    370.         //设置积分
    371.         orderEntity.setIntegration(integrationTotal);
    372.         //设置成长值
    373.         orderEntity.setGrowth(growthTotal);
    374.  
    375.         //设置订单删除状态(0-未删除，1-已删除)
    376.         orderEntity.setDeleteStatus(0);
    377.  
    378.     }

    分流程（submitOrder方法是封装SubmitOrderResponseVo对象）：

    1. package com.saodai.saodaimall.order.vo;
    2.  
    3. import com.saodai.saodaimall.order.entity.OrderEntity;
    4. import lombok.Data;
    5.  
    6. /**
    7.  * 下单后返回的数据封装类
    8.  **/
    10. @Data
    11. public class SubmitOrderResponseVo {
    12.  
    13.     //下单成功的订单信息
    14.     private OrderEntity order;
    15.  
    16.     /** 错误状态码 **/
    17.     private Integer code;
    18.  
    19.  
    20. }

    1、把OrderSubmitVo对象（前台传过来已经封装好的）放到本地线程，方便后面共享

    1. package com.saodai.saodaimall.order.vo;
    2.  
    3. import lombok.Data;
    4.  
    5. import java.math.BigDecimal;
    6.  
    7. /**
    8.  * 封装订单提交数据的vo
    9.  **/
    11. @Data
    12. public class OrderSubmitVo {
    13.  
    14.     /** 收获地址的id **/
    15.     private Long addrId;
    16.  
    17.     /** 支付方式 **/
    18.     private Integer payType;
    19.     //无需提交要购买的商品，去购物车再获取一遍
    20.     //优惠、发票
    21.  
    22.     /** 防重令牌 **/
    23.     private String orderToken;
    24.  
    25.     /** 应付价格 **/
    26.     private BigDecimal payPrice;
    27.  
    28.     /** 订单备注 **/
    29.     private String remarks;
    30.  
    31.     //用户相关的信息，直接去session中取出即可
    32. }

    2、验证令牌是否合法【令牌的对比和删除必须保证原子性】

    3、创建订单（订单和订单项都有对应的数据库表）-->（封装OrderCreateTo对象）

    1. package com.saodai.saodaimall.order.to;
    2.  
    3.  
    4. import com.saodai.saodaimall.order.entity.OrderEntity;
    5. import com.saodai.saodaimall.order.entity.OrderItemEntity;
    6. import lombok.Data;
    7.  
    8. import java.math.BigDecimal;
    9. import java.util.List;
    10.  
    11. /**
    12.  *生成的订单类（组合类型的订单）
    13.  **/
    15. @Data
    16. public class OrderCreateTo {
    17.  
    18.  
    19.     //订单实体类
    20.     private OrderEntity order;
    21.  
    22.     //订单项
    23.     private List<OrderItemEntity> orderItems;
    24.  
    25.     /** 订单计算的应付价格 **/
    26.     private BigDecimal payPrice;
    27.  
    28.     /** 运费 **/
    29.     private BigDecimal fare;
    30.  
    31. }

    i、IdWorker.getTimeId()是jdk提供的生成订单订单号的方法

    ii、通过builderOrder方法来构造订单（封装OrderEntity对象）

    1. package com.saodai.saodaimall.order.entity;
    2.  
    3. import com.baomidou.mybatisplus.annotation.TableField;
    4. import com.baomidou.mybatisplus.annotation.TableId;
    5. import com.baomidou.mybatisplus.annotation.TableName;
    6. import lombok.Data;
    7.  
    8. import java.io.Serializable;
    9. import java.math.BigDecimal;
    10. import java.util.Date;
    11. import java.util.List;
    12.  
    13. /**
    14.  * 订单实体类
    15.  */
    16. @Data
    17. @TableName("oms_order")
    18. public class OrderEntity implements Serializable {
    19. 	private static final long serialVersionUID = 1L;
    20.  
    21. 	/**
    22. 	 * id
    23. 	 */
    24. 	@TableId
    25. 	private Long id;
    26. 	/**
    27. 	 * member_id
    28. 	 */
    29. 	private Long memberId;
    30. 	/**
    31. 	 * 订单号
    32. 	 */
    33. 	private String orderSn;
    34. 	/**
    35. 	 * 使用的优惠券
    36. 	 */
    37. 	private Long couponId;
    38. 	/**
    39. 	 * create_time
    40. 	 */
    41. 	private Date createTime;
    42. 	/**
    43. 	 * 用户名
    44. 	 */
    45. 	private String memberUsername;
    46. 	/**
    47. 	 * 订单总额
    48. 	 */
    49. 	private BigDecimal totalAmount;
    50. 	/**
    51. 	 * 应付总额
    52. 	 */
    53. 	private BigDecimal payAmount;
    54. 	/**
    55. 	 * 运费金额
    56. 	 */
    57. 	private BigDecimal freightAmount;
    58. 	/**
    59. 	 * 促销优化金额（促销价、满减、阶梯价）
    60. 	 */
    61. 	private BigDecimal promotionAmount;
    62. 	/**
    63. 	 * 积分抵扣金额
    64. 	 */
    65. 	private BigDecimal integrationAmount;
    66. 	/**
    67. 	 * 优惠券抵扣金额
    68. 	 */
    69. 	private BigDecimal couponAmount;
    70. 	/**
    71. 	 * 后台调整订单使用的折扣金额
    72. 	 */
    73. 	private BigDecimal discountAmount;
    74. 	/**
    75. 	 * 支付方式【1->支付宝；2->微信；3->银联； 4->货到付款；】
    76. 	 */
    77. 	private Integer payType;
    78. 	/**
    79. 	 * 订单来源[0->PC订单；1->app订单]
    80. 	 */
    81. 	private Integer sourceType;
    82. 	/**
    83. 	 * 订单状态【0->待付款；1->待发货；2->已发货；3->已完成；4->已关闭；5->无效订单】
    84. 	 */
    85. 	private Integer status;
    86. 	/**
    87. 	 * 物流公司(配送方式)
    88. 	 */
    89. 	private String deliveryCompany;
    90. 	/**
    91. 	 * 物流单号
    92. 	 */
    93. 	private String deliverySn;
    94. 	/**
    95. 	 * 自动确认时间（天）
    96. 	 */
    97. 	private Integer autoConfirmDay;
    98. 	/**
    99. 	 * 可以获得的积分
    100. 	 */
    101. 	private Integer integration;
    102. 	/**
    103. 	 * 可以获得的成长值
    104. 	 */
    105. 	private Integer growth;
    106. 	/**
    107. 	 * 发票类型[0->不开发票；1->电子发票；2->纸质发票]
    108. 	 */
    109. 	private Integer billType;
    110. 	/**
    111. 	 * 发票抬头
    112. 	 */
    113. 	private String billHeader;
    114. 	/**
    115. 	 * 发票内容
    116. 	 */
    117. 	private String billContent;
    118. 	/**
    119. 	 * 收票人电话
    120. 	 */
    121. 	private String billReceiverPhone;
    122. 	/**
    123. 	 * 收票人邮箱
    124. 	 */
    125. 	private String billReceiverEmail;
    126. 	/**
    127. 	 * 收货人姓名
    128. 	 */
    129. 	private String receiverName;
    130. 	/**
    131. 	 * 收货人电话
    132. 	 */
    133. 	private String receiverPhone;
    134. 	/**
    135. 	 * 收货人邮编
    136. 	 */
    137. 	private String receiverPostCode;
    138. 	/**
    139. 	 * 省份/直辖市
    140. 	 */
    141. 	private String receiverProvince;
    142. 	/**
    143. 	 * 城市
    144. 	 */
    145. 	private String receiverCity;
    146. 	/**
    147. 	 * 区
    148. 	 */
    149. 	private String receiverRegion;
    150. 	/**
    151. 	 * 详细地址
    152. 	 */
    153. 	private String receiverDetailAddress;
    154. 	/**
    155. 	 * 订单备注
    156. 	 */
    157. 	private String note;
    158. 	/**
    159. 	 * 确认收货状态[0->未确认；1->已确认]
    160. 	 */
    161. 	private Integer confirmStatus;
    162. 	/**
    163. 	 * 删除状态【0->未删除；1->已删除】
    164. 	 */
    165. 	private Integer deleteStatus;
    166. 	/**
    167. 	 * 下单时使用的积分
    168. 	 */
    169. 	private Integer useIntegration;
    170. 	/**
    171. 	 * 支付时间
    172. 	 */
    173. 	private Date paymentTime;
    174. 	/**
    175. 	 * 发货时间
    176. 	 */
    177. 	private Date deliveryTime;
    178. 	/**
    179. 	 * 确认收货时间
    180. 	 */
    181. 	private Date receiveTime;
    182. 	/**
    183. 	 * 评价时间
    184. 	 */
    185. 	private Date commentTime;
    186. 	/**
    187. 	 * 修改时间
    188. 	 */
    189. 	private Date modifyTime;
    190.  
    191. 	/**
    192. 	 * 订单项
    193. 	 */
    194. 	@TableField(exist = false)
    195. 	private List<OrderItemEntity> orderItemEntityList;
    196.  
    197. }
    198.    /**
    199.      *   构建订单数据
    200.      * @param orderSn 订单号
    201.      * @return
    202.      */
    203.     private OrderEntity builderOrder(String orderSn) {
    204.  
    205.         /**通过拦截器中线程共享数据来获取当前用户登录信息**/
    206.         MemberResponseVo memberResponseVo = LoginUserInterceptor.loginUser.get();
    207.  
    208.         OrderEntity orderEntity = new OrderEntity();
    209.         orderEntity.setMemberId(memberResponseVo.getId());
    210.         orderEntity.setOrderSn(orderSn);
    211.         orderEntity.setMemberUsername(memberResponseVo.getUsername());
    212.  
    213.         /**通过线程共享数据来获取地址id信息**/
    214.         OrderSubmitVo orderSubmitVo = confirmVoThreadLocal.get();
    215.  
    216.  
    217.         /**通过远程获取收货地址和运费信息来**/
    218.         R fareAddressVo = wmsFeignService.getFare(orderSubmitVo.getAddrId());
    219.         FareVo fareResp = fareAddressVo.getData("data", new TypeReference<FareVo>() {});
    220.  
    221.         //获取到运费信息
    222.         BigDecimal fare = fareResp.getFare();
    223.         orderEntity.setFreightAmount(fare);
    224.  
    225.         //获取到收货地址信息
    226.         MemberAddressVo address = fareResp.getAddress();
    227.         //设置收货人信息
    228.         orderEntity.setReceiverName(address.getName());
    229.         orderEntity.setReceiverPhone(address.getPhone());
    230.         //设置收货人邮编
    231.         orderEntity.setReceiverPostCode(address.getPostCode());
    232.         orderEntity.setReceiverProvince(address.getProvince());
    233.         orderEntity.setReceiverCity(address.getCity());
    234.         //设置地区
    235.         orderEntity.setReceiverRegion(address.getRegion());
    236.         //设置详细地址
    237.         orderEntity.setReceiverDetailAddress(address.getDetailAddress());
    238.  
    239.         //设置订单相关的状态信息  CREATE_NEW(0,"待付款")
    240.         orderEntity.setStatus(OrderStatusEnum.CREATE_NEW.getCode());
    241.          //设置自动确认时间（天）
    242.         orderEntity.setAutoConfirmDay(7);
    243.         //设置确认收货状态[0->未确认；1->已确认]
    244.         orderEntity.setConfirmStatus(0);
    245.         return orderEntity;
    246.     }
        • 通过拦截器中线程共享数据来获取当前用户登录信息并封装到订单对象 OrderEntity
        • 通过线程共享数据来获取前台提交过来的orderSubmitVo对象数据
        • 通过AddrId地址Id来远程库存服务获取收货地址和运费信息来封装到订单对象OrderEntity
        • 设置订单相关的状态信息为待付款
        • 设置自动确认时间（天）和设置确认收货状态[0->未确认；1->已确认]

    iii、通过builderOrderItems方法来构造所有订单项（封装 List对象，指的所有订单项）

    1. package com.saodai.saodaimall.order.entity;
    2.  
    3. import com.baomidou.mybatisplus.annotation.TableId;
    4. import com.baomidou.mybatisplus.annotation.TableName;
    5. import lombok.Data;
    6.  
    7. import java.io.Serializable;
    8. import java.math.BigDecimal;
    9.  
    10. /**
    11.  * 订单项信息
    12.  */
    13. @Data
    14. @TableName("oms_order_item")
    15. public class OrderItemEntity implements Serializable {
    16. 	private static final long serialVersionUID = 1L;
    17.  
    18. 	/**
    19. 	 * id
    20. 	 */
    21. 	@TableId
    22. 	private Long id;
    23. 	/**
    24. 	 * order_id
    25. 	 */
    26. 	private Long orderId;
    27. 	/**
    28. 	 * order_sn
    29. 	 */
    30. 	private String orderSn;
    31. 	/**
    32. 	 * spu_id
    33. 	 */
    34. 	private Long spuId;
    35. 	/**
    36. 	 * spu_name
    37. 	 */
    38. 	private String spuName;
    39. 	/**
    40. 	 * spu_pic
    41. 	 */
    42. 	private String spuPic;
    43. 	/**
    44. 	 * 品牌
    45. 	 */
    46. 	private String spuBrand;
    47. 	/**
    48. 	 * 商品分类id
    49. 	 */
    50. 	private Long categoryId;
    51. 	/**
    52. 	 * 商品sku编号
    53. 	 */
    54. 	private Long skuId;
    55. 	/**
    56. 	 * 商品sku名字
    57. 	 */
    58. 	private String skuName;
    59. 	/**
    60. 	 * 商品sku图片
    61. 	 */
    62. 	private String skuPic;
    63. 	/**
    64. 	 * 商品sku价格
    65. 	 */
    66. 	private BigDecimal skuPrice;
    67. 	/**
    68. 	 * 商品购买的数量
    69. 	 */
    70. 	private Integer skuQuantity;
    71. 	/**
    72. 	 * 商品销售属性组合（JSON）
    73. 	 */
    74. 	private String skuAttrsVals;
    75. 	/**
    76. 	 * 商品促销分解金额
    77. 	 */
    78. 	private BigDecimal promotionAmount;
    79. 	/**
    80. 	 * 优惠券优惠分解金额
    81. 	 */
    82. 	private BigDecimal couponAmount;
    83. 	/**
    84. 	 * 积分优惠分解金额
    85. 	 */
    86. 	private BigDecimal integrationAmount;
    87. 	/**
    88. 	 * 该商品经过优惠后的分解金额
    89. 	 */
    90. 	private BigDecimal realAmount;
    91. 	/**
    92. 	 * 赠送积分
    93. 	 */
    94. 	private Integer giftIntegration;
    95. 	/**
    96. 	 * 赠送成长值
    97. 	 */
    98. 	private Integer giftGrowth;
    99.  
    100. }
    101.   /**
    102.      * 构建所有订单项数据
    103.      * @param orderSn 订单号
    104.      * @return
    105.      */
    106.     public List<OrderItemEntity> builderOrderItems(String orderSn) {
    107.  
    108.         List<OrderItemEntity> orderItemEntityList = new ArrayList<>();
    109.  
    110.         //获取购物车中选中了的购物项
    111.         List<OrderItemVo> currentCartItems = cartFeignService.getCurrentCartItems();
    112.         if (currentCartItems != null && currentCartItems.size() > 0) {
    113.             orderItemEntityList = currentCartItems.stream().map((items) -> {
    114.                 //构建订单项数据
    115.                 OrderItemEntity orderItemEntity = builderOrderItem(items);
    116.                 orderItemEntity.setOrderSn(orderSn);
    117.  
    118.                 return orderItemEntity;
    119.             }).collect(Collectors.toList());
    120.         }
    121.  
    122.         return orderItemEntityList;
    123.     }
    124.     /**
    125.      * 构建某一个订单项的数据
    126.      * @param items 购物项
    127.      * @return
    128.      */
    129.     private OrderItemEntity builderOrderItem(OrderItemVo items) {
    130.  
    131.         OrderItemEntity orderItemEntity = new OrderItemEntity();
    132.  
    133.         //1、商品的spu信息
    134.         Long skuId = items.getSkuId();
    135.  
    136.         /**远程调用商品服务来获取spu的信息**/
    137.         R spuInfo = productFeignService.getSpuInfoBySkuId(skuId);
    138.         SpuInfoVo spuInfoData = spuInfo.getData("data", new TypeReference<SpuInfoVo>() {
    139.         });
    140.         orderItemEntity.setSpuId(spuInfoData.getId());
    141.         orderItemEntity.setSpuName(spuInfoData.getSpuName());
    142.         orderItemEntity.setSpuBrand(spuInfoData.getBrandName());
    143.         orderItemEntity.setCategoryId(spuInfoData.getCatalogId());
    144.  
    145.         //2、商品的sku信息
    146.         orderItemEntity.setSkuId(skuId);
    147.         orderItemEntity.setSkuName(items.getTitle());
    148.         //设置商品sku图片
    149.         orderItemEntity.setSkuPic(items.getImage());
    150.          //设置商品sku价格
    151.         orderItemEntity.setSkuPrice(items.getPrice());
    152.          //商品购买的数量
    153.         orderItemEntity.setSkuQuantity(items.getCount());
    154.  
    155.         //使用StringUtils.collectionToDelimitedString将list集合转换为String
    156.         String skuAttrValues = StringUtils.collectionToDelimitedString(items.getSkuAttrValues(), ";");
    157.         //设置商品销售属性组合（JSON）
    158.         orderItemEntity.setSkuAttrsVals(skuAttrValues);
    159.  
    160.         //3、商品的优惠信息
    161.  
    162.         //4、商品的积分信息
    163.          //设置赠送成长值
    164.         orderItemEntity.setGiftGrowth(items.getPrice().multiply(new BigDecimal(items.getCount())).intValue());
    165.          //设置赠送积分
    166.         orderItemEntity.setGiftIntegration(items.getPrice().multiply(new BigDecimal(items.getCount())).intValue());
    167.  
    168.         //5、订单项的价格信息
    169.         //设置商品促销分解金额
    170.         orderItemEntity.setPromotionAmount(BigDecimal.ZERO);
    171.         //设置优惠券优惠分解金额
    172.         orderItemEntity.setCouponAmount(BigDecimal.ZERO);
    173.         //设置积分优惠分解金额
    174.         orderItemEntity.setIntegrationAmount(BigDecimal.ZERO);
    175.  
    176.         //当前订单项的实际金额.总额 - 各种优惠价格
    177.         //原来的价格    orderItemEntity.getSkuQuantity()是获取商品购买的数量
    178.         BigDecimal origin = orderItemEntity.getSkuPrice().multiply(new BigDecimal(orderItemEntity.getSkuQuantity().toString()));
    179.         //原价减去优惠价得到最终的价格
    180.         BigDecimal subtract = origin.subtract(orderItemEntity.getCouponAmount())
    181.                 .subtract(orderItemEntity.getPromotionAmount())
    182.                 .subtract(orderItemEntity.getIntegrationAmount());
    183.         orderItemEntity.setRealAmount(subtract);
    184.  
    185.         return orderItemEntity;
    186.     }
        • 远程调用购物车服务来获取购物车中的所有购物项
        • 遍历通过builderOrderItem方法构造订单项的数据（封装OrderItemEntity对象，指的单个订单项）
          • 远程调用商品服务来获取spu的信息
          • 设置商品的sku信息
          • 使用StringUtils.collectionToDelimitedString将list集合转换为String
          • 设置商品的积分信息
          • 设置订单项的价格信息

    iv、计算订单各种价格(总价，优惠价，积分价等等)

    1.  /**
    2.      *  计算价格的方法
    3.      */
    4.     private void computePrice(OrderEntity orderEntity, List<OrderItemEntity> orderItemEntities) {
    5.  
    6.         //总价
    7.         BigDecimal total = new BigDecimal("0.0");
    8.         //优惠券优惠分解金额
    9.         BigDecimal coupon = new BigDecimal("0.0");
    10.         //积分优惠分解金额
    11.         BigDecimal intergration = new BigDecimal("0.0");
    12.         //商品促销分解金额
    13.         BigDecimal promotion = new BigDecimal("0.0");
    14.  
    15.         //积分、成长值
    16.         Integer integrationTotal = 0;
    17.         Integer growthTotal = 0;
    18.  
    19.         //订单总额，叠加每一个订单项的总额信息
    20.         for (OrderItemEntity orderItem : orderItemEntities) {
    21.             //优惠券优惠总金额
    22.             coupon = coupon.add(orderItem.getCouponAmount());
    23.             //商品促销总金额
    24.             promotion = promotion.add(orderItem.getPromotionAmount());
    25.             //积分优惠总金额
    26.             intergration = intergration.add(orderItem.getIntegrationAmount());
    27.  
    28.             //总价
    29.             total = total.add(orderItem.getRealAmount());
    30.  
    31.             //赠送总积分
    32.             integrationTotal += orderItem.getGiftIntegration();
    33.             //赠送总成长值
    34.             growthTotal += orderItem.getGiftGrowth();
    35.  
    36.         }
    37.         //1、订单价格相关的
    38.         orderEntity.setTotalAmount(total);
    39.         //设置应付总额(总额+运费)
    40.         orderEntity.setPayAmount(total.add(orderEntity.getFreightAmount()));
    41.         //设置优惠总价
    42.         orderEntity.setCouponAmount(coupon);
    43.         //设置商品促销总价
    44.         orderEntity.setPromotionAmount(promotion);
    45.         //设置积分优惠总价
    46.         orderEntity.setIntegrationAmount(intergration);
    47.  
    48.         //设置积分
    49.         orderEntity.setIntegration(integrationTotal);
    50.         //设置成长值
    51.         orderEntity.setGrowth(growthTotal);
    52.  
    53.         //设置订单删除状态(0-未删除，1-已删除)
    54.         orderEntity.setDeleteStatus(0);
    55.  
    56.     }

    4、验证前端界面传来的价格和计算后的价格是否相同（验价，只要小于两个的差值0.01都可以接受）

    5、保存订单信息

    1>保存订单

    2>保存订单项

    1.   /**
    2.      * 保存订单所有数据
    3.      * @param orderCreateTo
    4.      */
    5.     private void saveOrder(OrderCreateTo orderCreateTo) {
    6.  
    7.         //获取订单信息
    8.         OrderEntity order = orderCreateTo.getOrder();
    9.         order.setModifyTime(new Date());
    10.         order.setCreateTime(new Date());
    11.         //保存订单
    12.         this.baseMapper.insert(order);
    13.  
    14.         //获取订单项信息
    15.         List<OrderItemEntity> orderItems = orderCreateTo.getOrderItems();
    16.         //批量保存订单项数据（代码构造器自动生成的方法）
    17.         orderItemService.saveBatch(orderItems);
    18.     }

    6、调用库存服务来进行锁库存（如果有异常要进行回滚，但是这里的回滚不是加个@Transactional可以实现的）

    i、封装传给库存服务的WareSkuLockVo对象

    1. package com.saodai.saodaimall.order.vo;
    2.  
    3. import lombok.Data;
    4.  
    5. import java.util.List;
    6.  
    7. /**
    8.  *  锁定库存的vo
    9.  **/
    11. @Data
    12. public class WareSkuLockVo {
    13.  
    14.     //订单号
    15.     private String orderSn;
    16.  
    17.     /** 需要锁住的所有库存信息 **/
    18.     private List<OrderItemVo> locks;
    19.  
    20.  
    21.  
    22. }
    1. package com.saodai.saodaimall.order.vo;
    2.  
    3. import lombok.Data;
    4.  
    5. import java.math.BigDecimal;
    6. import java.util.List;
    7.  
    8. /**
    9.  * 订单项类（其实就是购物项）
    10.  **/
    12. @Data
    13. public class OrderItemVo {
    14.  
    15.     private Long skuId;
    16.  
    17.     private Boolean check;
    18.  
    19.     private String title;
    20.  
    21.     private String image;
    22.  
    23.     /**
    24.      * 商品套餐属性
    25.      */
    26.     private List<String> skuAttrValues;
    27.  
    28.     private BigDecimal price;
    29.  
    30.     private Integer count;
    31.  
    32.     private BigDecimal totalPrice;
    33.  
    34.     private Boolean hasStock;
    35.  
    36.     /** 商品重量 **/
    37.     private BigDecimal weight = new BigDecimal("0.085");
    38. }

    ii、远程调用功库存服务来锁库存

    1.  /**
    2.      * 锁定库存
    3.      * @param vo
    4.      *
    5.      * 库存解锁的场景
    6.      *      1）、下订单成功，订单过期没有支付被系统自动取消或者被用户手动取消，都要解锁库存
    7.      *      2）、下订单成功，库存锁定成功，接下来的业务调用失败，导致订单回滚。之前锁定的库存就要自动解锁
    8.      *
    9.      *
    10.      * @return
    11.      */
    12.     @PostMapping(value = "/lock/order")
    13.     public R orderLockStock(@RequestBody WareSkuLockVo vo) {
    14.  
    15.         try {
    16.             boolean lockStock = wareSkuService.orderLockStock(vo);
    17.             return R.ok().setData(lockStock);
    18.         } catch (NoStockException e) {
    19.             //    NO_STOCK_EXCEPTION(21000,"商品库存不足")
    20.             return R.error(NO_STOCK_EXCEPTION.getCode(),NO_STOCK_EXCEPTION.getMessage());
    21.         }
    22.     }
    23. /**
    24.      * 为某个订单锁定库存
    25.      * @param vo
    26.      * @return
    27.      */
    28.     @Transactional(rollbackFor = Exception.class)
    29.     @Override
    30.     public boolean orderLockStock(WareSkuLockVo vo) {
    31.  
    32.         /**
    33.          *
    34.          * 用于解锁库存（回溯）
    35.          */
    36.         //封装订单锁库存工作单实体类(表示我准备要给哪个订单锁库存了)
    37.         WareOrderTaskEntity wareOrderTaskEntity = new WareOrderTaskEntity();
    38.         wareOrderTaskEntity.setOrderSn(vo.getOrderSn());
    39.         wareOrderTaskEntity.setCreateTime(new Date());
    40.         wareOrderTaskService.save(wareOrderTaskEntity);
    41.  
    42.         //1、按照下单的收货地址，找到一个就近仓库，锁定库存
    43.         //2、找到每个商品在哪个仓库都有库存
    44.         List<OrderItemVo> locks = vo.getLocks();
    45.  
    46.         List<SkuWareHasStock> collect = locks.stream().map((item) -> {
    47.             SkuWareHasStock stock = new SkuWareHasStock();
    48.             Long skuId = item.getSkuId();
    49.             stock.setSkuId(skuId);
    50.             stock.setNum(item.getCount());
    51.             //查询这个商品在哪个仓库有库存
    52.             List<Long> wareIdList = wareSkuDao.listWareIdHasSkuStock(skuId);
    53.             stock.setWareId(wareIdList);
    54.  
    55.             return stock;
    56.         }).collect(Collectors.toList());
    57.  
    58.         //2、锁定库存
    59.         for (SkuWareHasStock hasStock : collect) {
    60.             //判断锁库存是否成功的标志位（只要有一个仓库锁定成功就可）
    61.             boolean skuStocked = false;
    62.             Long skuId = hasStock.getSkuId();
    63.             List<Long> wareIds = hasStock.getWareId();
    64.  
    65.             if (StringUtils.isEmpty(wareIds)) {
    66.                 //没有任何仓库有这个商品的库存
    67.                 throw new NoStockException(skuId);
    68.             }
    69.  
    70.             //1、如果每一个商品都锁定成功,将当前商品锁定了几件的工作单记录发给MQ
    71.             //2、锁定失败。前面保存的工作单信息都回滚了。发送出去的消息，即使要解锁库存，由于在数据库查不到指定的id，所有就不用解锁
    72.             for (Long wareId : wareIds) {
    73.                 //进行锁库存操作（锁定成功就返回1，失败就返回0）
    74.                 Long count = wareSkuDao.lockSkuStock(skuId,wareId,hasStock.getNum());
    75.                 if (count == 1) {
    76.                     skuStocked = true;
    77.                     //封装库存工作单详情（具体给订单的哪个商品锁库存）
    78.                     WareOrderTaskDetailEntity taskDetailEntity = WareOrderTaskDetailEntity.builder()
    79.                             .skuId(skuId)
    80.                             .skuName("")
    81.                             .skuNum(hasStock.getNum())
    82.                             .taskId(wareOrderTaskEntity.getId())
    83.                             .wareId(wareId)
    84.                             .lockStatus(1)
    85.                             .build();
    86.                     wareOrderTaskDetailService.save(taskDetailEntity);
    87.  
    88.                     /**告诉RabbitMQ库存锁定成功**/   
    89.                     StockLockedTo lockedTo = new StockLockedTo();
    90.                     //设置库存工作单的id（其实就是订单锁库存工作单的id号）
    91.                     lockedTo.setId(wareOrderTaskEntity.getId());
    92.                     StockDetailTo detailTo = new StockDetailTo();
    93.                     BeanUtils.copyProperties(taskDetailEntity,detailTo);
    94.                     lockedTo.setDetailTo(detailTo);
    95.  
    96.                     /**
    97.                      * 把消息发给RabbitMQ队列的stock-event-exchange交换机
    98.                      * 延时后的消息会被交换机stock-event-exchange根据路由键stock.release
    99.                      * （这个是MyRabbitMQConfig配置中的stockDelay方法设置的）发送到队列stock.release.stock.queue
    100.                      * 特别注意：只需要给交换机指定的路由键就可以路由到对应的队列，前提是要先在配置里设置好绑定关系
    101.                      *
    102.                      */
    103.                     rabbitTemplate.convertAndSend("stock-event-exchange","stock.locked",lockedTo);
    104.                     break;
    105.                 } else {
    106.                     //当前仓库锁失败，重试下一个仓库
    107.                 }
    108.             }
    109.  
    110.             if (skuStocked == false) {
    111.                 //当前商品所有仓库都没有锁住
    112.                 throw new NoStockException(skuId);
    113.             }
    114.         }
    115.  
    116.         //3、肯定全部都是锁定成功的
    117.         return true;
    118.     }
      • 封装WareOrderTaskEntity对象，用于后面异常时的数据回溯(表示我准备要给哪个订单锁库存了，对应数据库wms_ware_order_task表)
    1. package com.saodai.saodaimall.ware.entity;
    2.  
    3. import com.baomidou.mybatisplus.annotation.TableId;
    4. import com.baomidou.mybatisplus.annotation.TableName;
    5. import lombok.Data;
    6.  
    7. import java.io.Serializable;
    8. import java.util.Date;
    9.  
    10. /**
    11.  * 订单锁库存工作单(表示我准备要给哪个订单锁库存了)
    12.  */
    13. @Data
    14. @TableName("wms_ware_order_task")
    15. public class WareOrderTaskEntity implements Serializable {
    16. 	private static final long serialVersionUID = 1L;
    17.  
    18. 	/**
    19. 	 * id
    20. 	 */
    21. 	@TableId
    22. 	private Long id;
    23. 	/**
    24. 	 * order_id
    25. 	 */
    26. 	private Long orderId;
    27. 	/**
    28. 	 * order_sn
    29. 	 */
    30. 	private String orderSn;
    31. 	/**
    32. 	 * 收货人
    33. 	 */
    34. 	private String consignee;
    35. 	/**
    36. 	 * 收货人电话
    37. 	 */
    38. 	private String consigneeTel;
    39. 	/**
    40. 	 * 配送地址
    41. 	 */
    42. 	private String deliveryAddress;
    43. 	/**
    44. 	 * 订单备注
    45. 	 */
    46. 	private String orderComment;
    47. 	/**
    48. 	 * 付款方式【 1:在线付款 2:货到付款】
    49. 	 */
    50. 	private Integer paymentWay;
    51. 	/**
    52. 	 * 任务状态
    53. 	 */
    54. 	private Integer taskStatus;
    55. 	/**
    56. 	 * 订单描述
    57. 	 */
    58. 	private String orderBody;
    59. 	/**
    60. 	 * 物流单号
    61. 	 */
    62. 	private String trackingNo;
    63. 	/**
    64. 	 * create_time
    65. 	 */
    66. 	private Date createTime;
    67. 	/**
    68. 	 * 仓库id
    69. 	 */
    70. 	private Long wareId;
    71. 	/**
    72. 	 * 工作单备注
    73. 	 */
    74. 	private String taskComment;
    75.  
    76. }
      • 找到每个商品在哪个仓库都有库存（封装 List对象）
    1.    /**锁库存的内部类**/
    2.     @Data
    3.     class SkuWareHasStock {
    4.         //商品id
    5.         private Long skuId;
    6.         //商品数量
    7.         private Integer num;
    8.         //商品所在仓库的id
    9.         private List<Long> wareId;
    10.     }
    1. <!--    查询这个商品在哪个仓库有库存-->
    2. <select id="listWareIdHasSkuStock" resultType="java.lang.Long">
    3.   SELECT
    4.   ware_id
    5.   FROM
    6.   wms_ware_sku
    7.   WHERE
    8.   sku_id = #{skuId}
    9.   AND stock - stock_locked > 0
    10. </select>
      • 锁定库存（修改需要锁库存的商品的锁库存数量和封装 WareOrderTaskDetailEntity对象）
        • 遍历前面封装的 List对象
        • 设置判断锁库存是否成功的标志位（只要有一个仓库锁定成功就可）
        • 如果 List对象不为空就遍历每个库存仓库，调用lockSkuStock方法来锁库存
      • 锁库存成功后把消息发给RabbitMQ队列
    1. <!--    锁定库存-->
    2.     <update id="lockSkuStock">
    3.         UPDATE wms_ware_sku
    4.         SET stock_locked = stock_locked + #{num}
    5.         WHERE
    6.             sku_id = #{skuId}
    7.           AND ware_id = #{wareId}
    8.           AND stock - stock_locked > 0
    9.     </update>
    1. package com.saodai.saodaimall.ware.entity;
    2.  
    3. import com.baomidou.mybatisplus.annotation.TableId;
    4. import com.baomidou.mybatisplus.annotation.TableName;
    5. import lombok.AllArgsConstructor;
    6. import lombok.Builder;
    7. import lombok.Data;
    8. import lombok.NoArgsConstructor;
    9.  
    10. import java.io.Serializable;
    11.  
    12. /**
    13. * 库存工作单详情（具体给订单的哪个商品锁库存）
    14. */
    15.  
    16. @NoArgsConstructor
    17. @AllArgsConstructor
    18. @Builder
    19. @Data
    20. @TableName("wms_ware_order_task_detail")
    21. public class WareOrderTaskDetailEntity implements Serializable {
    22.     private static final long serialVersionUID = 1L;
    23.     
    24.     /**
    25.     * id
    26.     */
    27.     @TableId
    28.     private Long id;
    29.     /**
    30.     * sku_id
    31.     */
    32.     private Long skuId;
    33.     /**
    34.     * sku_name
    35.     */
    36.     private String skuName;
    37.     /**
    38.     * 购买个数
    39.     */
    40.     private Integer skuNum;
    41.     /**
    42.     * 工作单id
    43.     */
    44.     private Long taskId;
    45.     
    46.     /**
    47.     * 仓库id
    48.     */
    49.     private Long wareId;
    50.     
    51.     /**
    52.     * 锁定状态
    53.     */
    54.     private Integer lockStatus;
    55.     
    56. }
    1. package com.saodai.common.to.mq;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6.  * 发送到mq消息队列的to
    7.  **/
    9. @Data
    10. public class StockLockedTo {
    11.  
    12.     /** 库存工作单的id **/
    13.     private Long id;
    14.  
    15.     /** 工作单详情的所有信息  StockDetailTo对象内容就是上面的WareOrderTaskDetailEntity **/
    16.     private StockDetailTo detailTo;
    17. }

    7、解库存

    锁库存成功后就会发消息给stock-event-exchange交换机，交换机根据路由键stock.locked把消息路由到stock.delay.queue延时队列（跟上面一样，这个延时队列的消息不会被消费掉），时间过期后就把消息根据路由键stock.release路由到stock.release.stock.queue队列，然后这个消息队列的消息是被一个专门解库存的监听器来监听（注意这里有两种解库存的监听方法，一个是自动解库存的监听，一个是订单服务的订单取消后立马解库存的监听）

    rabbitTemplate.convertAndSend("stock-event-exchange","stock.locked",lockedTo);
    1. package com.saodai.saodaimall.ware.listener;
    2.  
    3. import com.rabbitmq.client.Channel;
    4. import com.saodai.common.to.OrderTo;
    5. import com.saodai.common.to.mq.StockLockedTo;
    6. import com.saodai.saodaimall.ware.service.WareSkuService;
    7. import lombok.extern.slf4j.Slf4j;
    8. import org.springframework.amqp.core.Message;
    9. import org.springframework.amqp.rabbit.annotation.RabbitHandler;
    10. import org.springframework.amqp.rabbit.annotation.RabbitListener;
    11. import org.springframework.beans.factory.annotation.Autowired;
    12. import org.springframework.stereotype.Service;
    13.  
    14. import java.io.IOException;
    15.  
    16.  
    17. /**
    18.  * RabbitMQ的监听器
    19.  * 这里有两个监听方法，这两个监听识别的依据是看传入的是StockLockedTo还是OrderTo
    20.  * 一个是监听的库存自动解锁
    21.  * 一个是监听订单取消后库存解锁
    22.  */
    24. @Slf4j
    25. @RabbitListener(queues = "stock.release.stock.queue")
    26. @Service
    27. public class StockReleaseListener {
    28.  
    29.     @Autowired
    30.     private WareSkuService wareSkuService;
    31.  
    32.     /**
    33.      ** 监听库存自动解锁
    34.      */
    35.     @RabbitHandler
    36.     public void handleStockLockedRelease(StockLockedTo to, Message message, Channel channel) throws IOException {
    37.         log.info("******收到解锁库存的信息******");
    38.         try {
    39.  
    40.             System.out.println("******收到解锁库存的信息******");
    41.             //当前消息是否被第二次及以后（重新）派发过来了
    42.             // Boolean redelivered = message.getMessageProperties().getRedelivered();
    43.  
    44.             //解锁库存
    45.             wareSkuService.unlockStock(to);
    46.             // 手动删除消息
    47.             channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
    48.         } catch (Exception e) {
    49.             // 解锁失败 将消息重新放回队列，让别人消费
    50.             channel.basicReject(message.getMessageProperties().getDeliveryTag(),true);
    51.         }
    52.     }
    53.  
    54.     /**
    55.      *
    56.      * 防止订单服务卡顿，导致订单状态消息一直改不了，库存优先到期，查订单状态新建，什么都不处理
    57.      *导致卡顿的订单，永远都不能解锁库存
    58.      * 订单释放直接和库存释放进行绑定
    59.      * @param orderTo
    60.      * @param message
    61.      * @param channel
    62.      * @throws IOException
    63.      */
    64.     @RabbitHandler
    65.     public void handleOrderCloseRelease(OrderTo orderTo, Message message, Channel channel) throws IOException {
    66.  
    67.         log.info("******收到订单关闭，准备解锁库存的信息******");
    68.  
    69.         try {
    70.             wareSkuService.unlockStock(orderTo);
    71.             // 手动删除消息
    72.             channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
    73.         } catch (Exception e) {
    74.             // 解锁失败 将消息重新放回队列，让别人消费
    75.             channel.basicReject(message.getMessageProperties().getDeliveryTag(),true);
    76.         }
    77.     }
    78.  
    79.  
    80. }
    1. package com.saodai.common.to.mq;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6.  * 发送到mq消息队列的to
    7.  **/
    9. @Data
    10. public class StockLockedTo {
    11.  
    12.     /** 库存工作单的id **/
    13.     private Long id;
    14.  
    15.     /** 工作单详情的所有信息  StockDetailTo对象内容就是上面的WareOrderTaskDetailEntity **/
    16.     private StockDetailTo detailTo;
    17. }

    解锁库存的思路

    首先查询数据库的库存详细工作单表看看有没有成功锁定库存（如果成功锁库存了会有对应的一条记录），如果没有那就说明库存没有锁成功，那自然就不需要解锁了

    • 库存详细工作单表有这条记录那就证明库存锁定成功了
      • 具体需不需要解库存还要先看订单状态
        • 先查询有没有这个订单，没有这个订单必须解锁库存（可能出现因为有异常造成的数据回滚导致订单不存在的情况，但是库存锁成功了）
        • 有这个订单，不一定解锁库存，要根据订单的状态来决定是否解库存
          • 订单状态是已取消状态，说明是用户没有支付订单过期了，那就必须解锁库存
          • 订单状态是已支付状态，说明是用户支付成功了，那就不能解锁库存
        • 除了判断上面的情况，还有考虑当前库存详细工作单的状态，只有满足订单状态是已取消状态并且是已锁定的状态那才可以解库存
          • 已锁定：解锁库存
          • 已解锁 ：不能再解锁
    1.  /**
    2.      * (这个方法是由StockReleaseListener监听器调用的)
    3.      * 锁库存失败后的自动解锁（也就是回溯）
    4.      * @param to
    5.      */
    6.     @Override
    7.     public void unlockStock(StockLockedTo to) {
    8.  
    9.         //获取库存详细工作单类
    10.         StockDetailTo detail = to.getDetailTo();
    11.         //库存详细工作单的id
    12.         Long detailId = detail.getId();
    13. 		//WareOrderTaskDetailEntity是库存详细工作单类
    14.         WareOrderTaskDetailEntity taskDetailInfo = wareOrderTaskDetailService.getById(detailId);
    15.         if (taskDetailInfo != null) {
    16.             //查出wms_ware_order_task工作单的信息
    17.             Long id = to.getId();
    18.             //订单锁库存工作单(获取哪个订单要锁库存)
    19.             WareOrderTaskEntity orderTaskInfo = wareOrderTaskService.getById(id);
    20.             //获取订单号查询订单状态
    21.             String orderSn = orderTaskInfo.getOrderSn();
    22.             //远程查询订单信息
    23.             R orderData = orderFeignService.getOrderStatus(orderSn);
    24.             if (orderData.getCode() == 0) {
    25.                 //订单数据返回成功
    26.                 OrderVo orderInfo = orderData.getData("data", new TypeReference<OrderVo>() {});
    27.  
    28.                 /**
    29.                  *     CREATE_NEW(0,"待付款"),
    30.                  *     PAYED(1,"已付款"),
    31.                  *     SENDED(2,"已发货"),
    32.                  *     RECIEVED(3,"已完成"),
    33.                  *     CANCLED(4,"已取消"),
    34.                  *     SERVICING(5,"售后中"),
    35.                  *     SERVICED(6,"售后完成");
    36.                  */
    37.                 //订单不存在（因为有异常造成的数据回滚导致订单不存在）或者订单状态是取消状态（orderInfo.getStatus() == 4）才可解库存
    38.                 if (orderInfo == null || orderInfo.getStatus() == 4) {
    39.                     //当前库存工作单详情状态1，已锁定，只有当前库存工作单详情状态未解锁才可以解锁
    40.                     if (taskDetailInfo.getLockStatus() == 1) {
    41.                         //调用真正接库存的方法unLockStock
    42.                         unLockStock(detail.getSkuId(),detail.getWareId(),detail.getSkuNum(),detailId);
    43.                     }
    44.                 }
    45.             } else {
    46.                 //消息拒绝以后重新放在队列里面，让别人继续消费解锁
    47.                 //远程调用服务失败
    48.                 throw new RuntimeException("远程调用服务失败");
    49.             }
    50.         } else {
    51.             //无需解锁
    52.         }
    53.     }
    54.  
    55.         /**
    56.      * 真正解锁库存的方法（自动解库存）
    57.      * @param skuId 需要解锁库存的商品id
    58.      * @param wareId  需要解锁库存的库存仓库id
    59.      * @param num  需要解锁库存的商品数量
    60.      * @param taskDetailId   库存工作单详情id
    61.      */
    62.     public void unLockStock(Long skuId,Long wareId,Integer num,Long taskDetailId) {
    63.  
    64.         //库存解锁（其实就是修改wms_ware_sku表中的stock_locked的值，之前锁库存锁了多少个就减去多少个）
    65.         wareSkuDao.unLockStock(skuId,wareId,num);
    66.  
    67.         //更新工作单的状态
    68.         WareOrderTaskDetailEntity taskDetailEntity = new WareOrderTaskDetailEntity();
    69.         taskDetailEntity.setId(taskDetailId);
    70.         //setLockStatus(2)表示变为已解锁（1表示已锁定，2表示已解锁，3表示减扣）
    71.         taskDetailEntity.setLockStatus(2);
    72.         wareOrderTaskDetailService.updateById(taskDetailEntity);
    73.  
    74.     }
    75.  
    76.  
    77.     /**
    78.      * 订单取消了就立马解库存
    79.      * 防止订单服务卡顿，导致订单状态消息一直改不了，库存优先到期，查订单状态新建，什么都不处理
    80.      * 导致卡顿的订单，永远都不能解锁库存
    81.      * @param orderTo
    82.      */
    83.     @Transactional(rollbackFor = Exception.class)
    84.     @Override
    85.     public void unlockStock(OrderTo orderTo) {
    86.  
    87.         String orderSn = orderTo.getOrderSn();
    88.         //查一下最新的库存解锁状态，防止重复解锁库存
    89.         WareOrderTaskEntity orderTaskEntity = wareOrderTaskService.getOrderTaskByOrderSn(orderSn);
    90.  
    91.         //按照工作单的id找到所有 没有解锁的库存，进行解锁（lock_status=1表示已锁定库存）
    92.         Long id = orderTaskEntity.getId();
    93.         List<WareOrderTaskDetailEntity> list = wareOrderTaskDetailService.list(new QueryWrapper<WareOrderTaskDetailEntity>()
    94.                 .eq("task_id", id).eq("lock_status", 1));
    95.  
    96.         for (WareOrderTaskDetailEntity taskDetailEntity : list) {
    97.             //解锁库存
    98.             unLockStock(taskDetailEntity.getSkuId(),
    99.                     taskDetailEntity.getWareId(),
    100.                     taskDetailEntity.getSkuNum(),
    101.                     taskDetailEntity.getId());
    102.         }
    103.  
    104.     }

    自动解库存

    1. /**
    2.      * (这个方法是由StockReleaseListener监听器调用的)
    3.      * 锁库存失败后的自动解锁（也就是回溯）
    4.      * @param to
    5.      */
    6.     @Override
    7.     public void unlockStock(StockLockedTo to) {
    8.  
    9.         //获取库存详细工作单类
    10.         StockDetailTo detail = to.getDetailTo();
    11.         //库存详细工作单的id
    12.         Long detailId = detail.getId();
    13. 		//WareOrderTaskDetailEntity是库存详细工作单类
    14.         WareOrderTaskDetailEntity taskDetailInfo = wareOrderTaskDetailService.getById(detailId);
    15.         if (taskDetailInfo != null) {
    16.             //查出wms_ware_order_task工作单的信息
    17.             Long id = to.getId();
    18.             //订单锁库存工作单(获取哪个订单要锁库存)
    19.             WareOrderTaskEntity orderTaskInfo = wareOrderTaskService.getById(id);
    20.             //获取订单号查询订单状态
    21.             String orderSn = orderTaskInfo.getOrderSn();
    22.             //远程查询订单信息
    23.             R orderData = orderFeignService.getOrderStatus(orderSn);
    24.             if (orderData.getCode() == 0) {
    25.                 //订单数据返回成功
    26.                 OrderVo orderInfo = orderData.getData("data", new TypeReference<OrderVo>() {});
    27.  
    28.                 /**
    29.                  *     CREATE_NEW(0,"待付款"),
    30.                  *     PAYED(1,"已付款"),
    31.                  *     SENDED(2,"已发货"),
    32.                  *     RECIEVED(3,"已完成"),
    33.                  *     CANCLED(4,"已取消"),
    34.                  *     SERVICING(5,"售后中"),
    35.                  *     SERVICED(6,"售后完成");
    36.                  */
    37.                 //订单不存在（因为有异常造成的数据回滚导致订单不存在）或者订单状态是取消状态（orderInfo.getStatus() == 4）才可解库存
    38.                 if (orderInfo == null || orderInfo.getStatus() == 4) {
    39.                     //当前库存工作单详情状态1，已锁定，只有当前库存工作单详情状态未解锁才可以解锁
    40.                     if (taskDetailInfo.getLockStatus() == 1) {
    41.                         //调用真正接库存的方法unLockStock
    42.                         unLockStock(detail.getSkuId(),detail.getWareId(),detail.getSkuNum(),detailId);
    43.                     }
    44.                 }
    45.             } else {
    46.                 //消息拒绝以后重新放在队列里面，让别人继续消费解锁
    47.                 //远程调用服务失败
    48.                 throw new RuntimeException("远程调用服务失败");
    49.             }
    50.         } else {
    51.             //无需解锁
    52.         }
    53.     }
    54.  
    55.         /**
    56.      * 真正解锁库存的方法（自动解库存）
    57.      * @param skuId 需要解锁库存的商品id
    58.      * @param wareId  需要解锁库存的库存仓库id
    59.      * @param num  需要解锁库存的商品数量
    60.      * @param taskDetailId   库存工作单详情id
    61.      */
    62.     public void unLockStock(Long skuId,Long wareId,Integer num,Long taskDetailId) {
    63.  
    64.         //库存解锁（其实就是修改wms_ware_sku表中的stock_locked的值，之前锁库存锁了多少个就减去多少个）
    65.         wareSkuDao.unLockStock(skuId,wareId,num);
    66.  
    67.         //更新工作单的状态
    68.         WareOrderTaskDetailEntity taskDetailEntity = new WareOrderTaskDetailEntity();
    69.         taskDetailEntity.setId(taskDetailId);
    70.         //setLockStatus(2)表示变为已解锁（1表示已锁定，2表示已解锁，3表示减扣）
    71.         taskDetailEntity.setLockStatus(2);
    72.         wareOrderTaskDetailService.updateById(taskDetailEntity);
    73.  
    74.     }
    • 自动解库存的具体实现流程
      • 获取库存详细工作单的id
    1. package com.saodai.common.to.mq;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6.  * 发送到mq消息队列的to
    7.  **/
    9. @Data
    10. public class StockLockedTo {
    11.  
    12.     /** 库存工作单的id **/
    13.     private Long id;
    14.  
    15.     /** 工作单详情的所有信息 **/
    16.     private StockDetailTo detailTo;
    17. }
    1. package com.saodai.common.to.mq;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6.  * 其实就是库存工作单详情实体类（具体给订单的哪个商品锁库存）
    7.  **/
    9. @Data
    10. public class StockDetailTo {
    11.  
    12.     private Long id;
    13.     /**
    14.      * sku_id
    15.      */
    16.     private Long skuId;
    17.     /**
    18.      * sku_name
    19.      */
    20.     private String skuName;
    21.     /**
    22.      * 购买个数
    23.      */
    24.     private Integer skuNum;
    25.     /**
    26.      * 工作单id
    27.      */
    28.     private Long taskId;
    29.  
    30.     /**
    31.      * 仓库id
    32.      */
    33.     private Long wareId;
    34.  
    35.     /**
    36.      * 锁定状态
    37.      */
    38.     private Integer lockStatus;
    39.  
    40. }
      • 查询数据库有没有这个库存详细工作单类
    1. package com.saodai.saodaimall.ware.entity;
    2.  
    3. import com.baomidou.mybatisplus.annotation.TableId;
    4. import com.baomidou.mybatisplus.annotation.TableName;
    5. import lombok.AllArgsConstructor;
    6. import lombok.Builder;
    7. import lombok.Data;
    8. import lombok.NoArgsConstructor;
    9.  
    10. import java.io.Serializable;
    11.  
    12. /**
    13.  * 库存工作单详情（具体给订单的哪个商品锁库存）
    14.  */
    16. @NoArgsConstructor
    17. @AllArgsConstructor
    18. @Builder
    19. @Data
    20. @TableName("wms_ware_order_task_detail")
    21. public class WareOrderTaskDetailEntity implements Serializable {
    22. 	private static final long serialVersionUID = 1L;
    23.  
    24. 	/**
    25. 	 * id
    26. 	 */
    27. 	@TableId
    28. 	private Long id;
    29. 	/**
    30. 	 * sku_id
    31. 	 */
    32. 	private Long skuId;
    33. 	/**
    34. 	 * sku_name
    35. 	 */
    36. 	private String skuName;
    37. 	/**
    38. 	 * 购买个数
    39. 	 */
    40. 	private Integer skuNum;
    41. 	/**
    42. 	 * 工作单id
    43. 	 */
    44. 	private Long taskId;
    45.  
    46. 	/**
    47. 	 * 仓库id
    48. 	 */
    49. 	private Long wareId;
    50.  
    51. 	/**
    52. 	 * 锁定状态
    53. 	 */
    54. 	private Integer lockStatus;
    55.  
    56. }
      • 查询订单锁库存工作单(获取哪个订单要锁库存)
    1. package com.saodai.saodaimall.ware.entity;
    2.  
    3. import com.baomidou.mybatisplus.annotation.TableId;
    4. import com.baomidou.mybatisplus.annotation.TableName;
    5. import lombok.Data;
    6.  
    7. import java.io.Serializable;
    8. import java.util.Date;
    9.  
    10. /**
    11.  * 订单锁库存工作单(表示我准备要给哪个订单锁库存了)
    12.  */
    13. @Data
    14. @TableName("wms_ware_order_task")
    15. public class WareOrderTaskEntity implements Serializable {
    16. 	private static final long serialVersionUID = 1L;
    17.  
    18. 	/**
    19. 	 * id
    20. 	 */
    21. 	@TableId
    22. 	private Long id;
    23. 	/**
    24. 	 * order_id
    25. 	 */
    26. 	private Long orderId;
    27. 	/**
    28. 	 * order_sn
    29. 	 */
    30. 	private String orderSn;
    31. 	/**
    32. 	 * 收货人
    33. 	 */
    34. 	private String consignee;
    35. 	/**
    36. 	 * 收货人电话
    37. 	 */
    38. 	private String consigneeTel;
    39. 	/**
    40. 	 * 配送地址
    41. 	 */
    42. 	private String deliveryAddress;
    43. 	/**
    44. 	 * 订单备注
    45. 	 */
    46. 	private String orderComment;
    47. 	/**
    48. 	 * 付款方式【 1:在线付款 2:货到付款】
    49. 	 */
    50. 	private Integer paymentWay;
    51. 	/**
    52. 	 * 任务状态
    53. 	 */
    54. 	private Integer taskStatus;
    55. 	/**
    56. 	 * 订单描述
    57. 	 */
    58. 	private String orderBody;
    59. 	/**
    60. 	 * 物流单号
    61. 	 */
    62. 	private String trackingNo;
    63. 	/**
    64. 	 * create_time
    65. 	 */
    66. 	private Date createTime;
    67. 	/**
    68. 	 * 仓库id
    69. 	 */
    70. 	private Long wareId;
    71. 	/**
    72. 	 * 工作单备注
    73. 	 */
    74. 	private String taskComment;
    75.  
    76. }
      • 根据订单号远程查询订单
    1. package com.saodai.saodaimall.ware.vo;
    2.  
    3. import lombok.Data;
    4.  
    5. import java.math.BigDecimal;
    6. import java.util.Date;
    7.  
    8.  
    9.  
    10. @Data
    11. public class OrderVo {
    12.  
    13.     private Long id;
    14.     /**
    15.      * member_id
    16.      */
    17.     private Long memberId;
    18.     /**
    19.      * 订单号
    20.      */
    21.     private String orderSn;
    22.     /**
    23.      * 使用的优惠券
    24.      */
    25.     private Long couponId;
    26.     /**
    27.      * create_time
    28.      */
    29.     private Date createTime;
    30.     /**
    31.      * 用户名
    32.      */
    33.     private String memberUsername;
    34.     /**
    35.      * 订单总额
    36.      */
    37.     private BigDecimal totalAmount;
    38.     /**
    39.      * 应付总额
    40.      */
    41.     private BigDecimal payAmount;
    42.     /**
    43.      * 运费金额
    44.      */
    45.     private BigDecimal freightAmount;
    46.     /**
    47.      * 促销优化金额（促销价、满减、阶梯价）
    48.      */
    49.     private BigDecimal promotionAmount;
    50.     /**
    51.      * 积分抵扣金额
    52.      */
    53.     private BigDecimal integrationAmount;
    54.     /**
    55.      * 优惠券抵扣金额
    56.      */
    57.     private BigDecimal couponAmount;
    58.     /**
    59.      * 后台调整订单使用的折扣金额
    60.      */
    61.     private BigDecimal discountAmount;
    62.     /**
    63.      * 支付方式【1->支付宝；2->微信；3->银联； 4->货到付款；】
    64.      */
    65.     private Integer payType;
    66.     /**
    67.      * 订单来源[0->PC订单；1->app订单]
    68.      */
    69.     private Integer sourceType;
    70.     /**
    71.      * 订单状态【0->待付款；1->待发货；2->已发货；3->已完成；4->已关闭；5->无效订单】
    72.      */
    73.     private Integer status;
    74.     /**
    75.      * 物流公司(配送方式)
    76.      */
    77.     private String deliveryCompany;
    78.     /**
    79.      * 物流单号
    80.      */
    81.     private String deliverySn;
    82.     /**
    83.      * 自动确认时间（天）
    84.      */
    85.     private Integer autoConfirmDay;
    86.     /**
    87.      * 可以获得的积分
    88.      */
    89.     private Integer integration;
    90.     /**
    91.      * 可以获得的成长值
    92.      */
    93.     private Integer growth;
    94.     /**
    95.      * 发票类型[0->不开发票；1->电子发票；2->纸质发票]
    96.      */
    97.     private Integer billType;
    98.     /**
    99.      * 发票抬头
    100.      */
    101.     private String billHeader;
    102.     /**
    103.      * 发票内容
    104.      */
    105.     private String billContent;
    106.     /**
    107.      * 收票人电话
    108.      */
    109.     private String billReceiverPhone;
    110.     /**
    111.      * 收票人邮箱
    112.      */
    113.     private String billReceiverEmail;
    114.     /**
    115.      * 收货人姓名
    116.      */
    117.     private String receiverName;
    118.     /**
    119.      * 收货人电话
    120.      */
    121.     private String receiverPhone;
    122.     /**
    123.      * 收货人邮编
    124.      */
    125.     private String receiverPostCode;
    126.     /**
    127.      * 省份/直辖市
    128.      */
    129.     private String receiverProvince;
    130.     /**
    131.      * 城市
    132.      */
    133.     private String receiverCity;
    134.     /**
    135.      * 区
    136.      */
    137.     private String receiverRegion;
    138.     /**
    139.      * 详细地址
    140.      */
    141.     private String receiverDetailAddress;
    142.     /**
    143.      * 订单备注
    144.      */
    145.     private String note;
    146.     /**
    147.      * 确认收货状态[0->未确认；1->已确认]
    148.      */
    149.     private Integer confirmStatus;
    150.     /**
    151.      * 删除状态【0->未删除；1->已删除】
    152.      */
    153.     private Integer deleteStatus;
    154.     /**
    155.      * 下单时使用的积分
    156.      */
    157.     private Integer useIntegration;
    158.     /**
    159.      * 支付时间
    160.      */
    161.     private Date paymentTime;
    162.     /**
    163.      * 发货时间
    164.      */
    165.     private Date deliveryTime;
    166.     /**
    167.      * 确认收货时间
    168.      */
    169.     private Date receiveTime;
    170.     /**
    171.      * 评价时间
    172.      */
    173.     private Date commentTime;
    174.     /**
    175.      * 修改时间
    176.      */
    177.     private Date modifyTime;
    178.  
    179. }
      • 进行双重判断
        • 先判断订单不存在（因为有异常造成的数据回滚导致订单不存在）或者订单状态是取消状态
        • 在判断当前库存工作单详情状态是不是1，1表示已锁定，只有当前库存工作单详情状态未解锁才可以解锁
      • 调用unLockStock方法实现真正的解库存（自动解库存）
        • 更新库存的数量（还原）
        • 更新工作单的状态为已解锁
    1.      /**
    2.      * 真正解锁库存的方法（自动解库存）
    3.      * @param skuId 需要解锁库存的商品id
    4.      * @param wareId  需要解锁库存的库存仓库id
    5.      * @param num  需要解锁库存的商品数量
    6.      * @param taskDetailId   库存工作单详情id
    7.      */
    8.     public void unLockStock(Long skuId,Long wareId,Integer num,Long taskDetailId) {
    9.  
    10.         //库存解锁（其实就是修改wms_ware_sku表中的stock_locked的值，之前锁库存锁了多少个就减去多少个）
    11.         wareSkuDao.unLockStock(skuId,wareId,num);
    12.  
    13.         //更新工作单的状态
    14.         WareOrderTaskDetailEntity taskDetailEntity = new WareOrderTaskDetailEntity();
    15.         taskDetailEntity.setId(taskDetailId);
    16.         //setLockStatus(2)表示变为已解锁（1表示已锁定，2表示已解锁，3表示减扣）
    17.         taskDetailEntity.setLockStatus(2);
    18.         wareOrderTaskDetailService.updateById(taskDetailEntity);
    19.  
    20.     }
    1. <!--    解锁库存-->
    2. <update id="unLockStock">
    3.   UPDATE wms_ware_sku
    4.   SET stock_locked = stock_locked - #{num}
    5.   WHERE
    6.   sku_id = ${skuId}
    7.   AND ware_id = #{wareId}
    8. </update>

    手动解库存

    • 订单服务的订单取消后立马解库存的具体逻辑
      • 首先通过订单号查询订单锁库存工作单
      • 通过订单锁库存工作单的id去库存详细工作单去找对应的锁库存的记录，看有没有记录并且锁库存的状态是已锁定的状态，防止多次重复解库存（其中库存详细工作单中的工作id的值就是订单锁库存工作单的id的值）
      • 最后调用真正的解库存方法来解库存
    1.      /**
    2.      * 真正解锁库存的方法（自动解库存）
    3.      * @param skuId 需要解锁库存的商品id
    4.      * @param wareId  需要解锁库存的库存仓库id
    5.      * @param num  需要解锁库存的商品数量
    6.      * @param taskDetailId   库存工作单详情id
    7.      */
    8.     public void unLockStock(Long skuId,Long wareId,Integer num,Long taskDetailId) {
    9.  
    10.         //库存解锁（其实就是修改wms_ware_sku表中的stock_locked的值，之前锁库存锁了多少个就减去多少个）
    11.         wareSkuDao.unLockStock(skuId,wareId,num);
    12.  
    13.         //更新工作单的状态
    14.         WareOrderTaskDetailEntity taskDetailEntity = new WareOrderTaskDetailEntity();
    15.         taskDetailEntity.setId(taskDetailId);
    16.         //setLockStatus(2)表示变为已解锁（1表示已锁定，2表示已解锁，3表示减扣）
    17.         taskDetailEntity.setLockStatus(2);
    18.         wareOrderTaskDetailService.updateById(taskDetailEntity);
    19.  
    20.     }
    21.  
    22.  
    23.     /**
    24.      * 订单取消了就立马解库存
    25.      * 防止订单服务卡顿，导致订单状态消息一直改不了，库存优先到期，查订单状态新建，什么都不处理
    26.      * 导致卡顿的订单，永远都不能解锁库存
    27.      * @param orderTo
    28.      */
    29.     @Transactional(rollbackFor = Exception.class)
    30.     @Override
    31.     public void unlockStock(OrderTo orderTo) {
    32.  
    33.         String orderSn = orderTo.getOrderSn();
    34.         //查一下最新的库存解锁状态，防止重复解锁库存
    35.         WareOrderTaskEntity orderTaskEntity = wareOrderTaskService.getOrderTaskByOrderSn(orderSn);
    36.  
    37.         //按照工作单的id找到所有 没有解锁的库存，进行解锁（lock_status=1表示已锁定库存）
    38.         Long id = orderTaskEntity.getId();
    39.         List<WareOrderTaskDetailEntity> list = wareOrderTaskDetailService.list(new QueryWrapper<WareOrderTaskDetailEntity>()
    40.                 .eq("task_id", id).eq("lock_status", 1));
    41.  
    42.         for (WareOrderTaskDetailEntity taskDetailEntity : list) {
    43.             //解锁库存
    44.             unLockStock(taskDetailEntity.getSkuId(),
    45.                     taskDetailEntity.getWareId(),
    46.                     taskDetailEntity.getSkuNum(),
    47.                     taskDetailEntity.getId());
    48.         }
    49.  
    50.     }

  • 相关阅读:
    Day 01 python学习笔记
    Python-逻辑运算
    java中Random的使用
    Word格式处理控件Aspose.Words for .NET教程——使用超链接和HTML
    SD-WAN跨境网络专线|跨境访问无忧！让海外SaaS平台与视频会议更稳定轻松的解决方案
    一张张截图教你使用gitee
    全新UI彩虹外链网盘系统源码（前后端美化模板）
    SpringBoot怎么整合第三方缓存技术/EhCache缓存技术使用以及Redis缓存技术使用怎么在SpringBoot中使用
    使用 PyGame 显示图像的四种方案
    Redis（五）的事务
  • 原文地址：https://blog.csdn.net/qq_50954361/article/details/128180620