海豚英语
blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
hjl
2024-05-30 50672a5c91c33f2833f91981b562af3d88b9f1d6 
 ruoyi-service/ruoyi-goods/src/main/java/com/ruoyi/goods/service/impl/TGoodsServiceImpl.java


@@ -3,8 +3,9 @@


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;


import com.ruoyi.common.core.constant.Constants;


import com.ruoyi.common.core.constant.RedisConstants;


import com.ruoyi.common.core.domain.R;


import com.ruoyi.common.core.exception.GlobalException;


import com.ruoyi.common.security.utils.SecurityUtils;


import com.ruoyi.common.security.service.TokenService;


import com.ruoyi.goods.domain.Recipient;


import com.ruoyi.goods.domain.TGoods;


import com.ruoyi.goods.domain.TOrder;


@@ -12,9 +13,11 @@


import com.ruoyi.goods.mapper.TGoodsMapper;


import com.ruoyi.goods.service.ITGoodsService;


import com.ruoyi.goods.service.ITOrderService;


import com.ruoyi.goods.vo.GoodDetailVO;


import com.ruoyi.goods.vo.TGoodsVO;


import com.ruoyi.study.api.domain.TUser;


import com.ruoyi.study.api.feignClient.StudyClient;


import com.ruoyi.system.api.model.LoginUserParent;


import org.redisson.api.RSemaphore;


import org.redisson.api.RedissonClient;


import org.springframework.stereotype.Service;


@@ -22,9 +25,8 @@




import javax.annotation.Resource;


import java.util.Date;


import java.util.HashMap;


import java.util.List;


import java.util.Map;


import java.util.stream.Collectors;




/**


 * <p>


@@ -43,67 +45,152 @@


    private StudyClient studyClient;


    @Resource


    private ITOrderService orderService;


    @Resource


    private TokenService tokenService;




    @Override


    public List<TGoodsVO> goodRecommend(String userId) {


    public List<TGoodsVO> goodRecommend(Integer userId) {


        return baseMapper.goodRecommend(userId);


    }




    @Override


    public Map<String, Object> redeemNow(String goodId, Recipient recipient) {


    public GoodDetailVO redeemNow(String goodId, Recipient recipient) {


        // 商品详情


        TGoods goods = lambdaQuery().eq(TGoods::getId, goodId).one();


        Map<String, Object> result = new HashMap<>(8);


        result.put("goodDetail", goods);


        // 用户收货地址


        result.put("address", recipient);


        // 库存预热，redisson分布式锁


        String key = String.format(RedisConstants.GOOD_STOCK, goods.getId());


        RSemaphore semaphore = redissonClient.getSemaphore(key);


        semaphore.trySetPermits(goods.getSurplus());


        return result;


        return new GoodDetailVO(goods, recipient);


    }




    @Override


    @Transactional(rollbackFor = Exception.class)


    public Object goodExchange(GoodExchangeDTO goodExchange, Recipient recipient) {


    public R goodExchange(GoodExchangeDTO goodExchange, Recipient recipient) {


        Integer number = goodExchange.getNumber();


        Integer goodId = goodExchange.getGoodId();


        TGoods good = this.getById(goodId);


        if (null == good) {


            throw new GlobalException("商品不存在，请稍后重试！");


            return R.exchangeError("商品不存在，请稍后重试！");


        }


        // 校验用户积分是否足够兑换


        TUser user = studyClient.userInfo().getData();


        LoginUserParent loginUser1 = tokenService.getLoginUser1();


        if (user == null){


            user = studyClient.getUserById(loginUser1.getUserid()).getData();


        }


        int needIntegral = good.getIntegral() * number;


        if (user.getIntegral() < needIntegral) {


            throw new GlobalException("兑换失败，当前剩余积分不足！");


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


            throw new GlobalException("当前商品库存不足！");


            semaphore.release(number);


            return R.exchangeError("当前商品库存不足");


        }


        // 兑换成功，生成订单信息、生成积分明细(积分明细需要远程调用rouyi-study服务)


        TOrder order = orderInfo(goodExchange, recipient, number, goodId, needIntegral);


        if (!orderService.save(order)) {


            throw new GlobalException("订单生成失败！");


        }


        boolean result = orderService.save(order);


        // 远程调用，生成积分明细


        Boolean boo = studyClient.addIntegralDetail(Constants.BURDEN + needIntegral, Constants.SHOPPING_CONSUME).getData();


        if (!boo) {


            throw new GlobalException("生成积分明细失败，请稍后重试！");


        result = result && studyClient.addIntegralDetail(Constants.BURDEN + needIntegral, Constants.SHOPPING_CONSUME).getData();


        // 扣除用户积分


        result = result && studyClient.exchangeIntegral(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 true;


        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 = 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("当前商品库存不足");


        }


        // 兑换成功，生成订单信息、生成积分明细(积分明细需要远程调用rouyi-study服务)


        TOrder order = orderInfo1(goodExchange, recipient, number, goodId, needIntegral);


        boolean result = orderService.save(order);


        // 远程调用，生成积分明细


        result = result && studyClient.addIntegralDetail1(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();


    }




    private TOrder orderInfo(GoodExchangeDTO goodExchange, Recipient recipient, Integer number, Integer goodId, int needIntegral) {


        TOrder order = new TOrder();


        order.setOrderNumber(goodExchange.getOrderNumber());


        order.setUserId(SecurityUtils.getUserId().intValue());


        order.setUserId(tokenService.getLoginUserStudy().getUserid());


        order.setInsertTime(new Date());


        order.setGoodsId(goodId);


        order.setCount(number);


        order.setState(1);


        order.setIntegral(needIntegral);


        order.setConsigneeName(recipient.getRecipient());


        order.setConsigneePhone(recipient.getRecipientPhone());


        order.setConsigneeAddress(recipient.getAddress());


        order.setDisabled(Boolean.FALSE);


        return order;


    }


    private TOrder orderInfo1(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);