谷粒随享

第7章订单

学习目标：

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

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.cache.GuiGuCache;
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;
import java.math.BigInteger;

@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(){
		Long userId = AuthContextHolder.getUserId();
		BigDecimal availableAmount = userAccountService.getAvailableAmount(userId);
		return Result.ok(availableAmount);
	}
}

UserAccountService接口：

/**
 * 获取指定用户账户可用余额
 * @return
 */
BigDecimal getAvailableAmount(Long userId);

UserAccountServiceImpl实现类：

/**
 * 获取指定用户账户可用余额
 *
 * @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);
    Assert.notNull(userAccount, "账户有误请联系管理员！");
    return userAccount.getAvailableAmount();
}

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

1.2 VIP会员结算

思路：

专辑订单
1. 判断用户是否购买过专辑
  1. 如果已购买抛出异常
  2. 未购买{要给订单明细，减免金额，总金额等属性赋值}
    1. 判断用户是否属于vip
    2. vip 计算订单总价与折扣价赋值订单明细与减免明细
    3. 非vip 计算订单总价与折扣价赋值订单明细与减免明细
vip 订单
1. 根据Id 获取到vip 配置信息
2. 赋值原始金额，减免金额，总金额，订单明细，减免金额
生成一个流水号存储到缓存，防止用户重复提交订单
给OrderInfoVo 实体类赋值
1. 防止用户非法操作订单金额，将订单对象OrderInfoVo变为字符串，在转换为map。在通过工具类SignHelper将map 变为字符串赋值给签名字段
最后返回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;


    /**
	 *查询VIP套餐列表
	 * @return
	 */
	@Operation(summary = "查询VIP套餐列表")
	@GetMapping("/vipServiceConfig/findAll")
	public Result<List<VipServiceConfig>> getAllVipConfig(){
		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
 * @returnb 
 */
@GuiGuCache(prefix = "vipservice:config:")
@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 org.springframework.beans.factory.annotation.Autowired;
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;


    /**
     * 选择各种商品(VIP会员、专辑、声音)订单结算渲染数据汇总
     *
     * @param tradeVo 购买项目类型、项目ID、[购买声音数量]
     * @return OrderInfoVo
     */
    @GuiGuLogin
    @Operation(summary = "选择各种商品订单结算渲染数据汇总")
    @PostMapping("/orderInfo/trade")
    public Result<OrderInfoVo> getOrderTradeData(@RequestBody TradeVo tradeVo) {
        Long userId = AuthContextHolder.getUserId();
        OrderInfoVo orderInfoVo = orderInfoService.getOrderTradeData(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> {


    /**
     * 选择各种商品(VIP会员、专辑、声音)订单结算渲染数据汇总
     *
     * @param tradeVo 购买项目类型、项目ID、[购买声音数量]
     * @return OrderInfoVo
     */
    OrderInfoVo getOrderTradeData(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 RedisTemplate redisTemplate;


    /**
     * 选择各种商品(VIP会员、专辑、声音)订单结算渲染数据汇总
     *
     * @param tradeVo 购买项目类型(1001-专辑 1002-声音 1003-vip会员)、项目ID、[购买声音数量]
     * @return OrderInfoVo
     */
    @Override
    public OrderInfoVo getOrderTradeData(Long userId, TradeVo tradeVo) {
        //1.初始化相关数据
        OrderInfoVo orderInfoVo = new OrderInfoVo();
        //1.1 初始化相关金额“0.00” 原价、减免价、订单价
        BigDecimal originalAmount = new BigDecimal("0.00");
        BigDecimal derateAmount = new BigDecimal("0.00");
        BigDecimal orderAmount = new BigDecimal("0.00");
        //1.2 初始商品清单、优惠列表
        List<OrderDetailVo> orderDetailVoList = new ArrayList<>();
        List<OrderDerateVo> orderDerateVoList = new ArrayList<>();

        //2.处理购买类型为VIP会员
        String itemType = tradeVo.getItemType();
        if (SystemConstant.ORDER_ITEM_TYPE_VIP.equals(itemType)) {
            //2.1 远程调用"用户服务"获取套餐详情
            VipServiceConfig vipServiceConfig = userFeignClient.getVipServiceConfig(tradeVo.getItemId()).getData();
            Assert.notNull(vipServiceConfig, "套餐信息为空");

            //2.2 计算VIP套餐相关价格封装相关价格
            //2.2.1 原价
            originalAmount = vipServiceConfig.getPrice();
            //2.2.2 减免价
            derateAmount = vipServiceConfig.getDiscountPrice();
            //2.2.3 订单价=原价-减免价
            orderAmount = originalAmount.subtract(derateAmount);

            //2.3 封装商品清单明细
            OrderDetailVo orderDetailVo = new OrderDetailVo();
            orderDetailVo.setItemId(tradeVo.getItemId());
            orderDetailVo.setItemName("VIP套餐：" + vipServiceConfig.getName());
            orderDetailVo.setItemUrl(vipServiceConfig.getImageUrl());
            //商品明细中价格为 原价
            orderDetailVo.setItemPrice(originalAmount);
            orderDetailVoList.add(orderDetailVo);

            //2.4 封装商品优惠明细
            OrderDerateVo orderDerateVo = new OrderDerateVo();
            orderDerateVo.setDerateAmount(derateAmount);
            orderDerateVo.setDerateType(SystemConstant.ORDER_DERATE_VIP_SERVICE_DISCOUNT);
            orderDerateVo.setRemarks("VIP限时抢购：活动价：" + orderAmount);
            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中相关信息
        //5.1  价格信息
        orderInfoVo.setOriginalAmount(originalAmount);
        orderInfoVo.setDerateAmount(derateAmount);
        orderInfoVo.setOrderAmount(orderAmount);
        //5.2 商品清单及优惠清单
        orderInfoVo.setOrderDetailVoList(orderDetailVoList);
        orderInfoVo.setOrderDerateVoList(orderDerateVoList);
        //5.3 TODO 其他信息”包含：流水号、项目类型、时间戳及签名
        //5.3 封装购买项目类型
        orderInfoVo.setItemType(tradeVo.getItemType());
        //5.4封装本次订单VO流水号
        //5.4.1 生成本次订单用户流水号Key
        String key = RedisConstant.ORDER_TRADE_NO_PREFIX+userId;
        //5.4.2 生成流水号
        String tradeNo = IdUtil.fastSimpleUUID();
        //5.4.3 将流水号存入Redis设置过期时间为5分钟
        redisTemplate.opsForValue().set(key, tradeNo, RedisConstant.ORDER_TRADE_EXPIRE, TimeUnit.MINUTES);
        //5.4.4 封装订单VO中流水号信息
        orderInfoVo.setTradeNo(tradeNo);
        //5.5封装本次订单信息产生签名值
        //5.5.1 封装订单信息VO中时间戳
        orderInfoVo.setTimestamp(DateUtil.current());
        //5.5.2 将订单VO信息转为Map TODO 将渲染订单确认页面无法封装付款方式payWay;排除掉
        Map<String, Object> paramsMap = BeanUtil.beanToMap(orderInfoVo, false, true);
        //5.5.3 对本次订单vo信息进行签名
        String sign = SignHelper.getSign(paramsMap);
        orderInfoVo.setSign(sign);
        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控制器

/**
 * 验证当前用户是否已购指定专辑ID
 * @param albumId
 * @return true:已购  false：未购
 */
@GuiGuLogin
@Operation(summary = "验证当前用户是否已购指定专辑ID")
@GetMapping("/userInfo/isPaidAlbum/{albumId}")
public Result<Boolean> isPaidAlbum(@PathVariable Long albumId){
    //1.获取用户ID
    Long userId = AuthContextHolder.getUserId();
    //2.查询用户是否已购专辑
    Boolean isPaid = userInfoService.isPaidAlbum(userId, albumId);
    return Result.ok(isPaid);
}

UserInfoService接口

/**
 * 判断指定用户ID是否购买过指定专辑
 * @param userId
 * @param albumId
 * @return
 */
Boolean isPaidAlbum(Long userId, Long albumId);

UserInfoServiceImpl实现类

/**
 * 判断指定用户ID是否购买过指定专辑
 *
 * @param userId
 * @param albumId
 * @return
 */
@Override
public Boolean isPaidAlbum(Long userId, Long albumId) {
    //1.构建查询条件：用户ID+专辑ID
    LambdaQueryWrapper<UserPaidAlbum> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(UserPaidAlbum::getUserId, userId);
    queryWrapper.eq(UserPaidAlbum::getAlbumId, albumId);
    Long count = userPaidAlbumMapper.selectCount(queryWrapper);
    //2.查询已购专辑数量判断
    return count > 0;
}

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

/**
 * 验证当前用户是否已购指定专辑ID
 * @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实现类

/**
 * 用户下单返回渲染订单确认页面数据
 * 为用户选择购买不同商品返回订单确认数据
 * 1.VIP会员  2.专辑  3.声音
 *
 * @param tradeVo itemType->项目类型: 1001-专辑 1002-声音 1003-vip会员
 * @return
 */
@Override
public OrderInfoVo getOrderTradeData(TradeVo tradeVo) {
    Long userId = AuthContextHolder.getUserId();
    //1.创建响应VO对象，将VO中需要相关价格，商品明细，优惠明细定义
    OrderInfoVo orderInfoVo = new OrderInfoVo();
    //1.1 原价：初始0.00
    BigDecimal originalAmount = new BigDecimal("0.00");
    //1.2 减免：初始0.00
    BigDecimal derateAmount = new BigDecimal("0.00");
    //1.3 订单：初始0.00
    BigDecimal orderAmount = new BigDecimal("0.00");
    //1.4 订单明细（商品）列表
    List<OrderDetailVo> orderDetailVoList = new ArrayList<>();
    //1.5 订单优惠列表
    List<OrderDerateVo> orderDerateVoList = new ArrayList<>();

    //2.处理购买项目类型为VIP会员 itemType=1003-vip会员  允许多次仅购买
    if (SystemConstant.ORDER_ITEM_TYPE_VIP.equals(tradeVo.getItemType())) {
        //2.1 ...省略代码
    } else if (SystemConstant.ORDER_ITEM_TYPE_ALBUM.equals(tradeVo.getItemType())) {
        //3.处理购买项目类型为专辑 itemType=1001-专辑
        Long albumId = tradeVo.getItemId();
        //3.1 远程调用“用户”服务判断是否已购专辑 已购买则抛出异常 true
        Boolean isPaid = userFeignClient.isPaidAlbum(albumId).getData();
        Assert.state(!isPaid, "请勿重复购买！");
        //3.2 远程调用“`用户”服务判获取用户信息断是否VIP
        UserInfoVo userInfoVo = userFeignClient.getUserInfoVo(userId).getData();
        Assert.notNull(userInfoVo, "用户信息有误！");
        Boolean isVIP = false;
        if (userInfoVo.getIsVip().intValue() == 1 && userInfoVo.getVipExpireTime().after(new Date())) {
            isVIP = true;
        }
        //3.3 远程调用“专辑”服务获取专辑信息（价格，不同用户折扣）
        AlbumInfo albumInfo = albumFeignClient.getAlbumInfo(albumId).getData();
        Assert.notNull(albumInfo, "专辑信息有误！");
        //3.4 根据专辑不同折扣计算不同用户身份价格
        //原价
        originalAmount = albumInfo.getPrice();
        //暂时认为无折扣，订单价=原价
        orderAmount = originalAmount;
        //3.4.1 判断当前专辑是否有普通用户折扣  订单价=原价*折扣     100 * 8 / 10
        if (albumInfo.getDiscount().intValue() != -1 && !isVIP) {
            // 折扣存在*.**避免精度问题 设置保留小数位，设置四舍五入
            orderAmount = originalAmount.multiply(albumInfo.getDiscount())
                    .divide(new BigDecimal("10"), 2, RoundingMode.HALF_UP);
        }
        //3.4.2 判断当前专辑是否有VIP用户折扣
        if (albumInfo.getVipDiscount().intValue() != -1 && isVIP) {
            orderAmount = originalAmount.multiply(albumInfo.getVipDiscount())
                    .divide(new BigDecimal("10"), 2, RoundingMode.HALF_UP);
        }
        //3.5 封装商品明细列表
        OrderDetailVo orderDetailVo = new OrderDetailVo();
        orderDetailVo.setItemId(albumId);
        orderDetailVo.setItemName("专辑：" + albumInfo.getAlbumTitle());
        orderDetailVo.setItemUrl(albumInfo.getCoverUrl());
        orderDetailVo.setItemPrice(originalAmount);
        orderDetailVoList.add(orderDetailVo);

        //3.6 封装商品优惠列表
        if (originalAmount.compareTo(orderAmount) != 0) {
            derateAmount = originalAmount.subtract(orderAmount);
            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(tradeVo.getItemType())) {
        //4.TODO 处理购买项目类型为声音 1002-声音

    }
    //5.封装订单确认页所需价格，商品，优惠，以及"其他信息"
    //5.1 封装订单确认页中基本信息
    orderInfoVo.setOriginalAmount(originalAmount);
    orderInfoVo.setDerateAmount(derateAmount);
    orderInfoVo.setOrderAmount(orderAmount);
    orderInfoVo.setOrderDetailVoList(orderDetailVoList);
    orderInfoVo.setOrderDerateVoList(orderDerateVoList);
    //封装其他信息
    //TODO 付款方式暂不确定，不设置
    //5.2 购买项目类型
    orderInfoVo.setItemType(tradeVo.getItemType());        //5.3 TODO 其他信息”包含：流水号、项目类型、时间戳及签名
    //5.3 TODO 其他信息”包含：流水号、项目类型、时间戳及签名
    //5.3 封装购买项目类型
    orderInfoVo.setItemType(tradeVo.getItemType());
    //5.4封装本次订单VO流水号
    //5.4.1 生成本次订单用户流水号Key
    String key = RedisConstant.ORDER_TRADE_NO_PREFIX + userId;
    //5.4.2 生成流水号
    String tradeNo = IdUtil.fastSimpleUUID();
    //5.4.3 将流水号存入Redis设置过期时间为5分钟
    redisTemplate.opsForValue().set(key, tradeNo, RedisConstant.ORDER_TRADE_EXPIRE, TimeUnit.MINUTES);
    //5.4.4 封装订单VO中流水号信息
    orderInfoVo.setTradeNo(tradeNo);
    //5.5封装本次订单信息产生签名值
    //5.5.1 封装订单信息VO中时间戳
    orderInfoVo.setTimestamp(DateUtil.current());
    //5.5.2 将订单VO信息转为Map TODO 将渲染订单确认页面无法封装付款方式payWay;排除掉
    Map<String, Object> paramsMap = BeanUtil.beanToMap(orderInfoVo, false, true);
    //5.5.3 对本次订单vo信息进行签名
    String sign = SignHelper.getSign(paramsMap);
    orderInfoVo.setSign(sign);
    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
 * @return
 */
@GuiGuLogin
@Operation(summary = "查询用户某个专辑已购声音ID列表")
@GetMapping("/userInfo/findUserPaidTrackList/{albumId}")
public Result<List<Long>> getUserPaidTrackIdList(@PathVariable Long albumId) {
    Long userId = AuthContextHolder.getUserId();
    List<Long> userPaidTrackIdList = userInfoService.getUserPaidTrackIdList(userId, albumId);
    return Result.ok(userPaidTrackIdList);
}

UserInfoService接口

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

UserInfoServiceImpl实现类

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

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

/**
 * 查询用户某个专辑已购声音ID列表
 *
 * @param albumId
 * @return
 */
@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

TrackInfoApiController控制器

控制器返回数据格式如下：因为当前专辑只支持单集购买！专辑的价格是 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 选择购买声音ID
 * @return [{name:"本集",price:1,trackCount:1},{name:"后10集",price:10,trackCount:10}...{name:"全集/45集",price:45,trackCount:45}] 待结算声音数量45
 */
@GuiGuLogin
@Operation(summary = "基于用户选择购买声音动态返回分集购买列表")
@GetMapping("/trackInfo/findUserTrackPaidList/{trackId}")
public Result<List<Map<String, Object>>> getUserFenJiBuyList(@PathVariable Long trackId){
    //1.获取当前用户ID
    Long userId = AuthContextHolder.getUserId();
    //2.动态根据待购声音数量动态构建分集购买列表
    List<Map<String, Object>> list = trackInfoService.getUserFenJiBuyList(userId, trackId);
    return Result.ok(list);
}

TrackInfoService接口

/**
 * 基于用户选择购买声音动态返回分集购买列表
 * @param userId 用户ID
 * @param trackId 选择购买声音ID
 * @return [{name:"本集",price:1,trackCount:1},{name:"后10集",price:10,trackCount:10}...{name:"全集/45集",price:45,trackCount:45}] 待结算声音数量45
 */
List<Map<String, Object>> getUserFenJiBuyList(Long userId, Long trackId);

TrackInfoServiceImpl实现类

思路：

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

/**
 * 基于用户选择购买声音动态返回分集购买列表
 *
 * @param userId  用户ID
 * @param trackId 选择购买声音ID
 * @return [{name:"本集",price:1,trackCount:1},{name:"后10集",price:10,trackCount:10}...{name:"全集/45集",price:45,trackCount:45}] 待结算声音数量45
 */
@Override
public List<Map<String, Object>> getUserFenJiBuyList(Long userId, Long trackId) {
    //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（not in）得到待购买声音数量
    LambdaQueryWrapper<TrackInfo> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(TrackInfo::getAlbumId, albumId);
    queryWrapper.ge(TrackInfo::getOrderNum, orderNum);
    if (CollectionUtil.isNotEmpty(userPaidTrackIdList)) {
        //说明该专辑下用户存在已购买声音ID
        queryWrapper.notIn(TrackInfo::getId, userPaidTrackIdList);
    }
    Long waitBuyTrackCount = trackInfoMapper.selectCount(queryWrapper);

    //4.根据待结算声音数量动态构建分集购买列表
    AlbumInfo albumInfo = albumInfoMapper.selectById(albumId);
    BigDecimal price = albumInfo.getPrice();
    List<Map<String, Object>> list = new ArrayList<>();
    //4.1 构建本集购买对象
    Map<String, Object> currMap = new HashMap<>();
    currMap.put("name", "本集");
    currMap.put("trackCount", 1);
    currMap.put("price", price);
    list.add(currMap);
    //4.2 构建其他分集购买对象
    //4.2.1 如果待结算声音长度在 N*10 - (N+1)*10 区间  
    for (int i = 10; i <= 50; i += 10) {
        //如果长度大于i 则显示 后 i 集
        if (waitBuyTrackCount > i) {
            Map<String, Object> map = new HashMap<>();
            map.put("name", "后"+i+"集");
            map.put("trackCount", i);
            map.put("price", price.multiply(BigDecimal.valueOf(i)));
            list.add(map);
        }else{
            //全集 精确集数
            Map<String, Object> map = new HashMap<>();
            map.put("name", "全集/后"+waitBuyTrackCount+"集");
            map.put("trackCount", waitBuyTrackCount);
            map.put("price", price.multiply(BigDecimal.valueOf(waitBuyTrackCount)));
            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控制器添加代码

/**
 * 基于用户选购声音ID作为基准按照购买数量返回待购声音列表
 *
 * @param trackId
 * @param trackCount
 * @return
 */
@GuiGuLogin
@Operation(summary = "基于用户选购声音ID作为基准按照购买数量返回待购声音列表")
@GetMapping("/trackInfo/findPaidTrackInfoList/{trackId}/{trackCount}")
public Result<List<TrackInfo>> getWaitBuyTrackInfoList(@PathVariable Long trackId, @PathVariable int trackCount) {
    //1.获取当前用户ID
    Long userId = AuthContextHolder.getUserId();
    //2.获取待购声音列表
    List<TrackInfo> list = trackInfoService.getWaitBuyTrackInfoList(userId, trackId, trackCount);
    return Result.ok(list);
}

TrackInfoService接口

/**
 * 基于用户选购声音ID作为基准按照购买数量返回待购声音列表
 *
 * @param userId 用户ID
 * @param trackId 选购声音ID
 * @param trackCount 限制数量
 * @return
 */
List<TrackInfo> getWaitBuyTrackInfoList(Long userId, Long trackId, int trackCount);

实现类

思路：

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

/**
 * 基于用户选购声音ID作为基准按照购买数量返回待购声音列表
 *
 * @param userId     用户ID
 * @param trackId    选购声音ID
 * @param trackCount 限制数量
 * @return
 */
@Override
public List<TrackInfo> getWaitBuyTrackInfoList(Long userId, Long trackId, int 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（not in）限制返回个数:trackCount 声音序号升序
    LambdaQueryWrapper<TrackInfo> queryWrapper = new LambdaQueryWrapper<>();
    //3.1 查询指定专辑
    queryWrapper.eq(TrackInfo::getAlbumId, albumId);
    //3.2 大于等于选择基准声音序号
    queryWrapper.ge(TrackInfo::getOrderNum, orderNum);
    if (CollectionUtil.isNotEmpty(userPaidTrackIdList)) {
        //3.2 排除已购声音ID
        queryWrapper.notIn(TrackInfo::getId, userPaidTrackIdList);
    }
    //3.3 限制查询列 订单服务需要得到专辑信息 故多查询专辑ID列
    queryWrapper.select(TrackInfo::getId, TrackInfo::getTrackTitle, TrackInfo::getCoverUrl, TrackInfo::getAlbumId);
    //3.4 按照序号升序排序
    queryWrapper.orderByAsc(TrackInfo::getOrderNum);
    //3.5 限制返回数量
    queryWrapper.last("limit "+trackCount);
    List<TrackInfo> waitBuyTrackInfoList = trackInfoMapper.selectList(queryWrapper);
    return waitBuyTrackInfoList;
}

AlbumFeignClient

/**
 * 基于用户选购声音ID作为基准按照购买数量返回待购声音列表
 *
 * @param trackId
 * @param trackCount
 * @return
 */
@GetMapping("/trackInfo/findPaidTrackInfoList/{trackId}/{trackCount}")
public Result<List<TrackInfo>> getWaitBuyTrackInfoList(@PathVariable Long trackId, @PathVariable int trackCount);

熔断类：

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

1.4.3 改造订单确认方法

/**
 * 获取订单确认页面所需数据
 * - 购买VIP套餐
 * - 购买专辑
 * - 购买声音
 *
 * @param tradeVo {itemType:"项目类型",:itemId:"项目",trackCount:"声音数量"}
 * @return 订单vo对象->为后续提交订单准备
 */
@Override
public OrderInfoVo getOrderTradeData(TradeVo tradeVo) {
    Long userId = AuthContextHolder.getUserId();
    //1.创建订单信息VO对象
    OrderInfoVo orderInfoVo = new OrderInfoVo();

    //1.1 声明默认价格 TODO：一定要传入字符串必须是 "0.00"
    //1.1.1 "商品"原价
    BigDecimal originalAmount = new BigDecimal("0.00");
    //1.1.2 "商品"减免价
    BigDecimal derateAmount = new BigDecimal("0.00");
    //1.1.3 "商品"订单价
    BigDecimal orderAmount = new BigDecimal("0.00");

    //1.2 声明商品列表集合
    List<OrderDetailVo> orderDetailVoList = new ArrayList<>();

    //1.3 声明优惠列表集合
    List<OrderDerateVo> orderDerateVoList = new ArrayList<>();

    //2.处理VIP会员（允许重复） 1001-专辑 1002-声音 1003-vip会员
    if (SystemConstant.ORDER_ITEM_TYPE_VIP.equals(tradeVo.getItemType())) {
        //省略代码...
    } else if (SystemConstant.ORDER_ITEM_TYPE_ALBUM.equals(tradeVo.getItemType())) {
        //3. 处理专辑（不允许重复购买）省略代码...
    } else if (SystemConstant.ORDER_ITEM_TYPE_TRACK.equals(tradeVo.getItemType())) {
       //4. TODO 处理购买类型为声音

        //4.1 远程调用专辑服务获取待购声音列表
        Long trackId = tradeVo.getItemId();
        List<TrackInfo> trackInfoList = albumFeignClient.getWaitBuyTrackInfoList(trackId, tradeVo.getTrackCount()).getData();
        Assert.notNull(trackInfoList, "无符合要求待结算声音列表");

        //4.2 远程调用专辑服务获取专辑信息得到声音单价
        AlbumInfo albumInfo = albumFeignClient.getAlbumInfo(trackInfoList.get(0).getAlbumId()).getData();
        BigDecimal price = albumInfo.getPrice();

        //4.3 计算声音相关价格封装相关价格
        originalAmount = price.multiply(BigDecimal.valueOf(trackInfoList.size()));
        orderAmount = originalAmount;

        //4.4 封装商品清单明细
        orderDetailVoList = trackInfoList.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中相关信息
    //5.1  价格信息
    orderInfoVo.setOriginalAmount(originalAmount);
    orderInfoVo.setDerateAmount(derateAmount);
    orderInfoVo.setOrderAmount(orderAmount);
    //5.2 商品清单及优惠清单
    orderInfoVo.setOrderDetailVoList(orderDetailVoList);
    orderInfoVo.setOrderDerateVoList(orderDerateVoList);
    //5.3 TODO 其他信息”包含：流水号、项目类型、时间戳及签名
    //5.3 封装购买项目类型
    orderInfoVo.setItemType(tradeVo.getItemType());
    //5.4封装本次订单VO流水号
    //5.4.1 生成本次订单用户流水号Key
    String key = RedisConstant.ORDER_TRADE_NO_PREFIX + userId;
    //5.4.2 生成流水号
    String tradeNo = IdUtil.fastSimpleUUID();
    //5.4.3 将流水号存入Redis设置过期时间为5分钟
    redisTemplate.opsForValue().set(key, tradeNo, RedisConstant.ORDER_TRADE_EXPIRE, TimeUnit.MINUTES);
    //5.4.4 封装订单VO中流水号信息
    orderInfoVo.setTradeNo(tradeNo);
    //5.5封装本次订单信息产生签名值
    //5.5.1 封装订单信息VO中时间戳
    orderInfoVo.setTimestamp(DateUtil.current());
    //5.5.2 将订单VO信息转为Map TODO 将渲染订单确认页面无法封装付款方式payWay;排除掉
    Map<String, Object> paramsMap = BeanUtil.beanToMap(orderInfoVo, false, true);
    //5.5.3 对本次订单vo信息进行签名
    String sign = SignHelper.getSign(paramsMap);
    orderInfoVo.setSign(sign);
    return orderInfoVo;

2、提交订单

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

专辑购买：

VIP 购买：

2.1 提交订单业务分析

分集购买声音只支持余额支付
购买VIP或专辑分为余额，微信支付

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

2.2 整合分布式事务Seata

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

分别在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;

分别在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>

订单微服务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集群名称

账户微服务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集群名称

用户微服务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

/**
 * 检查指定用户余额且完成余额扣减
 * 1.检查余额扣减余额
 * 2.新增账户变动日志
 *
 * @param accountDeductVo
 * @return
 */
@Override
@Transactional(rollbackFor = Exception.class)
public void checkAndDeduct(AccountDeductVo accountDeductVo) {
    //1.检查余额扣减余额
    int count = userAccountMapper.checkAndDeduct(accountDeductVo.getUserId(), accountDeductVo.getAmount());
    if (count == 0) {
        throw new GuiguException(ResultCodeEnum.ACCOUNT_LESS);
    }
    //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.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.math.BigDecimal;

@Mapper
public interface UserAccountMapper extends BaseMapper<UserAccount> {

    /**
     * 检查及扣减账户余额
     * @param userId 用户ID
     * @param amount 金额
     * @return
     */
    int checkAndDeduct(@Param("userId") Long userId, @Param("amount") BigDecimal amount);
}

UserAccountMapper.xml

<!--检查及扣减账户余额-->
<update id="checkAndDeduct">
	UPDATE user_account
	SET total_amount = total_amount - #{amount},
		available_amount = available_amount - #{amount},
		total_pay_amount = total_pay_amount + #{amount}
	WHERE
		user_id = #{userId}
	  AND available_amount >= #{amount}
	  AND is_deleted = 0
</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;

@Slf4j
@Component
public class AccountDegradeFeignClient implements AccountFeignClient {

    @Override
    public Result checkAndDeduct(AccountDeductVo accountDeductVo) {
        log.error("[账户服务]提供远程调用checkAndDeduct方法执行服务降级");
        return null;
    }
}

2.3.2 新增购买记录

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

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

UserInfoApiController控制器

/**
 * 虚拟物品发货，新增用户购买记录-处理购买类型：1.专辑 2.声音 3.会员
 *
 * @param userPaidRecordVo 购买记录VO对象
 * @return
 */
@Operation(summary = "虚拟物品发货，新增用户购买记录-处理购买类型：1.专辑 2.声音 3.会员")
@PostMapping("/userInfo/savePaidRecord")
public Result savePaidRecord(@RequestBody UserPaidRecordVo userPaidRecordVo) {
    userInfoService.savePaidRecord(userPaidRecordVo);
    return Result.ok();
}

UserInfoService业务接口

/**
 * 支付（余额，微信）成功后虚拟物品发货
 *
 * @param userPaidRecordVo
 * @return
 */
void savePaidRecord(UserPaidRecordVo userPaidRecordVo);

业务实现类UserInfoServiceImpl

@Autowired
private AlbumFeignClient albumFeignClient;

@Autowired
private UserVipServiceMapper userVipServiceMapper;

@Autowired
private VipServiceConfigMapper vipServiceConfigMapper;

/**
 * 虚拟物品发货，新增用户购买记录-处理购买类型：1.专辑 2.声音 3.会员
 *
 * @param userPaidRecordVo 购买记录VO对象 项目类型: 1001-专辑 1002-声音 1003-vip会员
 * @return
 */
@Override
@Transactional(rollbackFor = Exception.class)
public void savePaidRecord(UserPaidRecordVo userPaidRecordVo) {
    //1.处理购买项目类型为专辑
    if (SystemConstant.ORDER_ITEM_TYPE_ALBUM.equals(userPaidRecordVo.getItemType())) {
        //1.1 根据入参订单编号查询购买是否存在
        LambdaQueryWrapper<UserPaidAlbum> paidAlbumLambdaQueryWrapper = new LambdaQueryWrapper<>();
        paidAlbumLambdaQueryWrapper.eq(UserPaidAlbum::getOrderNo, userPaidRecordVo.getOrderNo());
        Long count = userPaidAlbumMapper.selectCount(paidAlbumLambdaQueryWrapper);
        if (count == 0) {
            //1.2 不存在则新增购买记录，反之说明已处理忽略即可
            UserPaidAlbum userPaidAlbum = new UserPaidAlbum();
            userPaidAlbum.setOrderNo(userPaidRecordVo.getOrderNo());
            userPaidAlbum.setUserId(userPaidRecordVo.getUserId());
            userPaidAlbum.setAlbumId(userPaidRecordVo.getItemIdList().get(0));
            userPaidAlbumMapper.insert(userPaidAlbum);
        }
    } else if (SystemConstant.ORDER_ITEM_TYPE_TRACK.equals(userPaidRecordVo.getItemType())) {
        //2.处理购买项目类型为声音
        LambdaQueryWrapper<UserPaidTrack> paidTrackLambdaQueryWrapper = new LambdaQueryWrapper<>();
        paidTrackLambdaQueryWrapper.eq(UserPaidTrack::getOrderNo, userPaidRecordVo.getOrderNo());
        Long count = userPaidTrackMapper.selectCount(paidTrackLambdaQueryWrapper);
        if (count == 0) {
            //1.2 不存在则新增购买记录，反之说明已处理忽略即可
            TrackInfo trackInfo = albumFeignClient.getTrackInfo(userPaidRecordVo.getItemIdList().get(0)).getData();
            for (Long paidTrackId : userPaidRecordVo.getItemIdList()) {
                UserPaidTrack userPaidTrack = new UserPaidTrack();
                userPaidTrack.setOrderNo(userPaidRecordVo.getOrderNo());
                userPaidTrack.setUserId(userPaidRecordVo.getUserId());
                userPaidTrack.setAlbumId(trackInfo.getAlbumId());
                userPaidTrack.setTrackId(paidTrackId);
                userPaidTrackMapper.insert(userPaidTrack);
            }
        }
    } else if (SystemConstant.ORDER_ITEM_TYPE_VIP.equals(userPaidRecordVo.getItemType())) {
        //3.处理购买项目类型为VIP会员
        //3.1 根据入参订单编号查询购买是否存在
        LambdaQueryWrapper<UserVipService> vipServiceLambdaQueryWrapper = new LambdaQueryWrapper<>();
        vipServiceLambdaQueryWrapper.eq(UserVipService::getOrderNo, userPaidRecordVo.getOrderNo());
        Long count = userVipServiceMapper.selectCount(vipServiceLambdaQueryWrapper);
        if (count == 0) {
            //3.1 保存本次会员购买记录
            UserVipService userVipService = new UserVipService();
            userVipService.setOrderNo(userPaidRecordVo.getOrderNo());
            userVipService.setUserId(userPaidRecordVo.getUserId());
            //3.1.1 根据用户ID查询用户信息 判断当前用户是否为VIP
            UserInfoVo userInfo = this.getUserInfo(userPaidRecordVo.getUserId());
            Boolean isVIP = false;
            if (userInfo.getIsVip().intValue() == 1 && userInfo.getVipExpireTime().after(new Date())) {
                isVIP = true;
            }
            //3.1.2 如果是普通用户 本次会员起始时间=当前时间 过期时间：当前时间+会员服务月数
            //3.2 查询套餐信息
            VipServiceConfig vipServiceConfig = vipServiceConfigMapper.selectById(userPaidRecordVo.getItemIdList().get(0));
            if (!isVIP) {
                //普通用户 新开会员
                userVipService.setStartTime(new Date());
                DateTime expireDate = DateUtil.offsetMonth(new Date(), vipServiceConfig.getServiceMonth());
                userVipService.setExpireTime(expireDate);
            } else {
                //3.1.3 如果是VIP-续期会员 本次会员起始时间=当前会员过期时间 过期时间：当前会员过期时间+会员服务月数
                DateTime startTime = DateUtil.offsetDay(userInfo.getVipExpireTime(), 1);
                userVipService.setStartTime(startTime);
                userVipService.setExpireTime(DateUtil.offsetMonth(startTime, vipServiceConfig.getServiceMonth()));
            }
            userVipServiceMapper.insert(userVipService);
            //3.2 用户表会员过期时间
            userInfo.setIsVip(1);
            userInfo.setVipExpireTime(userVipService.getExpireTime());
            userInfoMapper.updateById(BeanUtil.copyProperties(userInfo, UserInfo.class));
        }
    }

}

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

/**
 * 虚拟物品发货，新增用户购买记录-处理购买类型：1.专辑 2.声音 3.会员
 *
 * @param userPaidRecordVo 购买记录VO对象
 * @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.bean.BeanUtil;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.atguigu.tingshu.album.AlbumFeignClient;
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.service.UserInfoService;
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.context.annotation.Lazy;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * @author: atguigu
 * @create: 2024-05-25 15:22
 */
@Slf4j
@Component("1003")
public class VIPStrategyImpl implements PaidRecordStrategy {

    @Autowired
    private AlbumFeignClient albumFeignClient;

    @Autowired
    private UserVipServiceMapper userVipServiceMapper;

    @Autowired
    private VipServiceConfigMapper vipServiceConfigMapper;

    @Lazy //解决循环依赖问题
    @Autowired
    private UserInfoService userInfoService;


    @Autowired
    private UserInfoMapper userInfoMapper;

    /**
     * 处理购买项目类型VIP
     * @param userPaidRecordVo
     */
    @Override
    public void handlerPaidRecord(UserPaidRecordVo userPaidRecordVo) {
        log.info("[用户服务]处理购买项目类型VIP");
        //3.处理购买项目类型为VIP会员
        //3.1 根据入参订单编号查询购买是否存在
        LambdaQueryWrapper<UserVipService> vipServiceLambdaQueryWrapper = new LambdaQueryWrapper<>();
        vipServiceLambdaQueryWrapper.eq(UserVipService::getOrderNo, userPaidRecordVo.getOrderNo());
        Long count = userVipServiceMapper.selectCount(vipServiceLambdaQueryWrapper);
        if (count == 0) {
            //3.1 保存本次会员购买记录
            UserVipService userVipService = new UserVipService();
            userVipService.setOrderNo(userPaidRecordVo.getOrderNo());
            userVipService.setUserId(userPaidRecordVo.getUserId());
            //3.1.1 根据用户ID查询用户信息 判断当前用户是否为VIP
            UserInfoVo userInfo = userInfoService.getUserInfo(userPaidRecordVo.getUserId());
            Boolean isVIP = false;
            if (userInfo.getIsVip().intValue() == 1 && userInfo.getVipExpireTime().after(new Date())) {
                isVIP = true;
            }
            //3.1.2 如果是普通用户 本次会员起始时间=当前时间 过期时间：当前时间+会员服务月数
            //3.2 查询套餐信息
            VipServiceConfig vipServiceConfig = vipServiceConfigMapper.selectById(userPaidRecordVo.getItemIdList().get(0));
            if (!isVIP) {
                //普通用户 新开会员
                userVipService.setStartTime(new Date());
                DateTime expireDate = DateUtil.offsetMonth(new Date(), vipServiceConfig.getServiceMonth());
                userVipService.setExpireTime(expireDate);
            } else {
                //3.1.3 如果是VIP-续期会员 本次会员起始时间=当前会员过期时间 过期时间：当前会员过期时间+会员服务月数
                DateTime startTime = DateUtil.offsetDay(userInfo.getVipExpireTime(), 1);
                userVipService.setStartTime(startTime);
                userVipService.setExpireTime(DateUtil.offsetMonth(startTime, vipServiceConfig.getServiceMonth()));
            }
            userVipServiceMapper.insert(userVipService);
            //3.2 用户表会员过期时间
            userInfo.setIsVip(1);
            userInfo.setVipExpireTime(userVipService.getExpireTime());
            userInfoMapper.updateById(BeanUtil.copyProperties(userInfo, UserInfo.class));
        }
    }
}

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

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

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-05-25 15:22
 */
@Slf4j
@Component("1001")
public class AblumStrategyImpl implements PaidRecordStrategy {

    @Autowired
    private UserPaidAlbumMapper userPaidAlbumMapper;

    /**
     * 处理购买项目类型专辑
     *
     * @param userPaidRecordVo
     */
    @Override
    public void handlerPaidRecord(UserPaidRecordVo userPaidRecordVo) {
        log.info("[用户服务]处理购买项目类型专辑");
        //1.处理购买项目类型为专辑
        //1.1 根据入参订单编号查询购买是否存在
        LambdaQueryWrapper<UserPaidAlbum> paidAlbumLambdaQueryWrapper = new LambdaQueryWrapper<>();
        paidAlbumLambdaQueryWrapper.eq(UserPaidAlbum::getOrderNo, userPaidRecordVo.getOrderNo());
        Long count = userPaidAlbumMapper.selectCount(paidAlbumLambdaQueryWrapper);
        if (count == 0) {
            //1.2 不存在则新增购买记录，反之说明已处理忽略即可
            UserPaidAlbum userPaidAlbum = new UserPaidAlbum();
            userPaidAlbum.setOrderNo(userPaidRecordVo.getOrderNo());
            userPaidAlbum.setUserId(userPaidRecordVo.getUserId());
            userPaidAlbum.setAlbumId(userPaidRecordVo.getItemIdList().get(0));
            userPaidAlbumMapper.insert(userPaidAlbum);
        }
    }
}

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

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

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;

/**
 * @author: atguigu
 * @create: 2024-05-25 15:22
 */
@Slf4j
@Component("1002")
public class TrackStrategyImpl implements PaidRecordStrategy {

    @Autowired
    private UserPaidTrackMapper userPaidTrackMapper;

    @Autowired
    private AlbumFeignClient albumFeignClient;

    /**
     * 处理购买项目类型声音
     * @param userPaidRecordVo
     */
    @Override
    public void handlerPaidRecord(UserPaidRecordVo userPaidRecordVo) {
      log.info("[用户服务]处理购买项目类型声音");
        //2.处理购买项目类型为声音
        LambdaQueryWrapper<UserPaidTrack> paidTrackLambdaQueryWrapper = new LambdaQueryWrapper<>();
        paidTrackLambdaQueryWrapper.eq(UserPaidTrack::getOrderNo, userPaidRecordVo.getOrderNo());
        Long count = userPaidTrackMapper.selectCount(paidTrackLambdaQueryWrapper);
        if (count == 0) {
            //1.2 不存在则新增购买记录，反之说明已处理忽略即可
            TrackInfo trackInfo = albumFeignClient.getTrackInfo(userPaidRecordVo.getItemIdList().get(0)).getData();
            for (Long paidTrackId : userPaidRecordVo.getItemIdList()) {
                UserPaidTrack userPaidTrack = new UserPaidTrack();
                userPaidTrack.setOrderNo(userPaidRecordVo.getOrderNo());
                userPaidTrack.setUserId(userPaidRecordVo.getUserId());
                userPaidTrack.setAlbumId(trackInfo.getAlbumId());
                userPaidTrack.setTrackId(paidTrackId);
                userPaidTrackMapper.insert(userPaidTrack);
            }
        }
    }
}

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

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

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

import java.util.Map;

/**
 * @author: atguigu
 * @create: 2024-05-25 15:25
 */
@Slf4j
@Component
public class StrategyFactory {


    /**
     * Spring进行注入，通过Map接收注入Bean
     * Map中Key：IOC容器中策略实现类BeanID
     * Map中Value：不同策略实现类对象
     */
    @Autowired
    private Map<String, PaidRecordStrategy> strategyMap;


    /**
     * 根据传入购买项目类型返回具体实现类对象
     *
     * @param itemType
     * @return
     */
    public PaidRecordStrategy getStrategyByItemType(String itemType) {
        if (strategyMap.containsKey(itemType)) {
            return strategyMap.get(itemType);
        }
        log.error("该购买项目类型暂不支持处理");
        return null;
    }

}

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

@Autowired
private StrategyFactory strategyFactory;


/**
 * 支付（余额，微信）成功后虚拟物品发货
 * 可能会存在三种项目类型：1001-专辑 1002-声音 1003-vip会员
 *
 * @param userPaidRecordVo
 * @return
 */
@Override
@Transactional(rollbackFor = Exception.class)
public void savePaidRecord(UserPaidRecordVo userPaidRecordVo) {
    String itemType = userPaidRecordVo.getItemType();
    //1.根据购买项目类型获取该购买项目策略实现类对象
    PaidRecordStrategy paidStrategy = strategyFactory.getStrategyByItemType(itemType);
    //2.处理不同购买项目类型
    strategy.handlerPaidRecord(userPaidRecordVo);
}

2.3 提交订单

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

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

2.4.1 控制器

OrderInfoApiController

/**
 * 订单提交-支付方式选择（1.微信支付 2.余额支付）
 *
 * @param orderInfoVo
 * @return
 */
@GuiGuLogin
@Operation(summary = "订单提交-支付方式（1.微信支付 2.余额支付）")
@PostMapping("/orderInfo/submitOrder")
public Result<Map<String, String>> submitOrder(@RequestBody @Valid OrderInfoVo orderInfoVo) {
    Long userId = AuthContextHolder.getUserId();
    Map<String, String> map = orderInfoService.submitOrder(userId, orderInfoVo);
    return Result.ok(map);
}

2.4.2 接口与实现

/**
 * 订单提交-支付方式选择（1.微信支付 2.余额支付）
 *
 * @param userId 用户ID
 * @param orderInfoVo 订单VO信息
 * @return
 */
Map<String, String> submitOrder(Long userId, OrderInfoVo orderInfoVo);

/**
 * 保存订单 及订单明细，优惠列表
 * @param userId 用户ID
 * @param orderInfoVo 订单VO信息
 * @return 保存后订单对象
 */
OrderInfo saveOrderInfo(Long userId, OrderInfoVo orderInfoVo);

@Autowired
private AccountFeignClient accountFeignClient;

/**
 * 订单提交-支付方式选择（1.微信支付 2.余额支付）
 * 核心业务：
 * 1. 保存订单
 * 2. 扣减余额
 * 3. 虚拟物品发货
 *
 * @param userId      用户ID
 * @param orderInfoVo 订单VO信息
 * @return
 */
@Override
@GlobalTransactional(rollbackFor = Exception.class)
public Map<String, String> submitOrder(Long userId, OrderInfoVo orderInfoVo) {
    //1.业务校验：验证流水号避免用户利用业务回退导致订单重复提交
    //1.1 构建当前用户订单流水号Key查询Redis中流水号
    String key = RedisConstant.ORDER_TRADE_NO_PREFIX + userId;
    //1.2 如果Redis中存储流水号跟前端提交一致 通过校验，立即将Redis中流水删除 反之抛出异常终止业务
    String scriptText = "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<>(scriptText, Boolean.class);
    Boolean flag = (Boolean) redisTemplate.execute(redisScript, Arrays.asList(key), orderInfoVo.getTradeNo());
    if (!flag) {
        throw new GuiguException(400, "流水号验证失败,请重试");
    }


    //2.业务校验：验证签名 避免用户恶意篡改订单信息
    //2.1 将订单VO转为Map TODO 由于订单确认页生成签名使用payWay属性，验签确保参数中没有payWay
    Map<String, Object> mapParams = BeanUtil.beanToMap(orderInfoVo);
    mapParams.remove("payWay");
    //2.2 验证签名
    SignHelper.checkSign(mapParams);
    //3.保存订单及订单明细
    OrderInfo orderInfo = this.saveOrderInfo(userId, orderInfoVo);
    //4.TODO 处理用户选择支付方式为：余额  扣减余额 及 虚拟物品发货
    String payWay = orderInfoVo.getPayWay();
    if (SystemConstant.ORDER_PAY_ACCOUNT.equals(payWay)) {
        //4.1 远程调用账户服务完成余额扣减
        //4.1.1 准备扣减余额远程调用所需入参对象
        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);
        //4.1.3 因为存在全局异常处理，导致及时目标服务发生异常Feign接口正常响应Result(业务状态码非200)
        if (!ResultCodeEnum.SUCCESS.getCode().equals(result.getCode())) {
            throw new GuiguException(400, "余额扣减失败！");
        }
        //4.2 余额扣减成功后，该笔订单支付状态改为：已支付
        orderInfo.setOrderStatus(SystemConstant.ORDER_STATUS_PAID);
        orderInfoMapper.updateById(orderInfo);

        //4.3 远程调用用户服务完成虚拟物品发货
        //4.3.1 准备虚拟物品发货远程调用所需入参对象
        UserPaidRecordVo userPaidRecordVo = new UserPaidRecordVo();
        userPaidRecordVo.setOrderNo(orderInfo.getOrderNo());
        userPaidRecordVo.setUserId(orderInfo.getUserId());
        userPaidRecordVo.setItemType(orderInfo.getItemType());
        //获取购买项目ID集合
        List<Long> itemIdList =
                orderInfoVo.getOrderDetailVoList()
                        .stream().map(OrderDetailVo::getItemId)
                        .collect(Collectors.toList());
        userPaidRecordVo.setItemIdList(itemIdList);

        //4.3.2 发送Feign远程调用
        result = userFeignClient.savePaidRecord(userPaidRecordVo);
        //4.3.3 因为存在全局异常处理，导致及时目标服务发生异常Feign接口正常响应Result(业务状态码非200)
        if (!ResultCodeEnum.SUCCESS.getCode().equals(result.getCode())) {
            throw new GuiguException(400, "发货失败！");
        }
    } else if (SystemConstant.ORDER_PAY_WAY_WEIXIN.equals(payWay)) {
        //5.TODO 处理用户选择支付方式为：微信  采用延迟任务 延迟关单
    }
    //6.返回对象封装订单编号
    Map<String, String> map = new HashMap<>();
    map.put("orderNo", orderInfo.getOrderNo());
    return map;
}

2.4.3 保存订单方法

业务处理：

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

OrderInfoService接口

/**
 * 保存订单相关信息
 * @param userId 用户ID
 * @param orderInfoVo 订单VO信息
 * @return
 */
OrderInfo saveOrder(Long userId, OrderInfoVo orderInfoVo);

OrderInfoServiceImpl实现类


@Autowired
private OrderDetailMapper orderDetailMapper;

@Autowired
private OrderDerateMapper orderDerateMapper;

/**
 * 保存订单 及订单明细，优惠列表
 *
 * @param userId      用户ID
 * @param orderInfoVo 订单VO信息
 * @return 保存后订单对象
 */
@Override
public OrderInfo saveOrderInfo(Long userId, OrderInfoVo orderInfoVo) {
    //1.保存订单
    //1.1 将订单VO中信息拷贝到PO对象中
    OrderInfo orderInfo = BeanUtil.copyProperties(orderInfoVo, OrderInfo.class);
    //1.2 封装其他对象属性
    //1.2.1 设置用户ID
    orderInfo.setUserId(userId);
    //1.2.2 设置订单状态
    orderInfo.setOrderStatus(SystemConstant.ORDER_STATUS_UNPAID);
    //1.2.3 设置订单编号 商户侧确保全局唯一 规则：年月日+雪花算法
    String orderNo = DateUtil.today().replaceAll("-", "") + IdUtil.getSnowflakeNextId();
    orderInfo.setOrderNo(orderNo);
    //1.2.4 设置订单商品标题
    List<OrderDetailVo> orderDetailVoList = orderInfoVo.getOrderDetailVoList();
    if (CollectionUtil.isNotEmpty(orderDetailVoList)) {
        String itemName = orderDetailVoList.get(0).getItemName();
        orderInfo.setOrderTitle(itemName);
    }
    //1.3 保存订单得到订单ID
    orderInfoMapper.insert(orderInfo);
    Long orderId = orderInfo.getId();

    //2.保存订单明细
    if (CollectionUtil.isNotEmpty(orderDetailVoList)) {
        //2.1 将订单明细VO集合转为PO 关联订单ID
        orderDetailVoList.stream().forEach(orderDetailVo -> {
            OrderDetail orderDetail = BeanUtil.copyProperties(orderDetailVo, OrderDetail.class);
            orderDetail.setOrderId(orderId);
            //2.2 保存订单明细
            orderDetailMapper.insert(orderDetail);
            //TODO 如果进行批量新增 选择注入业务接口Iservice中saveBatch批量保存
        });
    }
    //3.保存订单优惠列表
    List<OrderDerateVo> orderDerateVoList = orderInfoVo.getOrderDerateVoList();
    if (CollectionUtil.isNotEmpty(orderDerateVoList)) {
        orderDerateVoList.stream().forEach(orderDerateVo -> {
            OrderDerate orderDerate = BeanUtil.copyProperties(orderDerateVo, OrderDerate.class);
            orderDerate.setOrderId(orderId);
            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分钟重试，直到出现阈值终止

技术选择：

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

4.2 延迟关闭订单

service-util利用redissonClient 发送延迟消息,提供公共业务

package com.atguigu.tingshu.common.delay;

import com.atguigu.tingshu.common.result.Result;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RBlockingQueue;
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.concurrent.TimeUnit;

/**
 * @author: atguigu
 * @create: 2024-04-24 10:45
 */
@Slf4j
@Component
public class DelayMessageService {


    @Autowired
    private RedissonClient redissonClient;


    /**
     * 发送延迟消息
     * @param queueName
     * @param data
     * @param ttl
     */
    public void sendDelayMsg(String queueName, String data, int ttl) {
        //1.基于Redisson客户端对象创建阻塞队列
        RBlockingQueue<String> blockingQueue = redissonClient.getBlockingQueue(queueName);
        //2.基于Redisson客户端对象将阻塞队列作为参数创建延迟队列
        RDelayedQueue<String> delayedQueue = redissonClient.getDelayedQueue(blockingQueue);
        //3.调用阻塞队列对象发送延迟消息
        delayedQueue.offer(data, ttl, TimeUnit.SECONDS);
        log.info("发送延迟消息到队列：{}成功：{}，延迟时间：{}s", queueName, data, ttl);
    }

}

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

@Autowired
private DelayMsgService delayMsgService;

/**
 * 提交订单
 *
 * @param userId
 * @param orderInfoVo
 * @return
 */
@Override
@GlobalTransactional(rollbackFor = Exception.class)
public String submitOrder(Long userId, OrderInfoVo orderInfoVo) {
    //...省略
	//8.TODO 选择微信支付，发送延迟任务，延迟关闭超时未支付订单 测试：30s
        delayMessageService.sendDelayMsg(KafkaConstant.QUEUE_ORDER_CANCEL, orderInfo.getId().toString(), 30);

}

监听消息：

package com.atguigu.tingshu.order.reciever;

import com.atguigu.tingshu.common.constant.KafkaConstant;
import com.atguigu.tingshu.order.service.OrderInfoService;
import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.redisson.api.RBlockingQueue;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * @author: atguigu
 * @create: 2024-04-24 10:50
 */
@Slf4j
@Component
public class OrderCancelHandler {


    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private OrderInfoService orderInfoService;


    @PostConstruct
    public void delayCloseOrder() {
        //1.基于Redisson客户端对象创建阻塞队列
        RBlockingQueue<String> blockingQueue = redissonClient.getBlockingQueue(KafkaConstant.QUEUE_ORDER_CANCEL);
        //2.JUC线程池工具类中提供创建单一线程线程池方法
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.submit(() -> {
            while (true) {
                String data = null;
                try {
                    data = blockingQueue.poll(5, TimeUnit.SECONDS);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                if (StringUtils.isNotBlank(data)) {
                    log.info("监听延迟关单消息订单ID:{}", data);
                    orderInfoService.cancelOrder(Long.valueOf(data));
                }
            }
        });
    }
}

OrderInfoService接口：

/**
 * 检查订单状态及关闭订单
 * @param orderId
 */
void cancelOrder(Long orderId);

OrderInfoServiceImpl实现类：

/**
 * 检查订单状态及关闭订单
 *
 * @param orderId
 */
@Override
public void cancelOrder(Long orderId) {
    //1.根据订单ID查询订单状态
    OrderInfo orderInfo = orderInfoMapper.selectById(orderId);
    if (orderInfo != null && SystemConstant.ORDER_STATUS_UNPAID.equals(orderInfo.getOrderStatus())) {
        //2.判断订单状态 如果是未支付，修改为已取消
        orderInfo.setOrderStatus(SystemConstant.ORDER_STATUS_CANCEL);
        orderInfoMapper.updateById(orderInfo);
        log.info("[订单服务]订单：{}超时未支付，取消订单", orderId);
    }
}

第7章 订单.md 85 KB Permalink History Raw

第7章 订单

1、订单结算

1.1 获取账户余额

1.1.1 初始化账户

1.1.2 显示账户余额

1.2 VIP会员结算

1.2.1 获取VIP套餐列表

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

1.2.3 VIP会员结算页数据汇总

1.2.2.1 控制器

1.2.2.2 业务层

1.3 专辑结算

1.3.1 Feign请求头丢失解决

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

1.3.3 专辑结算数据汇总

1.3.3.3 OrderInfoServiceImpl实现类

1.4 声音结算

1.4.1 声音分集购买列表

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

UserInfoApiController控制器

UserInfoService接口

UserInfoServiceImpl实现类

1.4.1.2 声音分集购买列表

TrackInfoApiController控制器

TrackInfoService接口

TrackInfoServiceImpl实现类

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

控制器

TrackInfoService接口

实现类

1.4.3 改造订单确认方法

2、提交订单

2.1 提交订单业务分析

2.2 整合分布式事务Seata

2.3 服务提供方

2.3.1 检查并扣减账户余额

2.3.2 新增购买记录

2.3.3 代码优化

2.3 提交订单

2.4.1 控制器

2.4.2 接口与实现

2.4.3 保存订单方法

3、我的订单

3.1 订单明细信息

3.2 我的订单列表

4、订单延迟关单

4.1 什么是延迟任务

4.2 延迟关闭订单

第7章订单.md 85 KB

Permalink History Raw

第7章订单