订单模块

功能介绍：

前台功能：

1.创建订单

controller层实现：

传入userId和收货地址shippingId，由后台自动创建订单。

    @RequestMapping("create.do")
    @ResponseBody
    public ServerResponse create(HttpServletRequest request, Integer shippingId) {
    //    User user = (User)session.getAttribute(Const.CURRENT_USER);

        String loginToken = CookieUtil.readLoginToken(request);
        if(StringUtils.isEmpty(loginToken)) {
            return ServerResponse.createByErrorMessage("用户未登录，无法获取当前用户的信息");
        }
        String userJsonStr = RedisShardedPoolUtil.get(loginToken);
        User user = JsonUtil.string2Obj(userJsonStr, User.class);

        if(user ==null){
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(),ResponseCode.NEED_LOGIN.getDesc());
        }
        //将userId和shippingId传入，创建订单
        return iOrderService.createOrder(user.getId(), shippingId);
    }

service层实现：

1）根据userId从购物车表CART中将已勾选的商品取出来，由cartList保存，然后根据这个cartList，由getCartOrderItem()生成订单详情orderItemList。

2）由订单详情orderItemList可以计算出整个订单的总价，由getOrderTotalPrice()实现。

3）根据以上计算出来的订单总价、收货地址shipingId、userId生成最后的订单order，由assembleOrder()实现，并持久化到数据库中。

4）由assembleOrder()生成的订单，是带有最后的订单号的orderNo，所以将这个订单号更新到之前的订单详情orderItemList中，由mybatis的批量插入实现。

5）根据订单详情orderItemList，去对应的商品表中减库存，由reduceProductStock()实现。

6）清空当前购物车，由cleanCart()实现。

7）将生成的最后的订单order和订单详情orderItemList，组合成vo后返回给前台。

    public ServerResponse createOrder(Integer userId, Integer shippingId) {
        //从购物车中获取数据
        //将购物车中已勾选的物品获取出来，这些物品会用来生成订单
        List<Cart> cartList = cartMapper.selectCheckedCartByUserId(userId);

        //根据这些物品，即cartList，生成订单详情List
        ServerResponse serverResponse = this.getCartOrderItem(userId, cartList);
        if(!serverResponse.isSuccess()) {
            return serverResponse;
        }
        List<OrderItem> orderItemList = (List<OrderItem>)serverResponse.getData();
        //根据订单详情list，计算订单总价
        BigDecimal payment = this.getOrderTotalPrice(orderItemList);

        //生成订单
        Order order = this.assembleOrder(userId, shippingId, payment);
        if(order == null) {
            return ServerResponse.createByErrorMessage("生成订单错误");
        }
        if(CollectionUtils.isEmpty(orderItemList)) {
            return ServerResponse.createByErrorMessage("购物车为空");
        }
        //将订单号逐一的更新到当前订单详情中，也就是一条订单数据可以对应多条订单详情
        for(OrderItem orderItem : orderItemList) {
            orderItem.setOrderNo(order.getOrderNo());
        }
        //mybatis批量插入
        //由于订单详情，一次性可能有多个商品，多个订单详情，也就是多条数据，所以这里就要使用一次性批量插入
        orderItemMapper.batchInsert(orderItemList);
        //生成成功，减少产品的库存
        this.reduceProductStock(orderItemList);

        //清空购物车
        this.cleanCart(cartList);

        //将订单明细返回给前端，返回给前端
        //pojo->vo
        //组装vo，传给前端的数据
        OrderVo orderVo = assembleOrderVo(order, orderItemList);
        return ServerResponse.createBySuccess(orderVo);
    }

getCartOrderItem()由购物车勾选状态生成订单详情实现：

从购物车表中获取productId，然后从product表中获取当前商品的详细信息，校验商品的在售和库存状态，然后组装订单详情，一种商品对应一个订单详情，一个订单详情由orderNo唯一标识，多个订单详情对应一个订单，最后将组装完成的订单详情cartItemList返回。

    private ServerResponse getCartOrderItem(Integer userId,List<Cart> cartList){
        List<OrderItem> orderItemList = Lists.newArrayList();
        if(CollectionUtils.isEmpty(cartList)){
            return ServerResponse.createByErrorMessage("购物车为空");
        }

        //校验购物车的数据,包括产品的状态和数量
        for(Cart cartItem : cartList){
            OrderItem orderItem = new OrderItem();
            //从购物车中获取productId，然后从product表中获取当前产品的详细信息
            Product product = productMapper.selectByPrimaryKey(cartItem.getProductId());
            //查看当前产品是否在售
            if(Const.ProductStatusEnum.ON_SALE.getCode() != product.getStatus()){
                return ServerResponse.createByErrorMessage("产品"+product.getName()+"不是在线售卖状态");
            }

            //校验库存，校验当前产品选购的数量是否超过产品本身库存
            if(cartItem.getQuantity() > product.getStock()){
                return ServerResponse.createByErrorMessage("产品"+product.getName()+"库存不足");
            }

            //组装订单详情，一种商品，一个订单详情，而订单详情又由orderNo唯一标识，所以可能多种商品有同样的orderNo，而orderNo又对应订单order中的一个订单，也由orderNo唯一标识

            orderItem.setUserId(userId);
            orderItem.setProductId(product.getId());
            orderItem.setProductName(product.getName());
            orderItem.setProductImage(product.getMainImage());
            orderItem.setCurrentUnitPrice(product.getPrice());
            orderItem.setQuantity(cartItem.getQuantity());
            // 这里将当前商品的总价：单价*数量，存进数据表
            orderItem.setTotalPrice(BigDecimalUtil.mul(product.getPrice().doubleValue(),cartItem.getQuantity()));
            //将当前订单详情加入订单详情List中
            orderItemList.add(orderItem);
        }
        //将订单详情list返回
        return ServerResponse.createBySuccess(orderItemList);
    }

getOrderTotalPrice()由订单详情计算出整个订单的总价：

由于在生成订单详情的时候，已经对每种商品单独计算过对应的总价，存储在订单详情中了，所以这里只需要将订单中的所有商品价值相加即可。

    private BigDecimal getOrderTotalPrice(List<OrderItem> orderItemList) {
        BigDecimal payment = new BigDecimal("0");
        //计算当前订单总计，逐一相加
        for(OrderItem orderItem : orderItemList) {
            payment = BigDecimalUtil.add(payment.doubleValue(), orderItem.getTotalPrice().doubleValue());
        }
        return payment;
    }

assembleOrder()由userId、订单详情、总价组装最后的订单：

由generateOrderNo()生成订单号，然后添加订单所需要的字段，比如订单号、订单状态、运费、支付类型、订单总价等，然后将订单持久化到数据库中。

    private Order assembleOrder(Integer userId, Integer shippingId, BigDecimal payment) {
        Order order = new Order();
        //生成订单号orderNo，很重要
        long orderNo = this.generateOrderNo();
        //设置订单号
        order.setOrderNo(orderNo);
        //设置订单状态
        order.setStatus(Const.OrderStatusEnum.NO_PAY.getCode());
        //设置运费
        order.setPostage(0);
        //设置支付类型
        order.setPaymentType(Const.PaymentTypeEnum.ONLINE_PAY.getCode());
        //设置订单总价
        order.setPayment(payment);
        order.setUserId(userId);
        order.setShippingId(shippingId);

        //将这个订单持久化到数据库中
        int rowCount = orderMapper.insert(order);
        if(rowCount > 0) {
            return order;
        }
        return null;
    }

reduceProductStock()由订单详情去对应的商品表中减库存：

    private void reduceProductStock(List<OrderItem> orderItemList) {
        //根据订单详情list，逐一针对商品，去product表中减库存
        for(OrderItem orderItem : orderItemList) {
            //根据productId,从product表中拿到当前商品
            Product product = productMapper.selectByPrimaryKey(orderItem.getProductId());
            //减库存
            product.setStock(product.getStock() - orderItem.getQuantity());
            //将库存信息更新到product表中
            productMapper.updateByPrimaryKeySelective(product);
        }
    }

cleanCart()清空购物车：

    private void cleanCart(List<Cart> cartList) {
        for(Cart cart : cartList) {
            //更新cart购物车表
            cartMapper.deleteByPrimaryKey(cart.getId());
        }
    }

2.获取购物车中已经选中的商品信息

service层实现：

根据userId从购物车表中，将当前用户选中的商品拿出来，由cartList记录。根据cartList，由getCartOrderItem()得到订单详情orderItemList，从订单详情orderItemList中计算订单总价。最后将订单详情、订单总价等组装成对应的vo对象返回给前端。

    public ServerResponse getOrderCartProduct(Integer userId) {
        OrderProductVo orderProductVo = new OrderProductVo();
        //从购物车中获取数据
        //根据userId，从购物车表中，将当前用户选中的商品拿出来
        List<Cart> cartList = cartMapper.selectCheckedCartByUserId(userId);
        //根据选中的商品list，得到订单详情
        ServerResponse serverResponse =  this.getCartOrderItem(userId,cartList);
        if(!serverResponse.isSuccess()){
            return serverResponse;
        }
        List<OrderItem> orderItemList =( List<OrderItem> ) serverResponse.getData();

        List<OrderItemVo> orderItemVoList = Lists.newArrayList();
        //从订单详情list中，计算订单总价
        BigDecimal payment = new BigDecimal("0");
        for(OrderItem orderItem : orderItemList){
            //计算订单总价
            payment = BigDecimalUtil.add(payment.doubleValue(),orderItem.getTotalPrice().doubleValue());
            //将订单详情，组装成订单详情vo对象，放在voList中
            orderItemVoList.add(assembleOrderItemVo(orderItem));
        }
        //将订单总价放在orderProductVo中
        orderProductVo.setProductTotalPrice(payment);
        //将订单详情voList放在orderProductVo中
        orderProductVo.setOrderItemVoList(orderItemVoList);
        //将图片服务器地址放在orderProductVo中
        orderProductVo.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix"));
        //将orderProductVo返回
        return ServerResponse.createBySuccess(orderProductVo);
    }

3.订单列表

4.订单详情

5.取消订单

controller层实现：

传入userId,orderNo参数，通过service层实现：

    @RequestMapping("cancel.do")
    @ResponseBody
    public ServerResponse cancel(HttpServletRequest request , Long orderNo) {
    //    User user = (User)session.getAttribute(Const.CURRENT_USER);

        String loginToken = CookieUtil.readLoginToken(request);
        if(StringUtils.isEmpty(loginToken)) {
            return ServerResponse.createByErrorMessage("用户未登录，无法获取当前用户的信息");
        }
        String userJsonStr = RedisShardedPoolUtil.get(loginToken);
        User user = JsonUtil.string2Obj(userJsonStr, User.class);

        if(user ==null){
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(),ResponseCode.NEED_LOGIN.getDesc());
        }
        return iOrderService.cancel(user.getId(), orderNo);
    }

service层实现：

通过userId，orderNo查到对应的订单，如果订单状态是未付款，则置订单状态为CANCELED，更行到数据库即可。

    public ServerResponse<String> cancel(Integer userId, Long orderNo) {
        //根据userId和orderNo拿到订单
        Order order = orderMapper.selectByUserIdAndOrderNo(userId, orderNo);
        if(order == null) {
            return ServerResponse.createByErrorMessage("该用户此订单不存在");
        }
        //判断订单状态
        if(order.getStatus() != Const.OrderStatusEnum.NO_PAY.getCode()) {
            return ServerResponse.createByErrorMessage("已付款，无法取消订单");
        }
        Order updateOrder = new Order();
        updateOrder.setId(order.getId());
        //更新订单状态
        updateOrder.setStatus(Const.OrderStatusEnum.CANCELED.getCode());
        //将更新状态更新到数据库中
        int row = orderMapper.updateByPrimaryKeySelective(updateOrder);
        if(row > 0) {
            return ServerResponse.createBySuccess();
        }
        return ServerResponse.createByError();
    }

后台功能：

1.订单列表

2.订单搜索

3.订单详情

4.订单发货

学习目标：

1.设计实用、安全、扩展性强大的常量、枚举类

2.订单号生成规则、订单严谨性判断

3.POJO和VO之间的实际操练

4.mybatis批量插入