时间戳

首页 > 技术文章 > 微信点餐之买家订单（5）

微信点餐之买家订单（5）

applesnt 2020-04-01 14:34 原文

创建javabean

1：定义订单状态枚举类：生成订单状态常量
com\imooc\vo\enums\OrderStatusEnum.java
创建类型【enum】

package com.imooc.vo.enums;
import lombok.Getter;

Getter
public enum OrderStatusEnum {
    NEW(0,"新订单"),
    FINISHED(1,"已完结"),
    CANCEL(2,"已取消"),
    ;
    private Integer code;
    private String msg;

    OrderStatusEnum(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }
}

2：定义支付状态枚举类：生成支付状态常量
com\imooc\vo\enums\PayStatusEnum.java
创建类型【enum】

package com.imooc.vo.enums;
import lombok.Getter;

Getter
public enum PayStatusEnum {
    WAIT(0,"等待支付"),
    SUCCESS(1,"支付成功"),
    ;
    private Integer code;
    private String msg;

    PayStatusEnum(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }
}

3：创建订单主表对象
com\imooc\vo\admin\OrderMaster.java

package com.imooc.vo.admin;

import com.imooc.vo.enums.OrderStatusEnum;
import com.imooc.vo.enums.PayStatusEnum;
import lombok.Data;
import org.hibernate.annotations.DynamicUpdate;
import javax.persistence.*;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;

/**
 * @author: menghaibin
 * @create: 2020-02-10 17:29
 * @description: 订单主业务类
 **/
@Entity
@Data
@Table(name = "order_master")
@DynamicUpdate
public class OrderMaster {

    @Id
    @Column(name = "order_id")
    private String orderId;

    /*买家名字*/
    @Column(name = "buyer_name")
    private String buyerName;

    /*买家电话*/
    @Column(name = "buyer_phone")
    private String buyerPhone;

    /*买家地址*/
    @Column(name = "buyer_address")
    private String buyerAddress;

    /*买家微信openid*/
    @Column(name = "buyer_openid")
    private String buyerOpenid;

    /*订单总金额*/
    @Column(name = "order_amount")
    private BigDecimal orderAmount;

    /*订单状态 初始为0新订单*/
    @Column(name = "order_status")
    private Integer orderStatus = OrderStatusEnum.NEW.getCode();

    /*支付状态 默认为0未支付*/
    @Column(name = "pay_status")
    private Integer payStatus = PayStatusEnum.WAIT.getCode();

    /*创建时间*/
    @Column(name = "create_time")
    private Date createTime;

    /*修改时间*/
    @Column(name = "update_time")
    private Date updateTime;

    /*订单包含的商品信息*/
    @Transient /*数据库对应的是忽略此字段*/
    private List<OrderDetail> orderDetailList;
}

4：创建订单详细表对象
com\imooc\vo\admin\OrderDetail.java

package com.imooc.vo.admin;

import lombok.Data;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import java.math.BigDecimal;

/**
 * @author: menghaibin
 * @create: 2020-02-10 17:54
 * @description: 订单详细类
 **/
@Entity
@Data
@Table(name = "order_detail")
public class OrderDetail {

    @Id
    @Column(name = "detail_id")
    private String detailId;

    /*订单id*/
    @Column(name = "order_id")
    private String orderId;

    /*商品id*/
    @Column(name = "product_id")
    private String productId;

    /*商品名称*/
    @Column(name = "product_name")
    private String productName;

    /*商品单价*/
    @Column(name = "product_price")
    private BigDecimal productPrice;

    /*商品数量*/
    @Column(name = "product_quantity")
    private Integer productQuantity;

    /*商品小图*/
    @Column(name = "product_icon")
    private String productIcon;
}

创建dao层接口

1：订单Dao
com\imooc\dao\OrderMasterDao.java

package com.imooc.dao;

import com.imooc.vo.admin.OrderMaster;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;

public interface OrderMasterDao extends JpaRepository<OrderMaster,String> {

    /*通过openid查询用户的订单信息*/
    Page<OrderMaster> findByBuyerOpenid(String buyerOpenid, Pageable pageable);
}

2：订单详细Dao
com\imooc\dao\OrderDetailDao.java

package com.imooc.dao;

import com.imooc.vo.admin.OrderDetail;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;

public interface OrderDetailDao extends JpaRepository<OrderDetail,String> {

    /*通过订单号查询包含的商品 一对多*/
    List<OrderDetail> findByOrderId(String orderId);
}

创建service层接口

1：首先创建一个数据DTO，用于订单数据再各层之间进行传输
com\imooc\dto\OrderDTO.java

package com.imooc.dto;

import com.imooc.vo.admin.OrderDetail;
import lombok.Data;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;

/**
 * @author: menghaibin
 * @create: 2020-02-10 21:25
 * @description: 用户订单信息在各个业务类中传输
 **/
@Data
public class OrderDTO {

    /*订单id*/
    private String orderId;

    /*买家名字*/
    private String buyerName;

    /*买家电话*/
    private String buyerPhone;

    /*买家地址*/
    private String buyerAddress;

    /*买家微信openid*/
    private String buyerOpenid;

    /*订单总金额*/
    private BigDecimal orderAmount;

    /*订单状态 初始为0新订单*/
    private Integer orderStatus;

    /*支付状态 默认为0未支付*/
    private Integer payStatus;

    /*创建时间*/
    private Date createTime;

    /*修改时间*/
    private Date updateTime;

    /*订单包含的商品信息*/
    private List<OrderDetail> orderDetailList;
}

2：定义service接口
com\imooc\service\OrderService.java

package com.imooc.service;
import com.imooc.dto.OrderDTO;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;

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

    /*查询单个订单*/
    OrderDTO findOne(String orderId);

    /*查询某个用户的订单列表*/
    Page<OrderDTO> findList(String buyerOpenid, Pageable pageable);

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

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

    /*支付订单*/
    OrderDTO paid(OrderDTO orderDTO);

    /*查收所有订单列表*/
    Page<OrderDTO> findList(Pageable pageable);
}

实现service层接口

2：创建购物车类（接收前端传过来的购物车信息）
com\imooc\dto\CartDTO.java

package com.imooc.dto;
import lombok.Data;

/**
 * @author: menghaibin
 * @create: 2020-02-11 20:51
 * @description: 购物车
 **/
@Data
public class CartDTO {

    /*商品id*/
    private String productId;
    /*商品数量*/
    private Integer productQuantity;

    public CartDTO(String productId, Integer productQuantity) {
        this.productId = productId;
        this.productQuantity = productQuantity;
    }
}

3：在ProductInfoService接口中添加两个方法（创建订单时会减库存，取消订单时会加库存）

 /*加库存*/
 public void increaseStock(List<CartDTO> cartDTOList);

 /*减库存*/
 public void decreaseStock(List<CartDTO> cartDTOList);

4：在ProductInfoServiceImp类中实现decreaseStock的方法（创建订单时会减库存）

/*减库存
* OrderServiceImp的create调用
* */
@Override
@Transactional/*事务*/
public void decreaseStock(List<CartDTO> cartDTOList) {

    for(CartDTO cartDTO : cartDTOList){
            //根据传递过来的产品id查询商品
            ProductInfo productInfo = productInfoDao.findOne(cartDTO.getProductId());
            if(productInfo == null){
                throw new SellException(ResultEnum.PRODUCT_NOT_EXIST);
            }
            //用查询出的库存减去传递过来的购买数量
            Integer result = productInfo.getProductStock() - cartDTO.getProductQuantity();
            if(result < 0){
                throw new SellException(ResultEnum.PRODUCT_STOCK_ERROR);
            }
            //更新数据库
            productInfo.setProductStock(result);
            productInfoDao.save(productInfo);
        }
}

5：创建service实现类
com\imooc\service\imp\OrderServiceImp.java
创建订单：create[警告：创建订单要用到分布式锁]

package com.imooc.service.imp;

import com.imooc.dao.OrderDetailDao;
import com.imooc.dao.OrderMasterDao;
import com.imooc.dto.CartDTO;
import com.imooc.dto.OrderDTO;
import com.imooc.exception.SellException;
import com.imooc.service.*;
import com.imooc.utils.KeyUtil;
import com.imooc.vo.admin.OrderDetail;
import com.imooc.vo.admin.OrderMaster;
import com.imooc.vo.admin.ProductInfo;
import com.imooc.vo.enums.OrderStatusEnum;
import com.imooc.vo.enums.PayStatusEnum;
import com.imooc.vo.enums.ResultEnum;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.List;
import java.util.stream.Collectors;

@Service
@Slf4j
public class OrderServiceImp implements OrderService{

    @Autowired
    private ProductInfoService productInfoService;

    @Autowired
    private OrderDetailDao orderDetailDao;

    @Autowired
    private OrderMasterDao orderMasterDao;
    
	@Override
    @Transactional/*事务管理*/
    public OrderDTO create(OrderDTO orderDTO) {

        /*生成订单id*/
        String orderId = KeyUtil.genUniqueKey();
        //定义总价变量
        BigDecimal orderAmount = new BigDecimal(BigInteger.ZERO);
        //1：查询商品（数量、价格，安全考虑不能从前台传值）
        for(OrderDetail orderDetail : orderDTO.getOrderDetailList()){
            ProductInfo productInfo = productInfoService.findOne(orderDetail.getProductId());
            if(productInfo == null){
                throw new SellException(ResultEnum.PRODUCT_NOT_EXIST);
            }
            //2：计算总价
            orderAmount = productInfo.getProductPrice()
                          .multiply(new BigDecimal(orderDetail.getProductQuantity()))
                          .add(orderAmount);
            //3:订单详情入库
            orderDetail.setDetailId(KeyUtil.genUniqueKey());
            orderDetail.setOrderId(orderId);
            /*
            *  两个对象之间的属性赋值，相同变量名即可自动赋值
            *  注意：要先进行这个方法属性的拷贝 在执行单独的属性赋值 要不然会覆盖单独set的属性值
            *  BeanUtils.copyProperties(productInfo,orderDetail);
            * */
            orderDetail.setProductId(productInfo.getProductId());
            orderDetail.setProductName(productInfo.getProductName());
            orderDetail.setProductPrice(productInfo.getProductPrice());
            orderDetail.setProductIcon(productInfo.getProductIcon());

            orderDetailDao.save(orderDetail);
        }

        //3：写入订单数据库（ordermaster）
        orderDTO.setOrderId(orderId);//用于返回给controller
        OrderMaster orderMaster = new OrderMaster();
        orderMaster.setOrderId(orderId);
        orderMaster.setOrderAmount(orderAmount);
        /*
        *   两个对象之间的属性赋值，相同变量名即可自动赋值
        *   注意：要先进行这个方法属性的拷贝 在执行单独的属性赋值，要不然会覆盖单独set的属性值
        *   BeanUtils.copyProperties(orderDTO,orderMaster);
        * */
        orderMaster.setBuyerOpenid(orderDTO.getBuyerOpenid());
        orderMaster.setBuyerName(orderDTO.getBuyerName());
        orderMaster.setBuyerPhone(orderDTO.getBuyerPhone());
        orderMaster.setBuyerAddress(orderDTO.getBuyerAddress());
        orderMasterDao.save(orderMaster);
        //4：扣库存
        /*java8特效 一个对象list转成另外一个对象list*/
        List<CartDTO> cartDTOList = orderDTO.getOrderDetailList().stream().map(e ->
                new CartDTO(e.getProductId(),e.getProductQuantity()))
                .collect(Collectors.toList());

        productInfoService.decreaseStock(cartDTOList);

        return orderDTO;
    }

}

查询单个订单：findOne

    @Override
    public OrderDTO findOne(String orderId) {

        /*查询该订单是否存在*/
        OrderMaster orderMaster = orderMasterDao.findOne(orderId);
        if(orderMaster == null){
            throw new SellException(ResultEnum.ORDER_NOT_EXIST);
        }
        /*根据订单id查询订单详细*/
        List<OrderDetail> orderDetailList = orderDetailDao.findByOrderId(orderId);
        if(CollectionUtils.isEmpty(orderDetailList)){
            throw new SellException(ResultEnum.ORDERDETAIL_NOT_EXIST);
        }
        
        OrderDTO orderDTO = new OrderDTO();
        BeanUtils.copyProperties(orderMaster,orderDTO);
        orderDTO.setOrderDetailList(orderDetailList);
        return orderDTO;
    }

查询固定用户的订单列表：findList
先定义一个对象转换类：ordermaster转成orderdto
com\imooc\converter\OrderMaster2OrderDTOConverter.java

package com.imooc.converter;

import com.imooc.dto.OrderDTO;
import com.imooc.vo.admin.OrderMaster;
import org.springframework.beans.BeanUtils;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author: menghaibin
 * @create: 2020-02-12 21:12
 * @description: 对象转换器
 **/
public class OrderMaster2OrderDTOConverter {

    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());
    }
}

实现findList方法：

@Override
    public Page<OrderDTO> findList(String buyerOpenid, Pageable pageable) {
        Page<OrderMaster> orderMasterPage = orderMasterDao.findByBuyerOpenid(buyerOpenid,pageable);
        /*Page<OrderMaster>转成List<OrderDTO>*/
        List<OrderDTO> orderDTOList = OrderMaster2OrderDTOConverter.convert(orderMasterPage.getContent());
        /*封装成page对象*/
        Page<OrderDTO> orderDTOPage = new PageImpl<OrderDTO>(orderDTOList,pageable,orderMasterPage.getTotalElements());
        return orderDTOPage;
    }

取消订单：cancel
1：在ProductInfoServiceImp类中实现increaseStock的方法（取消订单时会加库存）

 @Override
 @Transactional//事务
 public void increaseStock(List<CartDTO> cartDTOList) {

     for(CartDTO cartDTO : cartDTOList){
         ProductInfo productInfo = productInfoDao.findOne(cartDTO.getProductId());
         if(productInfo == null){
             throw new SellException(ResultEnum.ORDER_NOT_EXIST);
         }

         Integer result = productInfo.getProductStock()+cartDTO.getProductQuantity();
         productInfo.setProductStock(result);
         productInfoDao.save(productInfo);
     }
 }

2：编写取消订单cancel方法：

    @Override
    @Transactional//事务
    public OrderDTO cancel(OrderDTO orderDTO) {
        //判断订单状态，必须是新订单才可以取消
        if(!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())){
            log.error("[取消订单]订单状态不正确，订单编号是：{}，订单状态是：{}",orderDTO.getOrderId(),orderDTO.getOrderStatus());
            throw new SellException(ResultEnum.ORDER_STATUS_ERROR);
        }

        //修改订单状态
        OrderMaster orderMaster = new OrderMaster();
        //先更新状态
        orderDTO.setOrderStatus(OrderStatusEnum.CANCEL.getCode());
        //再执行拷贝
        BeanUtils.copyProperties(orderDTO,orderMaster);
        OrderMaster updateMaster = orderMasterDao.save(orderMaster);
        if(updateMaster == null){
            log.error("订单更新失败,订单是：{}",updateMaster);
            throw new SellException(ResultEnum.ORDER_UPDATE_ERROR);
        }
        //返还库存
        if(CollectionUtils.isEmpty(orderDTO.getOrderDetailList())){
            log.error("订单中无商品");
            throw new SellException(ResultEnum.ORDER_DETAIL_EMPTY);
        }
        List<CartDTO> cartDTOList = orderDTO.getOrderDetailList().stream().map(e ->
                                    new CartDTO(e.getProductId(),e.getProductQuantity())).collect(Collectors.toList());
        productInfoService.increaseStock(cartDTOList);
        //如果已支付 需要退款
        if(orderDTO.getPayStatus().equals(PayStatusEnum.SUCCESS.getCode())){
            //TODO
            //等支付功能完毕后补全
        }
        return orderDTO;
  }

完成订单：finish

 @Override
    @Transactional
    public OrderDTO finish(OrderDTO orderDTO) {
        //判断订单状态
        if(!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())){
            log.error("[完成订单]订单状态不正确，订单编号是：{}，订单状态是：{}",orderDTO.getOrderId(),orderDTO.getOrderStatus());
            throw new SellException(ResultEnum.ORDER_STATUS_ERROR);
        }
        //修改订单状态
        orderDTO.setOrderStatus(OrderStatusEnum.FINISHED.getCode());
        OrderMaster orderMaster = new OrderMaster();
        BeanUtils.copyProperties(orderDTO,orderMaster);
        OrderMaster updateMaster = orderMasterDao.save(orderMaster);
        if(updateMaster == null){
            log.info("订单更新失败,订单是：{}",updateMaster);
            throw new SellException(ResultEnum.ORDER_UPDATE_ERROR);
        }
        return orderDTO;
    }

支付订单：paid

@Override
    @Transactional//事务
    public OrderDTO paid(OrderDTO orderDTO) {
        //判断订单状态
        if(!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())){
            log.error("[订单支付]订单状态不正确，订单编号是：{}，订单状态是：{}",orderDTO.getOrderId(),orderDTO.getOrderStatus());
            throw new SellException(ResultEnum.ORDER_STATUS_ERROR);
        }
        //判断支付状态
        if(!orderDTO.getPayStatus().equals(PayStatusEnum.WAIT.getCode())){
            log.info("支付状态不正确");
            throw new SellException(ResultEnum.ORDER_PAY_STATUS_ERROR);
        }
        //修改支付订单
        orderDTO.setPayStatus(PayStatusEnum.SUCCESS.getCode());
        OrderMaster orderMaster = new OrderMaster();
        BeanUtils.copyProperties(orderDTO,orderMaster);
        OrderMaster updateMaster = orderMasterDao.save(orderMaster);
        if(updateMaster == null){
            log.info("支付失败,订单是：{}",updateMaster);
            throw new SellException(ResultEnum.ORDER_UPDATE_ERROR);
        }
        return orderDTO;
    }

创建controller层

首先创建一个表单提交的form对象，用于订单的表单提交以及验证：
com\imooc\form\OrderForm.java

package com.imooc.form;

import lombok.Data;
import org.hibernate.validator.constraints.NotEmpty;

import javax.print.DocFlavor;

/**
 * @author: menghaibin
 * @create: 2020-02-14 22:26
 * @description: 订单提交表单验证
 **/
@Data
public class OrderForm {

    /*买家姓名*/
    @NotEmpty(message = "姓名必填")
    private String name;

    /*买家手机号*/
    @NotEmpty(message = "手机号必填")
    private String phone;

    /*买家地址*/
    @NotEmpty(message = "地址必填")
    private String address;

    /*买家微信openid*/
    @NotEmpty(message = "openid必填")
    private String openid;

    /*购物车*/
    @NotEmpty(message = "购物车不能为空")
    private String items;
}

再创建OrderForm 对象转换类，OrderForm 转OrderDTO
com\imooc\converter\OrderForm2OrderDTOConverter.java

package com.imooc.converter;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.imooc.dto.OrderDTO;
import com.imooc.exception.SellException;
import com.imooc.form.OrderForm;
import com.imooc.vo.admin.OrderDetail;
import com.imooc.vo.enums.ResultEnum;
import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.List;

/**
 * @author: menghaibin
 * @create: 2020-02-17 14:26
 * @description: 表单提交转换类
 **/
@Slf4j
public class OrderForm2OrderDTOConverter {

    public static OrderDTO convert(OrderForm orderForm){
        Gson gson = new Gson();

        OrderDTO orderDTO = new OrderDTO();
        orderDTO.setBuyerName(orderForm.getName());
        orderDTO.setBuyerPhone(orderForm.getPhone());
        orderDTO.setBuyerAddress(orderForm.getAddress());
        orderDTO.setBuyerOpenid(orderForm.getOpenid());

        /*json字符串转换list*/
        List<OrderDetail> orderDetailList = new ArrayList<>();
        try{
            orderDetailList = gson.fromJson(orderForm.getItems(),new TypeToken<List<OrderDetail>>(){}.getType());
        }catch(Exception e){
            log.error("json转换list对象转换错误");
            throw new SellException(ResultEnum.PARAM_ERROR);
        }

        orderDTO.setOrderDetailList(orderDetailList);
        return orderDTO;
    }
}

创建controller控制类：
com\imooc\controller\BuyerOrderController.java

package com.imooc.controller;

import com.imooc.converter.OrderForm2OrderDTOConverter;
import com.imooc.dto.OrderDTO;
import com.imooc.exception.SellException;
import com.imooc.form.OrderForm;
import com.imooc.service.OrderService;
import com.imooc.vo.enums.ResultEnum;
import com.imooc.vo.front.ResultVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.HashMap;
import java.util.Map;

/**
 * @author: menghaibin
 * @create: 2020-02-14 21:17
 * @description: 买家订单controller
 **/
@RestController
@RequestMapping("/buyer/order")
@Slf4j
public class BuyerOrderController {

    @Autowired
    private OrderService orderService;
}

创建订单

说明：前端请求：POST /sell/buyer/order/create
参数：JSON

name: "张三"
phone: "18868822111"
address: "慕课网总部"
openid: "ew3euwhd7sjw9diwkq" //用户的微信openid
items: [{
    productId: "1423113435324",
    productQuantity: 2 //购买数量
}]

返回值：JSON

{
  "code": 0,
  "msg": "成功",
  "data": {
      "orderId": "147283992738221" 
  }
}

在BuyerOrderController编写创建订单的create方法：

//创建订单
@PostMapping("/create")
public ResultVo create(@Valid OrderForm orderForm, BindingResult bindingResult){
    if(bindingResult.hasErrors()){
        log.error("创建订单参数不正确");
        throw new SellException(ResultEnum.PARAM_ERROR.getCode(),bindingResult.getFieldError().getDefaultMessage());
    }
    OrderDTO orderDTO = OrderForm2OrderDTOConverter.convert(orderForm);
    if(CollectionUtils.isEmpty(orderDTO.getOrderDetailList())){
        log.error("创建订单时 购物车不能为空");
        throw new SellException(ResultEnum.CART_EMPTY);
    }
    OrderDTO createOrderDTO = orderService.create(orderDTO);
    Map<String,String> map = new HashMap<>();
    map.put("orderId",createOrderDTO.getOrderId());

    ResultVo resultVo = new ResultVo();
    resultVo.setData(map);
    resultVo.setCode(0);
    resultVo.setMsg("成功");
    return resultVo;
}

创建订单测试：postman

name:888
phone:18868822111
address:慕课网总部
openid:ew3euwhd7sjw9diwkq
items:[{productId:"1001",productQuantity:2}]

订单列表

说明：前端请求：/sell/buyer/order/list
参数：数值

openid: 18eu2jwk2kse3r42e2e
page: 0 //从第0页开始
size: 10

返回值：JSON

{
  "code": 0,
  "msg": "成功",
  "data": [
    {
      "orderId": "161873371171128075",
      "buyerName": "张三",
      "buyerPhone": "18868877111",
      "buyerAddress": "慕课网总部",
      "buyerOpenid": "18eu2jwk2kse3r42e2e",
      "orderAmount": 0,
      "orderStatus": 0,
      "payStatus": 0,
      "createTime": 1490171219,
      "updateTime": 1490171219,
      "orderDetailList": null
    },
    {
      "orderId": "161873371171128076",
      "buyerName": "张三",
      "buyerPhone": "18868877111",
      "buyerAddress": "慕课网总部",
      "buyerOpenid": "18eu2jwk2kse3r42e2e",
      "orderAmount": 0,
      "orderStatus": 0,
      "payStatus": 0,
      "createTime": 1490171219,
      "updateTime": 1490171219,
      "orderDetailList": null
    }]
}

在BuyerOrderController编写查询订单列表的list方法：

//订单列表
@GetMapping("/list")
public ResultVo list(@RequestParam("openid") String openid,
                      @RequestParam(value = "page",defaultValue = "0") Integer page,
                      @RequestParam(value = "size",defaultValue = "10") Integer size){
    if (StringUtils.isEmpty(openid)){
        log.error("openid 不能为空");
        throw new SellException(ResultEnum.PARAM_ERROR);
    }
    PageRequest pageRequest = new PageRequest(page,size);
    Page<OrderDTO> orderDTOPage = orderService.findList(openid,pageRequest);

    ResultVo resultVo = new ResultVo();
    resultVo.setCode(0);
    resultVo.setMsg("成功");
    resultVo.setData(orderDTOPage.getContent());
    return resultVo;
}

订单列表测试：postman

openid:ew3euwhd7sjw9diwkq

订单详情

说明：前端请求：GET /sell/buyer/order/detail
参数：数值

openid: 18eu2jwk2kse3r42e2e
orderId: 161899085773669363

返回值：JSON

{
    "code": 0,
    "msg": "成功",
    "data": {
          "orderId": "161899085773669363",
          "buyerName": "李四",
          "buyerPhone": "18868877111",
          "buyerAddress": "慕课网总部",
          "buyerOpenid": "18eu2jwk2kse3r42e2e",
          "orderAmount": 18,
          "orderStatus": 0,
          "payStatus": 0,
          "createTime": 1490177352,
          "updateTime": 1490177352,
          "orderDetailList": [
            {
                "detailId": "161899085974995851",
                "orderId": "161899085773669363",
                "productId": "157875196362360019",
                "productName": "招牌奶茶",
                "productPrice": 9,
                "productQuantity": 2,
                "productIcon": "http://xxx.com",
                "productImage": "http://xxx.com"
            }
        ]
    }
}

在BuyerOrderController编写查询订单列表的detail方法：

//订单详情
@GetMapping("/detail")
public ResultVo detail(@RequestParam("openid") String openid,
                        @RequestParam("orderId") String orderId){

    OrderDTO orderDTO = orderService.findOne(orderId);

    if(orderDTO == null){
        log.error("查询订单不存在");
        throw new SellException(ResultEnum.ORDER_NOT_EXIST);
    }

    if(!orderDTO.getBuyerOpenid().equals(openid)){
        log.error("查询订单错误，不是本人");
        throw new SellException(ResultEnum.ORDER_OWNER_ERROR);
    }

    ResultVo resultVo = new ResultVo();
    resultVo.setData(orderDTO);
    resultVo.setCode(0);
    resultVo.setMsg("成功");
    return resultVo;
}

订单详细测试：postman

openid:ew3euwhd7sjw9diwkq
orderId:1583332328179253522

取消订单

说明：前端请求：POST /sell/buyer/order/cancel
参数：数值

openid: 18eu2jwk2kse3r42e2e
orderId: 161899085773669363

返回值：JSON

{
    "code": 0,
    "msg": "成功",
    "data": null
}

在BuyerOrderController编写查询订单列表的cancel方法：

//取消订单
@PostMapping("/cancel")
public ResultVo cancel(@RequestParam("openid") String openid,
                        @RequestParam("orderId") String orderId){

    OrderDTO orderDTO = orderService.findOne(orderId);

    if(orderDTO == null){
        log.error("查询订单不存在");
        throw new SellException(ResultEnum.ORDER_NOT_EXIST);
    }

    if(!orderDTO.getBuyerOpenid().equals(openid)){
        log.error("查询订单错误，不是本人");
        throw new SellException(ResultEnum.ORDER_OWNER_ERROR);
    }

    orderService.cancel(orderDTO);
    ResultVo resultVo = new ResultVo();
    resultVo.setCode(0);
    resultVo.setMsg("成功");
    return resultVo;
}

取消订单测试：postman

openid:ew3euwhd7sjw9diwkq
orderId:1581925410436806302

推荐阅读