谷粒随享

第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.login.GuiGuLogin;
import com.atguigu.tingshu.common.result.Result;
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() {
        BigDecimal availableAmount = userAccountService.getAvailableAmount();
        return Result.ok(availableAmount);
    }

}

UserAccountService接口：

/**
 * 获取当前登录用户账户可用余额
 * @return
 */
BigDecimal getAvailableAmount();

UserAccountServiceImpl实现类：

/**
 * 获取当前登录用户账户可用余额
 *
 * @return
 */
@Override
public BigDecimal getAvailableAmount() {
    //1.获取当前用户ID
    Long userId = AuthContextHolder.getUserId();
    //2.根据用户ID查询账户记录
    LambdaQueryWrapper<UserAccount> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(UserAccount::getUserId, userId);
    UserAccount userAccount = userAccountMapper.selectOne(queryWrapper);
    Assert.notNull(userAccount, "用户{}账户不存在", userId);
    //3.返回可用余额
    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
 * @return
 */
@Operation(summary = "根据套餐ID查询套餐信息")
@GetMapping("/vipServiceConfig/getVipServiceConfig/{id}")
public Result<VipServiceConfig> getVipServiceConfig(@PathVariable Long id){
	VipServiceConfig config = vipServiceConfigService.getById(id);
	return Result.ok(config);
}

在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.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;

	/**
	 * 获取订单确认页面所需数据
	 * @param tradeVo {itemType:"项目类型",:itemId:"项目",trackCount:"声音数量"}
	 * @return 订单vo对象->为后续提交订单准备
	 */
	@GuiGuLogin
	@Operation(summary = "获取订单确认页面所需数据")
	@PostMapping("/orderInfo/trade")
	public Result<OrderInfoVo> getOrderTradeData(@RequestBody TradeVo tradeVo){
		OrderInfoVo orderInfoVo = orderInfoService.getOrderTradeData(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 tradeVo {itemType:"项目类型",:itemId:"项目",trackCount:"声音数量"}
     * @return 订单vo对象->为后续提交订单准备
     */
    OrderInfoVo getOrderTradeData(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.common.util.AuthContextHolder;
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 {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())) {
            //2.1 根据选择套餐ID远程调用“用户服务”获取套餐信息(商品信息)
            VipServiceConfig vipServiceConfig = userFeignClient.getVipServiceConfig(tradeVo.getItemId()).getData();
            Assert.notNull(vipServiceConfig, "套餐{}信息为空", tradeVo.getItemId());

            //2.2 为订单VO中商品价格赋值-原价、减免价、订单价
            originalAmount = vipServiceConfig.getPrice();
            orderAmount = vipServiceConfig.getDiscountPrice();
            derateAmount = originalAmount.subtract(orderAmount);

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

            //2.4 封装商品优惠明细列表
            if (originalAmount.compareTo(orderAmount) != 0) {
                OrderDerateVo orderDerateVo = new OrderDerateVo();
                orderDerateVo.setDerateType(SystemConstant.ORDER_DERATE_VIP_SERVICE_DISCOUNT);
                orderDerateVo.setDerateAmount(derateAmount);
                orderDerateVo.setRemarks("VIP套餐限时优惠：{}" + derateAmount);
                orderDerateVoList.add(orderDerateVo);
            }
        } else if (SystemConstant.ORDER_ITEM_TYPE_ALBUM.equals(tradeVo.getItemType())) {
            //3.TODO 处理专辑（不允许重复）

        } else if (SystemConstant.ORDER_ITEM_TYPE_TRACK.equals(tradeVo.getItemType())) {
            //4.TODO 处理声音（不允许重复）

        }
        //5.订单信息VO中三种商品订单确认 共有属性
        //5.1 封装购买项目类型
        orderInfoVo.setItemType(tradeVo.getItemType());
        //5.2 封装商品相关价格信息及商品清单
        orderInfoVo.setOriginalAmount(originalAmount);
        orderInfoVo.setDerateAmount(derateAmount);
        orderInfoVo.setOrderAmount(orderAmount);
        orderInfoVo.setOrderDetailVoList(orderDetailVoList);
        orderInfoVo.setOrderDerateVoList(orderDerateVoList);
        //5.3 生成订单流水号
        //5.3.1 构建当前用户本次订单流水号Key
        String tradeKey = RedisConstant.ORDER_TRADE_NO_PREFIX + userId;
        //5.3.2 采用全局唯一字符串作为流水号Value
        String tradeNo = IdUtil.randomUUID();
        //5.3.3 将流水号存入Redis
        redisTemplate.opsForValue().set(tradeKey, tradeNo, 5, TimeUnit.MINUTES);
        //5.3.4 封装流水号
        orderInfoVo.setTradeNo(tradeNo);

        //5.4 生成时间戳-确认订单跟提交订单间隔时间太长
        orderInfoVo.setTimestamp(DateUtil.current());
        //5.5 生订单签名
        //5.5.1 将订单VO转为Map TODO:无法确认支付方式 将payWay空属性排除
        Map<String, Object> map = BeanUtil.beanToMap(orderInfoVo, false, true);
        //5.5.2 生成签名
        String sign = SignHelper.getSign(map);
        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
 */
@GuiGuLogin
@Operation(summary = "验证当前用户是否购买过指定专辑")
@GetMapping("/userInfo/isPaidAlbum/{albumId}")
public Result<Boolean> isPaidAlbum(@PathVariable Long albumId) {
    Boolean isPaid = userInfoService.isPaidAlbum(albumId);
    return Result.ok(isPaid);
}

UserInfoService接口

/**
 * 根据当前登录用户ID+专辑ID查询是否存在购买记录
 * @param albumId
 * @return
 */
Boolean isPaidAlbum(Long albumId);

UserInfoServiceImpl实现类

/**
 * 根据当前登录用户ID+专辑ID查询是否存在购买记录
 *
 * @param albumId
 * @return
 */
@Override
public Boolean isPaidAlbum(Long albumId) {
    //1.获取当前用户ID
    Long userId = AuthContextHolder.getUserId();
    //2.用户ID+专辑ID查询是否存在购买记录
    LambdaQueryWrapper<UserPaidAlbum> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(UserPaidAlbum::getUserId, userId);
    queryWrapper.eq(UserPaidAlbum::getAlbumId, albumId);
    Long count = userPaidAlbumMapper.selectCount(queryWrapper);
    return count > 0;
}

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

/**
 * 验证当前用户是否购买过指定专辑
 * @param albumId
 * @return
 */
@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实现类

/**
 * 获取订单确认页面所需数据
 * - 购买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())) {
        //2.1 代码省略...
    } else if (SystemConstant.ORDER_ITEM_TYPE_ALBUM.equals(tradeVo.getItemType())) {
        //3. 处理专辑（不允许重复购买）
        //3.1 远程调用"用户服务"-判断用户是否已购专辑
        Boolean isPaid = userFeignClient.isPaidAlbum(tradeVo.getItemId()).getData();
        if (isPaid) {
            throw new GuiguException(ResultCodeEnum.REPEAT_BUY_ERROR);
        }
        //3.2 远程调用"用户服务"-获取当前用户身份信息
        UserInfoVo userInfoVo = userFeignClient.getUserInfoVo(userId).getData();
        Assert.notNull(userInfoVo, "用户{}不存在", userId);
        int isVip = userInfoVo.getIsVip().intValue();
        //3.3 远程调用"专辑服务"-获取专辑信息-得到价格及不同用户折扣
        AlbumInfo albumInfo = albumFeignClient.getAlbumInfo(tradeVo.getItemId()).getData();
        Assert.notNull(albumInfo, "专辑{}不存在", tradeVo.getItemId());
        //3.4 计算专辑价格封装原价，订单价，减免价   订单价=原价*折扣
        originalAmount = albumInfo.getPrice();
        orderAmount = originalAmount;
        //3.4.1 判断当前专辑是否有普通用户折扣（是否不等于-1） 且 当前用户是普通用户/VIP过期
        if (albumInfo.getDiscount().intValue() != -1) {
            if (isVip == 0 || (isVip == 1 && new Date().after(userInfoVo.getVipExpireTime()))) {
                //3.4.2 计算普通用户享受折扣   折扣8代表打8折
                orderAmount = originalAmount.multiply(albumInfo.getDiscount()).divide(new BigDecimal("10"), 2, RoundingMode.HALF_UP);
            }
        }
        //3.4.3 判断当前专辑是否有VIP用户折扣
        if (albumInfo.getVipDiscount().intValue() != -1) {
            if (isVip == 1 && userInfoVo.getVipExpireTime().after(new Date())) {
                //3.4.2 计算VIP用户享受折扣   折扣8代表打8折
                orderAmount = originalAmount.multiply(albumInfo.getVipDiscount()).divide(new BigDecimal("10"), 2, RoundingMode.HALF_UP);
            }
        }
        derateAmount = originalAmount.subtract(orderAmount);
        //3.5 封装商品明细列表
        OrderDetailVo orderDetailVo = new OrderDetailVo();
        orderDetailVo.setItemId(tradeVo.getItemId());
        orderDetailVo.setItemName("专辑：" + albumInfo.getAlbumTitle());
        orderDetailVo.setItemUrl(albumInfo.getCoverUrl());
        orderDetailVo.setItemPrice(originalAmount);
        orderDetailVoList.add(orderDetailVo);

        //3.6 封装商品优惠列表
        if (derateAmount.compareTo(new BigDecimal("0.00")) != 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(tradeVo.getItemType())) {
        //4.TODO 处理声音（不允许重复购买）

    }
    //5.订单信息VO中三种商品订单确认 共有属性
    //5.1 封装购买项目类型
    orderInfoVo.setItemType(tradeVo.getItemType());
    //5.2 封装商品相关价格信息及商品清单
    orderInfoVo.setOriginalAmount(originalAmount);
    orderInfoVo.setDerateAmount(derateAmount);
    orderInfoVo.setOrderAmount(orderAmount);
    orderInfoVo.setOrderDetailVoList(orderDetailVoList);
    orderInfoVo.setOrderDerateVoList(orderDerateVoList);
    //5.3 生成订单流水号
    //5.3.1 构建当前用户本次订单流水号Key
    String tradeKey = RedisConstant.ORDER_TRADE_NO_PREFIX + userId;
    //5.3.2 采用全局唯一字符串作为流水号Value
    String tradeNo = IdUtil.randomUUID();
    //5.3.3 将流水号存入Redis
    redisTemplate.opsForValue().set(tradeKey, tradeNo, 5, TimeUnit.MINUTES);
    //5.3.4 封装流水号
    orderInfoVo.setTradeNo(tradeNo);

    //5.4 生成时间戳-确认订单跟提交订单间隔时间太长
    orderInfoVo.setTimestamp(DateUtil.current());
    //5.5 生订单签名
    //5.5.1 将订单VO转为Map TODO:无法确认支付方式 将payWay空属性排除
    Map<String, Object> map = BeanUtil.beanToMap(orderInfoVo, false, true);
    //5.5.2 生成签名
    String sign = SignHelper.getSign(map);
    orderInfoVo.setSign(sign);

    //6.返回订单VO对象
    return orderInfoVo;
}

1.4 声音结算

1.4.1 声音分集购买列表

1.4.1.1 获取用户已支付声音Id列表

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) {
    List<Long> list = userInfoService.getUserPaidTrackIdList(albumId);
    return Result.ok(list);
}

UserInfoService接口

/**
 * 查询当前用户某个专辑中已购声音id集合
 * @param albumId 专辑ID
 * @return
 */
List<Long> getUserPaidTrackIdList(Long albumId);

UserInfoServiceImpl实现类

/**
 * 查询当前用户某个专辑中已购声音id集合
 *
 * @param albumId 专辑ID
 * @return
 */
@Override
public List<Long> getUserPaidTrackIdList(Long albumId) {
    //1.获取当前用户ID
    Long userId = AuthContextHolder.getUserId();
    //2.根据用户ID+专辑ID查询已购声音列表
    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);
    //3.获取已购声音ID列表
    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:"全集",price:17,trackCount:17}]
 */
@GuiGuLogin
@Operation(summary = "动态构建当前用户分集购买列表")
@GetMapping("/trackInfo/findUserTrackPaidList/{trackId}")
public Result<List<Map<String, Object>>> getUserWaitBuyList(@PathVariable Long trackId){
    List<Map<String, Object>> list = trackInfoService.getUserWaitBuyList(trackId);
    return Result.ok(list);
}

TrackInfoService接口

/**
 * 动态构建当前用户分集购买列表
 * @param trackId 选择“付费标识”声音ID
 * @return [{name:"本集",price:1,trackCount:1},{name:"后10集",price:10,trackCount:10},{name:"全集",price:17,trackCount:17}]
 */
List<Map<String, Object>> getUserWaitBuyList(Long trackId);

TrackInfoServiceImpl实现类

思路：

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

@Autowired
private UserFeignClient userFeignClient;

/**
 * 动态构建当前用户分集购买列表
 *
 * @param trackId 选择“付费标识”声音ID
 * @return [{name:"本集",price:1,trackCount:1},{name:"后10集",price:10,trackCount:10},{name:"全集",price:17,trackCount:17}]
 */
@Override
public List<Map<String, Object>> getUserWaitBuyList(Long trackId) {
    //1.获取当前用户id
    Long userId = AuthContextHolder.getUserId();
    //2.根据"选择购买声音ID"查询声音信息-得到专辑ID、声音序号
    TrackInfo trackInfo = trackInfoMapper.selectById(trackId);
    Long albumId = trackInfo.getAlbumId();
    AlbumInfo albumInfo = albumInfoMapper.selectById(albumId);
    BigDecimal price = albumInfo.getPrice();
    //3.根据专辑ID+声音序号条件查询所有大于指定序号声音列表
    LambdaQueryWrapper<TrackInfo> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(TrackInfo::getAlbumId, albumId);
    queryWrapper.ge(TrackInfo::getOrderNum, trackInfo.getOrderNum());
    List<TrackInfo> userWaitPayTrackList = trackInfoMapper.selectList(queryWrapper);
    //4.远程调用"用户服务"得到用户已购买声音ID集合
    List<Long> userPaidTrackIdList = userFeignClient.getUserPaidTrackIdList(albumId).getData();
    //5.如果存在已购买声音ID，将所有声音列表中已购买声音排除掉得到 “未购买声音列表”
    List<Map<String, Object>> list = new ArrayList<>();
    if (CollectionUtil.isNotEmpty(userPaidTrackIdList)) {
        userWaitPayTrackList = userWaitPayTrackList.stream()
                .filter(trackInfo1 -> !userPaidTrackIdList.contains(trackInfo1.getId()))
                .collect(Collectors.toList());
    }
    //6.根据未购买声音列表长度动态购买分集购买列表
    int size = userWaitPayTrackList.size();
    //6.1 构建"本集"购买对象
    Map<String, Object> currMap = new HashMap<>();
    currMap.put("name", "本集");
    currMap.put("price", price);
    currMap.put("trackCount", 1);
    list.add(currMap);

    //6.2 如果代购买声音列表长度在N*10~(N+1)*10 区间展示 固定显示后 N*10 集合
    //6.3 如果待购买声音列表长度大于N*10集 显示 全集
    for (int i = 10; i <= 50; i += 10) {
        if (size > i) {
            // 长度大于N*10集 显示固定后N*10集
            Map<String, Object> map = new HashMap<>();
            map.put("name", "后" + i + "集");
            map.put("price", price.multiply(new BigDecimal(i)));
            map.put("trackCount", i);
            list.add(map);
        } else {
            //显示全集 精确集数
            Map<String, Object> map = new HashMap<>();
            map.put("name", "全集（" + size + "集)");
            map.put("price", price.multiply(new BigDecimal(size)));
            map.put("trackCount", size);
            list.add(map);
            break;
        }
    }
    return list;
}

1.4.2 获取待结算声音列表

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>> getUserWaitBuyTrackInfoList(@PathVariable Long trackId, @PathVariable Integer trackCount){
    List<TrackInfo> list = trackInfoService.getUserWaitBuyTrackInfoList(trackId, trackCount);
    return Result.ok(list);
}

TrackInfoService接口

/**
 * 查询当前用户待购买声音列表作为待结算商品列表
 * @param trackId 选择购买声音ID
 * @param trackCount 购买集数
 * @return
 */
List<TrackInfo> getUserWaitBuyTrackInfoList(Long trackId, Integer trackCount);

实现类

思路：

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

/**
 * 查询当前用户待购买声音列表作为待结算商品列表
 *
 * @param trackId    选择购买声音ID
 * @param trackCount 购买集数
 * @return
 */
@Override
public List<TrackInfo> getUserWaitBuyTrackInfoList(Long trackId, Integer trackCount) {
    //1.根据声音ID查询声音信息得到声音所属专辑ID，序号
    TrackInfo trackInfo = trackInfoMapper.selectById(trackId);
    Long albumId = trackInfo.getAlbumId();
    Integer orderNum = trackInfo.getOrderNum();

    //2.查询声音表中用户未购买过的后*条声音记录
    //2.1 获取用户已购买声音ID列表
    List<Long> userPaidTrackIdList = userFeignClient.getUserPaidTrackIdList(albumId).getData();
    //2.2 构建查询声音条件对象
    LambdaQueryWrapper<TrackInfo> queryWrapper = new LambdaQueryWrapper<>();
    //2.2.1 查询指定专辑的声音
    queryWrapper.eq(TrackInfo::getAlbumId, albumId);
    if (CollectionUtil.isNotEmpty(userPaidTrackIdList)) {
        //2.2.2 如果存在用户已购买声音ID，将已购买声音排除掉
        queryWrapper.notIn(TrackInfo::getId, userPaidTrackIdList);
    }
    //2.2.3 声音序号大于当前购买声音序号
    queryWrapper.ge(TrackInfo::getOrderNum, orderNum);
    //2.2.4 按照声音序号升序
    queryWrapper.orderByAsc(TrackInfo::getOrderNum);
    //2.2.5 指定用户购买指定集数数量
    queryWrapper.last("limit " + trackCount);
    //2.2.6 避免将声音播放地址直接返回
    queryWrapper.select(TrackInfo::getId, TrackInfo::getTrackTitle, TrackInfo::getCoverUrl, TrackInfo::getAlbumId);
    //2.3 查询待购买声音列表
    return trackInfoMapper.selectList(queryWrapper);
}

AlbumFeignClient

/**
 * 查询当前用户待购买声音列表作为待结算商品列表
 * @param trackId 选择购买声音ID
 * @param trackCount 购买集数
 * @return
 */
@GetMapping("/trackInfo/findPaidTrackInfoList/{trackId}/{trackCount}")
public Result<List<TrackInfo>> getUserWaitBuyTrackInfoList(@PathVariable Long trackId, @PathVariable Integer trackCount);

熔断类：

@Override
public Result<List<TrackInfo>> getUserWaitBuyTrackInfoList(Long trackId, Integer trackCount) {
    log.error("远程调用专辑服务getUserWaitBuyTrackInfoList服务降级");
    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.处理声音（不允许重复购买）
        //4.1 远程调用"专辑服务"获取待购买声音列表
        List<TrackInfo> waitBuyTrackInfoList =
                albumFeignClient.getUserWaitBuyTrackInfoList(tradeVo.getItemId(), tradeVo.getTrackCount()).getData();
        if (CollectionUtil.isEmpty(waitBuyTrackInfoList)) {
            throw new GuiguException(400, "没有符合计算要求声音！");
        }
        //4.2 远程调用"专辑服务"获取专辑信息-得到声音单价
        AlbumInfo albumInfo = albumFeignClient.getAlbumInfo(waitBuyTrackInfoList.get(0).getAlbumId()).getData();
        //声音单价
        BigDecimal price = albumInfo.getPrice();

        //4.3 计算用户购买声音价格（原价=订单价）
        originalAmount = price.multiply(new BigDecimal(waitBuyTrackInfoList.size()));
        orderAmount = originalAmount;

        //4.4 封装本次订单中商品清单列表
        orderDetailVoList = waitBuyTrackInfoList.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.setItemType(tradeVo.getItemType());
    //5.2 封装商品相关价格信息及商品清单
    orderInfoVo.setOriginalAmount(originalAmount);
    orderInfoVo.setDerateAmount(derateAmount);
    orderInfoVo.setOrderAmount(orderAmount);
    orderInfoVo.setOrderDetailVoList(orderDetailVoList);
    orderInfoVo.setOrderDerateVoList(orderDerateVoList);
    //5.3 生成订单流水号
    //5.3.1 构建当前用户本次订单流水号Key
    String tradeKey = RedisConstant.ORDER_TRADE_NO_PREFIX + userId;
    //5.3.2 采用全局唯一字符串作为流水号Value
    String tradeNo = IdUtil.randomUUID();
    //5.3.3 将流水号存入Redis
    redisTemplate.opsForValue().set(tradeKey, tradeNo, 5, TimeUnit.MINUTES);
    //5.3.4 封装流水号
    orderInfoVo.setTradeNo(tradeNo);

    //5.4 生成时间戳-确认订单跟提交订单间隔时间太长
    orderInfoVo.setTimestamp(DateUtil.current());
    //5.5 生订单签名
    //5.5.1 将订单VO转为Map TODO:无法确认支付方式 将payWay空属性排除
    Map<String, Object> map = BeanUtil.beanToMap(orderInfoVo, false, true);
    //5.5.2 生成签名
    String sign = SignHelper.getSign(map);
    orderInfoVo.setSign(sign);

    //6.返回订单VO对象
    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

/**
 * 用户余额支付订单-验证扣减账户余额
 * TODO:跟虚拟物品发货接口保持一致，用户ID通过入参对象传递。将来采用微信/支付宝支付后，支付宝会有支付成功回调->请求商户系统不会携带Token访问
 *
 * @param accountDeductVo
 * @return 业务调用正常返回业务状态码：200，反之业务失败，触发全局事务回滚
 */
@Operation(summary = "用户余额支付订单-验证扣减账户余额")
@PostMapping("/userAccount/checkAndDeduct")
public Result checkAndDeduct(@RequestBody AccountDeductVo accountDeductVo) {
    userAccountService.checkAndDeduct(accountDeductVo);
    return Result.ok();
}

业务接口UserAccountService

/**
 * 用户余额支付订单-验证扣减账户余额
 * @param accountDeductVo
 */
void checkAndDeduct(AccountDeductVo accountDeductVo);

业务实现类UserAccountService

/**
 * 用户余额支付订单-验证扣减账户余额
 *
 * @param accountDeductVo
 */
@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 {

    /**
     * 用户余额支付订单-验证扣减账户余额
     * TODO:跟虚拟物品发货接口保持一致，用户ID通过入参对象传递。将来采用微信/支付宝支付后，支付宝会有支付成功回调->请求商户系统不会携带Token访问
     *
     * @param accountDeductVo
     * @return 业务调用正常返回业务状态码：200，反之业务失败，触发全局事务回滚
     */
    @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控制器

/**
 * 提交订单支付（余额，支付宝）成功-虚拟物品发货
 *
 * @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
@Transactional(rollbackFor = Exception.class)
public void savePaidRecord(UserPaidRecordVo userPaidRecordVo) {
    //付款项目类型: 1001-专辑 1002-声音 1003-vip会员
    //1.处理专辑购买记录
    if (SystemConstant.ORDER_ITEM_TYPE_ALBUM.equals(userPaidRecordVo.getItemType())) {
        //1.1 根据订单编号查询已购专辑记录 如果购买记录存在说明已经保存过则忽略
        LambdaQueryWrapper<UserPaidAlbum> userPaidAlbumLambdaQueryWrapper = new LambdaQueryWrapper<>();
        userPaidAlbumLambdaQueryWrapper.eq(UserPaidAlbum::getOrderNo, userPaidRecordVo.getOrderNo());
        userPaidAlbumLambdaQueryWrapper.last("last 1");
        Long count = userPaidAlbumMapper.selectCount(userPaidAlbumLambdaQueryWrapper);
        if (count > 0) {
            return;
        }
        //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.处理声音购买记录
        //2.1 根据订单编号查询已购声音记录 如果购买记录存在说明已经保存过则忽略
        LambdaQueryWrapper<UserPaidTrack> userPaidTrackLambdaQueryWrapper = new LambdaQueryWrapper<>();
        userPaidTrackLambdaQueryWrapper.eq(UserPaidTrack::getOrderNo, userPaidRecordVo.getOrderNo());
        userPaidTrackLambdaQueryWrapper.last("limit 1");
        Long count = userPaidTrackMapper.selectCount(userPaidTrackLambdaQueryWrapper);
        if (count > 0) {
            return;
        }
        //2.3 根据声音ID声音信息
        TrackInfo trackInfo = albumFeignClient.getTrackInfo(userPaidRecordVo.getItemIdList().get(0)).getData();
        //2.3 遍历已购声音ID列表构建用户已购声音记录，保存已购声音记录
        userPaidRecordVo.getItemIdList()
                .stream().forEach(trackId -> {
                    UserPaidTrack userPaidTrack = new UserPaidTrack();
                    userPaidTrack.setOrderNo(userPaidRecordVo.getOrderNo());
                    userPaidTrack.setUserId(userPaidRecordVo.getUserId());
                    userPaidTrack.setAlbumId(trackInfo.getAlbumId());
                    userPaidTrack.setTrackId(trackId);
                    userPaidTrackMapper.insert(userPaidTrack);
                });
    } else if (SystemConstant.ORDER_ITEM_TYPE_VIP.equals(userPaidRecordVo.getItemType())) {
        //3.处理会员购买记录
        //3.1 为购买会员保存会员购买记录
        //3.1.1 根据订单编号查询已购会员记录是否存在
        LambdaQueryWrapper<UserVipService> userVipServiceLambdaQueryWrapper = new LambdaQueryWrapper<>();
        userVipServiceLambdaQueryWrapper.eq(UserVipService::getOrderNo, userPaidRecordVo.getOrderNo());
        userVipServiceLambdaQueryWrapper.last("limit 1");
        Long count = userVipServiceMapper.selectCount(userVipServiceLambdaQueryWrapper);
        if (count > 0) {
            return;
        }
        //3.1.2 根据购买套餐ID查询套餐信息-得到会员服务月数用于计算过期时间
        VipServiceConfig vipServiceConfig = vipServiceConfigMapper.selectById(userPaidRecordVo.getItemIdList().get(0));
        Integer serviceMonth = vipServiceConfig.getServiceMonth();

        //3.1.3 判断用户会员新开或者会员续费
        UserVipService userVipService = new UserVipService();
        UserInfo userInfo = userInfoMapper.selectById(userPaidRecordVo.getUserId());
        int isVip = userInfo.getIsVip().intValue();
        if (isVip == 1 && userInfo.getVipExpireTime().after(new Date())) {
            //会员续费 本次VIP购买生效时间是现有会员过期时间
            userVipService.setStartTime(userInfo.getVipExpireTime());
            userVipService.setExpireTime(DateUtil.offsetMonth(userInfo.getVipExpireTime(), serviceMonth));
        } else {
            //新开会员 本次VIP购买生效时间为当前时间
            userVipService.setStartTime(new Date());
            userVipService.setExpireTime(DateUtil.offsetMonth(new Date(), serviceMonth));
        }
        //3.1.4 新增会员购买记录
        userVipService.setOrderNo(userVipService.getOrderNo());
        userVipService.setUserId(userPaidRecordVo.getUserId());
        userVipServiceMapper.insert(userVipService);

        //3.2 更新用户会员标识以及延长会员过期时间
        userInfo.setIsVip(1);
        userInfo.setVipExpireTime(userVipService.getExpireTime());
        userInfoMapper.updateById(userInfo);
    }
}

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

/**
 * 提交订单支付（余额，支付宝）成功-虚拟物品发货
 *
 * @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.pattern;

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

/**
 * 抽象策略接口
 * 定义抽象购买行为方法
 */
public interface UserPaidStrategy {


    /**
     * 抽象新增购买记录接口方法
     *
     * @param userPaidRecordVo
     */
    void saveUserPaidRecord(UserPaidRecordVo userPaidRecordVo);


}

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

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

import cn.hutool.core.date.DateUtil;
import com.atguigu.tingshu.common.constant.SystemConstant;
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.pattern.UserPaidStrategy;
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-03-09 11:35
 */
@Slf4j
@Component(SystemConstant.ORDER_ITEM_TYPE_VIP)
public class VIPUserPaidStrategy implements UserPaidStrategy {

    @Autowired
    private UserVipServiceMapper userVipServiceMapper;

    @Autowired
    private UserInfoMapper userInfoMapper;

    @Autowired
    private VipServiceConfigMapper vipServiceConfigMapper;

    /**
     * 处理购买项目类型为：VIP
     *
     * @param userPaidRecordVo
     */
    @Override
    public void saveUserPaidRecord(UserPaidRecordVo userPaidRecordVo) {
        log.info("处理购买项目类型为：VIP,{}", userPaidRecordVo);
        //3.处理会员购买记录
        //3.1 为购买会员保存会员购买记录
        //3.1.1 根据订单编号查询已购会员记录是否存在
        LambdaQueryWrapper<UserVipService> userVipServiceLambdaQueryWrapper = new LambdaQueryWrapper<>();
        userVipServiceLambdaQueryWrapper.eq(UserVipService::getOrderNo, userPaidRecordVo.getOrderNo());
        userVipServiceLambdaQueryWrapper.last("limit 1");
        Long count = userVipServiceMapper.selectCount(userVipServiceLambdaQueryWrapper);
        if (count > 0) {
            return;
        }
        //3.1.2 根据购买套餐ID查询套餐信息-得到会员服务月数用于计算过期时间
        VipServiceConfig vipServiceConfig = vipServiceConfigMapper.selectById(userPaidRecordVo.getItemIdList().get(0));
        Integer serviceMonth = vipServiceConfig.getServiceMonth();

        //3.1.3 判断用户会员新开或者会员续费
        UserVipService userVipService = new UserVipService();
        UserInfo userInfo = userInfoMapper.selectById(userPaidRecordVo.getUserId());
        int isVip = userInfo.getIsVip().intValue();
        if (isVip == 1 && userInfo.getVipExpireTime().after(new Date())) {
            //会员续费 本次VIP购买生效时间是现有会员过期时间
            userVipService.setStartTime(userInfo.getVipExpireTime());
            userVipService.setExpireTime(DateUtil.offsetMonth(userInfo.getVipExpireTime(), serviceMonth));
        } else {
            //新开会员 本次VIP购买生效时间为当前时间
            userVipService.setStartTime(new Date());
            userVipService.setExpireTime(DateUtil.offsetMonth(new Date(), serviceMonth));
        }
        //3.1.4 新增会员购买记录
        userVipService.setOrderNo(userPaidRecordVo.getOrderNo());
        userVipService.setUserId(userPaidRecordVo.getUserId());
        userVipServiceMapper.insert(userVipService);

        //3.2 更新用户会员标识以及延长会员过期时间
        userInfo.setIsVip(1);
        userInfo.setVipExpireTime(userVipService.getExpireTime());
        userInfoMapper.updateById(userInfo);
    }
}

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

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

import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.model.user.UserPaidAlbum;
import com.atguigu.tingshu.user.mapper.UserPaidAlbumMapper;
import com.atguigu.tingshu.user.pattern.UserPaidStrategy;
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;

/**
 * 1001-专辑 1002-声音 1003-vip会员
 *
 * @author: atguigu
 * @create: 2024-03-09 11:34
 */
@Slf4j
@Component(SystemConstant.ORDER_ITEM_TYPE_ALBUM)  //默认beanId 类名-首字母小写 albumUserPaidStrategy 将beanID设置为跟业务提交购买类型一致
public class AlbumUserPaidStrategy implements UserPaidStrategy {

    @Autowired
    private UserPaidAlbumMapper userPaidAlbumMapper;

    /**
     * 处理购买项目类型为：专辑
     *
     * @param userPaidRecordVo
     */
    @Override
    public void saveUserPaidRecord(UserPaidRecordVo userPaidRecordVo) {
        log.info("处理购买项目类型为：专辑,{}", userPaidRecordVo);
        //1.处理专辑购买记录
        //1.1 根据订单编号查询已购专辑记录 如果购买记录存在说明已经保存过则忽略
        LambdaQueryWrapper<UserPaidAlbum> userPaidAlbumLambdaQueryWrapper = new LambdaQueryWrapper<>();
        userPaidAlbumLambdaQueryWrapper.eq(UserPaidAlbum::getOrderNo, userPaidRecordVo.getOrderNo());
        userPaidAlbumLambdaQueryWrapper.last("limit 1");
        Long count = userPaidAlbumMapper.selectCount(userPaidAlbumLambdaQueryWrapper);
        if (count > 0) {
            return;
        }
        //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.pattern.impl;

import com.atguigu.tingshu.album.AlbumFeignClient;
import com.atguigu.tingshu.common.constant.SystemConstant;
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.pattern.UserPaidStrategy;
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-03-09 11:35
 */
@Slf4j
@Component(SystemConstant.ORDER_ITEM_TYPE_TRACK)
public class TrackUserPaidStrategy implements UserPaidStrategy {

    @Autowired
    private UserPaidTrackMapper userPaidTrackMapper;

    @Autowired
    private AlbumFeignClient albumFeignClient;

    /**
     * 处理购买项目类型：声音
     *
     * @param userPaidRecordVo
     */
    @Override
    public void saveUserPaidRecord(UserPaidRecordVo userPaidRecordVo) {
        log.info("理购买项目类型：声音,{}", userPaidRecordVo);
        //2.处理声音购买记录
        //2.1 根据订单编号查询已购声音记录 如果购买记录存在说明已经保存过则忽略
        LambdaQueryWrapper<UserPaidTrack> userPaidTrackLambdaQueryWrapper = new LambdaQueryWrapper<>();
        userPaidTrackLambdaQueryWrapper.eq(UserPaidTrack::getOrderNo, userPaidRecordVo.getOrderNo());
        userPaidTrackLambdaQueryWrapper.last("limit 1");
        Long count = userPaidTrackMapper.selectCount(userPaidTrackLambdaQueryWrapper);
        if (count > 0) {
            return;
        }
        //2.3 根据声音ID声音信息
        TrackInfo trackInfo = albumFeignClient.getTrackInfo(userPaidRecordVo.getItemIdList().get(0)).getData();
        //2.3 遍历已购声音ID列表构建用户已购声音记录，保存已购声音记录
        userPaidRecordVo.getItemIdList()
                .stream().forEach(trackId -> {
                    UserPaidTrack userPaidTrack = new UserPaidTrack();
                    userPaidTrack.setOrderNo(userPaidRecordVo.getOrderNo());
                    userPaidTrack.setUserId(userPaidRecordVo.getUserId());
                    userPaidTrack.setAlbumId(trackInfo.getAlbumId());
                    userPaidTrack.setTrackId(trackId);
                    userPaidTrackMapper.insert(userPaidTrack);
                });
    }
}

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

package com.atguigu.tingshu.user.pattern.facotry;

import com.atguigu.tingshu.common.execption.GuiguException;
import com.atguigu.tingshu.user.pattern.UserPaidStrategy;
import com.atguigu.tingshu.user.pattern.impl.AlbumUserPaidStrategy;
import com.atguigu.tingshu.user.pattern.impl.TrackUserPaidStrategy;
import com.atguigu.tingshu.user.pattern.impl.VIPUserPaidStrategy;
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-03-09 11:41
 */
@Slf4j
@Component
public class StrategyFactory {

    /**
     * 将目前所有策略实现类对象进行封装
     * Map中Key：实现类对象BeanID 就是不同策略实现类自定义beanID：购买项目类型
     * Map中Value：购买行为实现类对象
     */
    @Autowired
    private Map<String, UserPaidStrategy> userPaidStrategyMap;


    /**
     * 提供根据购买项目类型获取具体策略实现类对象
     *
     * @param orderItemType
     * @return
     */
    public UserPaidStrategy getStrategy(String orderItemType) {
        if (userPaidStrategyMap.containsKey(orderItemType)) {
            return userPaidStrategyMap.get(orderItemType);
        }
        throw new GuiguException(400, "购买项目类型不支持！");
    }
}

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

@Autowired
private StrategyFactory strategyFactory;


/**
 * 提交订单支付（余额，支付宝）成功-虚拟物品发货
 *
 * @param userPaidRecordVo
 */
@Override
@Transactional(rollbackFor = Exception.class)
public void savePaidRecord(UserPaidRecordVo userPaidRecordVo) {
    //付款项目类型: 1001-专辑 1002-声音 1003-vip会员
    //1.根据购买项目类型获取具体策略实现类对象
    UserPaidStrategy userPaidStrategy = strategyFactory.getStrategy(userPaidRecordVo.getItemType());
    //2.调用不同策略实现类实现不同行为
    userPaidStrategy.saveUserPaidRecord(userPaidRecordVo);
}

2.3 提交订单

我们将前端页面提交的数据统一封装到实体类OrderInfoVo中

package com.atguigu.tingshu.vo.order;

import com.atguigu.tingshu.common.util.Decimal2Serializer;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.Valid;
import jakarta.validation.constraints.DecimalMax;
import jakarta.validation.constraints.DecimalMin;
import jakarta.validation.constraints.Digits;
import jakarta.validation.constraints.NotEmpty;
import lombok.Data;

import java.math.BigDecimal;
import java.util.List;

@Data
@Schema(description = "订单对象")
public class OrderInfoVo {

    @NotEmpty(message = "交易号不能为空")
    @Schema(description = "交易号", required = true)
    private String tradeNo;

    @NotEmpty(message = "支付方式不能为空")
    @Schema(description = "支付方式：1101-微信 1102-支付宝 1103-账户余额", required = true)
    private String payWay;

    @NotEmpty(message = "付款项目类型不能为空")
    @Schema(description = "付款项目类型: 1001-专辑 1002-声音 1003-vip会员", required = true)
    private String itemType;

    /**
     * value：最小值
     * inclusive：是否可以等于最小值，默认true，>= 最小值
     * message：错误提示（默认有一个错误提示i18n支持中文）
     *
     * @DecimalMax 同上
     * @Digits integer： 整数位最多几位
     * fraction：小数位最多几位
     * message：同上，有默认提示
     */
    @DecimalMin(value = "0.00", inclusive = false, message = "订单原始金额必须大于0.00")
    @DecimalMax(value = "9999.99", inclusive = true, message = "订单原始金额必须大于9999.99")
    @Digits(integer = 4, fraction = 2)
    @Schema(description = "订单原始金额", required = true)
    @JsonSerialize(using = Decimal2Serializer.class)
    private BigDecimal originalAmount;

    @DecimalMin(value = "0.00", inclusive = true, message = "减免总金额必须大于0.00")
    @DecimalMax(value = "9999.99", inclusive = true, message = "减免总金额必须大于9999.99")
    @Digits(integer = 4, fraction = 2)
    @Schema(description = "减免总金额", required = true)
    @JsonSerialize(using = Decimal2Serializer.class)
    private BigDecimal derateAmount;

    @DecimalMin(value = "0.00", inclusive = false, message = "订单总金额必须大于0.00")
    @DecimalMax(value = "9999.99", inclusive = true, message = "订单总金额必须大于9999.99")
    @Digits(integer = 4, fraction = 2)
    @Schema(description = "订单总金额", required = true)
    @JsonSerialize(using = Decimal2Serializer.class)
    private BigDecimal orderAmount;

    @Valid
    @NotEmpty(message = "订单明细列表不能为空")
    @Schema(description = "订单明细列表", required = true)
    private List<OrderDetailVo> orderDetailVoList;

    @Schema(description = "订单减免明细列表")
    private List<OrderDerateVo> orderDerateVoList;

    @Schema(description = "时间戳", required = true)
    private Long timestamp;
    @Schema(description = "签名", required = true)
    private String sign;
}

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

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

2.4.1 控制器

OrderInfoApiController

/**
 * 当前用户提交订单（可能包含余额支付）
 *
 * @param orderInfoVo 订单VO信息
 * @return {orderNo:订单唯一编号}
 */
@GuiGuLogin
@Operation(summary = "当前用户提交订单（可能包含余额支付）")
@PostMapping("/orderInfo/submitOrder")
public Result<Map<String, String>> submitOrder(@RequestBody OrderInfoVo orderInfoVo) {
    Map<String, String> map = orderInfoService.submitOrder(orderInfoVo);
    return Result.ok(map);
}

2.4.2 接口与实现

/**
 * 当前用户提交订单（可能包含余额支付）
 *
 * @param orderInfoVo 订单VO信息
 * @return {orderNo:订单唯一编号}
 */
Map<String, String> submitOrder(OrderInfoVo orderInfoVo);

/**
 * 保存订单包含订单明细跟优惠明细
 * @param orderInfoVo 订单VO信息
 * @param userId 用户ID
 * @return 订单对象
 */
OrderInfo saveOrderInfo(OrderInfoVo orderInfoVo, Long userId);

@Autowired
private AccountFeignClient accountFeignClient;

/**
 * 当前用户提交订单（可能包含余额支付）
 *
 * @param orderInfoVo 订单VO信息
 * @return {orderNo:订单唯一编号}
 */
@Override
@GlobalTransactional(rollbackFor = Exception.class)
public Map<String, String> submitOrder(OrderInfoVo orderInfoVo) {
    Long userId = AuthContextHolder.getUserId();
    //1.业务校验，验证流水号-避免用户误操作回退页面导致订单重复提交
    //1.1 构建当前用户存入Redis流水号Key
    String key = RedisConstant.ORDER_TRADE_NO_PREFIX + userId;
    //1.2 采用Lua脚本-判断用户提交流水号跟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);
    //1.3 执行lua脚本
    Boolean flag = (Boolean) redisTemplate.execute(redisScript, Arrays.asList(key), orderInfoVo.getTradeNo());
    if (!flag) {
        throw new GuiguException(400, "流水号异常请重试！");
    }

    //2.业务校验，验证签名-避免用户篡改订单中任意信息 TODO:当时订单确认页面相应签名：没有加入支付方式"payWay"
    //2.1 将订单信息vo转为Map
    Map<String, Object> mapPrams = BeanUtil.beanToMap(orderInfoVo);
    //2.2 将Map参数中payWay排除掉
    mapPrams.remove("payWay");
    //2.3 验证签名-内部逻辑 1.获取原有旧的的签名值 2.将参数中旧签名移除掉，对所有业务数据再次进行签名
    SignHelper.checkSign(mapPrams);

    //3.处理订单相关业务（保存订单及订单明细，订单优惠明细）
    OrderInfo orderInfo = this.saveOrderInfo(orderInfoVo, userId);

    //4.如果用户采用余额支付（声音仅支持余额支付）
    // 订单支付方式 1101-微信 1102-支付宝 1103-账户余额
    if (SystemConstant.ORDER_PAY_ACCOUNT.equals(orderInfoVo.getPayWay())) {
        //4.1 远程调用账户服务进行余额扣减
        //4.1.1 构建扣减余额VO对象
        AccountDeductVo accountDeductVo = new AccountDeductVo();
        accountDeductVo.setOrderNo(orderInfo.getOrderNo());
        accountDeductVo.setUserId(userId);
        accountDeductVo.setAmount(orderInfo.getOrderAmount());
        accountDeductVo.setContent(orderInfo.getOrderTitle());
        //4.1.2 远程调用判断返回结果业务状态码是否200
        Result accountResult = accountFeignClient.checkAndDeduct(accountDeductVo);
        if (!ResultCodeEnum.SUCCESS.getCode().equals(accountResult.getCode())) {
            throw new GuiguException(500, "余额不足，请充值！");
        }
        //4.2 远程调用用户服务进行虚拟物品发货
        //4.2.1 构建购买记录VO对象
        //4.2.2 远程调用判断返回结果业务状态码是否200
        UserPaidRecordVo userPaidRecordVo = new UserPaidRecordVo();
        userPaidRecordVo.setOrderNo(orderInfo.getOrderNo());
        userPaidRecordVo.setUserId(userId);
        userPaidRecordVo.setItemType(orderInfoVo.getItemType());
        List<OrderDetailVo> orderDetailVoList = orderInfoVo.getOrderDetailVoList();
        if (CollectionUtil.isNotEmpty(orderDetailVoList)) {
            List<Long> itemIdList =
                    orderDetailVoList.stream()
                            .map(OrderDetailVo::getItemId).collect(Collectors.toList());
            userPaidRecordVo.setItemIdList(itemIdList);
        }

        Result userResult = userFeignClient.savePaidRecord(userPaidRecordVo);
        if (!ResultCodeEnum.SUCCESS.getCode().equals(userResult.getCode())) {
            throw new GuiguException(500, "发货失败，请联系管理员！");
        }

        //4.3 更新订单支付状态：已支付
        orderInfo.setOrderStatus(SystemConstant.ORDER_STATUS_PAID);
        orderInfoMapper.updateById(orderInfo);

    }
    //5.构建Map封装订单编号返回结果
    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 orderInfoVo 订单VO信息
 * @param userId      用户ID
 * @return 订单对象
 */
@Override
public OrderInfo saveOrderInfo(OrderInfoVo orderInfoVo, Long userId) {
    //1.保存订单信息
    //1.1 将前端提交订单基本属性拷贝对象方式拷贝到订单对象中
    OrderInfo orderInfo = BeanUtil.copyProperties(orderInfoVo, OrderInfo.class);
    //1.2 用户ID
    orderInfo.setUserId(userId);
    //1.3 订单标题 从商品明细VO中获取
    List<OrderDetailVo> orderDetailVoList = orderInfoVo.getOrderDetailVoList();
    String itemName = orderDetailVoList.get(0).getItemName();
    orderInfo.setOrderTitle(itemName);
    //1.4 订单状态：未支付
    orderInfo.setOrderStatus(SystemConstant.ORDER_STATUS_UNPAID);
    //1.5 订单编号 确保订单编号全局唯一 跟后续第三方支付对接使用到 规则：年月日+雪花算法分布式ID
    String today = DateUtil.today().replaceAll("-", "");
    String orderNo = today + IdUtil.getSnowflakeNextId();
    orderInfo.setOrderNo(orderNo);
    orderInfoMapper.insert(orderInfo);
    Long orderId = orderInfo.getId();

    //2.保存订单商品明细
    orderDetailVoList.stream()
            .forEach(orderDetailVo -> {
                OrderDetail orderDetail = BeanUtil.copyProperties(orderDetailVo, OrderDetail.class);
                //关联订单ID
                orderDetail.setOrderId(orderId);
                //保存订单明细
                orderDetailMapper.insert(orderDetail);
            });

    //3.保存订单优惠明细
    List<OrderDerateVo> orderDerateVoList = orderInfoVo.getOrderDerateVoList();
    if (CollectionUtil.isNotEmpty(orderDerateVoList)) {
        orderDerateVoList.stream().forEach(orderDerateVo -> {
            OrderDerate orderDerate = BeanUtil.copyProperties(orderDerateVo, OrderDerate.class);
            //关联订单ID
            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
 */
@GuiGuLogin
@Operation(summary = "查询指定订单信息")
@GetMapping("/orderInfo/getOrderInfo/{orderNo}")
public Result<OrderInfo> getOrderInfo(@PathVariable String orderNo) {
    OrderInfo orderInfo = orderInfoService.getOrderInfo(orderNo);
    return Result.ok(orderInfo);
}

OrderInfoService接口

/**
 * 获取订单信息
 *
 * @param userId
 * @param orderNo
 * @return
 */
OrderInfo getOrderInfo(Long userId, String orderNo);

OrderInfoServiceImpl实现

/**
 * 查询当前用户指定订单信息
 *
 * @param orderNo 订单编号
 * @return 订单信息包含：商品列表，优惠列表
 */
@Override
public OrderInfo getOrderInfo(String orderNo) {
    Long userId = AuthContextHolder.getUserId();
    //1.根据订单编号+用户ID查询订单信息
    LambdaQueryWrapper<OrderInfo> orderInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
    orderInfoLambdaQueryWrapper.eq(OrderInfo::getUserId, userId);
    orderInfoLambdaQueryWrapper.eq(OrderInfo::getOrderNo, orderNo);
    OrderInfo orderInfo = orderInfoMapper.selectOne(orderInfoLambdaQueryWrapper);

    if (orderInfo != null) {
        //2.根据订单ID查询订单明细列表
        LambdaQueryWrapper<OrderDetail> orderDetailLambdaQueryWrapper = new LambdaQueryWrapper<>();
        orderDetailLambdaQueryWrapper.eq(OrderDetail::getOrderId, orderInfo.getId());
        List<OrderDetail> orderDetailList = orderDetailMapper.selectList(orderDetailLambdaQueryWrapper);
        orderInfo.setOrderDetailList(orderDetailList);


        //3.根据订单ID查询订单优惠列表
        LambdaQueryWrapper<OrderDerate> orderDerateLambdaQueryWrapper = new LambdaQueryWrapper<>();
        orderDerateLambdaQueryWrapper.eq(OrderDerate::getOrderId, orderInfo.getId());
        List<OrderDerate> orderDerateList = orderDerateMapper.selectList(orderDerateLambdaQueryWrapper);
        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>> getUserOrderByPage(@PathVariable int page, @PathVariable int limit) {
    //1.构建分页对象
    Page<OrderInfo> pageInfo = new Page<>(page, limit);
    //2.调用业务逻辑
    orderInfoService.getUserOrderByPage(pageInfo);
    return Result.ok(pageInfo);
}

OrderInfoService接口

/**
 * 查询当前用户订单列表（包含订单商品明细）
 *
 * @param pageInfo 分页对象
 * @return
 */
void getUserOrderByPage(Page<OrderInfo> pageInfo);

OrderInfoServiceImpl实现

/**
 * 查询当前用户订单列表（包含订单商品明细）
 *
 * @param pageInfo 分页对象
 * @return
 */
@Override
public void getUserOrderByPage(Page<OrderInfo> pageInfo) {
    Long userId = AuthContextHolder.getUserId();
    //1.获取持久层接口，通过动态SQL查询订单列表
    orderInfoMapper.getUserOrderByPage1(pageInfo, userId);
}

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> {

    /** 分页获取订单列表
     * 解决mp一对多bug
     * @param pageInfo
     * @param userId
     * @return
     */
    Page<OrderInfo> getUserOrderByPage1(Page<OrderInfo> pageInfo, @Param("userId") Long userId);
}

OrderInfoMapper.xml 映射文件

<!--解决一对多分页bug 单独查询订单 订单明细分别查询-->
<resultMap id="orderInfoMap1" type="com.atguigu.tingshu.model.order.OrderInfo" autoMapping="true">
    <id column="id" property="id"></id>
    <!--select查询多方记录用于封装集合-->
    <collection property="orderDetailList"  ofType="com.atguigu.tingshu.model.order.OrderDetail" column="id" select="orderDetailList">
    </collection>
</resultMap>

<!--根据订单ID查询订单明细-->
<select id="orderDetailList" 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="getUserOrderByPage1" resultMap="orderInfoMap1">
    select
        oi.id,
        oi.order_title,
        oi.order_no,
        oi.order_status,
        oi.order_amount,
        oi.original_amount,
        oi.derate_amount,
        oi.item_type,
        oi.pay_way,
        oi.create_time
    from order_info oi
    where oi.user_id = #{userId} and oi.is_deleted = 0
    order by oi.create_time 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.order.util;

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 java.util.concurrent.TimeUnit;

/**
 * @author: atguigu
 * @create: 2024-03-11 11:30
 */
@Slf4j
@Component
public class DelayMesageUtil {

    @Autowired
    private RedissonClient redissonClient;


    /**
     * 基于Redisson实现延迟消息
     *
     * @param queueName 阻塞队列名称
     * @param data     消息内容
     * @param ttl      延迟时间
     * @param timeUnit 延迟时间单位
     */
    public void sendDelayMessage(String queueName, String data, int ttl, TimeUnit timeUnit) {
        try {
            //1.基于RedissonClient创建阻塞队列
            RBlockingQueue<String> blockingQueue = redissonClient.getBlockingQueue(queueName);
            //2.基于RedissonClient将阻塞队列作为参数场景延迟队列
            RDelayedQueue<String> delayedQueue = redissonClient.getDelayedQueue(blockingQueue);
            //3.调用延迟队列发送延迟消息
            delayedQueue.offer(data, ttl, timeUnit);
            log.info("延迟消息：{}，发送成功,延迟：{}秒", data, ttl);
        } catch (Exception e) {
            log.error("[延迟消息]发送延迟消息:{}异常", data);
            throw new RuntimeException(e);
        }
    }
}

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

@Autowired
private DelayMsgService delayMsgService;

/**
 * 提交订单
 *
 * @param userId
 * @param orderInfoVo
 * @return
 */
@Override
@GlobalTransactional(rollbackFor = Exception.class)
public String submitOrder(Long userId, OrderInfoVo orderInfoVo) {
    //...省略
    //6.发送延迟消息，用于验证订单支付状态且关闭订单 测试：1分钟 正式：15分钟
    delayMesageUtil.sendDelayMessage(KafkaConstant.QUEUE_ORDER_CANCEL, orderInfo.getId().toString(), 30, TimeUnit.SECONDS);

}

监听消息：

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

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;

/**
 * @author: atguigu
 * @create: 2024-03-11 11:34
 */
@Slf4j
@Component
public class DelayMessageListener {

    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private OrderInfoService orderInfoService;

    /**
     * 监听延迟关闭订单消息
     * 开启一个单一线程线程池负责监听延迟队列中消息
     */
    @PostConstruct
    public void cancelOrderDelayMsg() {
        log.info("开启监听延迟关单消息....");
        //1.创建线程池 单一线程
        ExecutorService executor = Executors.newSingleThreadExecutor();
        //2.提交任务
        executor.submit(() -> {
            //2.1 获取阻塞队列
            RBlockingQueue<String> blockingQueue = redissonClient.getBlockingQueue(KafkaConstant.QUEUE_ORDER_CANCEL);
            //2.1 开启采用循环方式获取阻塞队列中消息
            while (true) {
                String orderId = blockingQueue.poll();
                if (StringUtils.isNotBlank(orderId)) {
                    log.info("【订单服务】监听到延迟关单消息：{}", orderId);
                    orderInfoService.orderCancel(Long.valueOf(orderId));
                }
            }
        });
    }
}

OrderInfoService接口：

/**
 * 根据订单ID查询订单状态，未支付：改为取消
 * @param orderId 订单
 */
void orderCancel(Long orderId);

OrderInfoServiceImpl实现类：


/**
 * 根据订单ID查询订单状态，未支付：改为取消
 *
 * @param orderId 订单
 */
@Override
public void orderCancel(Long orderId) {
    //1.根据订单ID查询订单信息
    OrderInfo orderInfo = orderInfoMapper.selectById(orderId);
    //2.判断订单状态
    if (orderInfo != null && SystemConstant.ORDER_STATUS_UNPAID.equals(orderInfo.getOrderStatus())) {
        //3.修改订单状态：已取消
        orderInfo.setOrderStatus(SystemConstant.ORDER_STATUS_CANCEL);
        orderInfoMapper.updateById(orderInfo);
    }
}

第7章 订单.md 89 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列表

UserInfoApiController控制器

UserInfoService接口

UserInfoServiceImpl实现类

1.4.1.2 声音分集购买列表

TrackInfoApiController控制器

TrackInfoService接口

TrackInfoServiceImpl实现类

1.4.2 获取待结算声音列表

控制器

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 89 KB

Permalink History Raw

第7章订单