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

import java.util.List;

/**
 * @author: atguigu
 * @create: 2023-03-10 09:46
 */
@RestController
@RequestMapping("/api/user")
public class UserApiController {

    @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-03-07
 */
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-03-07
 */
@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", fallback = UserDegradeFeignClient.class)
public interface UserFeignClient {
   
   /**
    * 根据用户ID查询用户收件地址列表
    *
    * @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-03-10 09:51
*/
@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-03-10 10:17
*/
@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结构redisKey
   String cartKey = getCartKey(userId.toString());
   //2.查询所有购物车商品列表
   BoundHashOperations<String, String, CartInfo> hashOps = redisTemplate.boundHashOps(cartKey);
   List<CartInfo> cartInfoList = hashOps.values();
   //3.将购物车信息中isChecked=1过滤出来
   if (!CollectionUtils.isEmpty(cartInfoList)) {
       cartInfoList = cartInfoList.stream().filter(cartInfo -> {
           //过滤条件  true:需要数据  false:不需要数据
           return cartInfo.getIsChecked().intValue() == 1;
       }).collect(Collectors.toList());
   }
   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.stereotype.Service;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
   
import java.util.List;
   
@FeignClient(value = "service-cart", fallback = CartDegradeFeignClient.class)
public interface CartFeignClient {
   
   /**
    * 查询指定用户购物车中选中商品列表
    *
    * @param userId
    * @return
    */
   @GetMapping("/api/cart/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-03-10 10:30
*/
@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.checkerframework.checker.units.qual.A;
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-03-10 10:45
*/
@RestController
@RequestMapping("/api/order")
public class OrderApiController {
   
   
   @Autowired
   private OrderInfoService orderInfoService;
   
   
   /**
    * 渲染用户订单确认页面相关参数
    *
    * @param request
    * @return
    */
   @GetMapping("/auth/trade")
   public Result<Map> tradeDatas(HttpServletRequest request) {
       String userId = AuthContextHolder.getUserId(request);
       //调用业务层封装相关数据
       Map<String, Object> mapData = orderInfoService.tradeDatas(userId);
       return Result.ok(mapData);
   }
}

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-03-10
*/
public interface OrderInfoService extends IService<OrderInfo> {
   
   /**
    * 渲染用户订单确认页面相关参数
    *
    * @param userId 用户ID
    * @return
    */
   Map<String, Object> tradeDatas(String 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.product.client.ProductFeignClient;
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.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-03-10
*/
@Service
public class OrderInfoServiceImpl extends ServiceImpl<OrderInfoMapper, OrderInfo> implements OrderInfoService {
   
   @Autowired
   private ProductFeignClient productFeignClient;
   
   @Autowired
   private CartFeignClient cartFeignClient;
   
   @Autowired
   private UserFeignClient userFeignClient;
   
   
   /**
    * 汇总渲染页面所有的数据
    *
    * @param userId 用户ID
    * @return
    */
   @Override
   public Map<String, Object> tradeDatas(String userId) {
       System.err.println("userId:"+userId);
       Map<String, Object> tradeMap = new HashMap<>();
       //1.远程调用用户微服务得到当前用户收件地址列表 userAddressList
       List<UserAddress> userAddressList = userFeignClient.getUserAddressListByUserId(Long.valueOf(userId));
       if (!CollectionUtils.isEmpty(userAddressList)) {
           tradeMap.put("userAddressList", userAddressList);
       }
       //2.远程调用购物车微服务得到当前用户购物车中选中商品列表-商品清单 detailArrayList
       List<CartInfo> cartCheckedList = cartFeignClient.getCartCheckedList(Long.valueOf(userId));
       if (!CollectionUtils.isEmpty(cartCheckedList)) {
           //2.0 将得到集合中购物车对象CartInfo转为订单明细对象OrderDetail
           List<OrderDetail> orderDetailList = cartCheckedList.stream().map(cartInfo -> {
               OrderDetail orderDetail = new OrderDetail();
               orderDetail.setSkuId(cartInfo.getSkuId());
               orderDetail.setSkuName(cartInfo.getSkuName());
               orderDetail.setSkuNum(cartInfo.getSkuNum());
               orderDetail.setImgUrl(cartInfo.getImgUrl());
               orderDetail.setOrderPrice(productFeignClient.getSkuPrice(cartInfo.getSkuId()));
               return orderDetail;
           }).collect(Collectors.toList());
           tradeMap.put("detailArrayList", orderDetailList);
   
           //2.1 封装总商品数量 totalNum
           tradeMap.put("totalNum", cartCheckedList.size());
           //2.2 封装订单总金额 totalAmount
           OrderInfo orderInfo = new OrderInfo();
           orderInfo.setOrderDetailList(orderDetailList);
           //调用计算订单总金额方法
           orderInfo.sumTotalAmount();
           tradeMap.put("totalAmount", orderInfo.getTotalAmount());
       }
       //3.todo 避免订单重复提交,渲染订单确认页面中回显-业务唯一状态码 tradeNo
       return tradeMap;
   }
}

说明：接口已经封装，接下来暴露接口，提供给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;

public interface OrderInfoService extends IService<OrderInfo> {

    /**
     * 保存订单
     * @param orderInfo
     * @return
     */
    Long saveOrderInfo(OrderInfo orderInfo);
}

订单业务实现类：OrderServiceImpl

/**
 * 提交订单
 *
 * @param orderInfo
 * @param tradeNo   用户提交流水号
 * @return
 */
@Override
@Transactional(rollbackFor = Exception.class)
public Long submitOrder(OrderInfo orderInfo, String tradeNo) {
    //1.避免用户采用浏览器回退避免订单多次提交
    String userId = orderInfo.getUserId().toString();
    //Boolean flag = this.checkTradeNo(userId, tradeNo);
    //if (!flag) {
    //    throw new RuntimeException("页面提交参数有误!");
    //}
    //删除流水号
    //this.deleteTradeNo(userId);
    //判断跟删除流水号不是原子操作
    //采用LUA脚本保证 判断跟删除原子操作
    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
    redisScript.setScriptText("if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
            "then\n" +
            "    return redis.call(\"del\",KEYS[1])\n" +
            "else\n" +
            "    return 0\n" +
            "end");
    String redisKey = RedisConst.USER_KEY_PREFIX + userId + ":tradeNo";
    redisScript.setResultType(Long.class);
    Long flag = (Long) redisTemplate.execute(redisScript, Arrays.asList(redisKey), tradeNo);
    if (flag.intValue() == 0) {
        throw new RuntimeException("页面提交参数有误!");
    }

    //2.todo 调用第三方库存系统(仓储服务)接口进行验证商品库存

    //3.todo 调用商品微服务获取商品价格,验证商品价格是否发生变化

    //4.保存订单信息
    //4.1 封装订单表中其他信息
    orderInfo.sumTotalAmount();
    orderInfo.setOriginalTotalAmount(orderInfo.getTotalAmount());
    orderInfo.setOrderStatus(OrderStatus.UNPAID.name());
    orderInfo.setProcessStatus(ProcessStatus.UNPAID.name());
    orderInfo.setPaymentWay(PaymentType.ALIPAY.name());
    //生成订单编号(唯一)
    String outTradeNo = "ATGUIGU" + System.currentTimeMillis() + new Random().nextInt(1000);
    orderInfo.setOutTradeNo(outTradeNo);
    //获取商品名称
    List<OrderDetail> orderDetailList = orderInfo.getOrderDetailList();
    if (!CollectionUtils.isEmpty(orderDetailList)) {
        String tradeBody = orderDetailList.stream().map(OrderDetail::getSkuName).collect(Collectors.joining(","));
        if (tradeBody.length() > 100) {
            orderInfo.setTradeBody(tradeBody.substring(0, 100));
        } else {
            orderInfo.setTradeBody(tradeBody);
        }
        orderInfo.setImgUrl(orderDetailList.get(0).getImgUrl());
    }
    orderInfo.setOperateTime(new Date());
    //失效时间:24小时 超过该时间订单关闭
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.DATE, 1);
    orderInfo.setExpireTime(calendar.getTime());
    orderInfo.setProvinceId(1L); //正常按照前端提交地址ID查询用户地址信息
    calendar.add(Calendar.DATE, 30);
    orderInfo.setRefundableTime(calendar.getTime());
    //4.2 保存订单
    this.save(orderInfo);

    //5.保存订单明细信息
    for (OrderDetail orderDetail : orderDetailList) {
        orderDetail.setOrderId(orderInfo.getId());
        orderDetail.setSourceId(1L);
        orderDetail.setSourceType("MALL");
    }
    //批量保存订单明细
    orderDetailService.saveBatch(orderDetailList);
    return orderInfo.getId(); //返回订单ID
}

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 uuid = UUID.randomUUID().toString().replaceAll("-", "");
    String redisKey = RedisConst.USER_KEY_PREFIX + userId + ":tradeNo";
    redisTemplate.opsForValue().set(redisKey, uuid, 1, TimeUnit.DAYS);
    return uuid;
}

/**
 * 验证用户提交流水号跟Redis中流水号是否一致
 *
 * @param userId  用户ID
 * @param tradeNo 前端页面提交流水号
 * @return
 */
@Override
public Boolean checkTradeNo(String userId, String tradeNo) {
    //1.先查询redis中流水号是否有值
    String redisKey = RedisConst.USER_KEY_PREFIX + userId + ":tradeNo";
    String redisTradeNo = (String) redisTemplate.opsForValue().get(redisKey);
    if (StringUtils.isBlank(redisTradeNo)) {
        return false;
    }
    //2.判断流水号是否一致
    return redisTradeNo.equals(tradeNo);
}

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

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

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

/**
 * 汇总渲染页面所有的数据
 *
 * @param userId 用户ID
 * @return
 */
@Override
public Map<String, Object> tradeDatas(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
@Transactional(rollbackFor = Exception.class)
public Long submitOrder(OrderInfo orderInfo, String tradeNo) {
    //1.避免用户采用浏览器回退避免订单多次提交
    String userId = orderInfo.getUserId().toString();
    //Boolean flag = this.checkTradeNo(userId, tradeNo);
    //if (!flag) {
    //    throw new RuntimeException("页面提交参数有误!");
    //}
    //删除流水号
    //this.deleteTradeNo(userId);
    //判断跟删除流水号不是原子操作
    //采用LUA脚本保证 判断跟删除原子操作
    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
    redisScript.setScriptText("if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
            "then\n" +
            "    return redis.call(\"del\",KEYS[1])\n" +
            "else\n" +
            "    return 0\n" +
            "end");
    String redisKey = RedisConst.USER_KEY_PREFIX + userId + ":tradeNo";
    redisScript.setResultType(Long.class);
    Long flag = (Long) redisTemplate.execute(redisScript, Arrays.asList(redisKey), tradeNo);
    if (flag.intValue() == 0) {
        throw new RuntimeException("页面提交参数有误!");
    }

    //2.todo 调用第三方库存系统(仓储服务)接口进行验证商品库存

    //3.todo 调用商品微服务获取商品价格,验证商品价格是否发生变化


    //4.保存订单 订单明细 省略...
    return orderInfo.getId(); //返回订单ID
}

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中增加方法

/**
 * 订单保存业务
 * 1.防止订单重复提交
 * 2.验证每件商品库存是否充足，商品价格是否为最新
 * 3.保存订单以及订单详情
 * 4.购物车中中结算商品删除
 * 5.返回订单ID
 *
 * @param orderInfo 订单信息
 * @param tradeNo   用户提交流水号
 * @return
 */
@Override
public Long submitOrder(OrderInfo orderInfo, String tradeNo) {
    //1.防止订单重复提交 如果判断+删除java代码实现 不是原子操作
    String userId = orderInfo.getUserId().toString();
    //Boolean flag = this.checkTradeCode(userId, tradeNo);
    //if (!flag) {
    //    //抛出运行时异常或者自定义异常，封装错误提示信息给前端
    //    throw new RuntimeException("请勿重复提交订单！");
    //}
    //this.deleteTradeCode(userId);
    //KEYS[1]:用户流水号Key  ARGV[1]:用户提交流水号
    String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
            "then\n" +
            "    return redis.call(\"del\",KEYS[1])\n" +
            "else\n" +
            "    return 0\n" +
            "end";
    String tradeKey = "user:" + userId + ":tradecode";
    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
    redisScript.setScriptText(script);
    redisScript.setResultType(Long.class);
    Long result = (Long) redisTemplate.execute(redisScript, Arrays.asList(tradeKey), tradeNo);
    if (result == 0) {
        throw new RuntimeException("请勿重复提交订单！");
    }

    //2.验证每件商品库存是否充足，商品价格是否为最新
    //2.1 获取订单中订单详情中商品列表
    List<String> errorMsgList = new ArrayList<>();
    List<OrderDetail> orderDetails = orderInfo.getOrderDetailList();
    if (!CollectionUtils.isEmpty(orderDetails)) {
        String userCartKey = "user:" + userId + ":cart";
        BoundHashOperations<String, String, CartInfo> hashOps = redisTemplate.boundHashOps(userCartKey);
        //2.1遍历过程中判断每个商品库存以及价格是否合法
        for (OrderDetail orderDetail : orderDetails) {
            //2.2检验库存
            String checkStockUrl = "http://localhost:9001/hasStock?skuId=" + orderDetail.getSkuId() + "&num=" + orderDetail.getSkuNum();
            String stockResult = HttpClientUtil.doGet(checkStockUrl);
            if ("0".equals(stockResult)) {
                errorMsgList.add(orderDetail.getSkuName() + "库存不足");
            }
            //2.3查询价格是否为商品最新价格
            BigDecimal skuPrice = productFeignClient.getSkuPrice(orderDetail.getSkuId());
            if (orderDetail.getOrderPrice().compareTo(skuPrice) != 0) {
                //价格不一致
                errorMsgList.add(orderDetail.getSkuName() + "价格失效");
                //2.4修改redis中用户购物车中价格改为最新
                CartInfo cartInfo = hashOps.get(orderDetail.getSkuId().toString());
                cartInfo.setSkuPrice(skuPrice);
                hashOps.put(orderDetail.getSkuId().toString(), cartInfo);
            }
        }
    }
    if (!CollectionUtils.isEmpty(errorMsgList)) {
        throw new RuntimeException(StringUtils.join(errorMsgList, ","));
    }

    //3.保存订单以及订单详情
    //3.1 封装订单相关属性
    orderInfo.sumTotalAmount();
    orderInfo.setOrderStatus(OrderStatus.UNPAID.name());
    orderInfo.setPaymentWay(PaymentWay.ONLINE.name());
    String outTradeNo = "ATGUIGU" + System.currentTimeMillis() + new Random().nextInt(1000);
    orderInfo.setOutTradeNo(outTradeNo);
    orderInfo.setProcessStatus(ProcessStatus.UNPAID.name());
    StringBuilder stringBuilder = new StringBuilder();
    for (OrderDetail orderDetail : orderDetails) {
        stringBuilder.append(orderDetail.getSkuName() + " ");
    }
    if (stringBuilder.toString().length() > 100) {
        orderInfo.setTradeBody(stringBuilder.toString().substring(0, 100));
    } else {
        orderInfo.setTradeBody(stringBuilder.toString());
    }
    orderInfo.setImgUrl(orderDetails.get(0).getImgUrl());
    orderInfo.setOperateTime(new Date());
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.DATE, 1);
    orderInfo.setExpireTime(calendar.getTime());
    //3.2 将订单保存
    this.save(orderInfo);
    //3.3 封装订单详情对象 保存订单详情
    List<OrderDetail> orderDetailList = orderDetails.stream().map(orderDetail -> {
        orderDetail.setOrderId(orderInfo.getId());
        return orderDetail;
    }).collect(Collectors.toList());
    //3.4 批量新增订单详情
    if (!CollectionUtils.isEmpty(orderDetailList)) {
        orderDetailService.saveBatch(orderDetailList);
    }

    //TODO 4.购物车中中结算商品删除
    //5.返回订单ID
    return orderInfo.getId();
}

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;

/**
 * 订单保存业务
 * 1.防止订单重复提交
 * 2.验证每件商品库存是否充足，商品价格是否为最新
 * 3.保存订单以及订单详情
 * 4.购物车中中结算商品删除
 * 5.返回订单ID
 *
 * @param orderInfo 订单信息
 * @param tradeNo   用户提交流水号
 * @return
 */
@Override
public Long submitOrder(OrderInfo orderInfo, String tradeNo) {
    //1.防止订单重复提交 如果判断+删除java代码实现 不是原子操作
    String userId = orderInfo.getUserId().toString();
    //Boolean flag = this.checkTradeCode(userId, tradeNo);
    //if (!flag) {
    //    //抛出运行时异常或者自定义异常，封装错误提示信息给前端
    //    throw new RuntimeException("请勿重复提交订单！");
    //}
    //this.deleteTradeCode(userId);
    //KEYS[1]:用户流水号Key  ARGV[1]:用户提交流水号
    String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
            "then\n" +
            "    return redis.call(\"del\",KEYS[1])\n" +
            "else\n" +
            "    return 0\n" +
            "end";
    String tradeKey = "user:" + userId + ":tradecode";
    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
    redisScript.setScriptText(script);
    redisScript.setResultType(Long.class);
    Long result = (Long) redisTemplate.execute(redisScript, Arrays.asList(tradeKey), tradeNo);
    if (result == 0) {
        throw new RuntimeException("请勿重复提交订单！");
    }

    //2.验证每件商品库存是否充足，商品价格是否为最新
    //2.1 获取订单中订单详情中商品列表
    List<String> errorMsgList = new ArrayList<>();
    //声明集合存放异步任务
    List<CompletableFuture> futureArrayList = new ArrayList<>();
    List<OrderDetail> orderDetails = orderInfo.getOrderDetailList();
    if (!CollectionUtils.isEmpty(orderDetails)) {
        String userCartKey = "user:" + userId + ":cart";
        BoundHashOperations<String, String, CartInfo> hashOps = redisTemplate.boundHashOps(userCartKey);
        //2.1遍历过程中判断每个商品库存以及价格是否合法
        for (OrderDetail orderDetail : orderDetails) {
            //2.2检验库存
            CompletableFuture<Void> stockCompletableFuture = CompletableFuture.runAsync(() -> {
                String checkStockUrl = "http://localhost:9001/hasStock?skuId=" + orderDetail.getSkuId() + "&num=" + orderDetail.getSkuNum();
                String stockResult = HttpClientUtil.doGet(checkStockUrl);
                if ("0".equals(stockResult)) {
                    errorMsgList.add(orderDetail.getSkuName() + "库存不足");
                }
            }, threadPoolExecutor);
            futureArrayList.add(stockCompletableFuture);


            //2.3查询价格是否为商品最新价格
            CompletableFuture<Void> priceCompletableFuture = CompletableFuture.runAsync(() -> {
                BigDecimal skuPrice = productFeignClient.getSkuPrice(orderDetail.getSkuId());
                if (orderDetail.getOrderPrice().compareTo(skuPrice) != 0) {
                    //价格不一致
                    errorMsgList.add(orderDetail.getSkuName() + "价格失效");
                    //2.4修改redis中用户购物车中价格改为最新
                    CartInfo cartInfo = hashOps.get(orderDetail.getSkuId().toString());
                    cartInfo.setSkuPrice(skuPrice);
                    hashOps.put(orderDetail.getSkuId().toString(), cartInfo);
                }
            }, threadPoolExecutor);
            futureArrayList.add(priceCompletableFuture);
        }
    }
    //2.5 多个任务组合执行-并行执行
    CompletableFuture.allOf(futureArrayList.toArray(new CompletableFuture[futureArrayList.size()])).join();

    if (!CollectionUtils.isEmpty(errorMsgList)) {
        throw new RuntimeException(StringUtils.join(errorMsgList, ","));
    }

    //3.保存订单以及订单详情
    //3.1 封装订单相关属性
    orderInfo.sumTotalAmount();
    orderInfo.setOrderStatus(OrderStatus.UNPAID.name());
    orderInfo.setPaymentWay(PaymentWay.ONLINE.name());
    String outTradeNo = "ATGUIGU" + System.currentTimeMillis() + new Random().nextInt(1000);
    orderInfo.setOutTradeNo(outTradeNo);
    orderInfo.setProcessStatus(ProcessStatus.UNPAID.name());
    StringBuilder stringBuilder = new StringBuilder();
    for (OrderDetail orderDetail : orderDetails) {
        stringBuilder.append(orderDetail.getSkuName() + " ");
    }
    if (stringBuilder.toString().length() > 100) {
        orderInfo.setTradeBody(stringBuilder.toString().substring(0, 100));
    } else {
        orderInfo.setTradeBody(stringBuilder.toString());
    }
    orderInfo.setImgUrl(orderDetails.get(0).getImgUrl());
    orderInfo.setOperateTime(new Date());
    Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.DATE, 1);
    orderInfo.setExpireTime(calendar.getTime());
    //3.2 将订单保存
    this.save(orderInfo);
    //3.3 封装订单详情对象 保存订单详情
    List<OrderDetail> orderDetailList = orderDetails.stream().map(orderDetail -> {
        orderDetail.setOrderId(orderInfo.getId());
        return orderDetail;
    }).collect(Collectors.toList());
    //3.4 批量新增订单详情
    if (!CollectionUtils.isEmpty(orderDetailList)) {
        orderDetailService.saveBatch(orderDetailList);
    }

    //TODO 4.购物车中中结算商品删除
    //5.返回订单ID
    return orderInfo.getId();
}

4、我的订单

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

4.4 添加controller接口

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

@GetMapping("/auth/{page}/{limit}")
public Result getOrder(@PathVariable Long page,
                       @PathVariable Long limit,
                       HttpServletRequest request){
    //  查看我的订单. userId
    String userId = AuthContextHolder.getUserId(request);
    //  获取订单状态,
    String orderStatus = request.getParameter("orderStatus");
    //  带分页的查询
    Page<OrderInfo> orderInfoPage = new Page<>(page,limit);
    //  调用服务层方法.
    IPage<OrderInfo> infoIPage = this.orderService.getOrder(orderInfoPage,userId,orderStatus);
    //  返回封装的数据
    return Result.ok(infoIPage);
}

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类添加接口实现

@Override
public IPage<OrderInfo> getOrder(Page<OrderInfo> orderInfoPage, String userId, String orderStatus) {
    //  有订单，就需要有订单明细.
    IPage<OrderInfo> infoIPage = orderInfoMapper.selectOrder(orderInfoPage,userId,orderStatus);
    //  需要编写一个订单的状态名称. order.orderStatusName ,循环遍历订单，根据订单的状态获取订单的名称.
    infoIPage.getRecords().forEach(orderInfo -> {
        String statusNameByStatus = OrderStatus.getStatusNameByStatus(orderInfo.getOrderStatus());
        orderInfo.setOrderStatusName(statusNameByStatus);
    });
    return infoIPage;
}

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.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
   
public interface OrderInfoMapper extends BaseMapper<OrderInfo> {
   
   IPage<OrderInfo> selectOrder(Page<OrderInfo> orderInfoPage, String userId, String orderStatus);
}

添加接口对应的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 property="id" column="id"></id>
       <collection property="orderDetailList" ofType="com.atguigu.gmall.order.model.OrderDetail" autoMapping="true">
           <id property="id" column="order_detail_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_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}
       <if test="orderStatus!=null and orderStatus!=''">
           AND oi.order_status = #{orderStatus}
       </if>
       AND oi.order_status != 'SPLIT'
   </select>
</mapper>

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

/**
 * 订单状态-中文 转JSON调用该属性的get方法
 * @return
 */
public String getOrderStatusName() {
    String statusName = OrderStatus.getStatusNameByStatus(orderStatus);
    return statusName;
}

4.5 web-all 中添加控制器

OrderController

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

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