訂單管理模塊前臺用戶包括4個模塊：創(chuàng)建訂單、取消訂單、查詢訂單明細、查詢訂單List。
后臺管理員模塊主要有四個模塊：訂單List、訂單detail、訂單search、訂單發(fā)貨。

1.前臺

1.創(chuàng)建訂單流程：

1.根據(jù)userId獲取購物車當中已經(jīng)勾選的商品
2.根據(jù)userId,cartList，校驗產(chǎn)品狀態(tài)和庫存,并組裝orderItemList
3.從orderItemList計算總價
4.根據(jù)userId,shippingId,payment生成訂單(組裝order)，此時訂單的狀態(tài)要設置稱未支付狀態(tài)，并且訂單號的生成策略是當前時間+當前時間%9來計算的。
5.遍歷orderItem并設置其訂單號OrderNo，并批量插入orderItem
6.由orderItemList，減庫存
7.清空購物車(清空所有選中的)
8.組裝orderVo，返回給前端，orderVo中包括order、orderItem的信息

2.取消訂單流程

1.首先查詢訂單是否已付款，已付款無法取消
2.創(chuàng)建updateOrder，更新訂單的狀態(tài)為已取消

3.查詢訂單明細

1.根據(jù)userId, orderNo查詢訂單order，
2.然后由userId, orderNo查詢orderItemList，
3.使用order、orderItemList組裝orderVo

4.查詢訂單List

1.根據(jù)userID查詢orderList
2.由orderList,userId組裝orderVoList
3.返回

2.后臺

1.訂單List

1.selectAll()查詢orderList
2.由orderList,userId組裝orderVoList，userId=null
3.返回

2.訂單detail

1.由orderNo查Order
2.不為null時，由orderNo查orderItemList
3.使用order,orderItemList組裝orderVo

3.訂單search

在本次當中使用的根據(jù)orderNo搜索

4.訂單發(fā)貨

1.根據(jù)orderNo查詢order
2.根據(jù)order查看訂單的支付狀態(tài)，若已支付，則跟新訂單的狀態(tài)為已發(fā)貨。

3.代碼

***************************Controller 前臺*********************************
package com.mall.controller.portal;

import com.alipay.api.AlipayApiException;
import com.alipay.api.internal.util.AlipaySignature;
import com.alipay.demo.trade.config.Configs;
import com.google.common.collect.Maps;
import com.mall.common.Const;
import com.mall.common.ResponseCode;
import com.mall.common.ServerResponse;
import com.mall.pojo.User;
import com.mall.service.IOrderService;
import com.mall.vo.OrderProductVo;
import com.sun.org.apache.xpath.internal.operations.Bool;
import org.apache.ibatis.annotations.Param;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.Iterator;
import java.util.Map;

@Controller
@RequestMapping("/order/")
public class OrderController {

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

    @Autowired
    private IOrderService iOrderService;

    @ResponseBody
    @RequestMapping("create.do")
    public ServerResponse create(HttpSession session,Integer shippingId){
        User user=(User) session.getAttribute(Const.CURRENT_USER);
        if(user==null){
            return ServerResponse.createByErrorCodeMsg(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getMsg());
        }
        return iOrderService.createOrder(user.getId(),shippingId);
    }

    @ResponseBody
    @RequestMapping("detail.do")
    public ServerResponse detail(HttpSession session,Long orderNo){
        User user=(User) session.getAttribute(Const.CURRENT_USER);
        if(user==null){
            return ServerResponse.createByErrorCodeMsg(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getMsg());
        }
        return iOrderService.detailOrder(user.getId(),orderNo);
    }

    @ResponseBody
    @RequestMapping("list.do")
    public ServerResponse list(HttpSession session, @RequestParam(value = "pageNum",defaultValue = "1") int pageNum,@RequestParam(value = "pageSize",defaultValue = "10") int pageSize){
        User user=(User) session.getAttribute(Const.CURRENT_USER);
        if(user==null){
            return ServerResponse.createByErrorCodeMsg(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getMsg());
        }
        return iOrderService.listOrder(user.getId(),pageNum,pageSize);
    }

    @ResponseBody
    @RequestMapping("cancel.do")
    public ServerResponse cancel(HttpSession session,Long orderNo){
        User user=(User) session.getAttribute(Const.CURRENT_USER);
        if(user==null){
            return ServerResponse.createByErrorCodeMsg(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getMsg());
        }
        return iOrderService.cancelOrder(user.getId(),orderNo);
    }

    //獲取購物車當中已經(jīng)選中的商品
    @ResponseBody
    @RequestMapping("get_order_cart_product.do")
    public ServerResponse<OrderProductVo> getOrderCartProduct(HttpSession session){
        User user=(User) session.getAttribute(Const.CURRENT_USER);
        if(user==null){
            return ServerResponse.createByErrorCodeMsg(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getMsg());
        }
        return iOrderService.getOrderCartProduct(user.getId());
    }
}


***************************Controller 后臺*********************************
package com.mall.controller.backend;

import com.github.pagehelper.PageInfo;
import com.mall.common.Const;
import com.mall.common.ResponseCode;
import com.mall.common.ServerResponse;
import com.mall.pojo.User;
import com.mall.service.IOrderService;
import com.mall.service.IUserService;
import com.mall.vo.OrderVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpSession;

@Controller
@RequestMapping("/manage/order/")
public class OrderManageController {

    @Autowired
    private IUserService iUserService;
    @Autowired
    private IOrderService iOrderService;

    @ResponseBody
    @RequestMapping("list.do")
    public ServerResponse list(HttpSession session, @RequestParam(value = "pageNum",defaultValue = "1") int pageNum, @RequestParam(value = "pageSize",defaultValue = "10") int pageSize){
        User user=(User)session.getAttribute(Const.CURRENT_USER);
        if(user == null){
            return ServerResponse.createByErrorCodeMsg(ResponseCode.NEED_LOGIN.getCode(),ResponseCode.NEED_LOGIN.getMsg());
        }
        ServerResponse response=iUserService.checkUserRole(user);
        if(response.isSuccess()){
            return iOrderService.managerList(pageNum, pageSize);
        }
        return response;
    }

    @ResponseBody
    @RequestMapping("detail.do")
    public ServerResponse<OrderVo> detail(HttpSession session, Long orderNo){
        User user=(User)session.getAttribute(Const.CURRENT_USER);
        if(user == null){
            return ServerResponse.createByErrorCodeMsg(ResponseCode.NEED_LOGIN.getCode(),ResponseCode.NEED_LOGIN.getMsg());
        }
        ServerResponse response=iUserService.checkUserRole(user);
        if(response.isSuccess()){
            return iOrderService.managerDetail(orderNo);
        }
        return response;
    }

    @ResponseBody
    @RequestMapping("search.do")
    public ServerResponse<PageInfo> search(HttpSession session, Long orderNo, @RequestParam(value = "pageNum",defaultValue = "1") int pageNum, @RequestParam(value = "pageSize",defaultValue = "10") int pageSize){
        User user=(User)session.getAttribute(Const.CURRENT_USER);
        if(user == null){
            return ServerResponse.createByErrorCodeMsg(ResponseCode.NEED_LOGIN.getCode(),ResponseCode.NEED_LOGIN.getMsg());
        }
        ServerResponse response=iUserService.checkUserRole(user);
        if(response.isSuccess()){
            return iOrderService.managerSearch(orderNo,pageNum,pageSize);
        }
        return response;
    }


    @ResponseBody
    @RequestMapping("send_goods.do")
    public ServerResponse<String> sendGoods(HttpSession session, Long orderNo){
        User user=(User)session.getAttribute(Const.CURRENT_USER);
        if(user == null){
            return ServerResponse.createByErrorCodeMsg(ResponseCode.NEED_LOGIN.getCode(),ResponseCode.NEED_LOGIN.getMsg());
        }
        ServerResponse response=iUserService.checkUserRole(user);
        if(response.isSuccess()){
            return iOrderService.managerSendGoods(orderNo);
        }
        return response;
    }

}


***************************Service*****************************************
package com.mall.service.impl;

import com.alipay.api.AlipayResponse;
import com.alipay.api.response.AlipayTradePrecreateResponse;
import com.alipay.demo.trade.config.Configs;
import com.alipay.demo.trade.model.ExtendParams;
import com.alipay.demo.trade.model.GoodsDetail;
import com.alipay.demo.trade.model.builder.AlipayTradePrecreateRequestBuilder;
import com.alipay.demo.trade.model.result.AlipayF2FPrecreateResult;
import com.alipay.demo.trade.service.AlipayTradeService;
import com.alipay.demo.trade.service.impl.AlipayTradeServiceImpl;
import com.alipay.demo.trade.utils.ZxingUtils;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.mall.common.Const;
import com.mall.common.ServerResponse;
import com.mall.dao.*;
import com.mall.pojo.*;
import com.mall.service.IOrderService;
import com.mall.util.BigDecimalUtil;
import com.mall.util.DateTimeUtils;
import com.mall.util.FTPUtil;
import com.mall.util.PropertiesUtil;
import com.mall.vo.OrderItemVo;
import com.mall.vo.OrderProductVo;
import com.mall.vo.OrderVo;
import com.mall.vo.ShippingVo;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.aspectj.weaver.ast.Or;
import org.slf4j.ILoggerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.File;
import java.math.BigDecimal;
import java.util.*;

@Service("iOrderService")
public class OrderServiceImpl implements IOrderService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private OrderItemMapper orderItemMapper;
    @Autowired
    private PayInfoMapper payInfoMapper;
    @Autowired
    private CartMapper cartMapper;
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private ShippingMapper shippingMapper;

    private static final Logger log= LoggerFactory.getLogger(OrderServiceImpl.class);

    public ServerResponse createOrder(Integer userId,Integer shippingId){
        //從購物車當中獲取數(shù)據(jù)(已勾選的商品)
        List<Cart> cartList=cartMapper.selectChckedCartByUserId(userId);
        //校驗產(chǎn)品狀態(tài)和庫存
        ServerResponse<List<OrderItem>> response=this.getCartOrderItem(userId,cartList);
        if(!response.isSuccess()){
            return response;
        }

        //從orderItemList計算總價
        List<OrderItem> orderItemList=response.getData();
        BigDecimal payment=this.getOrderTotalPrice(orderItemList);

        //生成訂單
        Order order=this.assembleOrder(userId,shippingId,payment);
        if(order==null){
            return ServerResponse.createByErrorMsg("生成訂單錯誤");
        }
        //遍歷orderItem并設置其訂單號OrderNo
        for (OrderItem orderItem:orderItemList){
            orderItem.setOrderNo(order.getOrderNo());
        }
        //mybatis批量插入orderItem
        orderItemMapper.batchInsert(orderItemList);

        //生成訂單成功，減庫存
        this.reduceProductStock(orderItemList);
        //清空購物車
        this.clearCart(cartList);

        //返回給前端數(shù)據(jù),返回的數(shù)據(jù)當中包括order、orderItem的信息
        OrderVo orderVo=this.assembleOrderVo(order,orderItemList);
        return ServerResponse.createBySuccess(orderVo);
    }

    public ServerResponse<OrderVo> detailOrder(Integer userId,Long orderNo){
        Order order=orderMapper.selectOrderByUserIdOrderNo(userId, orderNo);
        if(order !=null){
            List<OrderItem> orderItemList=orderItemMapper.getOrderItemByOrderNoUserId(orderNo, userId);
            OrderVo orderVo=this.assembleOrderVo(order,orderItemList);
            return ServerResponse.createBySuccess(orderVo);
        }
        return ServerResponse.createByErrorMsg("該用戶不存在該訂單");
    }

    public ServerResponse<PageInfo> listOrder(Integer userId,int pageNum,int pageSize){
        PageHelper.startPage(pageNum, pageSize);
        List<Order> orderList=orderMapper.selectOrderByUserId(userId);
        List<OrderVo> orderVoList=this.assembleOrderVoList(orderList,userId);

        PageInfo pageInfo=new PageInfo(orderList);
        pageInfo.setList(orderVoList);
        return ServerResponse.createBySuccess(pageInfo);
    }
    public ServerResponse cancelOrder(Integer userId,Long orderNo){
        Order order=orderMapper.selectOrderByUserIdOrderNo(userId, orderNo);
        if(order == null){
            return ServerResponse.createByErrorMsg("該用戶此訂單不存在");
        }
        if(order.getStatus() != Const.OrderStatusEnum.NP_PAY.getCode()){
            return ServerResponse.createByErrorMsg("已付款,無法取消訂單");
        }
        Order updateOrder = new Order();
        updateOrder.setId(order.getId());
        updateOrder.setStatus(Const.OrderStatusEnum.CANCELED.getCode());
        int rowCount=orderMapper.updateByPrimaryKey(updateOrder);
        if(rowCount > 0){
            return ServerResponse.createBySuccess();
        }
        return ServerResponse.createByError();
    }

    public ServerResponse<OrderProductVo> getOrderCartProduct(Integer userId){
        OrderProductVo orderProductVo=new OrderProductVo();
        //從購物車當中獲取數(shù)據(jù)
        List<Cart> cartList=cartMapper.selectChckedCartByUserId(userId);
        //校驗庫存
        ServerResponse response=this.getCartOrderItem(userId,cartList);
        if(!response.isSuccess()){
            return response;
        }
        List<OrderItem> orderItemList=(List<OrderItem>) response.getData();
        List<OrderProductVo> orderProductVoList=Lists.newArrayList();
        //計算總價
        /*BigDecimal payment=new BigDecimal("0");
        for (OrderItem orderItem:orderItemList){
            payment=BigDecimalUtil.add(payment.doubleValue(),orderItem.getTotalPrice().doubleValue());
        }*/
        BigDecimal payment=this.getOrderTotalPrice(orderItemList);
        orderProductVo.setProductTotalPrice(payment);
        orderProductVo.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix"));
        return ServerResponse.createBySuccess(orderProductVo);
    }




    private ServerResponse<List<OrderItem>> getCartOrderItem(Integer userId,List<Cart> cartList){
        List<OrderItem> orderItemList=Lists.newArrayList();
        if(CollectionUtils.isEmpty(cartList)){
            return ServerResponse.createByErrorMsg("購物車為空");
        }
        //校驗購物車當中的數(shù)據(jù)，包括產(chǎn)品的狀態(tài)和數(shù)量(庫存)
        for (Cart cartItem:cartList){
            OrderItem orderItem=new OrderItem();

            Product product=productMapper.selectByPrimaryKey(cartItem.getProductId());
            if(product != null){
                //校驗產(chǎn)品的狀態(tài)
                if(Const.ProductStatusEnum.ON_SALE.getCode() != product.getStatus()){
                    return ServerResponse.createByErrorMsg("產(chǎn)品:"+product.getName()+"產(chǎn)品不是在線售賣狀態(tài)");
                }
                //校驗商品的數(shù)量
                if(cartItem.getQuantity() > product.getStock()){
                    return ServerResponse.createByErrorMsg("產(chǎn)品:"+product.getName()+"庫存不足");
                }
                //組裝OrderItem
                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(orderItem.getCurrentUnitPrice().doubleValue(),orderItem.getQuantity()));

                orderItemList.add(orderItem);
            }
        }
        return ServerResponse.createBySuccess(orderItemList);
    }
    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;
    }
    private Order assembleOrder(Integer userId,Integer shippingId,BigDecimal payment){
        Order order=new Order();
        long orderNo=this.generatorOrderNo();
        order.setOrderNo(orderNo);
        order.setStatus(Const.OrderStatusEnum.NP_PAY.getCode());
        order.setPostage(0);
        order.setUserId(userId);
        order.setPaymentType(Const.PaymentTypeEnum.ONLINE_PAY.getCode());
        order.setPayment(payment);
        order.setShippingId(shippingId);

        int rowCount=orderMapper.insert(order);
        if(rowCount>0){
            return order;
        }
        return null;
    }
    private Long generatorOrderNo(){
        long currentTime=System.currentTimeMillis();
        return currentTime+new Random().nextInt(1000);
    }
    private void reduceProductStock(List<OrderItem> orderItemList){
        for(OrderItem orderItem:orderItemList){
            Product product=productMapper.selectByPrimaryKey(orderItem.getProductId());
            product.setStock(product.getStock()-orderItem.getQuantity());
            int rowCount=productMapper.updateByPrimaryKey(product);
        }
    }
    private void clearCart(List<Cart> cartList){
        for (Cart cartItem:cartList){
            cartMapper.deleteByPrimaryKey(cartItem.getId());
        }
    }
    private OrderVo assembleOrderVo(Order order, List<OrderItem> orderItemList){
        OrderVo orderVo=new OrderVo();
        orderVo.setOrderNo(order.getOrderNo());
        orderVo.setPayment(order.getPayment());
        orderVo.setPaymentType(order.getPaymentType());
        orderVo.setPaymentTypeDesc(Const.PaymentTypeEnum.codeOf(order.getPaymentType()).getDesc());

        Shipping shipping=shippingMapper.selectByPrimaryKey(order.getShippingId());
        if(shipping !=null){
            orderVo.setReceiverName(shipping.getReceiverName());
            orderVo.setShippingVo(this.assembleShippingVo(shipping));
        }

        orderVo.setPaymentTime(DateTimeUtils.dateToStr(order.getPaymentTime()));
        orderVo.setCreateTime(DateTimeUtils.dateToStr(order.getCreateTime()));
        orderVo.setCloseTime(DateTimeUtils.dateToStr(order.getCloseTime()));
        orderVo.setSendTime(DateTimeUtils.dateToStr(order.getSendTime()));
        orderVo.setEndTime(DateTimeUtils.dateToStr(order.getEndTime()));
        orderVo.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix"));

        List<OrderItemVo> orderItemVoList=Lists.newArrayList();
        for (OrderItem orderItem:orderItemList){
            OrderItemVo orderItemVo=this.assembleOrderItemVo(orderItem);
            orderItemVoList.add(orderItemVo);
        }
        orderVo.setOrderItemVoList(orderItemVoList);

        return orderVo;
    }
    private ShippingVo assembleShippingVo(Shipping shipping){
        ShippingVo shippingVo=new ShippingVo();
        shippingVo.setReceiverName(shipping.getReceiverName());
        shippingVo.setReceiverAddress(shipping.getReceiverAddress());
        shippingVo.setReceiverCity(shipping.getReceiverCity());
        shippingVo.setReceiverDistrict(shipping.getReceiverDistrict());
        shippingVo.setReceiverMobile(shipping.getReceiverMobile());
        shippingVo.setReceiverProvince(shipping.getReceiverProvince());
        shippingVo.setReceiverPhone(shipping.getReceiverPhone());
        shippingVo.setReceiverZip(shipping.getReceiverZip());
        return shippingVo;
    }
    private OrderItemVo assembleOrderItemVo(OrderItem orderItem){
        OrderItemVo orderItemVo=new OrderItemVo();
        orderItemVo.setOrderNo(orderItem.getOrderNo());
        orderItemVo.setProductId(orderItem.getProductId());
        orderItemVo.setProductName(orderItem.getProductName());
        orderItemVo.setProductImage(orderItem.getProductImage());
        orderItemVo.setCurrentUnitPrice(orderItem.getCurrentUnitPrice());
        orderItemVo.setQuantity(orderItem.getQuantity());
        orderItemVo.setTotalPrice(orderItem.getTotalPrice());
        orderItemVo.setCreateTime(DateTimeUtils.dateToStr(orderItem.getCreateTime()));
        return orderItemVo;
    }
    private List<OrderVo> assembleOrderVoList(List<Order> orderList,Integer userId){
        List<OrderVo> orderVoList=Lists.newArrayList();
        for(Order order:orderList){
            List<OrderItem> orderItemList=Lists.newArrayList();
            if(userId==null ){
                //todo 管理員查詢，無需傳userId
                orderItemList=orderItemMapper.getOrderItemByOrderNo(order.getOrderNo());
            }else {
                orderItemList=orderItemMapper.getOrderItemByOrderNoUserId(order.getOrderNo(),order.getUserId());
            }
            OrderVo orderVo=this.assembleOrderVo(order,orderItemList);
            orderVoList.add(orderVo);
        }
        return orderVoList;
    }







    //backend
    public ServerResponse<PageInfo> managerList(int pageNum,int pageSize){
        PageHelper.startPage(pageNum, pageSize);
        List<Order> orderList=orderMapper.selectAll();
        List<OrderVo> orderVoList=this.assembleOrderVoList(orderList,null);
        PageInfo pageInfo=new PageInfo(orderList);
        pageInfo.setList(orderVoList);
        return ServerResponse.createBySuccess(pageInfo);
    }

    public ServerResponse<OrderVo> managerDetail(Long orderNo){
        Order order=orderMapper.selectOrderByOrderNo(orderNo);
        if(order != null){
            List<OrderItem> orderItemList=orderItemMapper.getOrderItemByOrderNo(orderNo);
            OrderVo orderVo=this.assembleOrderVo(order,orderItemList);
            return ServerResponse.createBySuccess(orderVo);
        }
        return ServerResponse.createByErrorMsg("訂單不存在");
    }

    public ServerResponse<PageInfo> managerSearch(Long orderNo,int pageNum,int pageSize){
        PageHelper.startPage(pageNum, pageSize);
        Order order=orderMapper.selectOrderByOrderNo(orderNo);
        if(order != null){
            List<OrderItem> orderItemList=orderItemMapper.getOrderItemByOrderNo(orderNo);
            OrderVo orderVo=this.assembleOrderVo(order,orderItemList);
            PageInfo pageInfo=new PageInfo(Lists.newArrayList(order));
            pageInfo.setList(Lists.newArrayList(orderVo));
            return ServerResponse.createBySuccess(pageInfo);
        }
        return ServerResponse.createByErrorMsg("訂單不存在");
    }

    public ServerResponse<String> managerSendGoods(Long orderNo){
        Order order=orderMapper.selectOrderByOrderNo(orderNo);
        if(order != null){
            if(order.getStatus() == Const.OrderStatusEnum.PAID.getCode()){
                order.setStatus(Const.OrderStatusEnum.SHIPPING.getCode());
                order.setSendTime(new Date());
                orderMapper.updateByPrimaryKey(order);
                return ServerResponse.createBySuccessMsg("發(fā)貨成功");
            }
        }
        return ServerResponse.createByErrorMsg("訂單不存在");
    }
}
*******************mybatis批量插入，id是自增的***********************

<insert id="batchInsert" parameterType="list" >
    insert into mmall_order_item (id,order_no,user_id, product_id,
    product_name, product_image, current_unit_price,
    quantity, total_price, create_time,
    update_time)
    values
    <foreach collection="orderItemList" index="index" item="item" separator="," >
      (
      #{item.id},#{item.orderNo},#{item.userId},#{item.productId},
      #{item.productName},#{item.productImage},#{item.currentUnitPrice},
      #{item.quantity},#{item.totalPrice},now(),
      now()
      )
    </foreach>