fix: Service replace Mapper

src/main/java/cn/seecoder/courselearning/service/coupon/CouponService.java

@@ -2,6 +2,8 @@ package cn.seecoder.courselearning.service.coupon;
 
 import cn.seecoder.courselearning.dto.CouponDTO;
 import cn.seecoder.courselearning.dto.DeliverCouponDTO;
+import cn.seecoder.courselearning.po.Coupon;
+import cn.seecoder.courselearning.po.UserCoupon;
 import cn.seecoder.courselearning.vo.CouponVO;
 import cn.seecoder.courselearning.vo.ResultVO;
 
@@ -17,4 +19,16 @@ public interface CouponService {
     // 查看某用户购买此课程可用的所有优惠
     ResultVO<List<CouponVO>> getAllAvailableCouponsForOrder(Integer orderId);
 
+    List<Coupon> getByOrderId(Integer orderId);
+
+    Coupon getByPrimaryKey(Integer couponId);
+
+    List<UserCoupon> getUserCouponsByUserId(Integer userId);
+
+    void deleteUserCoupon(Integer userId, Integer couponId);
+
+    void updateUserCoupon(UserCoupon userCoupon);
+
+    UserCoupon getUserCouponByCouponIdAndUserId(Integer couponId, Integer userId);
+
 }

src/main/java/cn/seecoder/courselearning/service/course/CourseService.java

@@ -1,5 +1,6 @@
 package cn.seecoder.courselearning.service.course;
 
+import cn.seecoder.courselearning.po.Course;
 import cn.seecoder.courselearning.vo.CourseVO;
 import cn.seecoder.courselearning.vo.ResultVO;
 import com.github.pagehelper.PageInfo;
@@ -26,4 +27,6 @@ public interface CourseService {
     ResultVO<CourseVO> setCourseLike(Integer courseId, Integer userId);
     // 用户取消课程点赞
     ResultVO<CourseVO> cancelCourseLike(Integer courseId, Integer userId);
+
+    Course getByPrimaryKey(Integer courseId);
 }

src/main/java/cn/seecoder/courselearning/service/order/CourseOrderService.java

@@ -1,5 +1,6 @@
 package cn.seecoder.courselearning.service.order;
 
+import cn.seecoder.courselearning.po.CourseOrder;
 import cn.seecoder.courselearning.vo.CourseOrderVO;
 import cn.seecoder.courselearning.vo.ResultVO;
 
@@ -7,8 +8,6 @@ import java.util.List;
 
 
 public interface CourseOrderService {
-    // 创建订单
-    ResultVO<CourseOrderVO> insertCourseOrder(CourseOrderVO orderVO);
     // 更新订单
     ResultVO<CourseOrderVO> updateCourseOrder(Integer orderId, Integer orderStatus);
     // 根据用户id获取该用户的所有订单
@@ -18,9 +17,13 @@ public interface CourseOrderService {
     // 取消使用优惠券/活动
     ResultVO<Boolean> cancelCoupon(CourseOrderVO orderVO, Integer couponId);
 
+    CourseOrder queryMostRecentOrder(Integer uid, Integer courseId);
+
+    CourseOrder getByPrimaryKey(Integer orderId);
+
     ResultVO<CourseOrderVO> getCourseOrderById(Integer orderId);
     // 完成付款
     ResultVO<Boolean> payOrder(Integer orderId);
-    // 创建订单 NEW
+    // 创建订单
     ResultVO<CourseOrderVO> createCourseOrder(Integer courseId, Integer userId);
 }

src/main/java/cn/seecoder/courselearning/service/user/UserService.java

@@ -1,9 +1,10 @@
 package cn.seecoder.courselearning.service.user;
 
-import cn.seecoder.courselearning.vo.RechargeOrderVO;
+import cn.seecoder.courselearning.po.User;
 import cn.seecoder.courselearning.vo.ResultVO;
 import cn.seecoder.courselearning.vo.UserVO;
-import org.springframework.stereotype.Service;
+
+import java.util.List;
 
 
 public interface UserService {
@@ -14,5 +15,9 @@ public interface UserService {
     // 根据id查找用户
     UserVO getUser(Integer uid);
 
-    ResultVO<UserVO> decreaseBalance(Integer uid, Integer num);
+    void increaseBalance(Integer id, Integer delta);
+
+    void decreaseBalance(Integer id, Integer delta);
+
+    List<User> getAll();
 }

src/main/java/cn/seecoder/courselearning/serviceimpl/coupon/CouponServiceImpl.java

@@ -6,6 +6,9 @@ import cn.seecoder.courselearning.mapperservice.*;
 import cn.seecoder.courselearning.po.*;
 import cn.seecoder.courselearning.service.coupon.coupondeliverstrategy.CouponDeliverStrategy;
 import cn.seecoder.courselearning.service.coupon.CouponService;
+import cn.seecoder.courselearning.service.course.CourseService;
+import cn.seecoder.courselearning.service.order.CourseOrderService;
+import cn.seecoder.courselearning.service.user.UserService;
 import cn.seecoder.courselearning.util.Constant;
 import cn.seecoder.courselearning.util.CouponValidator;
 import cn.seecoder.courselearning.vo.CouponVO;
@@ -28,16 +31,16 @@ public class CouponServiceImpl implements CouponService {
     private CouponMapper couponMapper;
 
     @Resource
-    private UserMapper userMapper;
+    private UserCouponMapper userCouponMapper;
 
     @Resource
-    private UserCouponMapper userCouponMapper;
+    private UserService userService;
 
     @Resource
-    private CourseMapper courseMapper;
+    private CourseService courseService;
 
     @Resource
-    private CourseOrderMapper orderMapper;
+    private CourseOrderService orderService;
     /**
      * 直接创建优惠券并发放
      * @param couponDTO
@@ -81,7 +84,7 @@ public class CouponServiceImpl implements CouponService {
 
     @Override
     public ResultVO<List<CouponVO>> getAllAvailableCouponsForOrder(Integer orderId) {
-        CourseOrder courseOrder = orderMapper.selectByPrimaryKey(orderId);
+        CourseOrder courseOrder = orderService.getByPrimaryKey(orderId);
         if (orderId == null) {
             return new ResultVO<>(Constant.REQUEST_FAIL, "查询失败，订单不存在！", Collections.EMPTY_LIST);
         }
@@ -100,7 +103,7 @@ public class CouponServiceImpl implements CouponService {
             // 查询可用优惠券
             List<Coupon> userCoupons = couponMapper.selectByUserId(orderVO.getUserId());
             List<Coupon> availableCoupons = new ArrayList<>();
-            Course course = courseMapper.selectByPrimaryKey(orderVO.getCourseId());
+            Course course = courseService.getByPrimaryKey(orderVO.getCourseId());
             for (Coupon coupon : userCoupons) {
                 if (coupon.getType().getCouponStrategy().canUse(orderVO, coupon) && coupon.getScope().canUse(course, coupon)) {
                     // 再去除当前订单使用的
@@ -115,9 +118,39 @@ public class CouponServiceImpl implements CouponService {
         return new ResultVO<>(Constant.REQUEST_SUCCESS, "查询成功", Collections.EMPTY_LIST);
     }
 
+    @Override
+    public List<Coupon> getByOrderId(Integer orderId) {
+        return couponMapper.selectByOrderId(orderId);
+    }
+
+    @Override
+    public Coupon getByPrimaryKey(Integer couponId) {
+        return couponMapper.selectByPrimaryKey(couponId);
+    }
+
+    @Override
+    public List<UserCoupon> getUserCouponsByUserId(Integer userId) {
+        return userCouponMapper.selectByUserId(userId);
+    }
+
+    @Override
+    public void deleteUserCoupon(Integer userId, Integer couponId) {
+        userCouponMapper.deleteByUserIdAndCouponId(userId, couponId);
+    }
+
+    @Override
+    public void updateUserCoupon(UserCoupon userCoupon) {
+        userCouponMapper.update(userCoupon);
+    }
+
+    @Override
+    public UserCoupon getUserCouponByCouponIdAndUserId(Integer couponId, Integer userId) {
+        return userCouponMapper.selectByCouponIdAndUserId(couponId, userId);
+    }
+
     @Async("taskExecutor")
     protected void deliverCouponToUsers(DeliverCouponDTO deliverCouponDTO) {
-        List<User> users = userMapper.selectAll();
+        List<User> users = userService.getAll();
         Coupon coupon = couponMapper.selectByPrimaryKey(deliverCouponDTO.getCouponId());
         if (coupon == null || users.isEmpty()) return;
         List<User> targetUsers = new ArrayList<>();

src/main/java/cn/seecoder/courselearning/serviceimpl/coupon/couponstrategy/AbstractCouponStrategy.java

@@ -1,11 +1,11 @@
 package cn.seecoder.courselearning.serviceimpl.coupon.couponstrategy;
 
-import cn.seecoder.courselearning.mapperservice.CourseMapper;
 import cn.seecoder.courselearning.mapperservice.UserCouponMapper;
 import cn.seecoder.courselearning.po.Coupon;
 import cn.seecoder.courselearning.po.Course;
 import cn.seecoder.courselearning.po.UserCoupon;
 import cn.seecoder.courselearning.service.coupon.couponstrategy.CouponStrategy;
+import cn.seecoder.courselearning.service.course.CourseService;
 import cn.seecoder.courselearning.vo.CourseOrderVO;
 import org.springframework.beans.factory.annotation.Autowired;
 
@@ -20,7 +20,7 @@ public abstract class AbstractCouponStrategy implements CouponStrategy {
     protected UserCouponMapper userCouponMapper;
 
     @Autowired
-    protected CourseMapper courseMapper;
+    protected CourseService courseService;
 
     @Override
     public boolean canUse(CourseOrderVO orderVO, Coupon coupon) {
@@ -37,7 +37,7 @@ public abstract class AbstractCouponStrategy implements CouponStrategy {
             return false;
         }
         // 根据类型判断是否能使用在课程上
-        Course course = courseMapper.selectByPrimaryKey(orderVO.getCourseId());
+        Course course = courseService.getByPrimaryKey(orderVO.getCourseId());
         if (course == null) {
             // 无效订单
             return false;

src/main/java/cn/seecoder/courselearning/serviceimpl/course/CourseServiceImpl.java

@@ -2,10 +2,10 @@ package cn.seecoder.courselearning.serviceimpl.course;
 
 import cn.seecoder.courselearning.mapperservice.CourseLikesMapper;
 import cn.seecoder.courselearning.mapperservice.CourseMapper;
-import cn.seecoder.courselearning.mapperservice.CourseOrderMapper;
 import cn.seecoder.courselearning.po.Course;
 import cn.seecoder.courselearning.po.CourseOrder;
 import cn.seecoder.courselearning.service.course.CourseService;
+import cn.seecoder.courselearning.service.order.CourseOrderService;
 import cn.seecoder.courselearning.util.Constant;
 import cn.seecoder.courselearning.util.PageInfoUtil;
 import cn.seecoder.courselearning.vo.CourseVO;
@@ -26,7 +26,7 @@ public class CourseServiceImpl implements CourseService {
     @Resource
     private CourseLikesMapper courseLikesMapper;
     @Resource
-    private CourseOrderMapper orderMapper;
+    private CourseOrderService orderService;
 
     @Override
     public PageInfo<CourseVO> getCourses(Integer currPage, Integer pageSize, Integer uid, String key) {
@@ -78,7 +78,7 @@ public class CourseServiceImpl implements CourseService {
         boolean bought = false;
         boolean manageable = false;
         if(uid != null && uid > 0) {
-            CourseOrder order = orderMapper.queryMostRecentOrder(uid, courseId);
+            CourseOrder order = orderService.queryMostRecentOrder(uid, courseId);
             if(order != null)
                 bought = order.getStatus().equals(Constant.ORDER_STATUS_SUCCESS);
             manageable = uid.equals(course.getTeacherId());
@@ -118,12 +118,17 @@ public class CourseServiceImpl implements CourseService {
         return new ResultVO<>(Constant.REQUEST_SUCCESS, "操作成功", getCourse(courseId, userId));
     }
 
+    @Override
+    public Course getByPrimaryKey(Integer courseId) {
+        return courseMapper.selectByPrimaryKey(courseId);
+    }
+
     private PageInfo<CourseVO> getCourseVOPageInfo(Integer uid, PageInfo<Course> po) {
         PageInfo<CourseVO> result = PageInfoUtil.convert(po, CourseVO.class);
         if(uid != null && uid > 0){
             List<CourseVO> voList = result.getList();
             for(CourseVO vo: voList){
-                CourseOrder order = orderMapper.queryMostRecentOrder(uid, vo.getId());
+                CourseOrder order = orderService.queryMostRecentOrder(uid, vo.getId());
                 if(order != null)
                     vo.setBought(order.getStatus().equals(Constant.ORDER_STATUS_SUCCESS));
                 vo.setManageable(uid.equals(vo.getTeacherId()));

src/main/java/cn/seecoder/courselearning/serviceimpl/course/CourseWareServiceImpl.java

@@ -1,10 +1,10 @@
 package cn.seecoder.courselearning.serviceimpl.course;
 
-import cn.seecoder.courselearning.mapperservice.CourseOrderMapper;
 import cn.seecoder.courselearning.mapperservice.CourseWareMapper;
 import cn.seecoder.courselearning.po.CourseOrder;
 import cn.seecoder.courselearning.po.CourseWare;
 import cn.seecoder.courselearning.service.course.CourseWareService;
+import cn.seecoder.courselearning.service.order.CourseOrderService;
 import cn.seecoder.courselearning.util.Constant;
 import cn.seecoder.courselearning.vo.CourseWareVO;
 import cn.seecoder.courselearning.vo.ResultVO;
@@ -20,7 +20,7 @@ public class CourseWareServiceImpl implements CourseWareService {
     @Resource
     private CourseWareMapper courseWareMapper;
     @Resource
-    private CourseOrderMapper courseOrderMapper;
+    private CourseOrderService orderService;
 
     @Override
     public CourseWareVO getCourseWare(Integer uid, Integer courseWareId) {
@@ -28,7 +28,7 @@ public class CourseWareServiceImpl implements CourseWareService {
         Integer courseId = courseWare.getCourseId();
         boolean bought = false;
         if (uid != null && uid > 0){
-            CourseOrder order = courseOrderMapper.queryMostRecentOrder(uid, courseId);
+            CourseOrder order = orderService.queryMostRecentOrder(uid, courseId);
             if(order != null)
                 bought = order.getStatus().equals(Constant.ORDER_STATUS_SUCCESS);
         }
@@ -39,7 +39,7 @@ public class CourseWareServiceImpl implements CourseWareService {
     public List<CourseWareVO> getAllCourseWare(Integer uid, Integer courseId) {
         boolean bought = false;
         if (uid != null && uid > 0){
-            CourseOrder order = courseOrderMapper.queryMostRecentOrder(uid, courseId);
+            CourseOrder order = orderService.queryMostRecentOrder(uid, courseId);
             if(order != null)
                 bought = order.getStatus().equals(Constant.ORDER_STATUS_SUCCESS);
         }

src/main/java/cn/seecoder/courselearning/serviceimpl/order/CourseOrderServiceImpl.java

@@ -2,6 +2,7 @@ package cn.seecoder.courselearning.serviceimpl.order;
 
 import cn.seecoder.courselearning.mapperservice.*;
 import cn.seecoder.courselearning.po.*;
+import cn.seecoder.courselearning.service.coupon.CouponService;
 import cn.seecoder.courselearning.service.course.CourseService;
 import cn.seecoder.courselearning.service.order.CourseOrderService;
 import cn.seecoder.courselearning.service.user.UserService;
@@ -24,57 +25,13 @@ public class CourseOrderServiceImpl implements CourseOrderService {
     @Resource
     CourseOrderMapper orderMapper;
     @Resource
-    UserMapper userMapper;
-    @Resource
     CourseOrderCouponMapper courseOrderCouponMapper;
     @Resource
-    CouponMapper couponMapper;
+    UserService userService;
     @Resource
-    UserCouponMapper userCouponMapper;
-    @Resource
-    CourseMapper courseMapper;
-
+    CouponService couponService;
     @Resource
     CourseService courseService;
-    @Resource
-    UserService userService;
-
-    @Override
-    public ResultVO<CourseOrderVO> insertCourseOrder(CourseOrderVO orderVO) {
-        CourseOrder order;
-        try{
-            if((order = orderMapper.queryMostRecentOrder(orderVO.getUserId(), orderVO.getCourseId())) != null
-                && !order.getStatus().equals(Constant.ORDER_STATUS_CANCEL)){
-                return new ResultVO<>(Constant.REQUEST_FAIL, "当前用户已经购买过此课程，或者有上一笔未支付的订单", new CourseOrderVO(order));
-            }
-            order = new CourseOrder(orderVO);
-            Integer status = order.getStatus();
-            if(status.equals(Constant.ORDER_STATUS_UNPAID)){
-                // 当订单状态为未支付时，检查用户余额是否足够
-                User user = userMapper.selectByPrimaryKey(order.getUserId());
-                if(user.getBalance()>=orderVO.getCost()){
-                    userMapper.decreaseBalance(user.getId(), order.getCost());
-                    // 支付成功，将订单存入数据库
-                    order.setStatus(Constant.ORDER_STATUS_SUCCESS);
-                    orderMapper.insert(order);
-                    updateUserCoupon(order.getId(), user.getId());
-                }else {
-                    // 将订单存入数据库
-                    orderMapper.insert(order);
-                    // 若用户余额不足，则不保存订单，返回失败信息
-                    return new ResultVO<>(Constant.REQUEST_FAIL, "用户余额不足，未支付订单已保存", new CourseOrderVO(order));
-                }
-            }else if(status.equals(Constant.ORDER_STATUS_SUCCESS) || status.equals(Constant.ORDER_STATUS_WAIT)) {
-                // 若订单状态为已支付或等待发货，则直接存入数据库
-                orderMapper.insert(order);
-                updateUserCoupon(order.getId(), order.getUserId());
-                return new ResultVO<>(Constant.REQUEST_SUCCESS, "订单保存成功", new CourseOrderVO(order));
-            }
-        }catch (Exception e){
-            return new ResultVO<>(Constant.REQUEST_FAIL, e.toString());
-        }
-        return new ResultVO<>(Constant.REQUEST_SUCCESS, "课程购买成功", new CourseOrderVO(order));
-    }
 
     @Override
     public ResultVO<CourseOrderVO> updateCourseOrder(Integer orderId, Integer orderStatus) {
@@ -85,9 +42,9 @@ public class CourseOrderServiceImpl implements CourseOrderService {
         if((orderStatus.equals(Constant.ORDER_STATUS_SUCCESS)||orderStatus.equals(Constant.ORDER_STATUS_WAIT)) &&
                 order.getStatus().equals(Constant.ORDER_STATUS_UNPAID)){
             // 当订单原始状态为待支付 并且此时为支付成功时，需扣除用户余额
-            User user = userMapper.selectByPrimaryKey(order.getUserId());
+            UserVO user = userService.getUser(order.getUserId());
             if(user.getBalance()>=order.getCost()){
-                userMapper.decreaseBalance(user.getId(), order.getCost());
+                userService.decreaseBalance(user.getId(), order.getCost());
                 updateUserCoupon(orderId, user.getId());
             }else
                 return new ResultVO<>(Constant.REQUEST_FAIL, "用户余额不足");
@@ -104,15 +61,15 @@ public class CourseOrderServiceImpl implements CourseOrderService {
      */
     public void updateUserCoupon(Integer orderId, Integer userId) {
         // 更新用户优惠券状态
-        List<Coupon> orderCoupons = couponMapper.selectByOrderId(orderId);
-        List<UserCoupon> userCouponList = userCouponMapper.selectByUserId(userId);
+        List<Coupon> orderCoupons = couponService.getByOrderId(orderId);
+        List<UserCoupon> userCouponList = couponService.getUserCouponsByUserId(userId);
         for (UserCoupon userCoupon : userCouponList) {
             if (orderCoupons.stream().anyMatch(coupon -> coupon.getId().equals(userCoupon.getCouponId()))) {
                 if (userCoupon.getNums() == 1) {
-                    userCouponMapper.deleteByUserIdAndCouponId(userId, userCoupon.getCouponId());
+                    couponService.deleteUserCoupon(userId, userCoupon.getCouponId());
                 } else if (userCoupon.getNums() > 1) {
                     userCoupon.setNums(userCoupon.getNums() - 1);
-                    userCouponMapper.update(userCoupon);
+                    couponService.updateUserCoupon(userCoupon);
                 }
             }
         }
@@ -125,7 +82,7 @@ public class CourseOrderServiceImpl implements CourseOrderService {
         LocalDateTime now = LocalDateTime.now();
         for(CourseOrder order: orderList){
             // 获取订单对应的优惠券
-            List<Coupon> courseOrderCoupons = couponMapper.selectByOrderId(order.getId());
+            List<Coupon> courseOrderCoupons = couponService.getByOrderId(order.getId());
             List<Coupon> coupons = new ArrayList<>();
             boolean updated = false;
             // 查询的时候更新一下，以防优惠券在这个时候过期了
@@ -156,7 +113,7 @@ public class CourseOrderServiceImpl implements CourseOrderService {
      */
     @Override
     public ResultVO<Boolean> useCoupon(CourseOrderVO orderVO, Integer couponId) {
-        Coupon coupon = couponMapper.selectByPrimaryKey(couponId);
+        Coupon coupon = couponService.getByPrimaryKey(couponId);
         if (coupon == null) {
             return new ResultVO<>(Constant.REQUEST_FAIL, "错误的优惠券");
         }
@@ -165,12 +122,12 @@ public class CourseOrderServiceImpl implements CourseOrderService {
             return new ResultVO<>(Constant.REQUEST_FAIL, "优惠券过期或还未能使用");
         }
         // 判断用户有没有该优惠券
-        UserCoupon userCoupon = userCouponMapper.selectByCouponIdAndUserId(couponId, orderVO.getUserId());
+        UserCoupon userCoupon = couponService.getUserCouponByCouponIdAndUserId(couponId, orderVO.getUserId());
         if (userCoupon == null) {
             return new ResultVO<>(Constant.REQUEST_FAIL, "尚未拥有该优惠券");
         }
         // 判断能否使用
-        Course course = courseMapper.selectByPrimaryKey(orderVO.getCourseId());
+        Course course = courseService.getByPrimaryKey(orderVO.getCourseId());
         if (!coupon.getScope().canUse(course, coupon)) {
             return new ResultVO<>(Constant.REQUEST_FAIL, "该课程无法使用该优惠券");
         }
@@ -252,8 +209,18 @@ public class CourseOrderServiceImpl implements CourseOrderService {
         return new ResultVO<>(Constant.REQUEST_SUCCESS,"创建成功",courseOrderVO);
     }
 
+    @Override
+    public CourseOrder queryMostRecentOrder(Integer uid, Integer courseId) {
+        return orderMapper.queryMostRecentOrder(uid, courseId);
+    }
+
+    @Override
+    public CourseOrder getByPrimaryKey(Integer orderId) {
+        return orderMapper.selectByPrimaryKey(orderId);
+    }
+
     public void updateBestCost(CourseOrderVO orderVO) {
-        List<Coupon> usedCoupons = couponMapper.selectByOrderId(orderVO.getId());
+        List<Coupon> usedCoupons = couponService.getByOrderId(orderVO.getId());
         boolean[] used = new boolean[usedCoupons.size()];
         Arrays.fill(used, false);
         // 这里通过dfs算法计算最优价格，而IntHolder为可变的int，用于记录最小值

src/main/java/cn/seecoder/courselearning/serviceimpl/order/RechargeServiceImpl.java

@@ -5,9 +5,11 @@ import cn.seecoder.courselearning.mapperservice.UserMapper;
 import cn.seecoder.courselearning.po.RechargeOrder;
 import cn.seecoder.courselearning.po.User;
 import cn.seecoder.courselearning.service.order.RechargeService;
+import cn.seecoder.courselearning.service.user.UserService;
 import cn.seecoder.courselearning.util.Constant;
 import cn.seecoder.courselearning.vo.RechargeOrderVO;
 import cn.seecoder.courselearning.vo.ResultVO;
+import cn.seecoder.courselearning.vo.UserVO;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
@@ -20,7 +22,7 @@ public class RechargeServiceImpl implements RechargeService {
     private static final Logger logger = LoggerFactory.getLogger(RechargeService.class);
 
     @Resource
-    UserMapper userMapper;
+    UserService userService;
 
     @Resource
     RechargeOrderMapper rechargeOrderMapper;
@@ -33,13 +35,13 @@ public class RechargeServiceImpl implements RechargeService {
             ret.setCode(Constant.REQUEST_FAIL);
             ret.setMsg("userId 参数无效");
         }else{
-            User user = userMapper.selectByPrimaryKey(userId);
+            UserVO user = userService.getUser(userId);
             if(user != null){
                 try{
                     rechargeOrderVO.setCreateTime(new Date());
                     Integer value = rechargeOrderVO.getValue();
                     // 更新用户余额
-                    userMapper.increaseBalance(userId, value);
+                    userService.increaseBalance(userId, value);
                     RechargeOrder rechargeOrder = new RechargeOrder(rechargeOrderVO);
                     if(rechargeOrderMapper.insert(rechargeOrder) > 0){
                         ret.setCode(Constant.REQUEST_SUCCESS);

src/main/java/cn/seecoder/courselearning/serviceimpl/user/UserServiceImpl.java

@@ -11,6 +11,7 @@ import org.springframework.util.StringUtils;
 
 import javax.annotation.Resource;
 import java.util.Date;
+import java.util.List;
 
 
 @Service
@@ -61,8 +62,17 @@ public class UserServiceImpl implements UserService {
     }
 
     @Override
-    public ResultVO<UserVO> decreaseBalance(Integer uid, Integer num) {
-        userMapper.decreaseBalance(uid,num);
-        return new ResultVO<>(Constant.REQUEST_SUCCESS,"成功");
+    public void increaseBalance(Integer id, Integer delta) {
+        userMapper.increaseBalance(id, delta);
+    }
+
+    @Override
+    public void decreaseBalance(Integer id, Integer delta) {
+        userMapper.decreaseBalance(id, delta);
+    }
+
+    @Override
+    public List<User> getAll() {
+        return userMapper.selectAll();
     }
 }