第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.api;

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-05-06 09:31
 */
@RestController
@RequestMapping("/api/user")
public class UserApiController {

    @Autowired
    private UserAddressService userAddressService;


    /**
     * 根据指定用户查询用户收件地址列表
     * @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-05-04
 */
public interface UserAddressService extends IService<UserAddress> {

    /**
     * 根据指定用户查询用户收件地址列表
     * @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-05-04
 */
@Service
public class UserAddressServiceImpl extends ServiceImpl<UserAddressMapper, UserAddress> implements UserAddressService {

    /**
     * 根据指定用户查询用户收件地址列表
     *
     * @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", fallback = UserDegradeFeignClient.class)
public interface UserFeignClient {
   
   /**
    * 根据指定用户查询用户收件地址列表
    *
    * @param userId
    * @return
    */
   @GetMapping("/api/user/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 org.springframework.stereotype.Component;
   
import java.util.List;
   
/**
* @author: atguigu
* @create: 2023-05-06 09:36
*/
@Component
public class UserDegradeFeignClient implements UserFeignClient {
   @Override
   public List<UserAddress> getUserAddressListByUserId(Long userId) {
       return null;
   }
}

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

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

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

package com.atguigu.gmall.cart.api;
   
import com.atguigu.gmall.cart.model.CartInfo;
import com.atguigu.gmall.cart.service.CartService;
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-05-06 09:40
*/
@RestController
@RequestMapping("/api/cart")
public class CartApiController {
   
   @Autowired
   private CartService cartService;
   
   /**
    * 查询指定用户选中购物车商品列表
    * @param userId
    * @return
    */
   @GetMapping("/getCartCheckedList/{userId}")
   public List<CartInfo> getCartCheckedList(@PathVariable("userId") Long userId){
       return cartService.getCartCheckedList(userId);
   }
}

CartService业务层接口

/**
* 查询指定用户购物车中选中商品列表
* @param userId
* @return
*/
List<CartInfo> getCartCheckedList(Long userId);

CartServiceImpl业务层实现类

/**
* 查询指定用户选中购物车商品列表
*
* @param userId
* @return
*/
@Override
public List<CartInfo> getCartCheckedList(Long userId) {
   //1.构建用户购物车hash结构key
   String cartKey = RedisConst.USER_KEY_PREFIX + userId + RedisConst.USER_CART_KEY_SUFFIX;
   BoundHashOperations<String, String, CartInfo> hashOps = redisTemplate.boundHashOps(cartKey);
   List<CartInfo> cartInfoList = hashOps.values();
   //2.查询购物车列表,对购物数据进行过滤
   if(!CollectionUtils.isEmpty(cartInfoList)){
       cartInfoList = cartInfoList.stream().filter(cartInfo -> {
           // true :需要数据   false:不需要的数据
           return cartInfo.getIsChecked().intValue() == 1;
       }).collect(Collectors.toList());
   }
   if (CollectionUtils.isEmpty(cartInfoList)) {
       throw new RuntimeException("没有需要结算商品!");
   }
   return cartInfoList;
}

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

package com.atguigu.gmall.cart.client;
   
import com.atguigu.gmall.cart.client.impl.CartDegradeFeignClient;
import com.atguigu.gmall.cart.model.CartInfo;
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-cart",path = "/api/cart", fallback = CartDegradeFeignClient.class)
public interface CartFeignClient {
   
   /**
    * 查询指定用户选中购物车商品列表
    * @param userId
    * @return
    */
   @GetMapping("/getCartCheckedList/{userId}")
   public List<CartInfo> getCartCheckedList(@PathVariable("userId") Long userId);
}

服务降级类

package com.atguigu.gmall.cart.client.impl;
   
import com.atguigu.gmall.cart.client.CartFeignClient;
import com.atguigu.gmall.cart.model.CartInfo;
import org.springframework.stereotype.Component;
   
import java.util.List;
   
/**
* @author: atguigu
* @create: 2023-05-06 09:48
*/
@Component
public class CartDegradeFeignClient implements CartFeignClient {
   @Override
   public List<CartInfo> getCartCheckedList(Long userId) {
       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;

@SpringBootApplication
@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.api;
   
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-05-06 10:34
*/
@RestController
@SuppressWarnings("all")
@RequestMapping("/api/order/auth")
public class OrderApiController {
   
   @Autowired
   private OrderInfoService orderInfoService;
   
   
   /**
    * 汇总渲染订单确认页面所选的数据
    *
    * @return
    */
   @GetMapping("/trade")
   public Result orderTrade(HttpServletRequest request) {
       //1.获取当前登录用户ID
       String userId = AuthContextHolder.getUserId(request);
       //2.调用业务逻辑汇总订单确认数据
       Map<String, Object> mapResult = orderInfoService.trade(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-05-06
*/
public interface OrderInfoService extends IService<OrderInfo> {
   
   /**
    * 汇总订单确认页面所需数据
    * @param userId 用户ID
    * @return
    */
   Map<String, Object> trade(Long userId);
}

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

package com.atguigu.gmall.order.service.impl;
   
import com.atguigu.gmall.cart.client.CartFeignClient;
import com.atguigu.gmall.cart.model.CartInfo;
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 org.springframework.beans.BeanUtils;
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.stream.Collectors;
   
/**
* 订单表 订单表 业务实现类
*
* @author atguigu
* @since 2023-05-06
*/
@Service
@SuppressWarnings("all")
public class OrderInfoServiceImpl extends ServiceImpl<OrderInfoMapper, OrderInfo> implements OrderInfoService {
   
   
   @Autowired
   private UserFeignClient userFeignClient;
   
   @Autowired
   private CartFeignClient cartFeignClient;
   
   
   /**
    * 汇总订单确认页面所需数据
    *
    * @param userId 用户ID
    * @return
    */
   @Override
   public Map<String, Object> trade(Long userId) {
       HashMap<String, Object> mapResult = new HashMap<>();
       //1.调用用户微服务获取收件地址列表
       List<UserAddress> userAddressList = userFeignClient.getUserAddressListByUserId(userId);
       if (!CollectionUtils.isEmpty(userAddressList)) {
           mapResult.put("userAddressList", userAddressList);
       }
       //2.调用购物车微服务获取需要结算商品
       List<CartInfo> cartCheckedList = cartFeignClient.getCartCheckedList(userId);
       if (!CollectionUtils.isEmpty(cartCheckedList)) {
           //2.1 将集合泛型从购物车转为订单明细类型
           List<OrderDetail> orderDetailList = cartCheckedList.stream().map(cartInfo -> {
               OrderDetail orderDetail = new OrderDetail();
               BeanUtils.copyProperties(cartInfo, orderDetail);
               //2.2 单独设置价格属性
               orderDetail.setOrderPrice(cartInfo.getSkuPrice());
               return orderDetail;
           }).collect(Collectors.toList());
           mapResult.put("detailArrayList", orderDetailList);
           //3.封装${totalNum}订单商品数量
           mapResult.put("totalNum", orderDetailList.size());
           // 4.${totalAmount}:订单总金额
           OrderInfo orderInfo = new OrderInfo();
           orderInfo.setOrderDetailList(orderDetailList);
           orderInfo.sumTotalAmount();
           mapResult.put("totalAmount", orderInfo.getTotalAmount());
       }
       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", fallback = OrderDegradeFeignClient.class)
public interface OrderFeignClient {

    /**
     * 渲染用户订单确认页面相关参数
     *
     * @param request
     * @return
     */
    @GetMapping("/api/order/auth/trade")
    public Result<Map> tradeDatas();
}

服务降级类：

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

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

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

/**
 * @author: atguigu
 * @create: 2023-03-10 11:37
 */
@Component
public class OrderDegradeFeignClient implements OrderFeignClient {
    @Override
    public Result<Map> tradeDatas() {
        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;

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-03-10 11:39
 */
@Controller
public class OrderController {

    @Autowired
    private OrderFeignClient orderFeignClient;

    /**
     * 渲染订单确认页面
     *
     * @param model
     * @return
     */
    @GetMapping("/trade.html")
    public String tradeHtml(Model model) {
        //1.远程调用订单微服务-获取渲染订单确认页面相关数据
        Result<Map> result = orderFeignClient.tradeDatas();
        model.addAllAttributes(result.getData());
        //2.渲染页面
        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
 * @param request
 * @return
 */
@PostMapping("auth/submitOrder")
public Result submitOrder(@RequestBody OrderInfo orderInfo, HttpServletRequest request) {
    // 获取到用户Id
    String userId = AuthContextHolder.getUserId(request);
    orderInfo.setUserId(Long.parseLong(userId));

    // 验证通过，保存订单！
    Long orderId = orderInfoService.saveOrderInfo(orderInfo);
    return Result.ok(orderId);
}

3.3 添加接口与实现类

订单业务接口：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
     * @return
     */
    Long submitOrder(OrderInfo orderInfo);
}

订单业务实现类：OrderServiceImpl

/**
 * 提交保存订单
 *
 * @param orderInfo
 * @return
 */
@Override
public Long submitOrder(OrderInfo orderInfo) {
    //1.避免用户无意使用浏览器回退导致重复提交 todo
    //2.验证商品库存是否充足(远程调用第三方库存系统) todo
    //3.验证订单中商品价格是否为发生变化(远程调用商品服务获取) todo
    //4.保存订单,保存订单明细
    Long orderId = saveOrderInfo(orderInfo);
    return orderId;
}

/**
 * 保存订单信息
 *
 * @param orderInfo
 * @return
 */
@Transactional(rollbackFor = Exception.class)
private Long saveOrderInfo(OrderInfo orderInfo) {
    //1.保存订单信息
    //1.1 为订单对象中部分属性赋值
    orderInfo.sumTotalAmount();//订单总金额
    orderInfo.setOrderStatus(OrderStatus.UNPAID.name());
    //生成订单唯一编号 改编号用于支付  TODO 采用雪花算法生成
    String outTradeNo = "SPH" + System.currentTimeMillis();
    orderInfo.setOutTradeNo(outTradeNo);
    List<OrderDetail> orderDetailList = orderInfo.getOrderDetailList();
    if (!CollectionUtils.isEmpty(orderDetailList)) {
        orderInfo.setImgUrl(orderDetailList.get(0).getImgUrl()); //默认订单显示商品图片
        String tradeBody = orderDetailList.stream()
                .map(OrderDetail::getSkuName).collect(Collectors.joining(","));
        if (tradeBody.length() > 100) {
            tradeBody.substring(0, 100);
        }
        orderInfo.setTradeBody(tradeBody);
    }
    orderInfo.setOperateTime(new Date());
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.HOUR, 1);
    orderInfo.setExpireTime(calendar.getTime());
    orderInfo.setProcessStatus(ProcessStatus.UNPAID.name());
    //todo 从提交用户收件地址中获取  得到用户收件地址详细信息获取
    orderInfo.setProvinceId(1L);
    //1.2 执行订单保存
    this.save(orderInfo);
    Long orderId = orderInfo.getId();

    //2.保存订单明细信息
    orderDetailList.stream().forEach(orderDetail -> {
        orderDetail.setOrderId(orderId);
        //sourceId 1商城订单
        orderDetail.setSourceId(1L);
        orderDetail.setSourceType("MALL");
    });
    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实现类

@Autowired
private RedisTemplate redisTemplate;


/**
 * 为生成订单确认页面中流水号
 *
 * @param userId
 * @return
 */
@Override
public String generateTradeNo(String userId) {
    String tradeNo = UUID.randomUUID().toString().replaceAll("-", "");
    String tradeKey = "tradeNo:" + userId;
    redisTemplate.opsForValue().set(tradeKey, tradeNo);
    return tradeNo;
}

/**
 * 验证用户提交流水号,跟redis中流水号是否一致
 *
 * @param userId
 * @param tradeNo 客户端提交流水号
 * @return
 */
@Override
public Boolean checkTradeNo(String userId, String tradeNo) {
    String tradeKey = "tradeNo:" + userId;
    String redisTradeNo = (String) redisTemplate.opsForValue().get(tradeKey);
    return tradeNo.equals(redisTradeNo);
}

/**
 * 删除流水号
 *
 * @param userId
 */
@Override
public void deleteTradeNo(String userId) {
    String tradeKey = "tradeNo:" + userId;
    redisTemplate.delete(tradeKey);
}

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

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

/**
 * 汇总渲染页面所有的数据
 *
 * @param userId 用户ID
 * @return
 */
@Override
public Map<String, Object> trade(String userId) {
    //~~~~~省略代码
    //3. 避免订单重复提交,渲染订单确认页面中回显-业务唯一流水号 tradeNo
    String tradeNo = this.generateTradeNo(userId);
    tradeMap.put("tradeNo", tradeNo);
    return tradeMap;
}

3.5.3 在OrderApiController控制器中实现

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

/**
 * 提交保存订单
 *
 * @param orderInfo
 * @param tradeNo
 * @return
 */
@Override
public Long submitOrder(OrderInfo orderInfo, String tradeNo) {
    //1.避免用户无意使用浏览器回退导致重复提交
    //Boolean flag = checkTradeNo(orderInfo.getUserId() + "", tradeNo);
    //if (!flag) {
    //    throw new RuntimeException("请勿重复提交订单!");
    //}
    ////1.1 将流水号删除
    //deleteTradeNo(orderInfo.getUserId().toString());

    //采用lua脚本保证判断流水号 删除流水号原子性
    String luaScriptText = "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<>();
    redisScript.setScriptText(luaScriptText);
    redisScript.setResultType(Long.class);
    String tradeKey = "tradeNo:" + orderInfo.getUserId();
    Long flag = (Long) redisTemplate.execute(redisScript, Arrays.asList(tradeKey), tradeNo);
    if(flag.intValue()==0){
        throw new RuntimeException("请勿重复提交订单!");
    }
    //2.验证商品库存是否充足(远程调用第三方库存系统) todo
    //3.验证订单中商品价格是否为发生变化(远程调用商品服务获取) todo
    //4.保存订单,保存订单明细
    Long orderId = saveOrderInfo(orderInfo);
    return orderId;
}

3.6 验库存与验证价格

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

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

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

详见《库存管理系统》

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

3.6.1 导入项目ware-manage项目

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

打开库存项目

点击OK.

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

填写库存信息！

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

验证库存：

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

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

验证库存数量方法

在orderService接口中定义验库存接口

/**
 * 验证库存
 * @param skuId
 * @param skuNum
 * @return
 */
boolean checkStock(Long skuId, Integer skuNum);

实现类OrderInfoServiceImpl


@Value("${ware.url}")
private String WARE_URL;

@Override
public boolean checkStock(Long skuId, Integer skuNum) {
    // 远程调用http://localhost:9001/hasStock?skuId=10221&num=2
    String result = HttpClientUtil.doGet(WARE_URL + "/hasStock?skuId=" + skuId + "&num=" + skuNum);
    return "1".equals(result);
}

3.6.3 submitOrder中增加方法


@Value("${ware.url}")
private String wareUrl;

@Autowired
private ProductFeignClient productFeignClient;


/**
 * 提交保存订单
 *
 * @param orderInfo
 * @param tradeNo
 * @return
 */
@Override
public Long submitOrder(OrderInfo orderInfo, String tradeNo) {
    //1.避免用户无意使用浏览器回退导致重复提交
    //Boolean flag = checkTradeNo(orderInfo.getUserId() + "", tradeNo);
    //if (!flag) {
    //    throw new RuntimeException("请勿重复提交订单!");
    //}
    ////4.1 将流水号删除
    //deleteTradeNo(orderInfo.getUserId().toString());

    //采用lua脚本保证判断流水号 删除流水号原子性
    String luaScriptText = "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<>();
    redisScript.setScriptText(luaScriptText);
    redisScript.setResultType(Long.class);
    String tradeKey = "tradeNo:" + orderInfo.getUserId();
    Long flag = (Long) redisTemplate.execute(redisScript, Arrays.asList(tradeKey), tradeNo);
    if (flag.intValue() == 0) {
        throw new RuntimeException("请勿重复提交订单!");
    }
    //2.验证商品库存是否充足(远程调用第三方库存系统) todo
    //3.验证订单中商品价格是否为发生变化(远程调用商品服务获取) todo
    //2.1 获取订单中所有订单商品明细 遍历商品 验证库存 验证价格
    List<OrderDetail> orderDetailList = orderInfo.getOrderDetailList();
    if (!CollectionUtils.isEmpty(orderDetailList)) {
        for (OrderDetail orderDetail : orderDetailList) {
            //2.2 远程调用第三方库存系统获取库存是否冲突 http://localhost:9001/hasStock?skuId=20&num=7
            String skuWareUrl = wareUrl + "/hasStock?skuId=" + orderDetail.getSkuId() + "&num=" + orderDetail.getSkuNum();
            String hashStock = HttpClientUtil.doGet(skuWareUrl);
            if (hashStock.equals("0")) {
                throw new RuntimeException("商品库存不足");
            }
            //2.3 远程调用商品微服务获取商品价格是否为最新
            BigDecimal skuPrice = productFeignClient.getSkuPrice(orderDetail.getSkuId());
            if (skuPrice.compareTo(orderDetail.getOrderPrice()) != 0) {
                //2.4 更新当前用户购物车中缓存价格更新为最新
                String cartKey = RedisConst.USER_KEY_PREFIX + orderInfo.getUserId() + RedisConst.USER_CART_KEY_SUFFIX;
                BoundHashOperations<String, String, CartInfo> hashOps = redisTemplate.boundHashOps(cartKey);
                CartInfo cartInfo = hashOps.get(orderDetail.getSkuId().toString());
                if (cartInfo != null) {
                    cartInfo.setSkuPrice(skuPrice);
                    hashOps.put(orderDetail.getSkuId().toString(), cartInfo);
                }
                throw new RuntimeException("订单中商品价格失效!");
            }
        }
    }
    //4.保存订单,保存订单明细
    Long orderId = saveOrderInfo(orderInfo);
    return orderId;
}

3.6.4 优化下单

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

3.6.4.1 引入线程类

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

package com.atguigu.gmall.order.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Configuration
public class ThreadPoolConfig {

    /**
     *
     * public ThreadPoolExecutor(int corePoolSize,
     *                               int maximumPoolSize,
     *                               long keepAliveTime,
     *                               TimeUnit unit,
     *                               BlockingQueue<Runnable> workQueue,
     *                               ThreadFactory threadFactory,
     *                               RejectedExecutionHandler handler)
     * 构造函数的参数含义如下：
     *
     * corePoolSize:指定了线程池中的线程数量，它的数量决定了添加的任务是开辟新的线程去执行，还是放到workQueue任务队列中去；
     * maximumPoolSize:指定了线程池中的最大线程数量，这个参数会根据你使用的workQueue任务队列的类型，决定线程池会开辟的最大线程数量；
     * keepAliveTime:当线程池中空闲线程数量超过corePoolSize时，多余的线程会在多长时间内被销毁；
     * unit:keepAliveTime的单位
     * workQueue:任务队列，被添加到线程池中，但尚未被执行的任务；它一般分为直接提交队列、有界任务队列、无界任务队列、优先任务队列几种；
     * threadFactory:线程工厂，用于创建线程，一般用默认即可；
     * handler:拒绝策略；当任务太多来不及处理时，如何拒绝任务；
     * @return
     */
    @Bean
    public ThreadPoolExecutor threadPoolExecutor(){

        return new ThreadPoolExecutor(50, 500, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10000));
    }
}

3.6.4.2 调整下单类

@Autowired
private ThreadPoolExecutor threadPoolExecutor;



/**
 * 提交保存订单
 *
 * @param orderInfo
 * @param tradeNo
 * @return
 */
@Override
public Long submitOrder(OrderInfo orderInfo, String tradeNo) {
    //1.避免用户无意使用浏览器回退导致重复提交
    //Boolean flag = checkTradeNo(orderInfo.getUserId() + "", tradeNo);
    //if (!flag) {
    //    throw new RuntimeException("请勿重复提交订单!");
    //}
    ////4.1 将流水号删除
    //deleteTradeNo(orderInfo.getUserId().toString());

    //采用lua脚本保证判断流水号 删除流水号原子性
    String luaScriptText = "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<>();
    redisScript.setScriptText(luaScriptText);
    redisScript.setResultType(Long.class);
    String tradeKey = "tradeNo:" + orderInfo.getUserId();
    Long flag = (Long) redisTemplate.execute(redisScript, Arrays.asList(tradeKey), tradeNo);
    if (flag.intValue() == 0) {
        throw new RuntimeException("请勿重复提交订单!");
    }
    //2.验证商品库存是否充足(远程调用第三方库存系统) todo
    //3.验证订单中商品价格是否为发生变化(远程调用商品服务获取) todo
    //2.1 获取订单中所有订单商品明细 遍历商品 验证库存 验证价格
    List<OrderDetail> orderDetailList = orderInfo.getOrderDetailList();
    //定义错误信息集合
    List<String> erroMsgList = new ArrayList<>();
    //定义异步任务集合
    ArrayList<CompletableFuture> allCompletableFutures = new ArrayList<>();
    if (!CollectionUtils.isEmpty(orderDetailList)) {
        for (OrderDetail orderDetail : orderDetailList) {

            //2.2 远程调用第三方库存系统获取库存是否冲突 http://localhost:9001/hasStock?skuId=20&num=7
            CompletableFuture<Void> stockCompletableFuture = CompletableFuture.runAsync(() -> {
                String skuWareUrl = wareUrl + "/hasStock?skuId=" + orderDetail.getSkuId() + "&num=" + orderDetail.getSkuNum();
                String hashStock = HttpClientUtil.doGet(skuWareUrl);
                if (hashStock.equals("0")) {
                    //throw new RuntimeException("商品库存不足");
                    erroMsgList.add("库存不足:" + orderDetail.getSkuName());
                }
            }, threadPoolExecutor);
            allCompletableFutures.add(stockCompletableFuture);


            //2.3 远程调用商品微服务获取商品价格是否为最新
            CompletableFuture<Void> priceCompletableFuture = CompletableFuture.runAsync(() -> {
                log.info("验证价格:{}", orderDetail.getSkuId());
                BigDecimal skuPrice = productFeignClient.getSkuPrice(orderDetail.getSkuId());
                if (skuPrice.compareTo(orderDetail.getOrderPrice()) != 0) {
                    //2.4 更新当前用户购物车中缓存价格更新为最新
                    String cartKey = RedisConst.USER_KEY_PREFIX + orderInfo.getUserId() + RedisConst.USER_CART_KEY_SUFFIX;
                    BoundHashOperations<String, String, CartInfo> hashOps = redisTemplate.boundHashOps(cartKey);
                    CartInfo cartInfo = hashOps.get(orderDetail.getSkuId().toString());
                    if (cartInfo != null) {
                        cartInfo.setSkuPrice(skuPrice);
                        hashOps.put(orderDetail.getSkuId().toString(), cartInfo);
                    }
                    // 收集价格失效商品
                    erroMsgList.add("价格失效:" + orderDetail.getSkuName());
                }
            }, threadPoolExecutor);

            allCompletableFutures.add(priceCompletableFuture);
        }
        // 将所有异步任务执行
        CompletableFuture
                .allOf(allCompletableFutures.toArray(new CompletableFuture[allCompletableFutures.size()]))
                .join();

        // 判断错误集合是否有数据
        if (!CollectionUtils.isEmpty(erroMsgList)) {
            String errorMsg = erroMsgList.
                    stream().collect(Collectors.joining(","));
            throw new RuntimeException(errorMsg);
        }
    }

    //4.保存订单,保存订单明细
    Long orderId = saveOrderInfo(orderInfo);
    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("/{page}/{limit}")
public Result getOrderList(HttpServletRequest request, @PathVariable("page") Long page, @PathVariable("limit") Long limit) {
    Page<OrderInfo> infoPage = new Page<>(page, limit);
    //获取当前用户ID
    String userId = AuthContextHolder.getUserId(request);
    infoPage = orderInfoService.getOrderList(infoPage, userId);
    return Result.ok(infoPage);
}

4.1 添加service接口

在OrderService类添加接口

/**
 * 查看我的订单.
 * @param orderInfoPage
 * @param userId
 * @param orderStatus
 * @return
 */
IPage<OrderInfo> getOrder(Page<OrderInfo> orderInfoPage, String userId, String orderStatus);

4.2 添加service接口实现

在OrderServiceImpl类添加接口实现

/**
 * 查询我的订单列表
 *
 * @param page
 * @param limit
 * @return
 */
@Override
public Page<OrderInfo> getOrderList(Page<OrderInfo> infoPage, String userId) {
    //方式一:采用Wrapper 先查询当前用户所有订单 遍历订单 查询当前订单包含订单明细
    //方式二:编写自定义SQL
    OrderInfoMapper orderInfoMapper = this.getBaseMapper();
    infoPage = orderInfoMapper.getOrderList(infoPage, userId);
    return infoPage;
}

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-05-06
*/
public interface OrderInfoMapper extends BaseMapper<OrderInfo> {
   
   /**
    * 分页查询当前用户订单列表
    * @param infoPage
    * @param userId
    * @return
    */
   Page<OrderInfo> getOrderList(Page<OrderInfo> infoPage, @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_deatil_id" property="id"></id>
       </collection>
   </resultMap>
   
   <!--查询用户订单列表-->
   <select id="getOrderList" resultMap="orderInfoMap">
       select
           oi.id,
           oi.consignee,
           oi.consignee_tel,
           oi.total_amount,
           oi.order_status,
           oi.user_id,
           oi.payment_way,
           oi.delivery_address,
           oi.order_comment,
           oi.out_trade_no,
           oi.trade_body,
           od.id order_deatil_id,
           od.sku_id,
           od.sku_name,
           od.img_url,
           od.order_price,
           od.sku_num
       from order_info oi inner join  order_detail od on od.order_id = oi.id
       where oi.user_id = #{userId}
       order by  oi.create_time
   </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 51 KB Permalink History Raw