Spring Boot点餐系统实战(8)–买家订单service层(下)

avatar 2017年11月16日13:27:15 11 6470 views
博主分享免费Java教学视频，B站账号：Java刘哥 ，长期提供技术问题解决、项目定制：本站商品点此
上一节介绍了买家订单 service 层的创建订单的实现，本文将介绍剩余的其他部分（查询一个订单，查询订单列表，取消订单，完结订单和支付订单）。

本文关键词


抽出常用方法

lambad 表达式

其他的继承上一节...


一、开发准备


1、修改的文件



其他的继承上一节


二、convert 创建


OrderMaster2OrderDTOConverter.java
  1. package com.liuyanzhao.sell.converter;
  3. import com.liuyanzhao.sell.dto.OrderDTO;
  4. import com.liuyanzhao.sell.entity.OrderMaster;
  5. import org.springframework.beans.BeanUtils;
  7. import java.util.List;
  8. import java.util.stream.Collectors;
  10. /**
  11.  * @Author: 言曌
  12.  * @Date: 2017/11/14
  13.  * @Time: 下午10:02
  14.  */
  16. public class OrderMaster2OrderDTOConverter {
  18.     public static OrderDTO convert(OrderMaster orderMaster) {
  19.         OrderDTO orderDTO = new OrderDTO();
  20.         BeanUtils.copyProperties(orderMaster,orderDTO);
  21.         return orderDTO;
  22.     }
  24.     public static List<OrderDTO> convert(List<OrderMaster> orderMasterList) {
  25.         return orderMasterList.stream().map(e ->
  26.             convert(e)
  27.         ).collect(Collectors.toList());
  28.     }
  29. }

这个类的目的就是将 orderMaster 对象转成 orderDTO 对象，将 List<OrderMaster>  转成 List<OrderDTO> ，我们之前的做法都是直接在 Service 里写，这样代码冗余度较高。通过这个类，我们实现转换会更加方便。


三、ProductServiceImpl.java 的补充


我们之前在第三章里的商品信息Service层开发和测试中的增加库存和减少库存的方法还没有实现

现在补上。
  1. package com.liuyanzhao.sell.service.impl;
  3. import com.liuyanzhao.sell.dao.ProductInfoDao;
  4. import com.liuyanzhao.sell.dto.CartDTO;
  5. import com.liuyanzhao.sell.entity.ProductInfo;
  6. import com.liuyanzhao.sell.enums.ProductStatusEnum;
  7. import com.liuyanzhao.sell.enums.ResultEnum;
  8. import com.liuyanzhao.sell.exception.SellException;
  9. import com.liuyanzhao.sell.service.ProductService;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.data.domain.Page;
  12. import org.springframework.data.domain.Pageable;
  13. import org.springframework.stereotype.Service;
  14. import org.springframework.transaction.annotation.Transactional;
  16. import java.util.List;
  18. /**
  19.  * @Author: 言曌
  20.  * @Date: 2017/11/12
  21.  * @Time: 上午11:39
  22.  */
  24. @Service
  25. public class ProductServiceImpl implements ProductService {
  27.     @Autowired
  28.     private ProductInfoDao dao;
  30.     @Override
  31.     public ProductInfo findOne(String productId) {
  32.         return dao.findOne(productId);
  33.     }
  35.     @Override
  36.     public List<ProductInfo> findUpAll() {
  37.         //return dao.findByProductStatus(0);
  38.         return dao.findByProductStatus(ProductStatusEnum.UP.getCode());
  39.     }
  41.     @Override
  42.     public Page<ProductInfo> findAll(Pageable pageable) {
  43.         return dao.findAll(pageable);
  44.     }
  46.     @Override
  47.     public ProductInfo save(ProductInfo productInfo) {
  48.         return dao.save(productInfo);
  49.     }
  51.     @Override  
  52.     @Transactional  
  53.     public void increaseStock(List<CartDTO> cartDTOList) {  
  54.         for(CartDTO cartDTO : cartDTOList) {  
  55.             ProductInfo productInfo = dao.findOne(cartDTO.getProductId());  
  56.             if(productInfo == null) {  
  57.                 throw new SellException(ResultEnum.PRODUCT_NOT_EXIST);  
  58.             }  
  59.             Integer result = productInfo.getProductStock() + cartDTO.getProductQuantity();  
  60.             productInfo.setProductStock(result);  
  61.             dao.save(productInfo);  
  62.         }  
  63.     }  
  64.   
  65.     @Override  
  66.     @Transactional  
  67.     public void decreaseStock(List<CartDTO> cartDTOList) {  
  68.         for(CartDTO cartDTO : cartDTOList) {  
  69.             ProductInfo productInfo = dao.findOne(cartDTO.getProductId());  
  70.             if(productInfo == null) {  
  71.                 throw new SellException(ResultEnum.PRODUCT_NOT_EXIST);  
  72.             }  
  73.   
  74.             Integer result = productInfo.getProductStock() - cartDTO.getProductQuantity();  
  75.             if(result < 0) {  
  76.                 throw new SellException(ResultEnum.PRODUCT_STOCK_ERROR);  
  77.             }  
  78.             productInfo.setProductStatus(result);  
  79.             dao.save(productInfo);  
  80.         }  
  81.     }  
  82. }




四、Service 层的创建


1、OrderService.java
  1. package com.liuyanzhao.sell.service;
  3. import com.liuyanzhao.sell.dto.OrderDTO;
  4. import org.springframework.data.domain.Page;
  5. import org.springframework.data.domain.Pageable;
  7. /**
  8.  * @Author: 言曌
  9.  * @Date: 2017/11/13
  10.  * @Time: 上午11:17
  11.  */
  13. public interface OrderService {
  15.     //创建订单
  16.     OrderDTO create(OrderDTO orderDTO);
  18.     //查询单个订单
  19.     OrderDTO findOne(String orderId);
  21.     //查询订单列表
  22.     Page<OrderDTO> findList(String buyerOpenid, Pageable pageable);
  24.     //取消订单
  25.     OrderDTO cancel(OrderDTO orderDTO);
  27.     //完结订单
  28.     OrderDTO finish(OrderDTO orderDTO);
  30.     //支付订单
  31.     OrderDTO paid(OrderDTO orderDTO);
  33. }



2、OrderServiceImpl.java
  1. package com.liuyanzhao.sell.service.impl;
  3. import com.liuyanzhao.sell.converter.OrderMaster2OrderDTOConverter;
  4. import com.liuyanzhao.sell.dao.OrderDetailDao;
  5. import com.liuyanzhao.sell.dao.OrderMasterDao;
  6. import com.liuyanzhao.sell.dto.CartDTO;
  7. import com.liuyanzhao.sell.dto.OrderDTO;
  8. import com.liuyanzhao.sell.entity.OrderDetail;
  9. import com.liuyanzhao.sell.entity.OrderMaster;
  10. import com.liuyanzhao.sell.entity.ProductInfo;
  11. import com.liuyanzhao.sell.enums.OrderStatusEnum;
  12. import com.liuyanzhao.sell.enums.PayStatusEnum;
  13. import com.liuyanzhao.sell.enums.ResultEnum;
  14. import com.liuyanzhao.sell.exception.SellException;
  15. import com.liuyanzhao.sell.service.OrderService;
  16. import com.liuyanzhao.sell.service.ProductService;
  17. import com.liuyanzhao.sell.utils.KeyUtil;
  18. import lombok.extern.slf4j.Slf4j;
  19. import org.springframework.beans.BeanUtils;
  20. import org.springframework.beans.factory.annotation.Autowired;
  21. import org.springframework.data.domain.Page;
  22. import org.springframework.data.domain.PageImpl;
  23. import org.springframework.data.domain.Pageable;
  24. import org.springframework.stereotype.Service;
  25. import org.springframework.transaction.annotation.Transactional;
  26. import org.springframework.util.CollectionUtils;
  28. import java.math.BigDecimal;
  29. import java.math.BigInteger;
  30. import java.util.ArrayList;
  31. import java.util.List;
  32. import java.util.stream.Collectors;
  34. /**
  35.  * @Author: 言曌
  36.  * @Date: 2017/11/13
  37.  * @Time: 上午11:29
  38.  */
  39. @Slf4j
  40. @Service
  41. public class OrderServiceImpl implements OrderService{
  44.     @Autowired
  45.     private ProductService productService;
  47.     @Autowired
  48.     private OrderDetailDao orderDetailDao;
  50.     @Autowired
  51.     private OrderMasterDao orderMasterDao;
  53.     @Override
  54.     @Transactional //事务管理
  55.     public OrderDTO create(OrderDTO orderDTO) {
  57.         String orderId = KeyUtil.genUniqueKey();
  58.         BigDecimal orderAmount = new BigDecimal(BigInteger.ZERO );
  60.         //1、查询商品（数量，价格）
  61.         List<OrderDetail> orderDetailList = new ArrayList<>();
  62.         for(OrderDetail orderDetail:orderDTO.getOrderDetailList()) {
  63.             ProductInfo productInfo = productService.findOne(orderDetail.getProductId());
  64.             if(productInfo == null) {
  65.                 throw new SellException(ResultEnum.PRODUCT_NOT_EXIST);
  66.             }
  68.             //2、计算订单总价
  69.             orderAmount = productInfo.getProductPrice()
  70.                     .multiply(new BigDecimal(orderDetail.getProductQuantity()))
  71.                     .add(orderAmount);
  73.             //订单详情入库
  74.             orderDetail.setDetailId(KeyUtil.genUniqueKey());
  75.             orderDetail.setOrderId(orderId);
  76.             BeanUtils.copyProperties(productInfo,orderDetail);
  77.             orderDetailDao.save(orderDetail);
  79.         }
  82.         //3、写入订单数据库(orderMaster和orderDetail)
  83.         OrderMaster orderMaster = new OrderMaster();
  84.         BeanUtils.copyProperties(orderDTO,orderMaster);
  85.         orderMaster.setOrderId(orderId);
  86.         orderMaster.setOrderAmount(orderAmount);
  87.         orderMaster.setOrderStatus(OrderStatusEnum.NEW.getCode());
  88.         orderMaster.setPayStatus(PayStatusEnum.WAIT.getCode());
  89.         orderMasterDao.save(orderMaster);
  91.         //4、扣库存
  92.         List<CartDTO> cartDTOList = new ArrayList<>();
  93.         orderDTO.getOrderDetailList().stream().map(e->
  94.             new CartDTO(e.getProductId(),e.getProductQuantity())
  95.         ).collect(Collectors.toList());
  96.         productService.decreaseStock(cartDTOList);
  98.         return orderDTO;
  99.     }
  101.     @Override
  102.     public OrderDTO findOne(String orderId) {
  103.         OrderMaster orderMaster = orderMasterDao.findOne(orderId);
  104.         if(orderMaster == null) {
  105.             throw new SellException(ResultEnum.ORDER_NOT_EXIST);
  106.         }
  108.         List<OrderDetail> orderDetailList = orderDetailDao.findByOrderId(orderId);
  109.         if(CollectionUtils.isEmpty(orderDetailList)) {
  110.             throw new SellException(ResultEnum.ORDERDETAIL_NOT_EXIST);
  111.         }
  113.         OrderDTO orderDTO = new OrderDTO();
  114.         BeanUtils.copyProperties(orderMaster,orderDTO);
  115.         orderDTO.setOrderDetailList(orderDetailList);
  116.         return orderDTO;
  117.     }
  119.     @Override
  120.     public Page<OrderDTO> findList(String buyerOpenid, Pageable pageable) {
  122.         Page<OrderMaster> orderMasterPage = orderMasterDao.findByBuyerOpenid(buyerOpenid,pageable);
  124.         List<OrderDTO> orderDTOList = OrderMaster2OrderDTOConverter.convert(orderMasterPage.getContent());
  126.         Page<OrderDTO> orderDTOPage = new PageImpl<OrderDTO>(orderDTOList,pageable,orderMasterPage.getTotalElements());
  128.         return orderDTOPage;
  129.     }
  131.     @Override
  132.     @Transactional
  133.     public OrderDTO cancel(OrderDTO orderDTO) {
  135.         OrderMaster orderMaster = new OrderMaster();
  136.         //判断订单状态
  137.         if(!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())) {
  138.             log.error("【取消订单】订单状态不正确，orderId={}，orderStatus",orderDTO.getOrderId(),orderDTO.getOrderStatus());
  139.         }
  141.         //修改订单状态
  142.         orderDTO.setOrderStatus(OrderStatusEnum.CANCEL.getCode());
  143.         BeanUtils.copyProperties(orderDTO,orderMaster);
  144.         OrderMaster updateResult =  orderMasterDao.save(orderMaster);
  145.         if(updateResult == null) {
  146.             log.error("【取消订单】更新失败,orderMaster={}",orderMaster);
  147.             throw new SellException(ResultEnum.ORDER_UPDATE_FAIL);
  148.         }
  150.         //返回库存
  151.         if(CollectionUtils.isEmpty(orderDTO.getOrderDetailList())) {
  152.             log.error("【取消订单】订单中无商品详情，orderDTO={}",orderDTO);
  153.             throw new SellException(ResultEnum.ORDER_DETAIL_EMPTY);
  154.         }
  155.         List<CartDTO> cartDTOList = orderDTO.getOrderDetailList().stream()
  156.                 .map(e -> new CartDTO(e.getProductId(),e.getProductQuantity()))
  157.                 .collect(Collectors.toList());
  158.         productService.increaseStock(cartDTOList);
  160.         //如果已支付，需要退款
  161.         if(orderDTO.getPayStatus().equals(PayStatusEnum.SUCCESS.getCode())) {
  162.             //TODO
  163.         }
  164.         return orderDTO;
  165.     }
  167.     @Override
  168.     @Transactional
  169.     public OrderDTO finish(OrderDTO orderDTO) {
  170.         //判断订单状态
  171.         if(!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())) {
  172.             log.error("【完结订单】订单状态不正确，orderId={},orderStatus={}",orderDTO.getOrderId(),orderDTO.getOrderStatus());
  173.             throw new SellException(ResultEnum.ORDER_STATUS_ERROR);
  174.         }
  176.         //修改订单状态
  177.         orderDTO.setOrderStatus(OrderStatusEnum.FINISHED.getCode());
  178.         OrderMaster orderMaster = new OrderMaster();
  179.         BeanUtils.copyProperties(orderDTO,orderMaster);
  180.         OrderMaster updateResult = orderMasterDao.save(orderMaster);
  181.         if(updateResult == null) {
  182.             log.error("【完结订单】更新失败，orderStatus={}",orderMaster);
  183.             throw new SellException(ResultEnum.ORDER_UPDATE_FAIL);
  184.         }
  185.         return orderDTO;
  186.     }
  188.     @Override
  189.     @Transactional
  190.     public OrderDTO paid(OrderDTO orderDTO) {
  191.         //判断订单状态
  192.         if(!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())) {
  193.             log.error("【订单支付完成】订单状态不正确，orderId={},orderStatus={}",orderDTO.getOrderId(),orderDTO.getOrderStatus());
  194.             throw new SellException(ResultEnum.ORDER_STATUS_ERROR);
  195.         }
  197.         //判断支付状态
  198.         if(!orderDTO.getPayStatus().equals(PayStatusEnum.WAIT.getCode())) {
  199.             log.error("【订单支付完成】订单支付状态不正确，orderDTO={}",orderDTO);
  200.             throw new SellException(ResultEnum.ORDER_PAY_STATUS_ERROR);
  201.         }
  203.         //修改支付状态
  204.         orderDTO.setPayStatus(PayStatusEnum.SUCCESS.getCode());
  205.         OrderMaster orderMaster = new OrderMaster();
  206.         BeanUtils.copyProperties(orderDTO,orderMaster);
  207.         OrderMaster updateResult = orderMasterDao.save(orderMaster);
  208.         if(updateResult == null) {
  209.             log.error("【完结订单】更新失败，orderMaster={}",orderMaster);
  210.             throw new SellException(ResultEnum.ORDER_UPDATE_FAIL);
  211.         }
  213.         return orderDTO;
  214.     }
  215. }

注意：

① 这些方法记得加 @Transactional

② 162 行的退款操作我们暂时还没写，以 //TODO 标识


五、ResultEnum.java 的补充


随着开发的推进，我们的枚举属性也不断增加
  1. package com.liuyanzhao.sell.enums;
  3. import lombok.Getter;
  5. /**
  6.  * 返回给前端提示
  7.  * @Author: 言曌
  8.  * @Date: 2017/11/13
  9.  * @Time: 下午12:05
  10.  */
  12. @Getter
  13. public enum ResultEnum {
  15.     PRODUCT_NOT_EXIST(10,"商品不存在"),
  16.     PRODUCT_STOCK_ERROR(11, "库存不正确"),
  17.     ORDER_NOT_EXIST(12,"订单不存在"),
  18.     ORDERDETAIL_NOT_EXIST(13,"订单详情不存在"),
  19.     ORDER_STATUS_ERROR(14,"订单状态不正确"),
  20.     ORDER_UPDATE_FAIL(15,"订单更新失败"),
  21.     ORDER_DETAIL_EMPTY(16,"订单详情为空"),
  22.     ORDER_PAY_STATUS_ERROR(17,"订单支付状态不正确"),
  23.     ;
  25.     private Integer code;
  27.     private String message;
  29.     ResultEnum(Integer code, String message) {
  30.         this.code = code;
  31.         this.message = message;
  32.     }
  34. }



本文地址：https://liuyanzhao.com/6734.html
历史上的今天
十一月
16日
  • 微信
  • 交流学习，资料分享
  • weinxin
  • 个人淘宝
  • 店铺名：言曌博客咨询部

  • (部分商品未及时上架淘宝)
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：2   待审核评论数：0
  1. avatar 666
    回复 2017年11月22日 21:59:34

    买不起视频跑来看你更新了 :lol:

    • avatar 言曌
      回复 2017年11月22日 23:16:16

      视频内容比较多，最近比较忙，不准备更新了。

  2. avatar 憧憬点滴记忆
    回复 2017年11月16日 23:09:23

    可以可以，膜拜大神+1

    • avatar 言曌
      回复 2017年11月16日 23:11:06

      没有啦，我还是渣渣。准备明年春招找实习，然后秋招开始校招，19年7月份毕业，憧憬有推荐吗？