微信点餐SpringBoot-10：买家订单---Service层的实现_取消订单_完成订单_完成支付

1. OrderService

public interface OrderService {
    /**
     * 创建订单
     * @param orderDTO
     * @return
     */
    OrderDTO create(OrderDTO orderDTO);

    /**
     * 查询单个订单
     * @param orderId
     * @return
     */
    OrderDTO findOnes(String orderId);

    /**
     * 查询订单列表
     * @param buyerOpenid
     * @param pageable
     * @return
     */
    Page<OrderDTO> findList(String buyerOpenid, Pageable pageable);

    /**
     * 取消订单
     * @param orderDTO
     * @return
     */
    OrderDTO cancel(OrderDTO orderDTO);

    /**
     * 完结订单
     * @param orderDTO
     * @return
     */
    OrderDTO finish(OrderDTO orderDTO);

    /**
     * 支付订单
     * @param orderDTO
     * @return
     */
    OrderDTO paid(OrderDTO orderDTO);
}

2. OrderServiceImpl中查询订单的实现

@Slf4j
@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderMasterRepository repository;

    @Autowired
    private ProductService productService;

    @Autowired
    private OrderDetailRepository orderDetailRepository;

    @Autowired
    private OrderMasterRepository orderMasterRepository;
    
    /**
     * 根据买家订单号查询单个订单
     * @param orderId
     * @return
     */
    @Override
    public OrderDTO findOnes(String orderId) {
        OrderMaster orderMaster = orderMasterRepository.getOne(orderId);
        if(orderMaster==null){
            throw new SellException(ResultEnum.ORDER_NOT_EXIST);
        }

        List<OrderDetail> orderDetailList = orderDetailRepository.findByOrderId(orderId);
        if(orderDetailList==null){
            throw new SellException(ResultEnum.ORDERDETAIL_NOT_EXIST);
        }

        OrderDTO orderDTO = new OrderDTO();
        BeanUtils.copyProperties(orderMaster,orderDTO);
        orderDTO.setOrderDetailList(orderDetailList);

        return orderDTO;
    }

    /**
     * 根据买家微信openid查询买家订单列表
     * @param buyerOpenid
     * @param pageable
     * @return
     */
    @Override
    public Page<OrderDTO> findList(String buyerOpenid, Pageable pageable) {
        //从数据库中查询出的是OrderMaster
        Page<OrderMaster> orderMasterPage
                = orderMasterRepository.findByBuyerOpenid(buyerOpenid, pageable);

        //返回的是OrderDTO,因此需要转换
        List<OrderDTO> orderDTOList = OrderMaster2OrderDTO.convert(orderMasterPage.getContent());

        Page<OrderDTO> orderDTOPage
                = new PageImpl<OrderDTO>(orderDTOList,pageable,orderMasterPage.getTotalElements());
        return orderDTOPage;
    }

1. findones()方法—查询某个订单主表和对应订单详情表

下面为订单主表order_master：

可以通过order_id查询某个买家的信息：

下面是订单详情表，

一个order_id (如123456)可以对应多个订单详情，所有是orderDetailList
可以通过order_id得到订单详情列表集合：

由于方法的返回类型是OrderDTO，所以需要使用BeanUtils将OrderMaster装换为OrderDTO对象，同时为了展示每一个订单的详情还要加上OrderDetailList：

2. findList()方法—通过买家openid分页查询所有订单主表

在Service层实现下面这个方法，通过买家openid分页查询所有订单主表：
如下图为所有订单主表，同一个人（openid相同）下的所有的订单：

下面要做的就是通过买家的openid分页查询出买家所下的所有订单：

但是由于方法返回的是Page<OrderDTO>，但是我们查询出的是Page<OrderMaster>，所以需要进行类型转换：

下面是上述代码中将List<OrderMaster>转换为List<OrderDTO>的类：

/**
 * 将List<OrderMaster>转换为List<OrderDTO>
 */
public class OrderMaster2OrderDTO {
    public static OrderDTO convert(OrderMaster orderMaster){
        OrderDTO orderDTO = new OrderDTO();
        BeanUtils.copyProperties(orderMaster,orderDTO);
        return orderDTO;
    }

    public static List<OrderDTO> convert(List<OrderMaster> orderMasterList){
        return orderMasterList.stream()
                .map(e->convert(e))
                .collect(Collectors.toList());
    }
}

其实这里用到了jpa和Java 8 Lambda 表达式，可以补充一下相关的知识。

3. 测试类

@Test
 void findOnes() {
     OrderDTO result = orderService.findOnes(ORDER_ID);
     log.info("查询单个订单 result={}",result);
     Assert.assertEquals(ORDER_ID,result.getOrderId());
 }

 @Test
 void findList() {
     PageRequest request = PageRequest.of(0,2);
     Page<OrderDTO> orderDTOPage = orderService.findList(BUYER_OPENID,request);
     Assert.assertNotEquals(0,orderDTOPage.getTotalElements());
 }

3. OrderServiceImpl中取消订单的实现

@Slf4j
@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderMasterRepository repository;

    @Autowired
    private ProductService productService;

    @Autowired
    private OrderDetailRepository orderDetailRepository;

    @Autowired
    private OrderMasterRepository orderMasterRepository;
    
    /**
     * 取消订单
     * @param orderDTO
     * @return
     */
    @Transactional
    @Override
    public OrderDTO cancel(OrderDTO orderDTO) {
    
        OrderMaster orderMaster = new OrderMaster();

        //判断订单状态
       if(!orderDTO.getOrderStatus().equals(OrderStatuEnum.NEW.getCode())){
            log.error("【取消订单】订单信息不正确 orderId={},orderStatus={}", orderDTO.getOrderId(), orderDTO.getOrderStatus());
            throw new SellException(ResultEnum.ORDER_STATUS_ERROR);
        }
        
        //修改订单状态
        orderDTO.setOrderStatus(OrderStatuEnum.CANCEL.getCode());
        BeanUtils.copyProperties(orderDTO,orderMaster);
        OrderMaster updateResult = orderMasterRepository.save(orderMaster);
        if(updateResult==null){
            log.error("【取消订单】更新失败,orderMaster={}",orderMaster);
        }
        
        //返回库存
        if(CollectionUtils.isEmpty(orderDTO.getOrderDetailList())){
            log.error("【取消订单】订单没有商品详情,orderDTO={}",orderDTO);
            throw new SellException(ResultEnum.ORDER_DETAIL_EMPTY);
        }
        List<CartDTO> cartDTOList = orderDTO.getOrderDetailList().stream()
                .map(e->new CartDTO(e.getProductId(),e.getProductQuantity()))
                .collect(Collectors.toList());
        productService.increaseStock(cartDTOList);

        //如果已经支付，需要退款
       if(orderDTO.getPayStatus().equals(PayStatusEnum.SUCCESS.getCode())){
            //TODO
        }
        return orderDTO;
    }
}

下面要做的是取消订单的实现：

1、判断订单状态：

首先需要判断订单状态，只有是新下单的订单，我们才能进行取消订单的操作，而对于已经完结的订单和已经取消的订单是不能进行取消操作的。

下面是订单主表，要做的就是根据order_status取消某一个订单：

下面之所以使用orderDTO对象是因为创建出的订单返回的对象是OrderDTO：

2、修改订单状态：

如果订单状态为新创建的订单，如果想取消订单需要将订单状态修改为取消：
OrderDTO对象是数据库中的订单信息，通过这个对象将订单装填修改为cancel，修改后要将修改后的数据存入数据库中

3、返回库存：

首先判断这个订单里面有没有加入商品，如果有商品，那么我们需要将取消的订单里面的商品和对应的商品数量返回给库存，就是增加库存

这里同样运用了Java 8 Lambda 表达式，目的是通过OrderDTO对象查询出订单详情表中的商品id和商品数量，然后返回给库存：

4、测试类：

4. OrderServiceImpl中完结订单的实现

@Slf4j
@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderMasterRepository repository;

    @Autowired
    private ProductService productService;

    @Autowired
    private OrderDetailRepository orderDetailRepository;

    @Autowired
    private OrderMasterRepository orderMasterRepository;

    /**
     * 完结订单
     * @param orderDTO
     * @return
     */
    @Override
    @Transactional
    public OrderDTO finish(OrderDTO orderDTO) {
        //判断订单状态
       if(!orderDTO.getOrderStatus().equals(OrderStatuEnum.NEW.getCode())){
            log.error("【完结订单】订单状态不正确,orderId={},orderStatus={}",orderDTO.getOrderId(),orderDTO.getOrderStatus());
            throw new SellException(ResultEnum.ORDER_STATUS_ERROR);
        }
        
        //修改订单状态
        orderDTO.setOrderStatus(OrderStatuEnum.FINISHED.getCode());
        OrderMaster orderMaster = new OrderMaster();
        BeanUtils.copyProperties(orderDTO,orderMaster);
        OrderMaster updateResult = orderMasterRepository.save(orderMaster);
        if(updateResult==null){
            log.error("【完结订单】更新失败,orderMaster={}",orderMaster);
            throw new SellException(ResultEnum.ORDER_UPDATE_FAIL);
        }
        return orderDTO;
    }
}

下面要做的是完结订单的实现：

1、判断订单状态：

想要完结订单，首先判断订单是否是新创建的订单：

2、修改订单状态：

将订单状态修改为完结：

3、测试类：

5. OrderServiceImpl中完成支付的实现

@Slf4j
@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderMasterRepository repository;

    @Autowired
    private ProductService productService;

    @Autowired
    private OrderDetailRepository orderDetailRepository;

    @Autowired
    private OrderMasterRepository orderMasterRepository;

    /**
     * 完成支付
     * @param orderDTO
     * @return
     */
    @Override
    @Transactional
    public OrderDTO paid(OrderDTO orderDTO) {
        //判断订单状态
        if(!orderDTO.getOrderStatus().equals(OrderStatuEnum.NEW.getCode())){
            log.error("【订单支付完成】订单状态不正确,orderId={},orderStatus={}",orderDTO.getOrderId(),orderDTO.getOrderStatus());
            throw new SellException(ResultEnum.ORDER_STATUS_ERROR);
        }
        //判断支付状态
        if(!orderDTO.getPayStatus().equals(PayStatusEnum.WAIT.getCode())){
            log.error("【订单支付完成】订单支付状态不正确,orderDTO={}",orderDTO);
            throw new SellException(ResultEnum.ORDER_PAY_STATUS_ERROR);
        }
        //修改支付状态
        orderDTO.setPayStatus(PayStatusEnum.SUCCESS.getCode());
        OrderMaster orderMaster = new OrderMaster();
        BeanUtils.copyProperties(orderDTO,orderMaster);
        OrderMaster updateResult = orderMasterRepository.save(orderMaster);
        if(updateResult == null){
            log.error("【订单支付完成】更新失败,orderMaster={}",orderMaster);
            throw new SellException(ResultEnum.ORDER_UPDATE_FAIL);
        }
        return orderDTO;
    }
}

测试类：

 @Test
    void paid() {
        OrderDTO orderDTO = orderService.findOnes(ORDER_ID);
        OrderDTO result = orderService.paid(orderDTO);
        Assert.assertEquals(PayStatusEnum.SUCCESS.getCode(),result.getPayStatus());
    }

6. OrderServiceImplTest 测试类

@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
class OrderServiceImplTest {

    @Autowired
    private OrderService orderService;

    private final String BUYER_OPENID = "110110";
    private final String ORDER_ID = "1583721198784404461";

    @Test
    void create() {
        OrderDTO orderDTO = new OrderDTO();
        orderDTO.setBuyerName("师兄");
        orderDTO.setBuyerAddress("北京");
        orderDTO.setBuyerPhone("137659863");
        orderDTO.setBuyerOpenid(BUYER_OPENID);

        //购物车
        List<OrderDetail> orderDetailList = new ArrayList<>();
        OrderDetail o1 = new OrderDetail();
        //数据库中必须存在
        o1.setProductId("123458");
        o1.setProductQuantity(1);
        orderDetailList.add(o1);

        OrderDetail o2 = new OrderDetail();
        //数据库中必须存在
        o2.setProductId("123457");
        o2.setProductQuantity(2);
        orderDetailList.add(o2);

        orderDTO.setOrderDetailList(orderDetailList);

        OrderDTO result = orderService.create(orderDTO);
        log.info("创建订单 result={}",result);
    }

    @Test
    void findOnes() {
        OrderDTO result = orderService.findOnes(ORDER_ID);
        log.info("查询单个订单 result={}",result);
        Assert.assertEquals(ORDER_ID,result.getOrderId());
    }

    @Test
    void findList() {
        PageRequest request = PageRequest.of(0,2);
        Page<OrderDTO> orderDTOPage = orderService.findList(BUYER_OPENID,request);
        Assert.assertNotEquals(0,orderDTOPage.getTotalElements());
    }

    @Test
    void cancel() {
        OrderDTO orderDTO = orderService.findOnes(ORDER_ID);
        OrderDTO result = orderService.cancel(orderDTO);
        Assert.assertEquals(OrderStatuEnum.CANCEL.getCode(),result.getOrderStatus());
    }

    @Test
    void finish() {
        OrderDTO orderDTO = orderService.findOnes(ORDER_ID);
        OrderDTO result = orderService.finish(orderDTO);
        Assert.assertEquals(OrderStatuEnum.FINISHED.getCode(),result.getOrderStatus());
    }

    @Test
    void paid() {
        OrderDTO orderDTO = orderService.findOnes(ORDER_ID);
        OrderDTO result = orderService.paid(orderDTO);
        Assert.assertEquals(PayStatusEnum.SUCCESS.getCode(),result.getPayStatus());
    }
}