基于javaweb和mysql的ssm+maven网上图书商城系统(java+ssm+jsp+mysql+redis+easyui)

私信源码获取及调试交流

私信源码获取及调试交流

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8

开发工具

eclipse/idea/myeclipse/sts等均可配置运行

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb的SSM+Maven网上图书商城系统(java+ssm+jsp+mysql+redis+easyui)

这个项目涉及到Shiro整合JWT、秒杀功能所具备的基本要求(限流、乐观锁、接口隐藏、JMeter高并发测试等等)、消息中间件RabbitMQ的异步邮件通知和死信队列、沙箱支付宝模拟支付等等技术亮点。

项目功能：该项目分为买家、卖家、管理员三个角色。买家角色的功能：登录、注册、浏览图书、管理购物车、结算订单、支付订单、查看订单、修改个人信息等等功能。

卖家角色的功能：登录、注册、浏览商品、管理自己发布的图书、管理收到的订单、查看自己的收益详情等等。管理员角色的功能：登录、管理所有用户信息、管理权限信息、管理所有卖家发布的图书、管理所有订单信息、管理所有支付信息、查看总共收益详情等等。

应用技术：SSM + Jsp + MySQL + Redis + JWT + Shiro + EasyUI等

运行环境：Eclipse/IntelliJ IDEA + MySQL5.7 + Maven3.6.3+ JDK1.8 + Redis5.0.5+ Tomcat8.5 +

/**
 */
/**
 * 订单Order业务实现类
 */
@Service
@Transactional
public class OrderServiceImpl implements IOrderService {

    @Autowired
    private OrderDao orderDao;

    @Autowired
    private OrderItemDao orderItemDao;

    @Autowired
    private CartDao cartDao;

    @Autowired
    private IBookService bookService;

    @Autowired
    private StockDao stockDao;

    @Autowired
    private IStockService stockService;

    @Autowired
    private IPayService payService;

        //将生成的验证码放入session，以供放后面程序的验证使用
        request.getSession().setAttribute(method, generatorVCode);
        log.info("验证码成功生成，method=" + method + ",value=" + generatorVCode);
        try {
            ImageIO.write(captchaUtil.generatorRotateVCodeImage(generatorVCode, true), "gif", response.getOutputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

/**
 */

/**
 * 权限Authority控制类
 */
@Controller
public class AuthorityController {

    @Autowired
    private IAuthorityService authorityService;

    /**
     * 后台权限列表页面
     * @return
     */
    @GetMapping("/admin/authority/list")
    public String list(){
        return "admin/authority/list";
    }

    /**
     * 获取权限列表信息
     * @param page
     * @param rows

    @PostMapping("/home/cart/add")
    @ResponseBody
    public ResponseVo<Boolean> add(@RequestBody Cart cart, HttpServletRequest request){
        return cartService.addCart(cart, request);
    }

    /**
     * 删除购物车操作处理
     * @param cart
     * @return
     */
    @PostMapping("/home/cart/delete")
    @ResponseBody
    public ResponseVo<Boolean> delete(@RequestBody Cart cart){
        return cartService.deleteCart(cart);
    }

    /**
     * 更新购物车选择购买的数量
     * @param cart
     * @param type
     * @return
     */
    @PostMapping("/home/cart/update_quantity")
    @ResponseBody
    public ResponseVo<Boolean> updateQuantity(@RequestBody Cart cart, @RequestParam("type") String type){
        return cartService.updateQuantity(cart, type);
    }
}

/**
 */

/**
 * 前台订单Order控制类
 */
@Controller
public class HomeOrderController {

                throw new RuntimeException("图书《"+cart.getBook().getName()+"》已售罄，不允许购买了哦！");
            }
            // 5.更新库存 使用乐观锁版本号控制 避免超卖现象出现
            if(stockDao.updateStock(cart.getQuantity(), stock) <= 0){
                throw new RuntimeException("提交订单失败，请稍后重试！");
            }
        }
        // 6.创建订单  6.1同一个卖家的商品归并到一个订单中  Map<> 键key：卖家id 值value：购物车列表
        Map<String, List<Cart>> orderItemMap = new HashMap<>();
        cartList.forEach(e->{
            if(orderItemMap.containsKey(String.valueOf(e.getBook().getSellerId()))){
                //如果key中存在某卖家id
                List<Cart> selectedCartList = orderItemMap.get(String.valueOf(e.getBook().getSellerId()));
                selectedCartList.add(e);
                orderItemMap.put(String.valueOf(e.getBook().getSellerId()), selectedCartList);
            }else{
                //如果key中不存在某卖家id
                List<Cart> selectedCartList = new ArrayList<>();
                selectedCartList.add(e);
                orderItemMap.put(String.valueOf(e.getBook().getSellerId()), selectedCartList);
            }
        });
        Set<Long> orderIdSet = new HashSet<>();  //储存订单id的Set集合
        BigDecimal payTotalAmount = new BigDecimal("0.00"); //计算一个用户本次购买的总金额
        // 6.创建订单  6.2给每个订单赋值，准备存入数据库
        for(Map.Entry<String, List<Cart>> entry : orderItemMap.entrySet()){
            BigDecimal totalPrice = new BigDecimal("0.00");
            List<OrderItem> orderItemList = new ArrayList<>();
            List<Cart> selectedCartList = entry.getValue(); //值
            //计算总价，并封装订单详情数据
            for(Cart cart : selectedCartList){
                OrderItem orderItem = new OrderItem();
                if(BookIsKillEnum.YES.getCode().equals(cart.getBook().getIsKill())){
                    BigDecimal subtotal = new BigDecimal(cart.getQuantity()).multiply(cart.getBook().getNewPrice());
                    orderItem.setSubtotal(subtotal);
                    orderItem.setBookPrice(cart.getBook().getNewPrice());
                    totalPrice = totalPrice.add(subtotal);
                } else if(BookIsKillEnum.NO.getCode().equals(cart.getBook().getIsKill())){
                    BigDecimal subtotal = new BigDecimal(cart.getQuantity()).multiply(cart.getBook().getOldPrice());
                    orderItem.setSubtotal(subtotal);
                    orderItem.setBookPrice(cart.getBook().getOldPrice());
                    totalPrice = totalPrice.add(subtotal);
                }
                orderItem.setQuantity(cart.getQuantity());
                orderItem.setBookId(cart.getBook().getId());
                orderItem.setBookName(cart.getBook().getName());
                orderItem.setBookPic(cart.getBook().getPhoto());

            } catch (IOException e3) {
                e3.printStackTrace();
            }
            return false;
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

}

/**
 */

/**
 * 后台图书Book控制类
 */
@Controller
public class BookController {

    @Autowired
    private IBookService bookService;

    /**
     * 图书列表页面
     * @param model
     * @return
     */
    @GetMapping("/admin/book/list")
    public String list(Model model){
       return bookService.toBookList(model);
    }

    /**
     * 获取图书列表信息
     * @param page
     * @param name
     * @param state
     * @return
     */
    @PostMapping("/admin/book/list")
    @ResponseBody
    public Map<String, Object> list(Page page, String name, Integer state){
        return bookService.getBookList(page, name, state);

                if(BookIsKillEnum.YES.getCode().equals(cart.getBook().getIsKill())){
                    BigDecimal subtotal = new BigDecimal(cart.getQuantity()).multiply(cart.getBook().getNewPrice());
                    orderItem.setSubtotal(subtotal);
                    orderItem.setBookPrice(cart.getBook().getNewPrice());
                    totalPrice = totalPrice.add(subtotal);
                } else if(BookIsKillEnum.NO.getCode().equals(cart.getBook().getIsKill())){
                    BigDecimal subtotal = new BigDecimal(cart.getQuantity()).multiply(cart.getBook().getOldPrice());
                    orderItem.setSubtotal(subtotal);
                    orderItem.setBookPrice(cart.getBook().getOldPrice());
                    totalPrice = totalPrice.add(subtotal);
                }
                orderItem.setQuantity(cart.getQuantity());
                orderItem.setBookId(cart.getBook().getId());
                orderItem.setBookName(cart.getBook().getName());
                orderItem.setBookPic(cart.getBook().getPhoto());
                orderItemList.add(orderItem);
            }
            order.setOrderNo(String.valueOf(new SnowFlake(2,3).nextId()));
            order.setTotalPrice(totalPrice);
            payTotalAmount = payTotalAmount.add(totalPrice);
            order.setCustomerId(user.getId());
            order.setSellerId(Long.valueOf(entry.getKey()));
            order.setCreateTime(new Date());
            order.setCustomerDelete(OrderDeleteEnum.NO.getCode());
            order.setState(OrderStateEnum.NO_PAY.getCode());
            // 6.创建订单  6.3订单数据存入数据库，取出插入后返回的订单id
            if(orderDao.createOrder(order) <= 0){
                throw new RuntimeException("创建订单失败，请联系管理员");
            }
            // 6.创建订单  6.4订单详情数据存入数据库
            orderItemList.forEach(e->e.setOrderId(order.getId()));
            if(orderItemDao.batchInsert(orderItemList) <= 0){
                throw new RuntimeException("创建订单详情失败，请联系管理员");
            }
            orderIdSet.add(order.getId());
        }
        // 7.创建支付数据 7.1支付数据存入数据库
        long payId = payService.addPay(new Pay(
                null,
                String.valueOf(new SnowFlake(2,3).nextId()),
                payTotalAmount,
                new Date(),
                user.getId(),
                PayStateEnum.NO_PAY.getCode()
                ));
        if(payId == 0L){
            throw new RuntimeException("创建支付数据失败，请联系管理员！");
        }
        // 7.创建支付数据 7.2支付详情数据存入数据库
        int row = payItemService.addPayItem(payId, orderIdSet);

    /**
     * 前往搜索查询结果页面
     * @return
     */
    @GetMapping("/home/book/search")
    public String search(){
        return "home/book/search";
    }

    /**
     * 前台搜索图书操作处理
     * @param searchContent
     * @return
     */
    @PostMapping("/home/book/search")
    @ResponseBody
    public ResponseVo<List<Book>> getSearchBook(String searchContent){
        return bookService.getSearchBook(searchContent);
    }

    /**
     * 前台前往更多图书页面前数据加载
     * @return
     */
    @PostMapping("/home/book/more")
    @ResponseBody
    public ResponseVo<List<Book>> getMoreBook(){
        return bookService.getMoreBook();
    }

    /**
     * 前台首页图书展示
     * @return
     */
    @PostMapping("/home/book/index")
    @ResponseBody
    public ResponseVo<List<Book>> index(){
        return bookService.getBookByType();
    }

//    @Autowired
//    private IPayService payService;
//
//    @Autowired
//    private IPayItemService payItemService;
//
//    @Autowired
//    private IBookService bookService;
//
////     @Autowired
////    private AmqpTemplate amqpTemplate;
//
//    /**
//     * 支付页面
//     * @param req
//     * @param httpResponse
//     * @throws IOException
//     */
//    @GetMapping("/common/alipay/pay")
//    public void alipay(HttpServletRequest req, HttpServletResponse httpResponse) throws IOException {
//        User user = (User) SecurityUtils.getSubject().getPrincipal();
//        if(user == null){
//            throw new RuntimeException("还未登录或会话失效，请重新登录！");
//        }
//        String payId = (String) req.getSession().getAttribute(RuntimeConstant.payIdSession);
//        if(CommonUtil.isEmpty(payId)){
//            throw new RuntimeException("支付会话失效，请重新操作！");
//        }
//        QueryWrapper<Pay> queryWrapper = new QueryWrapper<>();
//        queryWrapper.eq("user_id", user.getId());
//        queryWrapper.eq("id", payId);
//        Pay selectedPay = payDao.selectOne(queryWrapper);
//        if(selectedPay == null){
//            throw new RuntimeException("数据非法，支付失败，请重新操作！");
//        }
//        Random r = new Random();
//        //实例化客户端,填入所需参数
//        AlipayClient alipayClient = new DefaultAlipayClient(GATEWAY_URL, APP_ID, APP_PRIVATE_KEY, FORMAT, CHARSET, ALIPAY_PUBLIC_KEY, SIGN_TYPE);
//        AlipayTradePagePayRequest request = new AlipayTradePagePayRequest();
//        //在公共参数中设置回跳和通知地址
//        request.setReturnUrl(RETURN_URL);
//        //request.setNotifyUrl(NOTIFY_URL);
//
//        //发送RabbitMQ异步消息 5分钟后检查是否已支付成功，如果没有，则取消订单
////        try{
////            //将Java对象匹配JSON结构

                orderItem.setBookPic(cart.getBook().getPhoto());
                orderItemList.add(orderItem);
            }
            order.setOrderNo(String.valueOf(new SnowFlake(2,3).nextId()));
            order.setTotalPrice(totalPrice);
            payTotalAmount = payTotalAmount.add(totalPrice);
            order.setCustomerId(user.getId());
            order.setSellerId(Long.valueOf(entry.getKey()));
            order.setCreateTime(new Date());
            order.setCustomerDelete(OrderDeleteEnum.NO.getCode());
            order.setState(OrderStateEnum.NO_PAY.getCode());
            // 6.创建订单  6.3订单数据存入数据库，取出插入后返回的订单id
            if(orderDao.createOrder(order) <= 0){
                throw new RuntimeException("创建订单失败，请联系管理员");
            }
            // 6.创建订单  6.4订单详情数据存入数据库
            orderItemList.forEach(e->e.setOrderId(order.getId()));
            if(orderItemDao.batchInsert(orderItemList) <= 0){
                throw new RuntimeException("创建订单详情失败，请联系管理员");
            }
            orderIdSet.add(order.getId());
        }
        // 7.创建支付数据 7.1支付数据存入数据库
        long payId = payService.addPay(new Pay(
                null,
                String.valueOf(new SnowFlake(2,3).nextId()),
                payTotalAmount,
                new Date(),
                user.getId(),
                PayStateEnum.NO_PAY.getCode()
                ));
        if(payId == 0L){
            throw new RuntimeException("创建支付数据失败，请联系管理员！");
        }
        // 7.创建支付数据 7.2支付详情数据存入数据库
        int row = payItemService.addPayItem(payId, orderIdSet);
        if(row <= 0){
            throw new RuntimeException("创建支付详情数据失败，请联系管理员！");
        }
        // 8.把支付id存入session中

        // 6.创建订单  6.1同一个卖家的商品归并到一个订单中  Map<> 键key：卖家id 值value：购物车列表
        Map<String, List<Cart>> orderItemMap = new HashMap<>();
        cartList.forEach(e->{
            if(orderItemMap.containsKey(String.valueOf(e.getBook().getSellerId()))){
                //如果key中存在某卖家id
                List<Cart> selectedCartList = orderItemMap.get(String.valueOf(e.getBook().getSellerId()));
                selectedCartList.add(e);
                orderItemMap.put(String.valueOf(e.getBook().getSellerId()), selectedCartList);
            }else{
                //如果key中不存在某卖家id
                List<Cart> selectedCartList = new ArrayList<>();
                selectedCartList.add(e);
                orderItemMap.put(String.valueOf(e.getBook().getSellerId()), selectedCartList);
            }
        });
        Set<Long> orderIdSet = new HashSet<>();  //储存订单id的Set集合
        BigDecimal payTotalAmount = new BigDecimal("0.00"); //计算一个用户本次购买的总金额
        // 6.创建订单  6.2给每个订单赋值，准备存入数据库
        for(Map.Entry<String, List<Cart>> entry : orderItemMap.entrySet()){
            BigDecimal totalPrice = new BigDecimal("0.00");
            List<OrderItem> orderItemList = new ArrayList<>();
            List<Cart> selectedCartList = entry.getValue(); //值
            //计算总价，并封装订单详情数据
            for(Cart cart : selectedCartList){
                OrderItem orderItem = new OrderItem();
                if(BookIsKillEnum.YES.getCode().equals(cart.getBook().getIsKill())){
                    BigDecimal subtotal = new BigDecimal(cart.getQuantity()).multiply(cart.getBook().getNewPrice());
                    orderItem.setSubtotal(subtotal);
                    orderItem.setBookPrice(cart.getBook().getNewPrice());
                    totalPrice = totalPrice.add(subtotal);
                } else if(BookIsKillEnum.NO.getCode().equals(cart.getBook().getIsKill())){
                    BigDecimal subtotal = new BigDecimal(cart.getQuantity()).multiply(cart.getBook().getOldPrice());
                    orderItem.setSubtotal(subtotal);
                    orderItem.setBookPrice(cart.getBook().getOldPrice());
                    totalPrice = totalPrice.add(subtotal);
                }
                orderItem.setQuantity(cart.getQuantity());
                orderItem.setBookId(cart.getBook().getId());
                orderItem.setBookName(cart.getBook().getName());
                orderItem.setBookPic(cart.getBook().getPhoto());
                orderItemList.add(orderItem);
            }
            order.setOrderNo(String.valueOf(new SnowFlake(2,3).nextId()));
            order.setTotalPrice(totalPrice);
            payTotalAmount = payTotalAmount.add(totalPrice);
            order.setCustomerId(user.getId());
            order.setSellerId(Long.valueOf(entry.getKey()));
            order.setCreateTime(new Date());

    public ResponseVo<Boolean> editState(String id, Integer state){
        return bookService.editState(id, state);
    }
}

/**
 */

/**
 * 后台用户User控制类
 */
@Controller
public class UserController {

    @Autowired
    private IUserService userService;

    /**
     * 后台用户登录页面
     * @return
     */
    @GetMapping("/admin/user/login")
    public String login(){
        return "admin/user/login";
    }

    /**
     * 后台用户登录操作处理
     * @param user
     * @param request
     * @param captcha
     * @return

//        //商户订单号，商户网站订单系统中唯一订单号，必填
//        //生成随机Id
//        String out_trade_no = selectedPay.getPayNo();
//        //付款金额，必填
//        String total_amount = String.valueOf(selectedPay.getTotalAmount());
//        //订单名称，必填
//        String subject ="网上图书商城订单支付";
//        //商品描述，可空
//        String body = "尊敬的用户："+user.getUsername()+"，欢迎您在网上图书商城下单！";
//        request.setBizContent("{\"out_trade_no\":\""+ out_trade_no +"\","
//                + "\"total_amount\":\""+ total_amount +"\","
//                + "\"subject\":\""+ subject +"\","
//                + "\"body\":\""+ body +"\","
//                + "\"timeout_express\":\""+"5m"+"\","
//                + "\"product_code\":\"FAST_INSTANT_TRADE_PAY\"}");
//        String form = "";
//        try {
//            form = alipayClient.pageExecute(request).getBody(); // 调用SDK生成表单
//        } catch (AlipayApiException e) {
//            e.printStackTrace();
//        }
//        httpResponse.setContentType("text/html;charset=" + CHARSET);
//        httpResponse.getWriter().write(form);// 直接将完整的表单html输出到页面
//        httpResponse.getWriter().flush();
//        httpResponse.getWriter().close();
//    }
//
//
//
//    /**
//     * 回调页面
//     * @param request
//     * @param response
//     * @return
//     * @throws IOException
//     * @throws AlipayApiException
//     */
//    @GetMapping(value = "/common/alipay/returnUrl")
//    public void returnUrl(HttpServletRequest request, HttpServletResponse response)
//            throws IOException, AlipayApiException {
//        logger.info("=================================同步回调=====================================");
//
//        // 获取支付宝GET过来反馈信息
//        Map<String, String> params = new HashMap<String, String>();
//        Map<String, String[]> requestParams = request.getParameterMap();
//        for (Iterator<String> iter = requestParams.keySet().iterator(); iter.hasNext(); ) {
//            String name = (String) iter.next();

        }catch(Exception e){
            //e.printStackTrace();
            //token失效或非法
            //判断该路径是否需要验证
            for(String str : RuntimeConstant.userNotNeedConfirmUrl){
                if(requestURI.equals(str)){
                    return true; //该路径不需要验证，直接通行
                }
            }
            //判断是否是ajax请求或者是axios请求
            if (CommonUtil.isAjax(request) || CommonUtil.isAxios(request)) {
                //表示是ajax请求或者是axios请求
                try {
                    response.setCharacterEncoding("UTF-8");
                    //JSON.parseObject，是将Json字符串转化为相应的对象；JSON.toJSONString则是将对象转化为Json字符串。
                    response.getWriter().write(JSON.toJSONString(CodeMsg.USER_SESSION_EXPIRED));
                } catch (IOException e2) {
                    e2.printStackTrace();
                }
                return false;
            }
            //不是ajax请求，直接跳转页面
            try {
                log.info("没有登录或token非法，跳转登录界面！当前URL={}",requestURI);
                //根据路径分别跳转不同的登录页面
                if(requestURI.contains("/home/")){
                    response.sendRedirect("../system/index");
                }else if(requestURI.contains("/admin/")){
                    response.sendRedirect("../user/login");
                }else{
                    response.sendRedirect("../../common/system/not_permit");
                }
            } catch (IOException e3) {
                e3.printStackTrace();
            }
            return false;
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

        if(count == 0){
            return ResponseVo.errorByMsg(CodeMsg.USER_SESSION_EXPIRED);
        }
        //大于10次则拒绝访问
        if(count > 10){
            return ResponseVo.errorByMsg(CodeMsg.REQUEST_COUNT_MANY);
        }
        cart.setUserId(user.getId());
        //进行统一表单验证
        CodeMsg validate = ValidateEntityUtil.validate(cart);
        if(!validate.getCode().equals(CodeMsg.SUCCESS.getCode())){
            return ResponseVo.errorByMsg(validate);
        }
        //判断MD5加密信息是否合法，不合法，则是用脚本访问接口，直接拒绝
        String redisKey = String.format(USER_BOOK_KEY_TEMPLATE, user.getId(), cart.getBookId().longValue());
        String md5 = stringRedisTemplate.opsForValue().get(redisKey);
        //判断MD5加密信息是否为空
        if(CommonUtil.isEmpty(md5)){
            return ResponseVo.errorByMsg(CodeMsg.ADD_CART_BUST);
        }
        String md5Token = "";
        Cookie[] cookies = request.getCookies();
        if(cookies != null && cookies.length > 0){
            for (Cookie cookie : cookies) {
                if ("md5_token".equals(cookie.getName())) {
                    md5Token = cookie.getValue();
                }
            }
        }
        //判断MD5加密信息是否合法
        if(!md5.equals(md5Token)){
            return ResponseVo.errorByMsg(CodeMsg.ADD_CART_ILLEGAL);
        }
        //根据id获取图书信息
        Map<String, Object> queryMap = new HashMap<>();
        queryMap.put("id", cart.getBookId());
        List<Book> selectedBook =  bookDao.getBookList(queryMap);
        if(selectedBook == null || selectedBook.size() != 1){
            return ResponseVo.errorByMsg(CodeMsg.BOOK_NOT_EXIST);
        }

            //2s内没获取到令牌桶中的令牌，选择抛弃
            logger.info("请求被限流，直接抛弃......");
            return ResponseVo.errorByMsg(CodeMsg.REQUEST_LIMIT);
        }
        logger.info("接收请求，执行后续业务......");
        User user = (User) SecurityUtils.getSubject().getPrincipal();
        if(user == null){
            return ResponseVo.errorByMsg(CodeMsg.USER_SESSION_EXPIRED);
        }
        //验证用户输入信息是否合法
        if(CommonUtil.isEmpty(order.getRemark())){
            order.setRemark("");
        }
        //进行统一表单验证
        CodeMsg validate = ValidateEntityUtil.validate(order);
        if(!validate.getCode().equals(CodeMsg.SUCCESS.getCode())){
            return ResponseVo.errorByMsg(validate);
        }
        //判断输入的手机号是否符合规范
        CodeMsg validatePhone = CommonUtil.validatePhone(order.getReceiverPhone());
        if(!validatePhone.getCode().equals(CodeMsg.SUCCESS.getCode())){
            return ResponseVo.errorByMsg(validatePhone);
        }
        //执行后面业务逻辑
        String cartIds = (String) request.getSession().getAttribute(RuntimeConstant.cartIdSession);
        if(CommonUtil.isEmpty(cartIds)){
            return ResponseVo.errorByMsg(CodeMsg.NO_SELECT_OR_PAY_EXPIRED);
        }
        //把ids根据','拆分，然后转换成List类型
        String[] split = cartIds.split(",");
        List<String> idsList = Arrays.asList(split);
        //取出该用户购物车中选择的信息
        Map<String, Object> queryMap = new HashMap<>();
        queryMap.put("idsList", idsList);
        //查询出购物车数据()
        List<Cart> cartList = cartDao.getCartList(queryMap);
        for(Cart cart : cartList){
            // 1.判断图书是否还存在
            if(cart.getBookId() == null || cart.getBook() == null){
                //图书已经不存在 自定义错误消息返回
                throw new RuntimeException("订单中有图书已经不存在了哦，请检查下订单！");
            }
            // 2.判断图书的状态是否是审核通过
            if(!BookStateEnum.AUDIT_SUCCESS.getCode().equals(cart.getBook().getState())){
                //图书状态不是审核通过，自定义错误消息返回

/**
 */

/**
 * 运行时触发异常捕获
 */
@ControllerAdvice
public class RuntimeExceptionHandler {

    private  final Logger logger = LoggerFactory.getLogger(RuntimeExceptionHandler.class);

    @ExceptionHandler(RuntimeException.class)
    @ResponseBody
    public ResponseVo<Boolean> handle(RuntimeException e) {
        e.printStackTrace();
        if(!CommonUtil.isEmpty(e.getMessage())){
            logger.info("异常信息={}", e.getMessage());
            if("提交订单失败，请稍后重试！".equals(e.getMessage())){
                return ResponseVo.errorByMsg(CodeMsg.SUBMIT_ORDER_ERROR);
            }else if(e.getMessage().contains("售罄")){
                CodeMsg codeMsg = CodeMsg.STOCK_SOLD_OUT;
                codeMsg.setMsg(e.getMessage());
                return ResponseVo.errorByMsg(codeMsg);
            }else if(e.getMessage().contains("秒杀时间已过")){
                CodeMsg codeMsg = CodeMsg.KILL_END_EXPIRED;
                codeMsg.setMsg(e.getMessage());
                return ResponseVo.errorByMsg(codeMsg);
            }else if(e.getMessage().contains("状态异常")){
                CodeMsg codeMsg = CodeMsg.BOOK_STATE_EXCEPTION;
                codeMsg.setMsg(e.getMessage());
                return ResponseVo.errorByMsg(codeMsg);
            }else if(e.getMessage().equals("订单中有图书已经不存在了哦，请检查下订单！")){
                return ResponseVo.errorByMsg(CodeMsg.ORDER_BOOK_NOT_EXIST);
            }else if(e.getMessage().equals("创建支付数据失败，请联系管理员！")){
                return ResponseVo.errorByMsg(CodeMsg.CREATE_PAY_ERROR);
            }else if(e.getMessage().equals("创建支付详情数据失败，请联系管理员！")){
                return ResponseVo.errorByMsg(CodeMsg.CREATE_PAY_ITEM_ERROR);
            }else if(e.getMessage().equals("还未登录或会话失效，请重新登录！")){
                return ResponseVo.errorByMsg(CodeMsg.USER_SESSION_EXPIRED);
            }else if(e.getMessage().equals("支付会话失效，请重新操作！")){
                return ResponseVo.errorByMsg(CodeMsg.PAY_SESSION_EXPIRED);
            }else if(e.getMessage().equals("数据非法，支付失败，请重新操作！")){
                return ResponseVo.errorByMsg(CodeMsg.PAY_DATA_ERROR);