tingshu-241229/第7章 订单.md

谷粒随享

第7章 订单

学习目标：

• 订单结算（页面渲染）对价格计算
  • 购买项目-VIP（允许重复购买）
  • 购买项目-专辑（只能购买一次）
  • 购买项目-声音（只能购买一次）
• 提交订单（余额付款）-->确保余额安全性
  • 分布式事务解决方案-Seata
• 我的订单
• 订单延迟关单
  • RabbitMQ提供延迟任务

1、订单结算

购买包含分为：

• 购买VIP会员
• 购买专辑
• 购买声音
• vip余额购买

购买VIP入口：

• 购买专辑入口：专辑表的price_type 价格类型 0202 购买整张专辑

1.1 获取账户余额

1.1.1 初始化账户

在新用户第一次登录的时候，就进行了初始化账户余额信息操作！

1.1.2 显示账户余额

当刷新主页的时候，会加载当前余额数据。

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/93

service-account 微服务中UserAccountApiController控制器

package com.atguigu.tingshu.account.api;

import com.atguigu.tingshu.account.service.UserAccountService;
import com.atguigu.tingshu.common.login.GuiGuLogin;
import com.atguigu.tingshu.common.result.Result;
import com.atguigu.tingshu.common.util.AuthContextHolder;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
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 java.math.BigDecimal;

@Tag(name = "用户账户管理")
@RestController
@RequestMapping("api/account")
@SuppressWarnings({"all"})
public class UserAccountApiController {

    @Autowired
    private UserAccountService userAccountService;


    /**
     * 查询当前用户账户可用余额
     *
     * @return 可用余额
     */
    @GuiGuLogin
    @Operation(summary = "查询当前用户账户可用余额")
    @GetMapping("/userAccount/getAvailableAmount")
    public Result<BigDecimal> getAvailableAmount() {
        //1.获取当前登录用户ID
        Long userId = AuthContextHolder.getUserId();
        //2.获取可用余额
        BigDecimal availableAmount = userAccountService.getAvailableAmount(userId);
        return Result.ok(availableAmount);
    }
}

UserAccountService接口：

/**
 * 查询当前用户账户可用余额
 * @param userId
 * @return
 */
BigDecimal getAvailableAmount(Long userId);

UserAccountServiceImpl实现类：

/**
 * 查询当前用户账户可用余额
 *
 * @param userId
 * @return
 */
@Override
public BigDecimal getAvailableAmount(Long userId) {
    LambdaQueryWrapper<UserAccount> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(UserAccount::getUserId, userId);
    queryWrapper.select(UserAccount::getAvailableAmount);
    UserAccount userAccount = userAccountMapper.selectOne(queryWrapper);
    if (userAccount != null) {
        return userAccount.getAvailableAmount();
    }
    return new BigDecimal("0.00");
}

在首页点击专辑封面标识为：VIP免费 会出现访问VIP服务配置管理接口

1.2 VIP会员结算

思路：

1. 专辑订单

   1. 判断用户是否购买过专辑
      1. 如果已购买抛出异常
      2. 未购买{要给订单明细，减免金额，总金额等属性赋值}
         1. 判断用户是否属于vip
         2. vip 计算订单总价与折扣价 赋值订单明细与减免明细
         3. 非vip 计算订单总价与折扣价 赋值订单明细与减免明细

2. vip 订单

   1. 根据Id 获取到vip 配置信息
   2. 赋值原始金额，减免金额，总金额，订单明细，减免金额

3. 生成一个流水号存储到缓存，防止用户重复提交订单

4. 给OrderInfoVo 实体类赋值

   1. 防止用户非法操作订单金额，将订单对象OrderInfoVo变为字符串，在转换为map。在通过工具类SignHelper将map 变为字符串赋值给签名字段

5. 最后返回OrderInfoVo 对象

1.2.1 获取VIP套餐列表

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/85

在service-user 微服务模块中的 VipServiceConfigApiController 控制器添加映射路径，返回 VipServiceConfig 实体类的集合数据。也就是查询vip_service_config表中的集合数据。

package com.atguigu.tingshu.user.api;

import com.atguigu.tingshu.common.result.Result;
import com.atguigu.tingshu.model.user.VipServiceConfig;
import com.atguigu.tingshu.user.service.VipServiceConfigService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
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 java.util.List;

@Tag(name = "VIP服务配置管理接口")
@RestController
@RequestMapping("api/user")
@SuppressWarnings({"all"})
public class VipServiceConfigApiController {

	@Autowired
	private VipServiceConfigService vipServiceConfigService;


    /**
     * 获取平台套餐列表
     *
     * @return
     */
    @Operation(summary = "获取平台套餐列表")
    @GetMapping("/vipServiceConfig/findAll")
    public Result<List<VipServiceConfig>> findAll() {
        List<VipServiceConfig> list = vipServiceConfigService.list();
        return Result.ok(list);
    }
}

1.2.2 根据套餐ID获取套餐详情

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/91

在VipServiceConfigApiController控制器中添加

/**
 * 根据套餐ID查询套餐详情
 * @param id
 * @return
 */
@Operation(summary = "根据套餐ID查询套餐详情")
@GetMapping("/vipServiceConfig/getVipServiceConfig/{id}")
public Result<VipServiceConfig> getVipServiceConfig(@PathVariable Long id) {
    VipServiceConfig vipServiceConfig = vipServiceConfigService.getById(id);
    return Result.ok(vipServiceConfig);
}

在service-user-client 模块UserFeignClient中添加

/**
 * 根据套餐ID查询套餐详情
 * @param id
 * @return
 */
@GetMapping("/vipServiceConfig/getVipServiceConfig/{id}")
public Result<VipServiceConfig> getVipServiceConfig(@PathVariable Long id);

UserDegradeFeignClient熔断类：

@Override
public Result<VipServiceConfig> getVipServiceConfig(Long id) {
    log.error("[用户服务]远程调用getVipServiceConfig执行服务降级");
    return null;
}

1.2.3 VIP会员结算页数据汇总

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/92

1.2.2.1 控制器

package com.atguigu.tingshu.order.api;

import com.atguigu.tingshu.common.login.GuiGuLogin;
import com.atguigu.tingshu.common.result.Result;
import com.atguigu.tingshu.common.util.AuthContextHolder;
import com.atguigu.tingshu.order.service.OrderInfoService;
import com.atguigu.tingshu.vo.order.OrderInfoVo;
import com.atguigu.tingshu.vo.order.TradeVo;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Tag(name = "订单管理")
@RestController
@RequestMapping("api/order")
@SuppressWarnings({"all"})
public class OrderInfoApiController {

    @Autowired
    private OrderInfoService orderInfoService;


    /**
     * 用户选择不同虚拟商品进行下单结算，封装渲染订单结算页所需要参数
     *
     * @param tradeVo
     * @return OrderInfoVo订单VO对象，将来订单提交时，需要将订单VO对象提交到服务端
     */
    @GuiGuLogin
    @Operation(summary = "用户选择不同虚拟商品进行下单结算，封装渲染订单结算页所需要参数")
    @PostMapping("/orderInfo/trade")
    public Result<OrderInfoVo> tradeData(@Valid @RequestBody TradeVo tradeVo) {
        //1.获取用户ID
        Long userId = AuthContextHolder.getUserId();
        //2.封装订单VO对象
        OrderInfoVo orderInfoVo = orderInfoService.tradeData(userId, tradeVo);
        return Result.ok(orderInfoVo);
    }

}

1.2.2.2 业务层

package com.atguigu.tingshu.order.service;

import com.atguigu.tingshu.model.order.OrderInfo;
import com.atguigu.tingshu.vo.order.OrderInfoVo;
import com.atguigu.tingshu.vo.order.TradeVo;
import com.baomidou.mybatisplus.extension.service.IService;

public interface OrderInfoService extends IService<OrderInfo> {


    /**
     * 订单确认数据汇总
     * @param userId 用户ID
     * @param tradeVo 选择购买商品交易vo对象
     * @return
     */
    OrderInfoVo tradeData(Long userId, TradeVo tradeVo);
}

package com.atguigu.tingshu.order.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.IdUtil;
import com.atguigu.tingshu.common.constant.RedisConstant;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.model.order.OrderInfo;
import com.atguigu.tingshu.model.user.VipServiceConfig;
import com.atguigu.tingshu.order.helper.SignHelper;
import com.atguigu.tingshu.order.mapper.OrderInfoMapper;
import com.atguigu.tingshu.order.service.OrderInfoService;
import com.atguigu.tingshu.user.client.UserFeignClient;
import com.atguigu.tingshu.vo.order.OrderDerateVo;
import com.atguigu.tingshu.vo.order.OrderDetailVo;
import com.atguigu.tingshu.vo.order.OrderInfoVo;
import com.atguigu.tingshu.vo.order.TradeVo;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class OrderInfoServiceImpl extends ServiceImpl<OrderInfoMapper, OrderInfo> implements OrderInfoService {

    @Autowired
    private OrderInfoMapper orderInfoMapper;

    @Autowired
    private UserFeignClient userFeignClient;

    @Autowired
    private AlbumFeignClient albumFeignClient;

    @Autowired
    private RedisTemplate redisTemplate;


    /**
     * 订单确认数据汇总
     *
     * @param userId  用户ID
     * @param tradeVo 选择购买商品交易vo对象
     * @return
     */
    @Override
    public OrderInfoVo tradeData(Long userId, TradeVo tradeVo) {
        //1.初始化OrderInfoVo
        OrderInfoVo orderInfoVo = new OrderInfoVo();
        //1.1. 初始化相关金额：0.00 此时金额必须是字符串"0.00"
        BigDecimal originalAmount = new BigDecimal("0.00");
        BigDecimal orderAmount = new BigDecimal("0.00");
        BigDecimal derateAmount = new BigDecimal("0.00");

        //1.2. 初始化商品及优惠列表
        List<OrderDetailVo> orderDetailVoList = new ArrayList<>();
        List<OrderDerateVo> orderDerateVoList = new ArrayList<>();

        //付款项目类型: 1001-专辑 1002-声音 1003-vip会员
        String itemType = tradeVo.getItemType();
        //2.处理购买商品类型为：VIP套餐
        if (SystemConstant.ORDER_ITEM_TYPE_VIP.equals(itemType)) {
            //2.1 远程调用“用户”服务获取套餐信息
            VipServiceConfig vipServiceConfig = userFeignClient.getVipServiceConfig(tradeVo.getItemId()).getData();
            Assert.notNull(vipServiceConfig, "选择套餐：{}有误", tradeVo.getItemId());
            //2.2 封装价格：原价 减免价 定价价
            originalAmount = vipServiceConfig.getPrice();
            orderAmount = vipServiceConfig.getDiscountPrice();
            if (orderAmount.compareTo(originalAmount) != 0) {
                //减免价格=原价-订单价
                derateAmount = originalAmount.subtract(orderAmount);
            }
            //2.3 封装订单中商品明细列表
            OrderDetailVo orderDetailVo = new OrderDetailVo();
            orderDetailVo.setItemId(tradeVo.getItemId());
            orderDetailVo.setItemName("会员：" + vipServiceConfig.getName());
            orderDetailVo.setItemPrice(vipServiceConfig.getPrice());
            orderDetailVo.setItemUrl(vipServiceConfig.getImageUrl());
            orderDetailVoList.add(orderDetailVo);
            //2.4 封装商品优惠列表
            if (orderAmount.compareTo(originalAmount) != 0) {
                OrderDerateVo orderDerateVo = new OrderDerateVo();
                orderDerateVo.setDerateType(SystemConstant.ORDER_DERATE_VIP_SERVICE_DISCOUNT);
                orderDerateVo.setDerateAmount(derateAmount);
                orderDerateVo.setRemarks("会员限时优惠：" + derateAmount);
                orderDerateVoList.add(orderDerateVo);
            }


        } else if (SystemConstant.ORDER_ITEM_TYPE_ALBUM.equals(itemType)) {
            //3.TODO 处理购买商品类型为：专辑
           
        } else if (SystemConstant.ORDER_ITEM_TYPE_TRACK.equals(itemType)) {
            //4.TODO 处理购买商品类型为：声音

        }
        //5.封装共有订单VO信息：价格、商品及优惠 TODO 、杂项信息(购买项目类型、流水号、时间戳签名)
        orderInfoVo.setOriginalAmount(originalAmount);
        orderInfoVo.setOrderAmount(orderAmount);
        orderInfoVo.setDerateAmount(derateAmount);
        orderInfoVo.setOrderDetailVoList(orderDetailVoList);
        orderInfoVo.setOrderDerateVoList(orderDerateVoList);
        orderInfoVo.setItemType(itemType);

        //5.1 为本次订单产生唯一流水号且存入Redis，将来在提交订单验证流水号
        String tradeNo = IdUtil.randomUUID();
        String tradeKey = RedisConstant.ORDER_TRADE_NO_PREFIX + userId;
        redisTemplate.opsForValue().set(tradeKey, tradeNo, RedisConstant.ORDER_TRADE_EXPIRE, TimeUnit.MINUTES);
        orderInfoVo.setTradeNo(tradeNo);

        //5.2 生成时间戳及订单签名
        orderInfoVo.setTimestamp(System.currentTimeMillis());
        //5.2.1 将订单VO转为Map TODO:将付款方式payWay空值属性排除掉 不需要参与签名计算
        Map<String, Object> orderInfoMap = BeanUtil.beanToMap(orderInfoVo, false, true);
        //5.2.2 调用工具类生成签名值
        String sign = SignHelper.getSign(orderInfoMap);
        orderInfoVo.setSign(sign);

        //6.响应订单VO对象
        return orderInfoVo;
    }
}

1.3 专辑结算

1.3.1 Feign请求头丢失解决

在service-util 微服务中添加远程 feign 远程调用拦截器，来获取token 数据。

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

package com.atguigu.tingshu.common.feign;

import feign.RequestInterceptor;
import feign.RequestTemplate;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

@Component
public class FeignInterceptor implements RequestInterceptor {

    public void apply(RequestTemplate requestTemplate){
        //  获取请求对象
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        //异步编排 与 MQ消费者端 为 null 避免出现空指针
        if(null != requestAttributes) {
            ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes)requestAttributes;
            HttpServletRequest request = servletRequestAttributes.getRequest();
            String token = request.getHeader("token");
            requestTemplate.header("token", token);
        }
    }
}

1.3.2 判断用户是否购买过专辑

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/90

service-user 微服务的UserInfoApiController控制器

/**
 * 查询当前用户是否购买指定专辑
 * @param albumId
 * @return true:已购买 false:未购买
 */
@GuiGuLogin
@Operation(summary = "查询当前用户是否购买指定专辑")
@GetMapping("/userInfo/isPaidAlbum/{albumId}")
public Result<Boolean> isPaidAlbum(@PathVariable Long albumId){
    Boolean isPaid = userInfoService.isPaidAlbum(albumId);
    return Result.ok(isPaid);
}

UserInfoService接口

/**
 * 查询当前用户是否购买指定专辑
 * @param albumId
 * @return
 */
Boolean isPaidAlbum(Long albumId);

UserInfoServiceImpl实现类

/**
 * 查询当前用户是否购买指定专辑
 *
 * @param albumId
 * @return
 */
@Override
public Boolean isPaidAlbum(Long albumId) {
    Long userId = AuthContextHolder.getUserId();
    LambdaQueryWrapper<UserPaidAlbum> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(UserPaidAlbum::getUserId, userId);
    queryWrapper.eq(UserPaidAlbum::getAlbumId, albumId);
    return userPaidAlbumMapper.selectCount(queryWrapper) > 0;
}

service-user-client 远程调用 UserFeignClient 添加

/**
 * 查询当前用户是否购买指定专辑
 * @param albumId
 * @return true:已购买 false:未购买
 */
@GetMapping("/userInfo/isPaidAlbum/{albumId}")
public Result<Boolean> isPaidAlbum(@PathVariable Long albumId);

UserDegradeFeignClient熔断类：

@Override
public Result<Boolean> isPaidAlbum(Long albumId) {
    log.error("[用户服务]提供远程调用isPaidAlbum服务降级");
    return null;
}

1.3.3 专辑结算数据汇总

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/92

1.3.3.3 OrderInfoServiceImpl实现类

/**
 * 订单确认数据汇总
 *
 * @param userId  用户ID
 * @param tradeVo 选择购买商品交易vo对象
 * @return
 */
@Override
public OrderInfoVo tradeData(Long userId, TradeVo tradeVo) {
    //1.初始化OrderInfoVo
    OrderInfoVo orderInfoVo = new OrderInfoVo();
    //1.1. 初始化相关金额：0.00 此时金额必须是字符串"0.00"
    BigDecimal originalAmount = new BigDecimal("0.00");
    BigDecimal orderAmount = new BigDecimal("0.00");
    BigDecimal derateAmount = new BigDecimal("0.00");

    //1.2. 初始化商品及优惠列表
    List<OrderDetailVo> orderDetailVoList = new ArrayList<>();
    List<OrderDerateVo> orderDerateVoList = new ArrayList<>();

    //付款项目类型: 1001-专辑 1002-声音 1003-vip会员
    String itemType = tradeVo.getItemType();
    //2.处理购买商品类型为：VIP套餐
    if (SystemConstant.ORDER_ITEM_TYPE_VIP.equals(itemType)) {
        //2.1...省略代码

    } else if (SystemConstant.ORDER_ITEM_TYPE_ALBUM.equals(itemType)) {
        //3. 处理购买商品类型为：专辑
        //3.1 远程调用“用户”服务是否已购专辑
        Long albumId = tradeVo.getItemId();
        Boolean isPaid = userFeignClient.isPaidAlbum(albumId).getData();
        if (isPaid) {
            throw new RuntimeException("用户已购买专辑：" + albumId);
        }
        //3.2 远程调用"专辑"服务获取专辑信息
        AlbumInfo albumInfo = albumFeignClient.getAlbumInfo(albumId).getData();
        Assert.notNull(albumInfo, "专辑：{}不存在", albumId);

        //3.3 远程调用用户服务获取用户身份，封装"商品"相关价格
        UserInfoVo userInfoVo = userFeignClient.getUserInfoVo(userId).getData();
        Boolean isVIP = false;
        if (1 == userInfoVo.getIsVip().intValue() && userInfoVo.getVipExpireTime().after(new Date())) {
            isVIP = true;
        }
        originalAmount = albumInfo.getPrice();
        orderAmount = originalAmount;
        //减免价=原价*折扣
        if (!isVIP && albumInfo.getDiscount().intValue() != -1) {
            //普通用户 且 专辑有普通用户折扣
            orderAmount = originalAmount.multiply(albumInfo.getDiscount()).divide(new BigDecimal("10"), 2, RoundingMode.HALF_UP);
        }

        if (isVIP && albumInfo.getVipDiscount().intValue() != -1) {
            //VIP用户 且 专辑有VIP用户折扣
            orderAmount = originalAmount.multiply(albumInfo.getVipDiscount()).divide(new BigDecimal("10"), 2, RoundingMode.HALF_UP);
        }
        if (orderAmount.compareTo(originalAmount) != 0) {
            derateAmount = originalAmount.subtract(orderAmount);
        }
        //3.4 封装"商品"列表及商品优惠列表
        OrderDetailVo orderDetailVo = new OrderDetailVo();
        orderDetailVo.setItemId(albumId);
        orderDetailVo.setItemName("专辑：" + albumInfo.getAlbumTitle());
        orderDetailVo.setItemUrl(albumInfo.getCoverUrl());
        orderDetailVo.setItemPrice(originalAmount);
        orderDetailVoList.add(orderDetailVo);

        if (orderAmount.compareTo(originalAmount) != 0) {
            OrderDerateVo orderDerateVo = new OrderDerateVo();
            orderDerateVo.setDerateType(SystemConstant.ORDER_DERATE_ALBUM_DISCOUNT);
            orderDerateVo.setDerateAmount(derateAmount);
            orderDerateVo.setRemarks("专辑限时优惠：" + derateAmount);
            orderDerateVoList.add(orderDerateVo);
        }
    } else if (SystemConstant.ORDER_ITEM_TYPE_TRACK.equals(itemType)) {
        //4.TODO 处理购买商品类型为：声音

    }
    //5.封装共有订单VO信息：价格、商品及优惠 TODO 、杂项信息(购买项目类型、流水号、时间戳签名)
    orderInfoVo.setOriginalAmount(originalAmount);
    orderInfoVo.setOrderAmount(orderAmount);
    orderInfoVo.setDerateAmount(derateAmount);
    orderInfoVo.setOrderDetailVoList(orderDetailVoList);
    orderInfoVo.setOrderDerateVoList(orderDerateVoList);
    orderInfoVo.setItemType(itemType);

    //5.1 为本次订单产生唯一流水号且存入Redis，将来在提交订单验证流水号
    String tradeNo = IdUtil.randomUUID();
    String tradeKey = RedisConstant.ORDER_TRADE_NO_PREFIX + userId;
    redisTemplate.opsForValue().set(tradeKey, tradeNo, RedisConstant.ORDER_TRADE_EXPIRE, TimeUnit.MINUTES);
    orderInfoVo.setTradeNo(tradeNo);

    //5.2 生成时间戳及订单签名
    orderInfoVo.setTimestamp(System.currentTimeMillis());
    //5.2.1 将订单VO转为Map TODO:将付款方式payWay空值属性排除掉 不需要参与签名计算
    Map<String, Object> orderInfoMap = BeanUtil.beanToMap(orderInfoVo, false, true);
    //5.2.2 调用工具类生成签名值
    String sign = SignHelper.getSign(orderInfoMap);
    orderInfoVo.setSign(sign);

    //6.响应订单VO对象
    return orderInfoVo;
}

1.4 声音结算

1.4.1 声音分集购买列表

1.4.1.1 获取已购声音Id列表Feign接口

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/94

service-user模块

UserInfoApiController控制器

/**
 * 查询当前用户某个专辑下已购声音ID列表
 * @param albumId 专辑ID
 * @return 已购声音ID列表
 */
@GuiGuLogin
@Operation(summary = "查询当前用户某个专辑下已购声音ID列表")
@GetMapping("/userInfo/findUserPaidTrackList/{albumId}")
public Result<List<Long>> getUserPaidTrackIdList(@PathVariable Long albumId){
    //1.获取当前登录用户ID
    Long userId = AuthContextHolder.getUserId();
    //2.调用业务逻辑获取已购声音ID列表
    List<Long> trackIdList = userInfoService.getUserPaidTrackIdList(userId, albumId);
    return Result.ok(trackIdList);
}

UserInfoService接口

/**
 * 查询当前用户某个专辑下已购声音ID列表
 * @param albumId 专辑ID
 * @return 已购声音ID列表
 */
List<Long> getUserPaidTrackIdList(Long userId, Long albumId);

UserInfoServiceImpl实现类

/**
 * 查询当前用户某个专辑下已购声音ID列表
 * @param albumId 专辑ID
 * @return 已购声音ID列表
 */
@Override
public List<Long> getUserPaidTrackIdList(Long userId, Long albumId) {
    LambdaQueryWrapper<UserPaidTrack> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(UserPaidTrack::getUserId, userId);
    queryWrapper.eq(UserPaidTrack::getAlbumId, albumId);
    //只需要获取已购声音ID
    queryWrapper.select(UserPaidTrack::getTrackId);
    List<UserPaidTrack> userPaidTrackList = userPaidTrackMapper.selectList(queryWrapper);
    if(CollectionUtil.isNotEmpty(userPaidTrackList)){
        return userPaidTrackList.stream().map(UserPaidTrack::getTrackId).collect(Collectors.toList());
    }
    return null;
}

service-user-client模块中UserFeignClient提供Feign接口

/**
 * 查询当前用户某个专辑下已购声音ID列表
 * @param albumId 专辑ID
 * @return 已购声音ID列表
 */
@GetMapping("/userInfo/findUserPaidTrackList/{albumId}")
public Result<List<Long>> getUserPaidTrackIdList(@PathVariable Long albumId);

UserDegradeFeignClient熔断类

@Override
public Result<List<Long>> getUserPaidTrackIdList(Long albumId) {
    log.error("[用户服务]远程调用getuserPaidTrackIdList执行服务降级");
    return null;
}

1.4.1.2 声音分集购买列表

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/95

AlbumInfoApiController控制器

控制器返回数据格式如下： 因为当前专辑只支持单集购买！专辑的价格是 album_info.price --> 当前专辑中的一条声音的价格 声音总价= album_info.price*trackCount

album_info 表中 price_type类型分为： 0201-单集 0202-整专辑

Map<String, Object> map = new HashMap<>();
map.put("name","本集"); // 显示文本
map.put("price",albumInfo.getPrice()); // 专辑声音对应的价格
map.put("trackCount",1); // 记录购买集数
list.add(map);

/**
 * 基于当前选择购买起始声音得到分集购买列表
 *
 * @param trackId
 * @return [{name:"本集",price:1,trackCount:1},{name:"后10集",price:10,trackCount:10}...{name:"全集/45集",price:45,trackCount:45}]
 */
@GuiGuLogin
@Operation(summary = "基于当前选择购买起始声音得到分集购买列表")
@GetMapping("/trackInfo/findUserTrackPaidList/{trackId}")
public Result<List<Map<String, Object>>> getUserTrackPaidList(@PathVariable Long trackId) {
    //1.从ThreadLocal中获取当前登录用户ID
    Long userId = AuthContextHolder.getUserId();
    //2.调用业务逻辑获取分集购买列表
    List<Map<String, Object>> list = albumInfoService.getUserTrackPaidList(userId, trackId);
    return Result.ok(list);
}

AlbumInfoService接口

/**
 * 基于当前选择购买起始声音得到分集购买列表
 * @param userId 用户ID
 * @param trackId 选择购买声音ID（起始计算参照）
 * @return
 */
List<Map<String, Object>> getUserTrackPaidList(Long userId, Long trackId);

AlbumInfoServiceImpl实现类

思路：

1. 先根据专辑Id+ {用户Id}获取到专辑对应的声音Id集合列表
2. 获取到当前专辑{albumId}中大于等于{orderNum}当前声音Id的集合列表
3. 获取到当前要支付的声音Id列表{ 2 与 1 做一个排除即可 }
4. 构造声音分集购买列表

/**
 * 基于当前选择购买起始声音得到分集购买列表
 *
 * @param userId  用户ID
 * @param trackId 选择购买声音ID（起始计算参照）
 * @return [{name:"本集",price:1,trackCount:1}]
 */
@Override
public List<Map<String, Object>> getUserTrackPaidList(Long userId, Long trackId) {
    //1.创建分集购买列表
    List<Map<String, Object>> list = new ArrayList<>();

    //2.根据声音ID查询到“起始”待购声音记录，得到当前声音徐浩、所属专辑ID
    TrackInfo trackInfo = trackInfoMapper.selectById(trackId);
    Integer orderNum = trackInfo.getOrderNum();
    Long albumId = trackInfo.getAlbumId();

    //3.根据"起始"声音序号获取所有待购买声音列表（可能包含用户已购声音）
    LambdaQueryWrapper<TrackInfo> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(TrackInfo::getAlbumId, albumId);
    queryWrapper.ge(TrackInfo::getOrderNum, orderNum);
    queryWrapper.select(TrackInfo::getId);
    List<TrackInfo> trackInfoList = trackInfoMapper.selectList(queryWrapper);

    //4.远程调用"用户服务"获取已购买声音ID列表
    List<Long> userPaidTrackIdList = userFeignClient.getUserPaidTrackIdList(albumId).getData();

    //5.如果存在已购声音ID，将已购声音ID排除掉得到真正未购买声音列表
    if (CollectionUtil.isNotEmpty(userPaidTrackIdList)) {
        trackInfoList = trackInfoList.stream()
                .filter(track -> !userPaidTrackIdList.contains(track.getId())).collect(Collectors.toList());
    }

    //6.根据未购买声音列表长度动态构建分集购买列表
    //6.0 根据专辑ID查询专辑价格=声音价格
    BigDecimal price = albumInfoMapper.selectById(albumId).getPrice();
    //6.1 构建"本集"分集购买对象
    Map<String, Object> currMap = new HashMap<>();
    currMap.put("name", "本集");
    currMap.put("price", price);
    currMap.put("trackCount", 1);
    list.add(currMap);
    //6.2 根据未购买声音数量循环最多构建6个分集购买对象（50集）
    int size = trackInfoList.size();
    //例如：size=12 展示 后10集，全集     size=35 展示 后10集 后20集 后30集 全集
    for (int i = 10; i <= 50; i += 10) {
        if (size > i) {
            Map<String, Object> map = new HashMap<>();
            map.put("name", "后" + i + "集");
            map.put("price", price.multiply(BigDecimal.valueOf(i)));
            map.put("trackCount", i);
            list.add(map);
        } else {
            Map<String, Object> map = new HashMap<>();
            map.put("name", "全集(" + size + "集）");
            map.put("price", price.multiply(BigDecimal.valueOf(size)));
            map.put("trackCount", size);
            list.add(map);
            break;
        }
    }
    return list;
}

1.4.2 获取待购声音列表Feign接口

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/96

控制器

service-album 微服务中的TrackInfoApiController控制器添加代码

/**
 * 查询当前用户未购买声音列表
 *
 * @param trackId    点击付费标识声音ID，将该声音作为起始标准
 * @param trackCount 购买数量
 * @return 待购声音列表
 */
@GuiGuLogin
@Operation(summary = "查询当前用户未购买声音列表")
@GetMapping("/trackInfo/findPaidTrackInfoList/{trackId}/{trackCount}")
public Result<List<TrackInfo>> getWaitBuyTrackList(@PathVariable Long trackId, @PathVariable Integer trackCount) {
    //1.从ThreadLocal中获取当前登录用户ID
    Long userId = AuthContextHolder.getUserId();
    //2.调用业务逻辑获取待购声音列表
    List<TrackInfo> list = albumInfoService.getWaitBuyTrackList(userId, trackId, trackCount);
    return Result.ok(list);
}

TrackInfoService接口

/**
 * 查询当前用户未购买声音列表
 * @param userId   用户ID
 * @param trackId 点击付费标识声音ID，将该声音作为起始标准
 * @param trackCount 购买数量
 * @return 待购声音列表
 */
List<TrackInfo> getWaitBuyTrackList(Long userId, Long trackId, Integer trackCount);

实现类

思路：

1. 根据声音Id 获取到当前声音对象
2. 远程调用用户服务获取已购买声音ID列表
3. 根据声音ID+当前声音序号查询待购声音列表，将已购声音进行排除
4. 返回待购声音集合对象返回

/**
 * 查询当前用户未购买声音列表
 *
 * @param userId     用户ID
 * @param trackId    点击付费标识声音ID，将该声音作为起始标准
 * @param trackCount 购买数量
 * @return 待购声音列表
 */
@Override
public List<TrackInfo> getWaitBuyTrackList(Long userId, Long trackId, Integer trackCount) {
    //1.根据声音ID查询到“起始”待购声音记录，得到当前声音序号、所属专辑ID
    TrackInfo trackInfo = trackInfoMapper.selectById(trackId);
    Long albumId = trackInfo.getAlbumId();
    Integer orderNum = trackInfo.getOrderNum();

    //2.远程调用用户服务获取已购买声音ID列表
    List<Long> userPaidTrackIdList = userFeignClient.getUserPaidTrackIdList(albumId).getData();

    //3.获取待购声音列表 查询条件：专辑ID，序号，已购声音ID 。排序字段：序号  。返回数量：购买数量
    LambdaQueryWrapper<TrackInfo> queryWrapper = new LambdaQueryWrapper<>();
    //3.1 等值查询专辑标题
    queryWrapper.eq(TrackInfo::getAlbumId, albumId);
    //3.2 大于等于当前选购声音序号
    queryWrapper.ge(TrackInfo::getOrderNum, orderNum);
    if (CollectionUtil.isNotEmpty(userPaidTrackIdList)) {
        //3.3 如果存在已购买声音，去除已购买声音ID
        queryWrapper.notIn(TrackInfo::getId, userPaidTrackIdList);
    }
    //3.4 按照声音序号升序
    queryWrapper.orderByAsc(TrackInfo::getOrderNum);
    //3.5 按用户选择购买数量获取声音列表
    queryWrapper.last("LIMIT " + trackCount);
    //3.6 执行查询列：多查询了专辑ID，需要在订单服务进行算价格需要获取专辑中价格
    queryWrapper.select(TrackInfo::getId, TrackInfo::getTrackTitle, TrackInfo::getCoverUrl, TrackInfo::getAlbumId);
    List<TrackInfo> list = trackInfoMapper.selectList(queryWrapper);
    return list;
}

AlbumFeignClient

/**
 * 查询当前用户未购买声音列表
 *
 * @param trackId    点击付费标识声音ID，将该声音作为起始标准
 * @param trackCount 购买数量
 * @return 待购声音列表
 */
@GetMapping("/trackInfo/findPaidTrackInfoList/{trackId}/{trackCount}")
public Result<List<TrackInfo>> getWaitBuyTrackList(@PathVariable Long trackId, @PathVariable Integer trackCount);

熔断类：

@Override
public Result<List<TrackInfo>> getWaitBuyTrackList(Long trackId, Integer trackCount) {
    log.error("[专辑服务]远程调用getWaitBuyTrackList执行服务降级");
    return null;
}

1.4.3 改造订单确认方法

/**
 * 订单确认数据汇总
 *
 * @param userId  用户ID
 * @param tradeVo 选择购买商品交易vo对象
 * @return
 */
@Override
public OrderInfoVo tradeData(Long userId, TradeVo tradeVo) {
    //1.初始化OrderInfoVo
    OrderInfoVo orderInfoVo = new OrderInfoVo();
    //1.1. 初始化相关金额：0.00 此时金额必须是字符串"0.00"
    BigDecimal originalAmount = new BigDecimal("0.00");
    BigDecimal orderAmount = new BigDecimal("0.00");
    BigDecimal derateAmount = new BigDecimal("0.00");

    //1.2. 初始化商品及优惠列表
    List<OrderDetailVo> orderDetailVoList = new ArrayList<>();
    List<OrderDerateVo> orderDerateVoList = new ArrayList<>();

    //付款项目类型: 1001-专辑 1002-声音 1003-vip会员
    String itemType = tradeVo.getItemType();
    //2.处理购买商品类型为：VIP套餐
    if (SystemConstant.ORDER_ITEM_TYPE_VIP.equals(itemType)) {
        //2.1 ...省略
    } else if (SystemConstant.ORDER_ITEM_TYPE_ALBUM.equals(itemType)) {
        //3. 处理购买商品类型为：专辑 ...省略
    } else if (SystemConstant.ORDER_ITEM_TYPE_TRACK.equals(itemType)) {
        //4.TODO 处理购买商品类型为：声音
        Long trackId = tradeVo.getItemId();
        Integer trackCount = tradeVo.getTrackCount();
        //4.1 远程调用"专辑服务"获取待购买声音列表
        List<TrackInfo> waitBuyTrackList = albumFeignClient.getWaitBuyTrackList(trackId, trackCount).getData();
        Assert.notNull(waitBuyTrackList, "不存在待结算声音");

        //4.2 远程调用专辑服务得到专辑信息-得到声音单价
        Long albumId = waitBuyTrackList.get(0).getAlbumId();
        AlbumInfo albumInfo = albumFeignClient.getAlbumInfo(albumId).getData();
        Assert.notNull(albumInfo, "专辑：{}不存在", albumId);

        //4.3 封装"商品"相关价格 声音单价*列表长度 注意：声音不支持折扣
        BigDecimal price = albumInfo.getPrice();
        originalAmount = price.multiply(BigDecimal.valueOf(waitBuyTrackList.size()));
        orderAmount = originalAmount;

        //4.4 封装"商品"列表 将集合泛型从TrackInfo转为OrderDetailVo
        orderDetailVoList = waitBuyTrackList
                .stream()
                .map(trackInfo -> {
                    OrderDetailVo orderDetailVo = new OrderDetailVo();
                    orderDetailVo.setItemId(trackInfo.getId());
                    orderDetailVo.setItemName(trackInfo.getTrackTitle());
                    orderDetailVo.setItemUrl(trackInfo.getCoverUrl());
                    orderDetailVo.setItemPrice(price);
                    return orderDetailVo;
                }).collect(Collectors.toList());
    }
    //5.封装共有订单VO信息：价格、商品及优惠 TODO 、杂项信息(购买项目类型、流水号、时间戳签名)
    orderInfoVo.setOriginalAmount(originalAmount);
    orderInfoVo.setOrderAmount(orderAmount);
    orderInfoVo.setDerateAmount(derateAmount);
    orderInfoVo.setOrderDetailVoList(orderDetailVoList);
    orderInfoVo.setOrderDerateVoList(orderDerateVoList);
    orderInfoVo.setItemType(itemType);

    //5.1 为本次订单产生唯一流水号且存入Redis，将来在提交订单验证流水号
    String tradeNo = IdUtil.randomUUID();
    String tradeKey = RedisConstant.ORDER_TRADE_NO_PREFIX + userId;
    redisTemplate.opsForValue().set(tradeKey, tradeNo, RedisConstant.ORDER_TRADE_EXPIRE, TimeUnit.MINUTES);
    orderInfoVo.setTradeNo(tradeNo);

    //5.2 生成时间戳及订单签名
    orderInfoVo.setTimestamp(System.currentTimeMillis());
    //5.2.1 将订单VO转为Map TODO:将付款方式payWay空值属性排除掉 不需要参与签名计算
    Map<String, Object> orderInfoMap = BeanUtil.beanToMap(orderInfoVo, false, true);
    //5.2.2 调用工具类生成签名值
    String sign = SignHelper.getSign(orderInfoMap);
    orderInfoVo.setSign(sign);

    //6.响应订单VO对象
    return orderInfoVo;
}

2、提交订单

声音购买-仅支持余额付款：

专辑购买：

VIP 购买：

2.1 提交订单业务分析

• 分集购买声音只支持余额支付

• 购买VIP或专辑分为余额，微信支付

1. 业务校验
   1. 校验签名
   2. 验证交易号，防止重复提交订单
2. 下单保存订单
   1. 微信支付（调用保存订单）
   2. 余额支付
      1. 远程调用账户服务扣减余额
      2. 远程调用用户服务新增购买记录
3. 如果出现异常，则进行全局事务回滚

2.2 整合分布式事务Seata

这里采用Seata提供AT模式进行分布式事务管理。

1. 分别在tingshu_account、tingshu_order、tingshu_user三个数据库中新增undo_log日志表

   CREATE TABLE `undo_log` (
    `id` bigint NOT NULL AUTO_INCREMENT,
    `branch_id` bigint NOT NULL,
    `xid` varchar(100) NOT NULL,
    `context` varchar(128) NOT NULL,
    `rollback_info` longblob NOT NULL,
    `log_status` int NOT NULL,
    `log_created` datetime NOT NULL,
    `log_modified` datetime NOT NULL,
    `ext` varchar(100) DEFAULT NULL,
    PRIMARY KEY (`id`),
    UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
   ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb3;
   

2. 分别在service-order、service-account、service-user三个模块pom.xml中增加Seata启动依赖

   <!--seata-->
   <dependency>
      <groupId>com.alibaba.cloud</groupId>
      <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
      <!-- 默认seata客户端版本比较低，排除后重新引入指定版本-->
      <exclusions>
          <exclusion>
              <groupId>io.seata</groupId>
              <artifactId>seata-spring-boot-starter</artifactId>
          </exclusion>
      </exclusions>
   </dependency>
   <dependency>
      <groupId>io.seata</groupId>
      <artifactId>seata-spring-boot-starter</artifactId>
   </dependency>
   

3. 订单微服务service-order模块新增Seata配置

   seata:
    enabled: true
    tx-service-group: ${spring.application.name}-group # 事务组名称
    service:
      vgroup-mapping:
        #指定事务分组至集群映射关系，集群名default需要与seata-server注册到Nacos的cluster保持一致
        service-order-group: default
    registry:
      type: nacos # 使用nacos作为注册中心
      nacos:
        server-addr: 192.168.200.6:8848 # nacos服务地址
        group: DEFAULT_GROUP # 默认服务分组
        namespace: "" # 默认命名空间
        cluster: default # 默认TC集群名称
   

4. 账户微服务service-account模块新增Seata配置

   seata:
    enabled: true
    tx-service-group: ${spring.application.name}-group # 事务组名称
    service:
      vgroup-mapping:
        #指定事务分组至集群映射关系，集群名default需要与seata-server注册到Nacos的cluster保持一致
        service-account-group: default
    registry:
      type: nacos # 使用nacos作为注册中心
      nacos:
        server-addr: 192.168.200.6:8848 # nacos服务地址
        group: DEFAULT_GROUP # 默认服务分组
        namespace: "" # 默认命名空间
        cluster: default # 默认TC集群名称
   

5. 用户微服务service-user模块新增Seata配置

   seata:
    enabled: true
    tx-service-group: ${spring.application.name}-group # 事务组名称
    service:
      vgroup-mapping:
        #指定事务分组至集群映射关系，集群名default需要与seata-server注册到Nacos的cluster保持一致
        service-user-group: default
    registry:
      type: nacos # 使用nacos作为注册中心
      nacos:
        server-addr: 192.168.200.6:8848 # nacos服务地址
        group: DEFAULT_GROUP # 默认服务分组
        namespace: "" # 默认命名空间
        cluster: default # 默认TC集群名称
   

2.3 服务提供方

2.3.1 检查并扣减账户余额

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/127

service-account账户服务UserAccountApiController

/**
 * 扣减账户余额
 *
 * @param accountDeductVo
 * @return
 */
@Operation(summary = "扣减账户余额")
@PostMapping("/userAccount/checkAndDeduct")
public Result checkAndDeduct(@RequestBody AccountDeductVo accountDeductVo) {
    //调用业务层完成余额扣减
    userAccountService.checkAndDeduct(accountDeductVo);
    return Result.ok();
}

业务接口UserAccountService

/**
 * 扣减账户余额
 *
 * @param accountDeductVo
 * @return
 */
void checkAndDeduct(AccountDeductVo accountDeductVo);

业务实现类UserAccountService

/**
 * 扣减账户余额
 *
 * @param accountDeductVo
 * @return
 */
@Override
public void checkAndDeduct(AccountDeductVo accountDeductVo) {
    //1.扣减账户余额
    int rows = userAccountMapper.checkAndDeduct(accountDeductVo);
    if (rows == 0) {
        throw new RuntimeException("账户余额不足");
    }
    //2.新增账户变动日志
    this.saveUserAccountDetail(accountDeductVo.getUserId(), accountDeductVo.getContent(), SystemConstant.ACCOUNT_TRADE_TYPE_MINUS, accountDeductVo.getAmount(), accountDeductVo.getOrderNo());
}

UserAccountMapper

package com.atguigu.tingshu.account.mapper;

import com.atguigu.tingshu.model.account.UserAccount;
import com.atguigu.tingshu.vo.account.AccountDeductVo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

@Mapper
public interface UserAccountMapper extends BaseMapper<UserAccount> {

    /**
     * 扣减余额
     * @param accountDeductVo
     */
    int checkAndDeduct(@Param("vo") AccountDeductVo accountDeductVo);
}

UserAccountMapper.xml

<!--扣减余额-->
<update id="checkAndDeduct">
	UPDATE user_account
	SET total_amount = total_amount - #{vo.amount},
		available_amount = available_amount - #{vo.amount},
		total_pay_amount = total_pay_amount + #{vo.amount}
	WHERE
		user_id = #{vo.userId}
	  AND available_amount >= #{vo.amount}
</update>

在service-account-client模块中提供Feign接口：AccountFeignClient

package com.atguigu.tingshu.account;

import com.atguigu.tingshu.account.impl.AccountDegradeFeignClient;
import com.atguigu.tingshu.common.result.Result;
import com.atguigu.tingshu.vo.account.AccountDeductVo;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

/**
 * <p>
 * 账号模块远程调用API接口
 * </p>
 *
 * @author atguigu
 */
@FeignClient(value = "service-account", path = "api/account", fallback = AccountDegradeFeignClient.class)
public interface AccountFeignClient {

    /**
     * 扣减账户余额
     *
     * @param accountDeductVo
     * @return
     */
    @PostMapping("/userAccount/checkAndDeduct")
    public Result checkAndDeduct(@RequestBody AccountDeductVo accountDeductVo);

}

服务降级类:AccountDegradeFeignClient

package com.atguigu.tingshu.account.impl;


import com.atguigu.tingshu.account.AccountFeignClient;
import com.atguigu.tingshu.common.result.Result;
import com.atguigu.tingshu.vo.account.AccountDeductVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class AccountDegradeFeignClient implements AccountFeignClient {

    @Override
    public Result checkAndDeduct(AccountDeductVo accountDeductVo) {
        return null;
    }
}

2.3.2 新增购买记录

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/118

service-user模块中UserInfoApiController提供处理购买记录Restful接口

UserInfoApiController控制器

/**
 * 用户付款成功后虚拟物品(VIP，专辑，声音)发货
 * @param userPaidRecordVo
 * @return
 */
@Operation(summary = "用户付款成功后虚拟物品发货")
@PostMapping("/userInfo/savePaidRecord")
public Result savePaidRecord(@RequestBody UserPaidRecordVo userPaidRecordVo){
    userInfoService.savePaidRecord(userPaidRecordVo);
    return Result.ok();
}

UserInfoService业务接口

/**
 * 保存用户不同购买项目类型的购买记录
 * @param userPaidRecordVo
 */
void savePaidRecord(UserPaidRecordVo userPaidRecordVo);

业务实现类UserInfoServiceImpl

@Autowired
private AlbumFeignClient albumFeignClient;

@Autowired
private UserVipServiceMapper userVipServiceMapper;

@Autowired
private VipServiceConfigMapper vipServiceConfigMapper;

/**
 * 保存用户不同购买项目类型的购买记录
 *
 * @param userPaidRecordVo
 */
@Override
public void savePaidRecord(UserPaidRecordVo userPaidRecordVo) {
    //1001-专辑 1002-声音 1003-vip会员
    String itemType = userPaidRecordVo.getItemType();
    //1.处理购买项目类型-声音
    if (SystemConstant.ORDER_ITEM_TYPE_TRACK.equals(itemType)) {
        //1.根据订单编号查询是否处理过声音购买记录
        LambdaQueryWrapper<UserPaidTrack> userPaidTrackLambdaQueryWrapper = new LambdaQueryWrapper<>();
        userPaidTrackLambdaQueryWrapper.eq(UserPaidTrack::getOrderNo, userPaidRecordVo.getOrderNo());
        userPaidTrackLambdaQueryWrapper.select(UserPaidTrack::getId);
        if (userPaidTrackMapper.selectCount(userPaidTrackLambdaQueryWrapper) > 0) {
            return;
        }
        //2.保存声音购买记录
        //2.1 根据声音ID查询声音信息获取所属专辑ID
        List<Long> trackIdList = userPaidRecordVo.getItemIdList();
        if (CollectionUtil.isNotEmpty(trackIdList)) {
            TrackInfo trackInfo = albumFeignClient.getTrackInfo(trackIdList.get(0)).getData();
            Long albumId = trackInfo.getAlbumId();
            for (Long trackId : trackIdList) {
                UserPaidTrack userPaidTrack = new UserPaidTrack();
                userPaidTrack.setAlbumId(albumId);
                userPaidTrack.setOrderNo(userPaidRecordVo.getOrderNo());
                userPaidTrack.setTrackId(trackId);
                userPaidTrack.setUserId(userPaidRecordVo.getUserId());
                userPaidTrackMapper.insert(userPaidTrack);
            }
        }
    } else if (SystemConstant.ORDER_ITEM_TYPE_ALBUM.equals(itemType)) {
        //2.TODO 处理购买项目类型-专辑
        //2.1 根据订单编号查询是否处理过专辑购买记录
        LambdaQueryWrapper<UserPaidAlbum> paidAlbumLambdaQueryWrapper = new LambdaQueryWrapper<>();
        paidAlbumLambdaQueryWrapper.eq(UserPaidAlbum::getOrderNo, userPaidRecordVo.getOrderNo());
        if (userPaidAlbumMapper.selectCount(paidAlbumLambdaQueryWrapper) > 0) {
            return;
        }
        //2.2 保存专辑购买记录
        if (CollectionUtil.isNotEmpty(userPaidRecordVo.getItemIdList())) {
            Long albumId = userPaidRecordVo.getItemIdList().get(0);
            UserPaidAlbum userPaidAlbum = new UserPaidAlbum();
            userPaidAlbum.setOrderNo(userPaidRecordVo.getOrderNo());
            userPaidAlbum.setUserId(userPaidRecordVo.getUserId());
            userPaidAlbum.setAlbumId(albumId);
            userPaidAlbumMapper.insert(userPaidAlbum);
        }
    } else if (SystemConstant.ORDER_ITEM_TYPE_VIP.equals(itemType)) {
        //3.处理购买项目类型-VIP会员
        //3.1 根据订单编号查询是否处理过VIP购买记录
        LambdaQueryWrapper<UserVipService> userVipServiceLambdaQueryWrapper = new LambdaQueryWrapper<>();
        userVipServiceLambdaQueryWrapper.eq(UserVipService::getOrderNo, userPaidRecordVo.getOrderNo());
        Long count = userVipServiceMapper.selectCount(userVipServiceLambdaQueryWrapper);
        if (count > 0) {
            return;
        }
        //3.2 保存本次会员购买记录
        UserVipService userVipService = new UserVipService();
        //3.2.1 获取当前用户VIP身份
        Boolean isVIP = false;
        UserInfoVo userInfoVo = getUserInfo(userPaidRecordVo.getUserId());
        if (userInfoVo.getIsVip().intValue() == 1 && userInfoVo.getVipExpireTime().after(new Date())) {
            isVIP = true;
        }
        //3.2.2 计算本次会员开始及过期时间
        //3.2.3 获取VIP套餐信息
        VipServiceConfig vipServiceConfig = vipServiceConfigMapper.selectById(userPaidRecordVo.getItemIdList().get(0));
        Integer serviceMonth = vipServiceConfig.getServiceMonth();

        Date startTime = new Date();
        if (!isVIP) {
            //普通用户
            userVipService.setStartTime(startTime);
            userVipService.setExpireTime(DateUtil.offsetMonth(startTime, serviceMonth));
        } else {
            startTime = DateUtil.offsetDay(userInfoVo.getVipExpireTime(), 1);
            userVipService.setStartTime(startTime);
            userVipService.setExpireTime(DateUtil.offsetMonth(startTime, serviceMonth));
        }
        userVipService.setOrderNo(userPaidRecordVo.getOrderNo());
        userVipService.setUserId(userPaidRecordVo.getUserId());
        userVipServiceMapper.insert(userVipService);
        //3.3 修改用户VIP标识及过期时间
        UserInfo userInfo = new UserInfo();
        userInfo.setId(userInfoVo.getId());
        userInfo.setIsVip(1);
        userInfo.setVipExpireTime(userVipService.getExpireTime());
        userInfoMapper.updateById(userInfo);
    }
}

在service-user模块中Feign接口提供远程调用方法：UserFeignClient

/**
 * 用户付款成功后虚拟物品(VIP，专辑，声音)发货
 * @param userPaidRecordVo
 * @return
 */
@PostMapping("/userInfo/savePaidRecord")
public Result savePaidRecord(@RequestBody UserPaidRecordVo userPaidRecordVo);

服务降级类：UserDegradeFeignClient

@Override
public Result savePaidRecord(UserPaidRecordVo userPaidRecordVo) {
    log.error("[用户服务]远程调用savePaidRecord执行服务降级");
    return null;
}

2.3.3 代码优化

​ 策略模式（Strategy Pattern）又叫政策模式（Policy Pattern），它是将定义的算法家族分别封装起来，让它们之间可以互相替换，从而让算法的变化不会影响到使用算法的用户。属于行为型模式。

策略模式使用的就是面向对象的继承和多态机制，从而实现同一行为在不同场景下具备不同实现。

优点：

• 策略类之间可以自由切换：由于策略类都实现同一个接口，所以使它们之间可以自由切换。
• 易于扩展：增加一个新的策略只需要添加一个具体的策略类即可，基本不需要改变原有的代码，符合“开闭原则“
• 避免使用多重条件选择语句（if else），充分体现面向对象设计思想。

缺点：

• 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。

策略模式的主要角色如下：

• 抽象策略（Strategy）类：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

• 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现或行为。

• 环境（Context）类：用来操作策略的上下文环境，屏蔽高层模块（客户端）对策略、算法的直接访问，封装可能存在的变化。

策略接口

package com.atguigu.tingshu.user.strategy;

import com.atguigu.tingshu.vo.user.UserPaidRecordVo;

/**
 * 处理不同类型商品购买记录的策略接口
 */
public interface PaidRecordStrategy {


    /**
     * 抽象出公用处理不同购买项目类型接口方法
     * @param userPaidRecordVo
     */
    public void handlerPaidRecord(UserPaidRecordVo userPaidRecordVo);

}

VIP购买项处理策略实现类：其中Bean对象ID要跟前端提交项目类型一致

package com.atguigu.tingshu.user.strategy.impl;

import cn.hutool.core.date.DateUtil;
import com.atguigu.tingshu.model.user.UserInfo;
import com.atguigu.tingshu.model.user.UserVipService;
import com.atguigu.tingshu.model.user.VipServiceConfig;
import com.atguigu.tingshu.user.mapper.UserInfoMapper;
import com.atguigu.tingshu.user.mapper.UserVipServiceMapper;
import com.atguigu.tingshu.user.mapper.VipServiceConfigMapper;
import com.atguigu.tingshu.user.strategy.PaidRecordStrategy;
import com.atguigu.tingshu.vo.user.UserInfoVo;
import com.atguigu.tingshu.vo.user.UserPaidRecordVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * @author: atguigu
 * @create: 2024-08-23 10:32
 */
@Slf4j
@Component("1003")
public class VIPPaidRecordStrategy implements PaidRecordStrategy {

    @Autowired
    private UserVipServiceMapper userVipServiceMapper;

    @Autowired
    private VipServiceConfigMapper vipServiceConfigMapper;

    @Autowired
    private UserInfoMapper userInfoMapper;

    /**
     * 处理购买商品类型为会员-发货逻辑
     * @param userPaidRecordVo
     */
    @Override
    public void handlerPaidRecord(UserPaidRecordVo userPaidRecordVo) {
        log.info("[用户服务]处理购买商品类型为会员发货逻辑");
        //3.处理购买项目类型-VIP会员
        //3.1 根据订单编号查询是否处理过VIP购买记录
        LambdaQueryWrapper<UserVipService> userVipServiceLambdaQueryWrapper = new LambdaQueryWrapper<>();
        userVipServiceLambdaQueryWrapper.eq(UserVipService::getOrderNo, userPaidRecordVo.getOrderNo());
        Long count = userVipServiceMapper.selectCount(userVipServiceLambdaQueryWrapper);
        if (count > 0) {
            return;
        }
        //3.2 保存本次会员购买记录
        UserVipService userVipService = new UserVipService();
        //3.2.1 获取当前用户VIP身份
        Boolean isVIP = false;
        UserInfo userInfo = userInfoMapper.selectById(userPaidRecordVo.getUserId());
        if (userInfo.getIsVip().intValue() == 1 && userInfo.getVipExpireTime().after(new Date())) {
            isVIP = true;
        }
        //3.2.2 计算本次会员开始及过期时间
        //3.2.3 获取VIP套餐信息
        VipServiceConfig vipServiceConfig = vipServiceConfigMapper.selectById(userPaidRecordVo.getItemIdList().get(0));
        Integer serviceMonth = vipServiceConfig.getServiceMonth();

        Date startTime = new Date();
        if (!isVIP) {
            //普通用户
            userVipService.setStartTime(startTime);
            userVipService.setExpireTime(DateUtil.offsetMonth(startTime, serviceMonth));
        } else {
            startTime = DateUtil.offsetDay(userInfo.getVipExpireTime(), 1);
            userVipService.setStartTime(startTime);
            userVipService.setExpireTime(DateUtil.offsetMonth(startTime, serviceMonth));
        }
        userVipService.setOrderNo(userPaidRecordVo.getOrderNo());
        userVipService.setUserId(userPaidRecordVo.getUserId());
        userVipServiceMapper.insert(userVipService);
        //3.3 修改用户VIP标识及过期时间
        userInfo.setIsVip(1);
        userInfo.setVipExpireTime(userVipService.getExpireTime());
        userInfoMapper.updateById(userInfo);
    }
}

专辑购买项处理策略实现类：其中Bean对象ID要跟前端提交项目类型一致

package com.atguigu.tingshu.user.strategy.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.atguigu.tingshu.model.user.UserPaidAlbum;
import com.atguigu.tingshu.user.mapper.UserPaidAlbumMapper;
import com.atguigu.tingshu.user.strategy.PaidRecordStrategy;
import com.atguigu.tingshu.vo.user.UserPaidRecordVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author: atguigu
 * @create: 2024-08-23 10:32
 */
@Slf4j
@Component("1001")
public class AlbumPaidRecordStrategy implements PaidRecordStrategy {

    @Autowired
    private UserPaidAlbumMapper userPaidAlbumMapper;


    /**
     * 处理购买商品类型为专辑-发货逻辑
     * @param userPaidRecordVo
     */
    @Override
    public void handlerPaidRecord(UserPaidRecordVo userPaidRecordVo) {
        log.info("[用户服务]处理购买商品类型为专辑发货逻辑");
        //2.TODO 处理购买项目类型-专辑
        //2.1 根据订单编号查询是否处理过专辑购买记录
        LambdaQueryWrapper<UserPaidAlbum> paidAlbumLambdaQueryWrapper = new LambdaQueryWrapper<>();
        paidAlbumLambdaQueryWrapper.eq(UserPaidAlbum::getOrderNo, userPaidRecordVo.getOrderNo());
        if (userPaidAlbumMapper.selectCount(paidAlbumLambdaQueryWrapper) > 0) {
            return;
        }
        //2.2 保存专辑购买记录
        if (CollectionUtil.isNotEmpty(userPaidRecordVo.getItemIdList())) {
            Long albumId = userPaidRecordVo.getItemIdList().get(0);
            UserPaidAlbum userPaidAlbum = new UserPaidAlbum();
            userPaidAlbum.setOrderNo(userPaidRecordVo.getOrderNo());
            userPaidAlbum.setUserId(userPaidRecordVo.getUserId());
            userPaidAlbum.setAlbumId(albumId);
            userPaidAlbumMapper.insert(userPaidAlbum);
        }
    }
}

声音购买项处理策略实现类：其中Bean对象ID要跟前端提交项目类型一致

package com.atguigu.tingshu.user.strategy.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.atguigu.tingshu.album.AlbumFeignClient;
import com.atguigu.tingshu.model.album.TrackInfo;
import com.atguigu.tingshu.model.user.UserPaidTrack;
import com.atguigu.tingshu.user.mapper.UserPaidTrackMapper;
import com.atguigu.tingshu.user.strategy.PaidRecordStrategy;
import com.atguigu.tingshu.vo.user.UserPaidRecordVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @author: atguigu
 * @create: 2024-08-23 10:32
 */
@Slf4j
@Component("1002")
public class TrackPaidRecordStrategy implements PaidRecordStrategy {

    @Autowired
    private AlbumFeignClient albumFeignClient;

    @Autowired
    private UserPaidTrackMapper userPaidTrackMapper;

    /**
     * 处理购买商品类型为声音-发货逻辑
     * @param userPaidRecordVo
     */
    @Override
    public void handlerPaidRecord(UserPaidRecordVo userPaidRecordVo) {
        log.info("[用户服务]处理购买商品类型为声音发货逻辑");
        //1.根据订单编号查询是否处理过声音购买记录
        LambdaQueryWrapper<UserPaidTrack> userPaidTrackLambdaQueryWrapper = new LambdaQueryWrapper<>();
        userPaidTrackLambdaQueryWrapper.eq(UserPaidTrack::getOrderNo, userPaidRecordVo.getOrderNo());
        userPaidTrackLambdaQueryWrapper.select(UserPaidTrack::getId);
        if (userPaidTrackMapper.selectCount(userPaidTrackLambdaQueryWrapper) > 0) {
            return;
        }
        //2.保存声音购买记录
        //2.1 根据声音ID查询声音信息获取所属专辑ID
        List<Long> trackIdList = userPaidRecordVo.getItemIdList();
        if (CollectionUtil.isNotEmpty(trackIdList)) {
            TrackInfo trackInfo = albumFeignClient.getTrackInfo(trackIdList.get(0)).getData();
            Long albumId = trackInfo.getAlbumId();
            for (Long trackId : trackIdList) {
                UserPaidTrack userPaidTrack = new UserPaidTrack();
                userPaidTrack.setAlbumId(albumId);
                userPaidTrack.setOrderNo(userPaidRecordVo.getOrderNo());
                userPaidTrack.setTrackId(trackId);
                userPaidTrack.setUserId(userPaidRecordVo.getUserId());
                userPaidTrackMapper.insert(userPaidTrack);
            }
        }
    }
}

提供工厂类组装所有的策略实现类

package com.atguigu.tingshu.user.strategy.fac;

import com.atguigu.tingshu.user.strategy.PaidRecordStrategy;
import com.atguigu.tingshu.user.strategy.impl.AlbumPaidRecordStrategy;
import com.atguigu.tingshu.user.strategy.impl.TrackPaidRecordStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.swing.*;
import java.util.Map;

/**
 * @author: atguigu
 * @create: 2024-08-23 10:35
 */
@Slf4j
@Component
public class StrategyFactory {

    /**
     * 通过Spring注入机制将PaidRecordStrategy接口下所有实现类对象自动注入到Map
     * Map中Key 为策略类型-策略实现类Bean名称(1001,1002,1003)
     * Map中Value 具体策略实现类对象
     */
    @Autowired
    private Map<String, PaidRecordStrategy> strategyMap;


    /**
     * 根据策略类型获取对应策略实现类对象
     *
     * @param strategy
     * @return
     */
    public PaidRecordStrategy getStrategy(String strategy) {
        if (strategyMap.containsKey(strategy)) {
            return strategyMap.get(strategy);
        }
        throw new RuntimeException("策略类型不存在");
    }
}

UserInfoServiceImpl业务调用工厂获取不同策略实现类完成方法调用

@Autowired
private StrategyFactory strategyFactory;

/**
 * 保存用户不同购买项目类型的购买记录
 *
 * @param userPaidRecordVo
 */
@Override
public void savePaidRecord(UserPaidRecordVo userPaidRecordVo) {
    //1001-专辑 1002-声音 1003-vip会员
    String itemType = userPaidRecordVo.getItemType();
    PaidRecordStrategy strategy = strategyFactory.getStrategy(itemType);
    strategy.handlerPaidRecord(userPaidRecordVo);
}

2.3 提交订单

在service-order 微服务中添加提交订单控制器

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/99

2.4.1 控制器

OrderInfoApiController

/**
 * 提交订单
 *
 * @param orderInfoVo
 * @return
 */
@GuiGuLogin
@Operation(summary = "提交订单")
@PostMapping("/orderInfo/submitOrder")
public Result<Map<String, String>> submitOrder(@RequestBody @Validated OrderInfoVo orderInfoVo) {
    //1.获取当前登录用户ID
    Long userId = AuthContextHolder.getUserId();
    //2.调用业务逻辑提交订单
    Map<String, String> map = orderInfoService.submitOrder(userId, orderInfoVo);
    return Result.ok(map);
}

2.4.2 接口与实现

/**
 * 提交订单
 * @param userId 用户ID
 * @param orderInfoVo 订单vo信息
 * @return {orderNo:"订单编号"}
 */
Map<String, String> submitOrder(Long userId, OrderInfoVo orderInfoVo);

/**
 * 保存订单相关信息
 * @param userId
 * @param orderInfoVo
 * @return
 */
OrderInfo saveOrderInfo(Long userId, OrderInfoVo orderInfoVo);

@Autowired
private AccountFeignClient accountFeignClient;

/**
 * 提交订单
 *
 * @param userId      用户ID
 * @param orderInfoVo 订单vo信息
 * @return {orderNo:"订单编号"}
 */
@Override
@GlobalTransactional(rollbackFor = Exception.class)
public Map<String, String> submitOrder(Long userId, OrderInfoVo orderInfoVo) {
    //1.业务校验：验证流水号是否一致 避免用户误触回退按钮导致订单重复提交
    //1.1 确保判断流水号删除流水号原子性采用lua脚本来实现
    String tradeKey = RedisConstant.ORDER_TRADE_NO_PREFIX + userId;
    //1.2 创建Lua脚本
    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";
    DefaultRedisScript<Boolean> redisScript = new DefaultRedisScript<>(script, Boolean.class);
    Boolean flag = (Boolean) redisTemplate.execute(redisScript, Arrays.asList(tradeKey), orderInfoVo.getTradeNo());
    if (!flag) {
        throw new GuiguException(500, "流水号校验失败请重试");
    }
    //2.业务校验：验证签名是否一致 避免用户篡改订单vo中参数导致商户利益损害
    //2.1 将提交订单VO转为Map用于验证签名
    Map<String, Object> orderInfoMap = BeanUtil.beanToMap(orderInfoVo);
    //2.2 将Map中的payWay属性去除 在订单确认页生成签名没有加入payWay属性
    orderInfoMap.remove("payWay");
    SignHelper.checkSign(orderInfoMap);
    //3.核心业务1：保存订单相关信息（订单、订单明细、订单减免） 订单状态：未支付
    OrderInfo orderInfo = this.saveOrderInfo(userId, orderInfoVo);

    //4.判断付款方式-如果是账户余额付款
    if (SystemConstant.ORDER_PAY_ACCOUNT.equals(orderInfoVo.getPayWay())) {
        //4.1.核心业务2：余额扣减
        //4.1.1 构建扣减余额VO对象
        AccountDeductVo accountDeductVo = new AccountDeductVo();
        accountDeductVo.setOrderNo(orderInfo.getOrderNo());
        accountDeductVo.setUserId(orderInfo.getUserId());
        accountDeductVo.setAmount(orderInfo.getOrderAmount());
        accountDeductVo.setContent(orderInfo.getOrderTitle());
        //4.1.2 远程调用账户服务扣减余额 一定要判断Feign调用结果业务状态码
        Result result = accountFeignClient.checkAndDeduct(accountDeductVo);
        if (!result.getCode().equals(200)) {
            throw new GuiguException(500, "账户余额不足");
        }

        //扣减余额成功后，修改订单状态：已支付
        orderInfo.setOrderStatus(SystemConstant.ORDER_STATUS_PAID);
        orderInfoMapper.updateById(orderInfo);

        //4.2.核心业务3：虚拟物品发货
        //4.2.1 构建虚拟物品发货VO对象
        UserPaidRecordVo userPaidRecordVo = new UserPaidRecordVo();
        userPaidRecordVo.setOrderNo(orderInfo.getOrderNo());
        userPaidRecordVo.setUserId(orderInfo.getUserId());
        userPaidRecordVo.setItemType(orderInfo.getItemType());
        List<Long> itemIdList = orderInfoVo.getOrderDetailVoList().stream().map(OrderDetailVo::getItemId).collect(Collectors.toList());
        userPaidRecordVo.setItemIdList(itemIdList);
        //4.2.2 远程调用用户服务虚拟物品发货 一定要判断Feign调用结果业务状态码
        result = userFeignClient.savePaidRecord(userPaidRecordVo);
        if (!result.getCode().equals(200)) {
            throw new GuiguException(500, "虚拟物品发货异常");
        }
    }
    //5.TODO 判断付款方式-如果是微信付款，采用延迟消息完成延迟关单
    if (SystemConstant.ORDER_PAY_WAY_WEIXIN.equals(orderInfoVo.getPayWay())) {

    }
    Map<String, String> map = new HashMap<>();
    map.put("orderNo", orderInfo.getOrderNo());
    return map;
}

2.4.3 保存订单方法

业务处理：

• 1.将订单相关信息封装为订单对象，向订单表增加一条记录
• 2.将提交订单明细封装为订单明细集合，批量向订单明细表新增若干条记录
• 3.将提交优惠明细封装为优惠明细集合，批量向优惠明细表新增若干条记录

OrderInfoService接口

/**
 * 保存订单相关信息
 * @param userId
 * @param orderInfoVo
 * @return
 */
OrderInfo saveOrderInfo(Long userId, OrderInfoVo orderInfoVo);

OrderInfoServiceImpl实现类

@Autowired
private OrderDetailMapper orderDetailMapper;

@Autowired
private OrderDerateMapper orderDerateMapper;

/**
 * 保存订单相关信息（订单、订单明细、订单减免）
 *
 * @param userId
 * @param orderInfoVo
 * @return
 */
@Override
public OrderInfo saveOrderInfo(Long userId, OrderInfoVo orderInfoVo) {
    //1.保存订单信息
    OrderInfo orderInfo = BeanUtil.copyProperties(orderInfoVo, OrderInfo.class);
    //1.1 设置订单状态设置为：未支付
    orderInfo.setOrderStatus(SystemConstant.ORDER_STATUS_UNPAID);
    //1.2 设置用户ID
    orderInfo.setUserId(userId);
    //1.3 设置订单名称（从订单项获取名称）
    List<OrderDetailVo> orderDetailVoList = orderInfoVo.getOrderDetailVoList();
    if (CollectionUtil.isNotEmpty(orderDetailVoList)) {
        orderInfo.setOrderTitle(orderDetailVoList.get(0).getItemName());
    }
    //1.4 设置订单编号（确保全局唯一用于对接支付平台） 年月日+雪花算法
    String oderNo = DateUtil.today().replaceAll("-", "") + IdUtil.getSnowflake(1, 1).nextIdStr();
    orderInfo.setOrderNo(oderNo);
    orderInfoMapper.insert(orderInfo);
    Long orderId = orderInfo.getId();
    //2.保存订单明细列表
    //2.1 获取订单明细列表
    if (CollectionUtil.isNotEmpty(orderDetailVoList)) {
        for (OrderDetailVo orderDetailVo : orderDetailVoList) {
            OrderDetail orderDetail = BeanUtil.copyProperties(orderDetailVo, OrderDetail.class);
            //2.1 关联订单
            orderDetail.setOrderId(orderId);
            //2.2 保存订单明细
            orderDetailMapper.insert(orderDetail);
        }
    }
    //3.保存订单减免列表
    List<OrderDerateVo> orderDerateVoList = orderInfoVo.getOrderDerateVoList();
    if (CollectionUtil.isNotEmpty(orderDerateVoList)) {
        for (OrderDerateVo orderDerateVo : orderDerateVoList) {
            OrderDerate orderDerate = BeanUtil.copyProperties(orderDerateVo, OrderDerate.class);
            //3.1 关联订单
            orderDerate.setOrderId(orderId);
            //3.2 保存订单减免
            orderDerateMapper.insert(orderDerate);
        }
    }
    return orderInfo;
}

3、我的订单

3.1 订单明细信息

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/100

当支付成功之后，点击查看订单

在service-order 微服务OrderInfoApiController中添加

/**
 * 根据订单编号查询订单信息（包含明细） 考虑到在支付成功后收到微信异步回调需要获取订单信息固该接口不需要登录访问
 *
 * @param orderNo
 * @return
 */ 
@Operation(summary = "根据订单编号查询订单信息")
@GetMapping("/orderInfo/getOrderInfo/{orderNo}")
public Result<OrderInfo> getOrderInfo(@PathVariable String orderNo) {
    OrderInfo orderInfo = orderInfoService.getOrderInfo(orderNo);
    return Result.ok(orderInfo);
}

OrderInfoService接口

/**
 * 根据订单编号查询订单信息
 * @param orderNo
 * @return
 */
OrderInfo getOrderInfo(String orderNo);

OrderInfoServiceImpl实现

/**
 * 根据订单编号查询订单信息
 *
 * @param orderNo
 * @return
 */
@Override
public OrderInfo getOrderInfo(String orderNo) {
    //1.根据订单编号查询订单信息
    LambdaUpdateWrapper<OrderInfo> orderInfoLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
    orderInfoLambdaUpdateWrapper.eq(OrderInfo::getOrderNo, orderNo);
    OrderInfo orderInfo = orderInfoMapper.selectOne(orderInfoLambdaUpdateWrapper);
    if (orderInfo != null) {

        //2.根据订单ID查询订单明细列表
        LambdaUpdateWrapper<OrderDetail> orderDetailLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
        orderDetailLambdaUpdateWrapper.eq(OrderDetail::getOrderId, orderInfo.getId());
        List<OrderDetail> orderDetailList = orderDetailMapper.selectList(orderDetailLambdaUpdateWrapper);
        if (CollectionUtil.isNotEmpty(orderDetailList)) {
            orderInfo.setOrderDetailList(orderDetailList);
        }
        //3.根据订单ID查询订单优惠列表
        LambdaUpdateWrapper<OrderDerate> orderDerateLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
        orderDerateLambdaUpdateWrapper.eq(OrderDerate::getOrderId, orderInfo.getId());
        List<OrderDerate> orderDerateList = orderDerateMapper.selectList(orderDerateLambdaUpdateWrapper);
        if (CollectionUtil.isNotEmpty(orderDerateList)) {
            orderInfo.setOrderDerateList(orderDerateList);
        }
    }
    return orderInfo;
}

需要展示订单支付状态、支付方式，固在OrderInfo中增加对应属性get方法即可保证响应JSON中有对应属性

public String getOrderStatusName() {
   if("0901".equals(orderStatus)){
      return "未支付";
   } else if ("0902".equals(orderStatus)) {
      return "已支付";
   } else if ("0903".equals(orderStatus)) {
      return "已取消";
   }
   return null;
}

public String getPayWayName() {
	if ("1101".equals(payWay)) {
		return "微信";
	} else if ("1102".equals(payWay)) {
		return "支付宝";
	} else if ("1103".equals(payWay)) {
		return "余额";
	}
	return "";
}

3.2 我的订单列表

YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/136

service-order 的OrderInfoApiController 控制器 添加

/**
 * 查询当前用户订单列表
 *
 * @param page
 * @param limit
 * @return
 */
@GuiGuLogin
@Operation(summary = "查询当前用户订单列表")
@GetMapping("/orderInfo/findUserPage/{page}/{limit}")
public Result<Page<OrderInfo>> getOrderByPage(@PathVariable int page, @PathVariable int limit) {
    Long userId = AuthContextHolder.getUserId();
    Page<OrderInfo> pageInfo = new Page<>(page, limit);
    pageInfo = orderInfoService.getOrderByPage(userId, pageInfo);
    return Result.ok(pageInfo);
}

OrderInfoService接口

/**
 * 查询当前用户订单列表
 *
 * @param userId
 * @param pageInfo
 * @return
 */
Page<OrderInfo> getOrderByPage(Long userId, Page<OrderInfo> pageInfo);

OrderInfoServiceImpl实现

/**
 * 查询当前用户订单列表
 *
 * @param userId
 * @param pageInfo
 * @return
 */
@Override
public Page<OrderInfo> getOrderByPage(Long userId, Page<OrderInfo> pageInfo) {
    //1.调用持久层动态SQL查询订单及订单明细
    pageInfo = orderInfoMapper.getOrderByPage(pageInfo, userId);
    return pageInfo;
}

OrderInfoMapper 接口

package com.atguigu.tingshu.order.mapper;

import com.atguigu.tingshu.model.order.OrderInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

@Mapper
public interface OrderInfoMapper extends BaseMapper<OrderInfo> {

    /**
     * 查询当前用户订单列表
     * @param pageInfo
     * @param userId
     * @return
     */
    Page<OrderInfo> getOrderByPage(Page<OrderInfo> pageInfo, @Param("userId") Long userId);
}

OrderInfoMapper.xml 映射文件

<resultMap id="orderInfoResultMap" type="com.atguigu.tingshu.model.order.OrderInfo" autoMapping="true">
    <id property="id" column="id"></id>
    <!--订单明细列表 select指定查询ID(查询订单明细)-->
    <collection property="orderDetailList" column="id" select="getOrderDetailById"></collection>
</resultMap>

<!--根据订单ID查询订单明细列表-->
<select id="getOrderDetailById" resultType="com.atguigu.tingshu.model.order.OrderDetail">
    select id,item_id,item_name,item_price,item_url from order_detail where order_id = #{id}
</select>

<!--分页查询订单列表-->
<select id="getOrderByPage" resultMap="orderInfoResultMap">
    select oi.id,
           oi.order_no,
           oi.order_status,
           oi.original_amount,
           oi.derate_amount,
           oi.order_amount,
           oi.pay_way
    from order_info oi
    where user_id = #{userId}
      and oi.is_deleted = 0
    order by oi.id desc
</select>

4、订单延迟关单

4.1 什么是延迟任务

• 定时任务：有固定周期的，有明确的触发时间
• 延迟任务：没有固定的开始时间，它常常是由一个事件触发的，而在这个事件触发之后的一段时间内触发另一个事件，任务可以立即执行，也可以延迟

应用场景：

场景一：订单下单之后30分钟后，如果用户没有付钱，则系统自动取消订单；

场景二：接口对接出现网络问题，1分钟后重试，如果失败，2分钟重试，直到出现阈值终止

技术选择：

• Redisson-底层基于Redis实现延迟消息 https://github.com/Redisson/Redisson/wiki/7.-distributed-collections
• RabbitMQ-延迟消息（死信队列，延迟插件）

4.2 延迟关闭订单

service-order订单模块中提交订单方法中

//获取Nacos中配置的订单超时时间 
//注意：热部署更新配置需要在类上使用@RefreshScope注解
@Value("${order.cancel}")
private int ttl;


/**
 * 提交订单
 *
 * @param userId      用户ID
 * @param orderInfoVo 订单vo信息
 * @return {orderNo:"订单编号"}
 */
@Override
@GlobalTransactional(rollbackFor = Exception.class)
public Map<String, String> submitOrder(Long userId, OrderInfoVo orderInfoVo) {
    //1.业务校验：验证流水号是否一致 避免用户误触回退按钮导致订单重复提交 //省略
   
    //2.业务校验：验证签名是否一致 避免用户篡改订单vo中参数导致商户利益损害 //省略
   
    //3.核心业务1：保存订单相关信息（订单、订单明细、订单减免） 订单状态：未支付 //省略
    OrderInfo orderInfo = this.saveOrderInfo(userId, orderInfoVo);

    //4.判断付款方式-如果是账户余额付款
    if (SystemConstant.ORDER_PAY_ACCOUNT.equals(orderInfoVo.getPayWay())) {
       //省略
    }
    //5.TODO 判断付款方式-如果是微信付款，采用延迟消息完成延迟关单
    if (SystemConstant.ORDER_PAY_WAY_WEIXIN.equals(orderInfoVo.getPayWay())) {
        rabbitService.sendDealyMessage(MqConst.EXCHANGE_CANCEL_ORDER, MqConst.ROUTING_CANCEL_ORDER, orderInfo.getId(), ttl);
    }
    Map<String, String> map = new HashMap<>();
    map.put("orderNo", orderInfo.getOrderNo());
    return map;
}

配置延迟消息：

package com.atguigu.tingshu.order.config;

@Configuration
public class CanelOrderMqConfig {

    @Bean
    public Queue cancelQueue() {
        // 第一个参数是创建的queue的名字，第二个参数是是否支持持久化
        return new Queue(MqConst.QUEUE_CANCEL_ORDER, true);
    }

    @Bean
    public CustomExchange cancelExchange() {
        Map<String, Object> args = new HashMap<String, Object>();
        args.put("x-delayed-type", "direct");
        return new CustomExchange(MqConst.EXCHANGE_CANCEL_ORDER, "x-delayed-message", true, false, args);
    }

    @Bean
    public Binding bindingCancel() {
        return BindingBuilder.bind(cancelQueue()).to(cancelExchange()).with(MqConst.ROUTING_CANCEL_ORDER).noargs();
    }

}

监听延迟消息:

package com.atguigu.tingshu.order;

import com.atguigu.tingshu.common.rabbit.constant.MqConst;
import com.atguigu.tingshu.order.service.OrderInfoService;
import com.rabbitmq.client.Channel;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.PipedReader;

/**
 * @author: atguigu
 * @create: 2024-08-23 14:46
 */
@Slf4j
@Component
public class OrderReceiver {

    @Autowired
    private OrderInfoService orderInfoService;

    /**
     * 监听到延迟关单消息
     *
     * @param orderId 订单ID
     * @param message
     * @param channel
     */
    @SneakyThrows
    @RabbitListener(queues = MqConst.QUEUE_CANCEL_ORDER)
    public void cancelOrder(Long orderId, Message message, Channel channel) {
        if (orderId != null) {
            log.info("[订单服务]监听到延迟关单消息：{}", orderId);
            orderInfoService.cancelOrder(orderId);
        }
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}

OrderInfoService接口：

/**
 * 查询并且根据状态取消订单
 * @param orderId
 */
void cancelOrder(Long orderId);

OrderInfoServiceImpl实现类：

/**
 * 查询并且根据状态取消订单
 *
 * @param orderId
 */
@Override
@Transactional(rollbackFor = Exception.class)
public void cancelOrder(Long orderId) {
    //1.根据订单ID查询订单信息
    OrderInfo orderInfo = orderInfoMapper.selectById(orderId);
    //2.判读支付状态 ：如果是未支付，则取消订单
    if (SystemConstant.ORDER_STATUS_UNPAID.equals(orderInfo.getOrderStatus())) {
        //2.1 设置订单状态为已取消
        orderInfo.setOrderStatus(SystemConstant.ORDER_STATUS_CANCEL);
        //2.2 更新订单信息
        orderInfoMapper.updateById(orderInfo);
    }
}