第12章-购物车结算-订单提交

学习目标：

能够描述购物车结算及后续订单提交业务
完成用户下单功能
- 订单重复提交（使用浏览器回退）
- 验证商品库存
- 验证商品价格
- 保存订单及订单明细
完成订单列表功能

1、业务介绍

订单业务在整个电商平台中处于核心位置，也是比较复杂的一块业务。是把“物”变为“钱”的一个中转站。

整个订单模块一共分四部分组成：

结算
下单
对接支付服务
对接库存管理系统

2、结算页

入口：购物车点击计算按钮，结算必须要登录！

分析页面需要的数据：

1、需要用户地址信息

2、购物车中选择的商品列表

3、用户地址信息在service-user模块，购物车信息在service-cart模块，所以我们要在相应模块提供api接口，通过feign client调用获取数据

2.1 在 service-user模块获取地址列表

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/827

2.1.3 编写控制器

package com.atguigu.gmall.user.controller;

import com.atguigu.gmall.user.model.UserAddress;
import com.atguigu.gmall.user.service.UserAddressService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @author: atguigu
 * @create: 2023-06-25 09:41
 */
@RestController
@RequestMapping("/api/user")
public class UserController {

    @Autowired
    private UserAddressService userAddressService;


    /**
     * 根据用户ID查询用户收件地址
     * @param userId
     * @return
     */
    @GetMapping("/inner/findUserAddressListByUserId/{userId}")
    public List<UserAddress> getUserAddressListByUserId(@PathVariable("userId") Long userId){
        return userAddressService.getUserAddressListByUserId(userId);
    }

}

2.1.2 编写接口与实现类

package com.atguigu.gmall.user.service;

import com.atguigu.gmall.user.model.UserAddress;
import com.baomidou.mybatisplus.extension.service.IService;

import java.util.List;

/**
 * 用户地址表 业务接口类
 * @author atguigu
 * @since 2023-06-20
 */
public interface UserAddressService extends IService<UserAddress> {


    /**
     * 根据用户ID查询用户收件地址
     * @param userId
     * @return
     */
    List<UserAddress> getUserAddressListByUserId(Long userId);
}

package com.atguigu.gmall.user.service.impl;

import com.atguigu.gmall.user.model.UserAddress;
import com.atguigu.gmall.user.mapper.UserAddressMapper;
import com.atguigu.gmall.user.service.UserAddressService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 用户地址表 业务实现类
 *
 * @author atguigu
 * @since 2023-06-20
 */
@Service
public class UserAddressServiceImpl extends ServiceImpl<UserAddressMapper, UserAddress> implements UserAddressService {


    /**
     * 根据用户ID查询用户收件地址
     * @param userId
     * @return
     */
    @Override
    public List<UserAddress> getUserAddressListByUserId(Long userId) {
        LambdaQueryWrapper<UserAddress> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(UserAddress::getUserId, userId);
        return this.list(queryWrapper);
    }
}

2.1.1 添加mapper

package com.atguigu.gmall.user.mapper;

import com.atguigu.gmall.user.model.UserAddress;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface UserAddressMapper extends BaseMapper<UserAddress> {
}

2.1.3 提供Feign接口

选中gmall-client模块新建子模块：service-user-client

提供远程调用的API Feign接口

package com.atguigu.gmall.user.client;
   
import com.atguigu.gmall.user.client.impl.UserDegradeFeignClient;
import com.atguigu.gmall.user.model.UserAddress;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
   
import java.util.List;
   
@FeignClient(value = "service-user", path = "/api/user", fallback = UserDegradeFeignClient.class)
public interface UserFeignClient {
   
   /**
    * 根据指定用户查询用户收件地址列表
    *
    * @param userId
    * @return
    */
   @GetMapping("/inner/findUserAddressListByUserId/{userId}")
   public List<UserAddress> getUserAddressListByUserId(@PathVariable("userId") Long userId);
}

服务降级类

package com.atguigu.gmall.user.client.impl;
   
import com.atguigu.gmall.user.client.UserFeignClient;
import com.atguigu.gmall.user.model.UserAddress;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
   
import java.util.List;
   
/**
* @author: atguigu
* @create: 2023-06-25 09:45
*/
@Slf4j
@Component
public class UserDegradeFeignClient  implements UserFeignClient {
   @Override
   public List<UserAddress> getUserAddressListByUserId(Long userId) {
       log.error("[用户服务]Feign调用getUserAddressListByUserId方法服务降级");
       return null;
   }
}

2.2 在service-cart模块获取选中商品数据

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/691

CarApiController中处理获取指定用户选中购物车列表数据

package com.atguigu.gmall.cart.api;
   
import com.atguigu.gmall.cart.model.CartInfo;
import com.atguigu.gmall.cart.service.CartInfoService;
import com.atguigu.gmall.order.model.OrderDetail;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
   
import java.util.List;
   
/**
* @author: atguigu
* @create: 2023-08-10 09:37
*/
@RestController
@RequestMapping("/api/cart")
public class CartApiController {
   
   @Autowired
   private CartInfoService cartInfoService;
   
   
   /**
    * 根据用户ID，查询用户购物车商品，将CartInfo转为OrderDetail对象
    *
    * @param userId
    * @return
    */
   @ApiOperation("根据用户ID，查询用户购物车商品，将CartInfo转为OrderDetail对象")
   @GetMapping("/getCartCheckedList/{userId}")
   public List<OrderDetail> getCartCheckedList(@PathVariable("userId") Long userId) {
       return cartInfoService.getCartCheckedList(userId);
   }
}

CartService业务层接口

/**
* 根据用户ID，查询用户购物车商品，将CartInfo转为OrderDetail对象
*
* @param userId
* @return
*/
List<OrderDetail> getCartCheckedList(Long userId);

CartServiceImpl业务层实现类

/**
* 根据用户ID，查询用户购物车商品，将CartInfo转为OrderDetail对象
*
* @param userId
* @return
*/
@Override
public List<OrderDetail> getCartCheckedList(Long userId) {
   //1.构建用户购物车key
   String cartKey = USER_KEY_PREFIX + userId + USER_CART_KEY_SUFFIX;
   BoundHashOperations<String, String, CartInfo> hashOps = redisTemplate.boundHashOps(cartKey);
   //2.获取当前用户所有选中购物车商品列表
   List<CartInfo> allCartInfoList = hashOps.values();
   
   //3.将集合类型从CartInfo转为OrderInfo
   if (!CollectionUtils.isEmpty(allCartInfoList)) {
       List<OrderDetail> orderDetailList = allCartInfoList.stream().filter((cartInfo -> {
           return cartInfo.getIsChecked().intValue() == 1;
       })).map(cartInfo -> {
           OrderDetail orderDetail = new OrderDetail();
           orderDetail.setSkuId(cartInfo.getSkuId());
           orderDetail.setImgUrl(cartInfo.getImgUrl());
           orderDetail.setSkuName(cartInfo.getSkuName());
           orderDetail.setSkuNum(cartInfo.getSkuNum());
           orderDetail.setOrderPrice(cartInfo.getSkuPrice());
           return orderDetail;
       }).collect(Collectors.toList());
       return orderDetailList;
   }
   return null;
}

在service-cart-client模块中提供Feign API接口

package com.atguigu.gmall.cart.client;
   
import com.atguigu.gmall.cart.client.impl.CartDegradeFeignClient;
import com.atguigu.gmall.order.model.OrderDetail;
import io.swagger.annotations.ApiOperation;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
   
import java.util.List;
   
@FeignClient(value = "serivce-cart", path = "/api/cart", fallback = CartDegradeFeignClient.class)
public interface CartFeignClient {
   
   
   /**
    * 根据用户ID，查询用户购物车商品，将CartInfo转为OrderDetail对象
    *
    * @param userId
    * @return
    */
   @ApiOperation("根据用户ID，查询用户购物车商品，将CartInfo转为OrderDetail对象")
   @GetMapping("/getCartCheckedList/{userId}")
   public List<OrderDetail> getCartCheckedList(@PathVariable("userId") Long userId);
}

服务降级类

package com.atguigu.gmall.cart.client.impl;
   
import com.atguigu.gmall.cart.client.CartFeignClient;
import com.atguigu.gmall.order.model.OrderDetail;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
   
import java.util.List;
   
/**
* @author: atguigu
* @create: 2023-08-10 09:48
*/
@Slf4j
@Service
public class CartDegradeFeignClient  implements CartFeignClient {
   @Override
   public List<OrderDetail> getCartCheckedList(Long userId) {
       log.error("[购物车服务]remote调用getCartCheckedList服务降级");
       return null;
   }
}

2.3 搭建service-order模块

2.3.1 搭建service-order

在gmall-service下创建子模块：service-order

2.3.2 修改pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>gmall-service</artifactId>
        <groupId>com.atguigu.gmall</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service-order</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.atguigu.gmall</groupId>
            <artifactId>service-product-client</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>com.atguigu.gmall</groupId>
            <artifactId>service-cart-client</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>com.atguigu.gmall</groupId>
            <artifactId>service-user-client</artifactId>
            <version>1.0</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>service-order</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2.2.3 启动类

package com.atguigu.gmall;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.cloud.sleuth.instrument.async.AsyncDefaultAutoConfiguration;

@SpringBootApplication(exclude = {AsyncDefaultAutoConfiguration.class})
@EnableDiscoveryClient
@EnableFeignClients
public class OrderApp {
    public static void main(String[] args) {
        SpringApplication.run(OrderApp.class, args);
    }
}

2.3.4 配置文件

在service-order模块resources目录下创建：bootstrap.properties

spring.application.name=service-order
spring.profiles.active=dev
spring.cloud.nacos.discovery.server-addr=192.168.200.128:8848
spring.cloud.nacos.config.server-addr=192.168.200.128:8848
spring.cloud.nacos.config.prefix=${spring.application.name}
spring.cloud.nacos.config.file-extension=yaml
spring.cloud.nacos.config.shared-configs[0].data-id=common.yaml

注意:修改Nacos配置中心service-order-dev.yaml文件中数据库连接信息修改

2.3.5 订单的数据结构

order_info ：订单表

order_detail：订单明细

id	主键。自动生成
consignee	收货人名称。页面获取
consignee_tel	收货人电话。页面获取
deliveryAddress	收货地址。页面获取
total_amount	总金额。计算
order_status	订单状态，用于显示给用户查看。设定初始值。
userId	用户Id。网关过滤器已放到请求头中。
payment_way	支付方式（网上支付、货到付款）。页面获取
orderComment	订单状态。页面获取
out_trade_no	第三方支付编号。按规则生成
create_time	创建时间。设当前时间
expire_time	默认当前时间+1天
process_status	订单进度状态，程序控制、后台管理查看。设定初始值，
tracking_no	物流编号,初始为空，发货后补充
parent_order_id	拆单时产生，默认为空

id	主键，自动生成
order_id	订单编号，主表保存后给从表
sku_id	商品id 页面传递
sku_name	商品名称，后台添加
img_url	图片路径，后台添加
order_price	商品单价，从页面中获取，并验价。
sku_num	商品个数，从页面中获取

订单实体类

package com.atguigu.gmall.model.order;


@Data
@ApiModel(description = "订单信息")
@TableName("order_info")
public class OrderInfo extends BaseEntity {
   
   private static final long serialVersionUID = 1L;
   
   @ApiModelProperty(value = "收货人")
   @TableField("consignee")
   private String consignee;

   @ApiModelProperty(value = "收件人电话")
   @TableField("consignee_tel")
   private String consigneeTel;

   @ApiModelProperty(value = "总金额")
   @TableField("total_amount")
   private BigDecimal totalAmount;

   @ApiModelProperty(value = "订单状态")
   @TableField("order_status")
   private String orderStatus;

   @ApiModelProperty(value = "用户id")
   @TableField("user_id")
   private Long userId;

   @ApiModelProperty(value = "付款方式")
   @TableField("payment_way")
   private String paymentWay;

   @ApiModelProperty(value = "送货地址")
   @TableField("delivery_address")
   private String deliveryAddress;

   @ApiModelProperty(value = "订单备注")
   @TableField("order_comment")
   private String orderComment;

   @ApiModelProperty(value = "订单交易编号（第三方支付用)")
   @TableField("out_trade_no")
   private String outTradeNo;

   @ApiModelProperty(value = "订单描述(第三方支付用)")
   @TableField("trade_body")
   private String tradeBody;

   @ApiModelProperty(value = "创建时间")
   @TableField("create_time")
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")

   private Date createTime;

   @ApiModelProperty(value = "失效时间")
   @TableField("expire_time")
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")

   private Date expireTime;

   @ApiModelProperty(value = "进度状态")
   @TableField("process_status")
   private String processStatus;

   @ApiModelProperty(value = "物流单编号")
   @TableField("tracking_no")
   private String trackingNo;

   @ApiModelProperty(value = "父订单编号")
   @TableField("parent_order_id")
   private Long parentOrderId;

   @ApiModelProperty(value = "图片路径")
   @TableField("img_url")
   private String imgUrl;

   @TableField(exist = false)
   private List<OrderDetail> orderDetailList;

   @TableField(exist = false)
   private String wareId;

   // 计算总价格
   public void sumTotalAmount(){
      BigDecimal totalAmount=new BigDecimal("0");
      for (OrderDetail orderDetail : orderDetailList) {
         totalAmount= totalAmount.add(orderDetail.getOrderPrice().multiply(new BigDecimal(orderDetail.getSkuNum())));
      }
      this.totalAmount=  totalAmount;
   }

}

订单详情实体类

package com.atguigu.gmall.model.order;

@Data
@ApiModel(description = "订单明细")
@TableName("order_detail")
public class OrderDetail extends BaseEntity {
   
   private static final long serialVersionUID = 1L;
   
   @ApiModelProperty(value = "订单编号")
   @TableField("order_id")
   private Long orderId;

   @ApiModelProperty(value = "sku_id")
   @TableField("sku_id")
   private Long skuId;

   @ApiModelProperty(value = "sku名称（冗余)")
   @TableField("sku_name")
   private String skuName;

   @ApiModelProperty(value = "图片名称（冗余)")
   @TableField("img_url")
   private String imgUrl;

   @ApiModelProperty(value = "购买价格(下单时sku价格）")
   @TableField("order_price")
   private BigDecimal orderPrice;

   @ApiModelProperty(value = "购买个数")
   @TableField("sku_num")
   private Integer skuNum;

   // 是否有足够的库存！
   @TableField(exist = false)
   private String hasStock;

}

注意：其中hasStock是一个非持久化属性，用与传递【是否还有库存】的标志。如果商品在库存中有足够数据，suceess = "1"，fail="0"

2.3.5 接口封装OrderApiController

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/755

为了在确定订单的页面展示收货地址，所以在service-order模块的pom.xml添加依赖-(已添加)

<dependency>
   <groupId>com.atguigu.gmall</groupId>
   <artifactId>service-user-client</artifactId>
   <version>1.0</version>
</dependency>

在service-order模块中处理订单确认页面请求

package com.atguigu.gmall.order.controller;
   
import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.common.util.AuthContextHolder;
import com.atguigu.gmall.order.service.OrderInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
   
import javax.servlet.http.HttpServletRequest;
import java.util.Map;
   
/**
* @author: atguigu
* @create: 2023-08-10 10:17
*/
@RestController
@RequestMapping("/api/order")
public class OrderController {
   
   @Autowired
   private OrderInfoService orderInfoService;
   
   
   /**
    * 当前用户-汇总订单确认所需要数据
    *
    * @return
    */
   @GetMapping("/auth/trade")
   public Result orderTadeData(HttpServletRequest request) {
       //1.获取当前用户ID
       String userId = AuthContextHolder.getUserId(request);
   
       //2.调用业务层封装订单渲染需要数据 封装Map
       Map<String, Object> mapResult = orderInfoService.getOrderTadeData(Long.valueOf(userId));
       return Result.ok(mapResult);
   }
}

OrderInfoService接口

package com.atguigu.gmall.order.service;
   
import com.atguigu.gmall.order.model.OrderInfo;
import com.baomidou.mybatisplus.extension.service.IService;
   
import java.util.Map;
   
/**
* 订单表 订单表 业务接口类
* @author atguigu
* @since 2023-08-10
*/
public interface OrderInfoService extends IService<OrderInfo> {
   
   /**
    * 当前用户-汇总订单确认所需要数据
    *
    * @return
    */
   Map<String, Object> getOrderTadeData(Long userId);
}

在OrderInfoServiceImpl封装确认页面相关数据

package com.atguigu.gmall.order.service.impl;
   
import com.atguigu.gmall.cart.client.CartFeignClient;
import com.atguigu.gmall.order.model.OrderDetail;
import com.atguigu.gmall.order.model.OrderInfo;
import com.atguigu.gmall.order.mapper.OrderInfoMapper;
import com.atguigu.gmall.order.service.OrderInfoService;
import com.atguigu.gmall.user.client.UserFeignClient;
import com.atguigu.gmall.user.model.UserAddress;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
   
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ThreadPoolExecutor;
   
/**
* 订单表 订单表 业务实现类
*
* @author atguigu
* @since 2023-08-10
*/
@Slf4j
@Service
@SuppressWarnings("all")
public class OrderInfoServiceImpl extends ServiceImpl<OrderInfoMapper, OrderInfo> implements OrderInfoService {
   
   @Autowired
   private UserFeignClient userFeignClient;
   
   @Autowired
   private CartFeignClient cartFeignClient;
   
   @Autowired
   private ThreadPoolExecutor threadPoolExecutor;
   
   /**
    * 当前用户-汇总订单确认所需要数据
    * ${userAddressList}收件人地址列表
    * ${detailArrayList} 订单明细列表
    * ${totalNum} 商品数量
    * ${totalAmount} 订单总金额
    * ${tradeNo}-订单流水号
    *
    * @return
    */
   @Override
   public Map<String, Object> getOrderTadeData(Long userId) {
       Map<String, Object> mapResult = new HashMap<>();
   
       //1.远程调用用户服务获取用户收件地址列表
       CompletableFuture<Void> userAddressListCompletableFuture = CompletableFuture.runAsync(() -> {
           List<UserAddress> userAddressList = userFeignClient.getUserAddressListByUserId(userId);
           if (!CollectionUtils.isEmpty(userAddressList)) {
               mapResult.put("userAddressList", userAddressList);
           }
       }, threadPoolExecutor);
   
       //2.远程调用购物车服务获取选中购物车商品明细（订单明细）
       CompletableFuture<Void> orderDetailCompletableFuture = CompletableFuture.runAsync(() -> {
           List<OrderDetail> orderDetailList = cartFeignClient.getCartCheckedList(userId);
           if (!CollectionUtils.isEmpty(orderDetailList)) {
               mapResult.put("detailArrayList", orderDetailList);
   
               //3.基于订单明细计算总金额以及数量
               OrderInfo orderInfo = new OrderInfo();
               orderInfo.setOrderDetailList(orderDetailList);
               orderInfo.sumTotalAmount(); //计算总金额
               mapResult.put("totalAmount", orderInfo.getTotalAmount());
               mapResult.put("totalNum", orderDetailList.size());
           }
       }, threadPoolExecutor);
   
   
       //4.TODO 生成订单流水号-避免浏览器回退导致订单重复提交
           
       //5.异步任务并行执行汇总结果
       CompletableFuture.allOf(userAddressListCompletableFuture, orderDetailCompletableFuture).join();
       return mapResult;
   }
}

说明：接口已经封装，接下来暴露接口，提供给web-all模块前端展示数据

2.4 结算页面

2.4.1 搭建service-order-client模块

在gmall-client下创建子模块：service-order-client。搭建过程同service-cart-client

2.4.2 在service-order-client暴露接口

远程调用API Feign接口 注意:Feign接口方法参数不需要设置参数HttpServletRequest

package com.atguigu.gmall.order.client;

import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.order.client.impl.OrderDegradeFeignClient;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;

@FeignClient(value = "service-order", path = "/api/order", fallback = OrderDegradeFeignClient.class)
public interface OrderFeignClient {

    /**
     * 当前用户-汇总订单确认所需要数据
     * TODO:当Feign接口方法提供方方法中有HttpServletRequest一定不能设置，如果设置会封装参数异常
     *
     * @return
     */
    @GetMapping("/auth/trade")
    public Result<Map> orderTadeData();
}

服务降级类：

package com.atguigu.gmall.order.client.impl;

import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.order.client.OrderFeignClient;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @author: atguigu
 * @create: 2023-08-10 10:43
 */
@Slf4j
@Component
public class OrderDegradeFeignClient  implements OrderFeignClient {
    @Override
    public Result<Map> orderTadeData() {
        log.error("[订单服务]remote调用orderTadeData服务降级");
        return null;
    }
}

微服务之间用户信息传递

如上图：因为微服务之间并没有传递头文件，所以我们可以定义一个拦截器，每次微服务调用之前都先检查下头文件，将请求的头文件中的用户信息再放入到header中，再调用其他微服务即可。

在web-util中添加拦截器-(已经添加)

package com.atguigu.gmall.common.interceptor;

import javax.servlet.http.HttpServletRequest;

@Component
public class FeignInterceptor implements RequestInterceptor {

    public void apply(RequestTemplate requestTemplate){
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        requestTemplate.header("userTempId", request.getHeader("userTempId"));
        requestTemplate.header("userId", request.getHeader("userId"));
    }
}

2.4.3 配置网关

Nacos配置中心列表中找到server-gateway-dev.yaml修改增加动态路由

- id: web-order
  uri: lb://web-all
  predicates:
  - Host=order.gmall.com
- id: service-order
  uri: lb://service-order
  predicates:
  - Path=/*/order/**

2.4.4 在web-all模块中添加依赖

<dependency>
    <groupId>com.atguigu.gmall</groupId>
    <artifactId>service-order-client</artifactId>
    <version>1.0</version>
</dependency>

2.4.5 在web-all中添加控制器

package com.atguigu.gmall.web.controller;

import com.atguigu.gmall.common.result.Result;
import com.atguigu.gmall.order.client.OrderFeignClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;

/**
 * @author: atguigu
 * @create: 2023-06-25 11:22
 */
@Controller
public class OrderHtmlController {


    @Autowired
    private OrderFeignClient orderFeignClient;


    /**
     * 订单确认页面渲染
     *
     * @param model
     * @return
     */
    @GetMapping("/trade.html")
    public String tradeHtml(Model model) {
        //1.远程调用订单服务得到汇总数据
        Result<Map> result = orderFeignClient.orderTradeData();
        //2.渲染页面
        model.addAllAttributes(result.getData());
        return "order/trade";
    }
}

3、下订单

3.1 下单功能分析：

防止订单重复提交
保存单据: orderInfo orderDetail。
保存以后把购物车中的商品删除。{不删！}
重定向到支付页面。

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/771

3.2 编写控制器

service-order模块中：OrderApiController

/**
 * 提交普通商城订单
 * @param orderInfo
 * @return
 */
@PostMapping("/auth/submitOrder")
public Result submitOrder(HttpServletRequest request, @RequestBody OrderInfo orderInfo, @RequestParam("tradeNo") String tradeNo){
    //1.获取用户ID
    String userId = AuthContextHolder.getUserId(request);
    orderInfo.setUserId(Long.valueOf(userId));
    //2.提交订单
    Long orderId = orderInfoService.submitOrder(orderInfo, tradeNo);
    return Result.ok(orderId);
}

3.3 添加接口与实现类

雪花算法工具类用于生成订单编号:

package com.atguigu.gmall.common.util;

public class SnowFlake {
    // 因为二进制里第一个 bit 为如果是 1，那么都是负数，但是我们生成的 id 都是正数，所以第一个 bit 统一都是 0。

    /**
     * 机器ID  2进制5位
     */
    private long workerId;

    /**
     * 机房ID 2进制5位
     */
    private long datacenterId;

    /**
     * 代表一毫秒内生成的多个id的最新序号  12位，范围从0到4095
     */
    private long sequence;

    /**
     * 设置一个时间初始值(这个用自己业务系统上线的时间)    2^41 - 1   差不多可以用69年
     */
    private long twepoch = 1585644268888L;

    /**
     * 5位的机器id
     */
    private long workerIdBits = 5L;

    /**
     * 5位的机房id
     */
    private long datacenterIdBits = 5L;

    /**
     * 每毫秒内产生的id数 2 的 12次方
     */
    private long sequenceBits = 12L;

    /**
     * 这个是二进制运算，就是5 bit最多只能有31个数字，也就是说机器id最多只能是32以内
     */
    private long maxWorkerId = -1L ^ (-1L << workerIdBits);

    /**
     * 这个是一个意思，就是5 bit最多只能有31个数字，机房id最多只能是32以内
     */
    private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);

    /**
     * 机器ID向左移12位
     */
    private long workerIdShift = sequenceBits;

    /**
     * 机房ID向左移17位
     */
    private long datacenterIdShift = sequenceBits + workerIdBits;

    /**
     *时间戳向左移22位
     */
    private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;

    /**
     * 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095)
     */
    private long sequenceMask = -1L ^ (-1L << sequenceBits);

    /**
     * 上次生成ID的时间截，记录产生时间毫秒数，判断是否是同1毫秒
     */
    private long lastTimestamp = -1L;

    /**
     * 构造函数
     * @param workerId 服务器ID
     * @param datacenterId 机房ID
     * @param sequence 序号
     */
    public SnowFlake(long workerId, long datacenterId, long sequence){

        // 检查机房id和机器id是否超过最大值，不能小于0
        if (workerId>maxWorkerId||workerId<0){
            throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0",maxWorkerId));
        }

        if (datacenterId>maxDatacenterId||datacenterId<0){
            throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0",maxDatacenterId));
        }

        this.workerId=workerId;
        this.datacenterId=datacenterId;
        this.sequence=sequence;
    }

    /**
     * 这个是核心方法，通过调用nextId()方法，让当前这台机器上的snowflake算法程序生成一个全局唯一的id
     * @return
     */
    public synchronized long nextId(){
        // 获取当前的时间戳，单位是毫秒
        long timestamp=timeGen();

        //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
        if (timestamp<lastTimestamp){
            System.err.printf("clock is moving backwards. Rejecting requests until %d.",lastTimestamp);
            throw new RuntimeException(String.format("Clock moved backwards. Refusing to generate id for %d milliseconds",lastTimestamp-timestamp));
        }

        // 下面是说假设在同一个毫秒内，又发送了一个请求生成一个id
        // 这个时候就得把seqence序号给递增1，最多就是4096
        if (lastTimestamp == timestamp) {
            // 这个意思是说一个毫秒内最多只能有4096个数字，无论你传递多少进来，
            //这个位运算保证始终就是在4096这个范围内，避免你自己传递个sequence超过了4096这个范围
            sequence = (sequence + 1) & sequenceMask;
            //当某一毫秒的时间，产生的id数 超过4095，系统会进入等待，直到下一毫秒，系统继续产生ID
            if (sequence == 0) {
                // 阻塞到下一个毫秒,获得新的时间戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        }else{ // 时间戳改变，毫秒内序列重置
            sequence=0;
        }

        //上次生成ID的时间截
        lastTimestamp=timestamp;

        // 这儿就是最核心的二进制位运算操作，生成一个64bit的id
        // 先将当前时间戳左移，放到41 bit那儿；将机房id左移放到5 bit那儿；将机器id左移放到5 bit那儿；将序号放最后12 bit
        // 最后拼接起来成一个64 bit的二进制数字，转换成10进制就是个long型
        return ((timestamp-twepoch)<<timestampLeftShift)|
                (datacenterId<<datacenterIdShift)|
                (workerId<<workerIdShift)|sequence;
    }

    /**
     * 当某一毫秒的时间，产生的id数 超过4095，系统会进入等待，直到下一毫秒，系统继续产生ID
     * @param lastTimestamp 上次生成ID的时间截
     * @return 当前时间戳
     */
    private long tilNextMillis(long lastTimestamp) {
        long timestamp=timeGen();
        while(timestamp<=lastTimestamp){
            timestamp=timeGen();
        }
        return timestamp;
    }

    /**
     * 获取当前时间戳
     * @return 当前时间(毫秒)
     */
    private long timeGen() {
        return System.currentTimeMillis();
    }

    /**
     * main 测试类
     * @param args
     */
    public static void main(String[] args) {
        SnowFlake worker=new SnowFlake(1,1,1);
        for (int i=0;i<22;i++){
            System.out.println(worker.nextId());
        }
    }
}

雪花算法配置类:

package com.atguigu.gmall.order.config;

import com.atguigu.gmall.common.util.SnowFlake;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author: atguigu
 * @create: 2023-06-25 15:27
 */
@Configuration
public class SnowFlakeConfig {

    @Bean
    public SnowFlake snowFlake(){
        return new SnowFlake(1,1,1);
    }

}

订单业务接口：OrderService

package com.atguigu.gmall.order.service;

import com.atguigu.gmall.order.model.OrderInfo;
import com.baomidou.mybatisplus.extension.service.IService;

import java.util.Map;

/**
 * 订单表 订单表 业务接口类
 * @author atguigu
 * @since 2023-05-06
 */
public interface OrderInfoService extends IService<OrderInfo> {

    /**
     * 提交普通商城订单
     *
     * @param orderInfo
     * @param tradeNo
     * @return 订单ID
     */
    Long submitOrder(OrderInfo orderInfo, String tradeNo);

    /**
     * 保存订单(秒杀订单,普通商城订单)
     * @param orderInfo
     * @return
     */
    Long saveOrder(OrderInfo orderInfo);
}

订单业务实现类：OrderServiceImpl

@Autowired
private OrderDetailService orderDetailService;

@Autowired
private SnowFlake snowFlake;


/**
     * 订单提交,跟后续支付业务对接
     *
     * @param orderInfo
     * @return
     */
@Override
@Transactional(rollbackFor = Exception.class)
public Long submitOrder(OrderInfo orderInfo) {
    //TODO 业务校验
    //1.todo 验证用户是否存在使用浏览器回退导致订单重复提交-验证流水号
    //2.todo 远程调用第三方仓储服务-验证订单中订单明细商品库存是否充足
    //3.todo 远程调用商品服务-验证订单中订单明细商品价格是否变化
    //4.将订单以及订单明细保存
    Long orderId = this.saveOrder(orderInfo);
    return orderId;
}


/**
 * 保存订单以及订单明细
 *
 * @param orderInfo
 * @return
 */
@Override
public Long saveOrder(OrderInfo orderInfo) {
    //1.封装订单对象中若干个属性
    //1.1 计算订单总金额
    orderInfo.sumTotalAmount();
    //1.2 订单状态 消费者  工作人员
    orderInfo.setOrderStatus(OrderStatus.UNPAID.name());
    orderInfo.setProcessStatus(ProcessStatus.UNPAID.name());
    //1.3 生成订单编号 后续支付发货重要字段 规则：SPH年月日雪花算法
    Date now = new Date();
    String today = DateUtil.formatDate(now).replaceAll("-", "");
    long id = snowFlake.nextId();
    String outTradeNo = "SPH" + today + id;
    orderInfo.setOutTradeNo(outTradeNo);
    //1.4 订单商品名称信息 商品图片
    String tradeBody = "";
    List<OrderDetail> orderDetailList = orderInfo.getOrderDetailList();
    if (!CollectionUtils.isEmpty(orderDetailList)) {
        String skuNameStr = orderDetailList.stream().map(OrderDetail::getSkuName).collect(Collectors.joining(","));
        if (skuNameStr.length() > 100) {
            tradeBody = skuNameStr.substring(0, 100); //对接支付宝支付，如果订单中名称太长会导致调用支付接口失败
        } else {
            tradeBody = skuNameStr;
        }
        orderInfo.setTradeBody(tradeBody);
        orderInfo.setImgUrl(orderDetailList.get(0).getImgUrl());
    }
    //1.5 过期时间 普通商城订单 1小时不支付，自定关闭订单
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.HOUR, 1);
    orderInfo.setExpireTime(calendar.getTime());
    //1.4 其他属性封装
    orderInfo.setPaymentWay(PaymentWay.ONLINE.name());
    orderInfo.setOperateTime(now);
    orderInfo.setProvinceId(1L);
    //2.执行订单保存
    this.save(orderInfo);
    Long orderId = orderInfo.getId();

    //3.封装订单明细集合
    if (!CollectionUtils.isEmpty(orderDetailList)) {
        orderDetailList.stream().forEach(orderDetail -> {
            orderDetail.setOrderId(orderId);
            orderDetail.setSourceType("MALL");
            orderDetail.setSourceId(1L);
        });
        //4.批量保存订单明细集合
        orderDetailService.saveBatch(orderDetailList);
    }
    return orderId;
}

3.4 添加mapper

订单信息Mapper

package com.atguigu.gmall.order.mapper;


import com.atguigu.gmall.order.model.OrderInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface OrderInfoMapper extends BaseMapper<OrderInfo> {

}

package com.atguigu.gmall.order.mapper;

import com.atguigu.gmall.order.model.OrderDetail;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface OrderDetailMapper extends BaseMapper<OrderDetail> {
}

3.5 如何解决用户利用浏览器回退重复提交订单？

在进入结算页面时，生成一个结算流水号，然后保存到结算页面的隐藏元素中，每次用户提交都检查该流水号与页面提交的是否相符，订单保存以后把后台的流水号删除掉。那么第二次用户用同一个页面提交的话流水号就会匹配失败，无法重复保存订单。

3.5.1 修改结算页增加流水号的生成

OrderInfoService接口

/**
 * 生成流水号
 * @param userId
 * @return
 */
String generateTradeNo(String userId);


/**
 * 验证流水号是否一致
 * @param userId
 * @param tradeNo
 * @return
 */
Boolean checkTradeNo(String userId, String tradeNo);


/**
 * 删除业务流水号
 * @param userId
 */
void deleteTradeNo(String userId);

OrderInfoServiceImpl实现类

/**
 * 生成流水号
 *
 * @param userId
 * @return
 */
@Override
public String generateTradeNo(Long userId) {
    //1.未当前购买用户生成流水号Key
    String key = RedisConst.USER_KEY_PREFIX + userId + ":tradeno";
    String tradeNo = UUID.randomUUID().toString().replaceAll("-", "");
    //2.将流水号存入Redis
    redisTemplate.opsForValue().set(key, tradeNo, RedisConst.SKULOCK_EXPIRE_PX1, TimeUnit.MINUTES);
    return tradeNo;
}

/**
 * 验证流水号是否一致
 *
 * @param userId
 * @param tradeNo
 * @return
 */
@Override
public Boolean checkTradeNo(Long userId, String tradeNo) {
    String key = RedisConst.USER_KEY_PREFIX + userId + ":tradeno";
    String redisTradeNo = (String) redisTemplate.opsForValue().get(key);
    //1.2 判断用户提交流水号跟Redis存放是否一致
    return tradeNo.equals(redisTradeNo);
}

/**
 * 删除业务流水号
 *
 * @param userId
 */
@Override
public void deleteTradeNo(Long userId) {
    String key = RedisConst.USER_KEY_PREFIX + userId + ":tradeno";
    redisTemplate.delete(key);
}

3.5.2 在OrderController类trade方法添加交易流水号

修改com.atguigu.gmall.order.service.OrderInfoService#trade订单确认页面渲染方法

/**
 * 汇总渲染页面所有的数据
 *
 * @param userId 用户ID
 * @return
 */
@Override
public Map<String, Object> getOrderTadeData(String userId) {
    //~~~~~省略代码
    //4.生成订单流水号-避免浏览器回退导致订单重复提交
    String tradeNo = this.generateTradeNo(userId);
    mapResult.put("tradeNo", tradeNo);
    return tradeMap;
}

3.5.3 在OrderApiController控制器中实现

修改com.atguigu.gmall.order.controller.OrderApiController#submitOrder方法

/**
 * 订单提交,跟后续支付业务对接
 *
 * @param orderInfo
 * @param tradeNo
 * @return
 */
@Override
@Transactional(rollbackFor = Exception.class)
public Long submitOrder(OrderInfo orderInfo, String tradeNo) {
    //TODO 业务校验
    //1. 验证用户是否存在使用浏览器回退导致订单重复提交-验证流水号
    // todo 为了避免判断跟删除之间发生异常 需要保证判断跟删除原子性
   /* Boolean flag = this.checkTradeNo(orderInfo.getUserId(), tradeNo);
    if (!flag) {
        throw new RuntimeException("订单重复提交！");
    }
    this.deleteTradeNo(orderInfo.getUserId());*/
    String key = RedisConst.USER_KEY_PREFIX + orderInfo.getUserId() + ":tradeno";
    String sciptText = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
            "then\n" +
            "    return redis.call(\"del\",KEYS[1])\n" +
            "else\n" +
            "    return 0\n" +
            "end";

    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<Long>();
    redisScript.setScriptText(sciptText);
    redisScript.setResultType(Long.class);
    Long flag = (Long) redisTemplate.execute(redisScript, Arrays.asList(key), tradeNo);
    if (flag == 0) {
        throw new RuntimeException("订单重复提交！");
    }

    //2.todo 远程调用第三方仓储服务-验证订单中订单明细商品库存是否充足
    //3.todo 远程调用商品服务-验证订单中订单明细商品价格是否变化

    //4.将订单以及订单明细保存
    Long orderId = this.saveOrder(orderInfo);
    return orderId;
}

3.6 验库存与验证价格

通过restful接口查询商品是否有库存

一般电商系统的商品库存，都不由电商系统本身来管理，由另外一套仓库管理系统，或者进销存系统来管理，电商系统通过第三方接口调用该系统。

由于库管系统可能是异构的系统，所以不在微服务体系之内。只支持restful风格的webservice调用和消息队列的调用。

详见《库存管理系统》

根据手册中的接口文档，编写调用代码。

3.6.1 导入项目ware-manage项目

详情查看库存管理系统文档，把资料中的ware-manage项目直接放入到项目模块目录下。

打开库存项目

点击OK.

注意：导入后修改下库存系统工程中父工程的坐标信息；修改数据库连接信息；注释掉mybatisPlus配置

填写库存信息！

可以访问库存系统：http://localhost:9001/index

验证库存：

添加商品库存的时候，商品的库存应该选择同一个库存！

3.6.2 查询仓库数量，进行校验

3.6.3 submitOrder中增加方法

   /**
     * 订单提交,跟后续支付业务对接
     *
     * @param orderInfo
     * @param tradeNo
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long submitOrder(OrderInfo orderInfo, String tradeNo) {
        //TODO 业务校验
        //1. 验证用户是否存在使用浏览器回退导致订单重复提交-验证流水号
        // todo 为了避免判断跟删除之间发生异常 需要保证判断跟删除原子性
       /* Boolean flag = this.checkTradeNo(orderInfo.getUserId(), tradeNo);
        if (!flag) {
            throw new RuntimeException("订单重复提交！");
        }
        this.deleteTradeNo(orderInfo.getUserId());*/
        String key = RedisConst.USER_KEY_PREFIX + orderInfo.getUserId() + ":tradeno";
        String sciptText = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
                "then\n" +
                "    return redis.call(\"del\",KEYS[1])\n" +
                "else\n" +
                "    return 0\n" +
                "end";

        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<Long>();
        redisScript.setScriptText(sciptText);
        redisScript.setResultType(Long.class);
        Long flag = (Long) redisTemplate.execute(redisScript, Arrays.asList(key), tradeNo);
        if (flag == 0) {
            throw new RuntimeException("订单重复提交！");
        }

        List<OrderDetail> orderDetailList = orderInfo.getOrderDetailList();
        if (!CollectionUtils.isEmpty(orderDetailList)) {
            orderDetailList.forEach(orderDetail -> {
                //2.todo 远程调用第三方仓储服务-验证订单中订单明细商品库存是否充足
                Boolean hasStock = this.checkStock(orderDetail.getSkuId(), orderDetail.getSkuNum());
                if (!hasStock) {
                    throw new RuntimeException("商品:" + orderDetail.getSkuName() + ",库存不在");
                }

                //3.todo 远程调用商品服务-验证订单中订单明细商品价格是否变化
                //3.1 先查询商品最新价格
                BigDecimal skuPrice = productFeignClient.getSkuPrice(orderDetail.getSkuId());
                //3.2 比较订单明细价格跟数据库商品价格是否一致
                if (orderDetail.getOrderPrice().compareTo(skuPrice) != 0) {
                    //3.3 如果价格不一致，提示错误信息同时，修改当前用户购物车商品价格
                    String cartKey = USER_KEY_PREFIX + orderInfo.getUserId() + USER_CART_KEY_SUFFIX;
                    BoundHashOperations<String, String, CartInfo> hashOps = redisTemplate.boundHashOps(cartKey);
                    String hashKey = orderDetail.getSkuId().toString();
                    if (hashOps.hasKey(hashKey)) {
                        CartInfo cartInfo = hashOps.get(hashKey);
                        cartInfo.setSkuPrice(skuPrice);
                        hashOps.put(hashKey, cartInfo);
                    }
                    throw new RuntimeException("商品" + orderDetail.getSkuName() + ",价格发生变化，请重新提交订单！");
                }
            });
        }

        //4.将订单以及订单明细保存
        Long orderId = this.saveOrder(orderInfo);
        return orderId;
    }

3.6.4 优化下单

下单我们要校验库存与价格，请求比较多，时间比较长，我们可以通过异步编排的形式减少请求时间，异步编排我们前面已经学习过了，接下来怎么做呢

3.6.4.1 引入线程类

将service-item下面的config线程池配置类copy到service-order过来

3.6.4.2 调整下单类

/**
 * 订单提交,跟后续支付业务对接
 *
 * @param orderInfo
 * @param tradeNo
 * @return
 */
@Override
@Transactional(rollbackFor = Exception.class)
public Long submitOrder(OrderInfo orderInfo, String tradeNo) {
    //TODO 业务校验
    //1. 验证用户是否存在使用浏览器回退导致订单重复提交-验证流水号
    // todo 为了避免判断跟删除之间发生异常 需要保证判断跟删除原子性
   /* Boolean flag = this.checkTradeNo(orderInfo.getUserId(), tradeNo);
    if (!flag) {
        throw new RuntimeException("订单重复提交！");
    }
    this.deleteTradeNo(orderInfo.getUserId());*/
    String key = RedisConst.USER_KEY_PREFIX + orderInfo.getUserId() + ":tradeno";
    String sciptText = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
            "then\n" +
            "    return redis.call(\"del\",KEYS[1])\n" +
            "else\n" +
            "    return 0\n" +
            "end";

    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<Long>();
    redisScript.setScriptText(sciptText);
    redisScript.setResultType(Long.class);
    Long flag = (Long) redisTemplate.execute(redisScript, Arrays.asList(key), tradeNo);
    if (flag == 0) {
        throw new RuntimeException("订单重复提交！");
    }

    List<OrderDetail> orderDetailList = orderInfo.getOrderDetailList();
    if (!CollectionUtils.isEmpty(orderDetailList)) {
        //2.0 声明多个异步任务异常集合-将来异步任务验证失败，将异常信息写入到异常集合中
        List<String> errorList = new ArrayList<>();
        //2.x声明存放异步任务集合
        List<CompletableFuture> completableFutures = new ArrayList<>();

        orderDetailList.forEach(orderDetail -> {
            //2. 远程调用第三方仓储服务-验证订单中订单明细商品库存是否充足
            CompletableFuture<Void> stockCompletableFuture = CompletableFuture.runAsync(() -> {
                Boolean hasStock = this.checkStock(orderDetail.getSkuId(), orderDetail.getSkuNum());
                if (!hasStock) {
                    //throw new RuntimeException("商品:" + orderDetail.getSkuName() + ",库存不足！");
                    errorList.add("商品:" + orderDetail.getSkuName() + ",库存不足！");
                }
            }, threadPoolExecutor);
            completableFutures.add(stockCompletableFuture);

            //3. 远程调用商品服务-验证订单中订单明细商品价格是否变化
            CompletableFuture<Void> priceCompletableFuture = CompletableFuture.runAsync(() -> {
                //3.1 先查询商品最新价格
                BigDecimal skuPrice = productFeignClient.getSkuPrice(orderDetail.getSkuId());
                //3.2 比较订单明细价格跟数据库商品价格是否一致
                if (orderDetail.getOrderPrice().compareTo(skuPrice) != 0) {
                    //3.3 如果价格不一致，提示错误信息同时，修改当前用户购物车商品价格
                    String cartKey = USER_KEY_PREFIX + orderInfo.getUserId() + USER_CART_KEY_SUFFIX;
                    BoundHashOperations<String, String, CartInfo> hashOps = redisTemplate.boundHashOps(cartKey);
                    String hashKey = orderDetail.getSkuId().toString();
                    if (hashOps.hasKey(hashKey)) {
                        CartInfo cartInfo = hashOps.get(hashKey);
                        cartInfo.setSkuPrice(skuPrice);
                        hashOps.put(hashKey, cartInfo);
                    }
                    //throw new RuntimeException("商品" + orderDetail.getSkuName() + ",价格发生变化，请重新提交订单！");
                    errorList.add("商品" + orderDetail.getSkuName() + ",价格发生变化，请重新提交订单！");
                }
            }, threadPoolExecutor);
            completableFutures.add(priceCompletableFuture);

        });
        //4.保证所有异步任务都执行完毕
        CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[completableFutures.size()])).join();

        //5.判断异常集合是否有值 有值：某件商品验证失败
        if (!CollectionUtils.isEmpty(errorList)) {
            String errorMsg = errorList.stream().collect(Collectors.joining(","));
            throw new RuntimeException(errorMsg);
        }
    }
    //5.将订单以及订单明细保存
    Long orderId = this.saveOrder(orderInfo);

    //6.TODO 已经提交订单商品在购物车中清理（后续频繁进行提交订单）
    return orderId;
}

4、我的订单

YAPI接口地址：http://192.168.200.128:3000/project/11/interface/api/763

4.4 添加controller接口

在OrderApiController类添加处理我的订单列表方法

/**
 * 分页获取用户订单列表(包含订单明细)
 *
 * @param page
 * @param limit
 * @return
 */
@GetMapping("/auth/{page}/{limit}")
public Result getOrderByPage(HttpServletRequest request, @PathVariable("page") Long page, @PathVariable("limit") Long limit) {
    //1.获取登录用户ID
    String userId = AuthContextHolder.getUserId(request);
    //2.构建分页对象
    Page<OrderInfo> pageInfo = new Page<>(page, limit);
    //3.调用业务层查询
    pageInfo = orderInfoService.getOrderByPage(pageInfo, userId);
    return Result.ok(pageInfo);
}

4.1 添加service接口

在OrderService类添加接口

/**
 * 分页获取用户订单列表(包含订单明细)
 *
 * @param pageInfo 分页信息
 * @param userId 用户ID
 * @return
 */
Page<OrderInfo> getOrderByPage(Page<OrderInfo> pageInfo, String userId);

4.2 添加service接口实现

在OrderServiceImpl类添加接口实现

/**
 * 分页获取用户订单列表(包含订单明细)
 *
 * @param pageInfo 分页信息
 * @param userId 用户ID
 * @return
 */
@Override
public Page<OrderInfo> getOrderByPage(Page<OrderInfo> pageInfo, String userId) {
    //获取持久层对象调用动态SQL
    return this.getBaseMapper().getOrderByPage(pageInfo, userId);
}

4.3 添加mapper接口

在OrderInfoMapper类添加接口

package com.atguigu.gmall.order.mapper;
   
import com.atguigu.gmall.order.model.OrderInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Param;
   
/**
* 订单表 订单表 Mapper 接口
*
* @author atguigu
* @since 2023-06-25
*/
public interface OrderInfoMapper extends BaseMapper<OrderInfo> {
   
   /**
    * MP动态SQL实现分页,只需要传入Page分页对象,MP框架会自动拼接limit关键字
    * @param pageInfo
    * @param userId
    * @return
    */
   Page<OrderInfo> getOrderByPage(Page<OrderInfo> pageInfo, @Param("userId") String userId);
   
}

添加接口对应的xml文件方法

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.atguigu.gmall.order.mapper.OrderInfoMapper">
   
   <!--自定义结果集完成订单跟订单明细一对多配置-->
   <resultMap id="orderInfoMap" type="com.atguigu.gmall.order.model.OrderInfo" autoMapping="true">
       <id column="id" property="id"></id>
       <collection property="orderDetailList" ofType="com.atguigu.gmall.order.model.OrderDetail" autoMapping="true">
           <id column="order_detail_id" property="id"/>
       </collection>
   </resultMap>
   
   
   <select id="getOrderByPage" resultMap="orderInfoMap">
       select
           oi.id,
           oi.consignee,
           oi.consignee_tel,
           oi.total_amount,
           oi.order_status,
           oi.payment_way,
           oi.delivery_address,
           oi.order_comment,
           oi.out_trade_no,
           oi.trade_body,
           oi.tracking_no,
           oi.img_url,
           oi.create_time,
           od.id order_detail_id,
           od.sku_id,
           od.sku_name,
           od.sku_num,
           od.img_url,
           od.order_price
       from order_info oi inner join order_detail od
                                     on od.order_id = oi.id
       where oi.user_id = #{userId} and oi.order_status!='SPLIT' and oi.is_deleted = 0
       order by oi.create_time desc
   </select>
</mapper>

状态处理:在OrderInfo增加获取状态中文方法

/**
 * 订单状态:中文
 *
 * @return
 */
public String getOrderStatusName() {
    if (StringUtils.isEmpty(orderStatus)) {
        return "未知类型";
    }
    return OrderStatus.getStatusNameByStatus(orderStatus);
}

4.5 web-all 中添加控制器

OrderController

/**
 * 我的订单
 * @return
 */
@GetMapping("myOrder.html")
public String myOrder() {
    return "order/myOrder";
}

第12章-订单.md 58 KB Permalink History Raw