部分代码

无关风月

9 天以前 fafae77d59bc333a11c6b43e8f8606e190341e4a

 ruoyi-service/ruoyi-goods/src/main/java/com/ruoyi/goods/service/impl/TGoodsServiceImpl.java

@@ -18,12 +18,14 @@
import com.ruoyi.study.api.domain.TUser;
import com.ruoyi.study.api.feignClient.StudyClient;
import com.ruoyi.study.api.vo.UserPersonalCenterVO;
import com.ruoyi.system.api.model.LoginUserParent;
import org.redisson.api.RSemaphore;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;
@@ -48,10 +50,14 @@
    private ITOrderService orderService;
    @Resource
    private TokenService tokenService;

    @Override
    public List<TGoodsVO> goodRecommend(Integer userId) {
        return baseMapper.goodRecommend(userId);
    }

    @Override
    public TGoods getById1(Integer goodsId) {
        return this.baseMapper.getById1(goodsId);
    }

    @Override
@@ -65,9 +71,13 @@
        if (null != goods.getTotal()) {
            // 库存预热，redisson分布式锁
            String key = String.format(RedisConstants.GOOD_STOCK, goods.getId());
            List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getGoodsId, goodId)
            List<TOrder> orderList = orderService.lambdaQuery()
                    .eq(TOrder::getGoodsId, goodId)
                    .eq(TOrder::getDisabled, 0).list();
            int sum = orderList.stream().map(TOrder::getCount).mapToInt(Integer::intValue).sum();
            int sum = 0;
            if (!orderList.isEmpty()) {
                sum = orderList.stream().map(TOrder::getCount).mapToInt(Integer::intValue).sum();
            }
            // 计算商品剩余可兑换数量
            int number = goods.getTotal() - sum;
            if (number <= 0) {
@@ -75,7 +85,7 @@
            }
            // redisson分布式锁
            RSemaphore semaphore = redissonClient.getSemaphore(key);
            semaphore.trySetPermits(goods.getSurplus());
            semaphore.trySetPermits(number);
            semaphore.expire(Constants.SIXTY, TimeUnit.MINUTES);
        }
        return new GoodDetailVO(goods, recipient);
@@ -84,6 +94,7 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R<String> goodExchange(GoodExchangeDTO goodExchange, Recipient recipient) {
        // 用户本次兑换数量
        Integer number = goodExchange.getNumber();
        Integer goodId = goodExchange.getGoodId();
        TGoods good = lambdaQuery().eq(TGoods::getId, goodId).one();
@@ -101,14 +112,40 @@
            return R.exchangeError("兑换失败，当前剩余积分不足！");
        }
        if (null != good.getTotal()) {
            // 检查库存总数是否足够
            List<TOrder> order = orderService.lambdaQuery().eq(TOrder::getGoodsId, goodId)
                    .eq(TOrder::getDisabled, 0).list();
            int item;
            if (!order.isEmpty()) {
                item = order.stream().map(TOrder::getCount).collect(Collectors.toList())
                        .stream().mapToInt(Integer::intValue).sum();
            } else {
                item = 0;
            }
            boolean canBuy = good.getTotal() - item >= number;
            if (!canBuy) {
                throw new GlobalException("商品库存不足，兑换失败！");
            }
            // 检查用户兑换数量是否超过单用户最大兑换数量
            List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getUserId, user.getId())
                    .eq(TOrder::getGoodsId, goodId).list();
            // 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
            int totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
                    .stream().mapToInt(Integer::intValue).sum();
            boolean canExchange = orderList.isEmpty() || null == good.getUserCount() ||
                    (totalNumber + number) <= good.getUserCount();
            // 用户已兑换数量
            int totalNumber;
            if (orderList.isEmpty()) {
                totalNumber = 0;
            } else {
                // 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
                totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
                        .stream().mapToInt(Integer::intValue).sum();
            }
            boolean canExchange = true;
            if (null != good.getUserCount()) {
                if (number > good.getUserCount()) {
                    canExchange = false;
                } else {
                    canExchange = (totalNumber + number) <= good.getUserCount();
                }
            }
            if (!canExchange) {
                return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量，剩余兑换数量为: " +
                        (good.getUserCount() - totalNumber) + "！");
@@ -126,14 +163,34 @@
            }
            // 兑换成功，生成订单信息、生成积分明细(积分明细需要远程调用rouyi-study服务)
            boolean result = exchangeGood(goodExchange, recipient, number, goodId, needIntegral);
            // 扣除库存
            result = result && this.lambdaUpdate().set(TGoods::getTotal, good.getTotal() - number)
                    .eq(TGoods::getId, good.getId()).update();
            if (!result) {
                semaphore.release(number);
                return R.exchangeError("商品兑换失败！");
            }
        } else {
            if (null != good.getUserCount()) {
                // 检查用户兑换数量是否超过单用户最大兑换数量
                List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getUserId, user.getId())
                        .eq(TOrder::getGoodsId, goodId).list();
                int totalNumber;
                if (orderList.isEmpty()) {
                    totalNumber = 0;
                } else {
                    // 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
                    totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
                            .stream().mapToInt(Integer::intValue).sum();
                }
                Integer userCount = good.getUserCount();
                if (userCount > totalNumber) {
                    int i = userCount - totalNumber;
                    if (number > i) {
                        return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量，剩余兑换数量为: " +
                                i + "！");
                    }
                } else {
                    return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量！");
                }
            }
            boolean result = exchangeGood(goodExchange, recipient, number, goodId, needIntegral);
            if (!result) {
                return R.exchangeError("商品兑换失败！");
@@ -141,11 +198,123 @@
        }
        return R.ok();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R goodExchange1(GoodExchangeDTO goodExchange, Recipient recipient) {
        // 用户本次兑换数量
        Integer number = goodExchange.getNumber();
        Integer goodId = goodExchange.getGoodId();
        TGoods good = lambdaQuery().eq(TGoods::getId, goodId).one();
        if (null == good) {
            return R.exchangeError("商品不存在，请稍后重试！");
        }
        LoginUserParent loginUser1 = tokenService.getLoginUser1();
        if (null == loginUser1) {
            return R.tokenError("登录失效");
        }
        // 校验用户积分是否足够兑换
        TUser user = studyClient.userInfoParent().getData();
        if (null == user) {
            throw new GlobalException("用户信息获取失败！");
        }
        int needIntegral = good.getIntegral() * number;
        if (user.getIntegral() < needIntegral) {
            return R.exchangeError("兑换失败，当前剩余积分不足！");
        }
        if (null != good.getTotal()) {
            // 检查库存总数是否足够
            List<TOrder> order = orderService.lambdaQuery().eq(TOrder::getGoodsId, goodId)
                    .eq(TOrder::getDisabled, 0).list();
            int item;
            if (!order.isEmpty()) {
                item = order.stream().map(TOrder::getCount).collect(Collectors.toList())
                        .stream().mapToInt(Integer::intValue).sum();
            } else {
                item = 0;
            }
            boolean canBuy = good.getTotal() - item >= number;
            if (!canBuy) {
                return R.exchangeError("商品库存不足，兑换失败！");
//                throw new GlobalException("商品库存不足，兑换失败！");
            }
            // 检查用户兑换数量是否超过单用户最大兑换数量
            List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getUserId, user.getId())
                    .eq(TOrder::getGoodsId, goodId).list();
            // 用户已兑换数量
            int totalNumber;
            if (orderList.isEmpty()) {
                totalNumber = 0;
            } else {
                // 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
                totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
                        .stream().mapToInt(Integer::intValue).sum();
            }
            boolean canExchange = true;
            if (null != good.getUserCount()) {
                if (number > good.getUserCount()) {
                    canExchange = false;
                } else {
                    canExchange = (totalNumber + number) <= good.getUserCount();
                }
            }
            if (!canExchange) {
                return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量，剩余兑换数量为: " +
                        (good.getUserCount() - totalNumber) + "！");
            }
            // redisson分布式锁，防止超卖
            String key = String.format(RedisConstants.GOOD_STOCK, good.getId());
            RSemaphore semaphore = redissonClient.getSemaphore(key);
            // 请求超时时间 单位：毫秒
            semaphore.trySetPermits(1000);
            boolean tried = semaphore.tryAcquire(number);
            // 兑换失败，库存不足
            if (!tried) {
                semaphore.release(number);
                return R.exchangeError("当前商品库存不足");
            }
            // 兑换成功，生成订单信息、生成积分明细(积分明细需要远程调用rouyi-study服务)
            boolean result = exchangeGoodParent(goodExchange, recipient, number, goodId, needIntegral);
            if (!result) {
                semaphore.release(number);
                return R.exchangeError("商品兑换失败！");
            }
        } else {
            if (null != good.getUserCount()) {
                // 检查用户兑换数量是否超过单用户最大兑换数量
                List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getUserId, user.getId())
                        .eq(TOrder::getGoodsId, goodId).list();
                int totalNumber;
                if (orderList.isEmpty()) {
                    totalNumber = 0;
                } else {
                    // 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
                    totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
                            .stream().mapToInt(Integer::intValue).sum();
                }
                Integer userCount = good.getUserCount();
                if (userCount > totalNumber) {
                    int i = userCount - totalNumber;
                    if (number > i) {
                        return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量，剩余兑换数量为: " +
                                i + "！");
                    }
                } else {
                    return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量！");
                }
            }
            boolean result = exchangeGoodParent(goodExchange, recipient, number, goodId, needIntegral);
            if (!result) {
                return R.exchangeError("商品兑换失败！");
            }
        }
        return R.ok();
    }
    private Boolean exchangeGood(GoodExchangeDTO goodExchange, Recipient recipient, Integer number,
                                 Integer goodId, int needIntegral) {
        // 兑换成功，生成订单信息、生成积分明细(积分明细需要远程调用rouyi-study服务)
        TOrder order = orderInfo(goodExchange, recipient, number, goodId, needIntegral);
        order.setProvince(recipient.getProvince());
        order.setCity(recipient.getCity());
        boolean result = orderService.save(order);
        // 远程调用，生成积分明细
        result = result && studyClient.addIntegralDetail(Constants.BURDEN + needIntegral, Constants.SHOPPING_CONSUME).getData();
@@ -154,58 +323,25 @@
        return result;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R goodExchange1(GoodExchangeDTO goodExchange, Recipient recipient) {
        Integer number = goodExchange.getNumber();
        Integer goodId = goodExchange.getGoodId();
        TGoods good = this.getById(goodId);
        if (null == good) {
            return R.exchangeError("商品不存在，请稍后重试！");
        }
        // 校验用户积分是否足够兑换
        if (tokenService.getLoginUser1() == null) {
            return R.tokenError("登录失效");
        }
        TUser user = studyClient.getUserById(tokenService.getLoginUser1().getUserid()).getData();

        int needIntegral = good.getIntegral() * number;
        if (user.getIntegral() < needIntegral) {
            return R.exchangeError("兑换失败，当前剩余积分不足！");
        }
        // 检查用户兑换数量是否超过单用户最大兑换数量
        List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getUserId, user.getId()).eq(TOrder::getGoodsId, goodId).list();
        // 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
        int totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList()).stream().mapToInt(Integer::intValue).sum();
        boolean canExchange = orderList.isEmpty() || null == good.getUserCount() || (totalNumber + number) <= good.getUserCount();
        if (!canExchange) {
            return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量，剩余兑换数量为: " + (good.getUserCount() - totalNumber) + "！");
        }
        // redisson分布式锁，防止超卖
        String key = String.format(RedisConstants.GOOD_STOCK, good.getId());
        RSemaphore semaphore = redissonClient.getSemaphore(key);
        // 请求超时时间 单位：毫秒
        semaphore.trySetPermits(1000);
        boolean tried = semaphore.tryAcquire(number);
        // 兑换失败，库存不足
        if (!tried) {
            semaphore.release(number);
            return R.exchangeError("当前商品库存不足");
        }
    private Boolean exchangeGoodParent(GoodExchangeDTO goodExchange, Recipient recipient, Integer number,
                                       Integer goodId, int needIntegral) {
        // 兑换成功，生成订单信息、生成积分明细(积分明细需要远程调用rouyi-study服务)
        TOrder order = orderInfo1(goodExchange, recipient, number, goodId, needIntegral);
        TOrder order = orderInfoParent(goodExchange, recipient, number, goodId, needIntegral);
        order.setProvince(recipient.getProvince());
        order.setCity(recipient.getCity());
        boolean result = orderService.save(order);
        // 远程调用，生成积分明细
        result = result && studyClient.addIntegralDetail1(Constants.BURDEN + needIntegral, Constants.SHOPPING_CONSUME).getData();
        result = result && studyClient.addIntegralDetailParent(Constants.BURDEN + needIntegral, Constants.SHOPPING_CONSUME).getData();
        // 扣除用户积分
        result = result && studyClient.exchangeIntegral1(needIntegral, Constants.BURDEN).getData();
        // 扣除库存
        result = result && this.lambdaUpdate().set(TGoods::getSurplus, good.getSurplus() - number).eq(TGoods::getId, good.getId()).update();
        if (!result) {
            semaphore.release(number);
            return R.exchangeError("商品兑换失败！");
        }
        return R.ok();
        result = result && studyClient.exchangeIntegralParent(needIntegral, Constants.BURDEN).getData();
        return result;
    }



    @Override
    public void updateOne(TGoods dto) {
        this.baseMapper.updateOne(dto);
    }

    private TOrder orderInfo(GoodExchangeDTO goodExchange, Recipient recipient, Integer number, Integer goodId, int needIntegral) {
@@ -216,10 +352,28 @@
        order.setGoodsId(goodId);
        order.setCount(number);
        order.setState(1);
        order.setRemark(goodExchange.getRemark());
        order.setIntegral(needIntegral);
        order.setConsigneeName(recipient.getRecipient());
        order.setConsigneePhone(recipient.getRecipientPhone());
        order.setConsigneeAddress(recipient.getAddress());
        order.setConsigneeAddress(recipient.getProvince() + recipient.getCity() + recipient.getAddress());
        order.setDisabled(Boolean.FALSE);
        return order;
    }

    private TOrder orderInfoParent(GoodExchangeDTO goodExchange, Recipient recipient, Integer number, Integer goodId, int needIntegral) {
        TOrder order = new TOrder();
        order.setOrderNumber(goodExchange.getOrderNumber());
        order.setUserId(tokenService.getLoginUser1().getUserid());
        order.setInsertTime(new Date());
        order.setGoodsId(goodId);
        order.setCount(number);
        order.setState(1);
        order.setRemark(goodExchange.getRemark());
        order.setIntegral(needIntegral);
        order.setConsigneeName(recipient.getRecipient());
        order.setConsigneePhone(recipient.getRecipientPhone());
        order.setConsigneeAddress(recipient.getProvince() + recipient.getCity() + recipient.getAddress());
        order.setDisabled(Boolean.FALSE);
        return order;
    }