对于后台订单购物流程的API开发小结

最新推荐文章于 2020-05-10 00:35:58 发布
最新推荐文章于 2020-05-10 00:35:58 发布
阅读量2k 收藏 2
点赞数 2
分类专栏： 技术点分析 文章标签： api 业务流程 spring mvc 编辑器 淘宝网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/han1196639488/article/details/54880976
版权

springmvc开发订单类api接口

在接手到这个项目时，我对订单只是模糊的概念，淘宝的购物流程我想在坐的各位都知道，但是具体到开发的时候，考虑的细节那是很多的，如订单状态的判断，支付前的检查等等，下面我就说说订单的业务流程：
首先声明一个订单请求类，用来从客户端传来订单的请求信息
- 订单请求类

public class AddMemberOrderPaymentItemsRequest {

    private int orderId;
    private int memberId;
    private List<PaymentData> orderPayments;

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public int getMemberId() {
        return memberId;
    }

    public void setMemberId(int memberId) {
        this.memberId = memberId;
    }

    public List<PaymentData> getOrderPayments() {
        return orderPayments;
    }

    public void setOrderPayments(List<PaymentData> orderPayments) {
        this.orderPayments = orderPayments;
    }

}
  • 订单的支付数据类
public class OrderPaymentData {

    private String orderSn;
    private String paymentType;
    private Integer paymentTypeValue;
    private Integer paymentTypeFee;
    private Long paymentTime;
    private String notifyId;
    private Integer status;
    private String tradeNo;
    private String password;
    private Integer paymentSourceId;
    private String remark;

    public String getOrderSn() {
        return orderSn;
    }

    public void setOrderSn(String orderSn) {
        this.orderSn = orderSn;
    }

    public String getPaymentType() {
        return paymentType;
    }

    public void setPaymentType(String paymentType) {
        this.paymentType = paymentType;
    }

    public Integer getPaymentTypeValue() {
        return paymentTypeValue;
    }

    public void setPaymentTypeValue(Integer paymentTypeValue) {
        this.paymentTypeValue = paymentTypeValue;
    }

    public Integer getPaymentTypeFee() {
        return paymentTypeFee;
    }

    public void setPaymentTypeFee(Integer paymentTypeFee) {
        this.paymentTypeFee = paymentTypeFee;
    }

    public Long getPaymentTime() {
        return paymentTime;
    }

    public void setPaymentTime(Long paymentTime) {
        this.paymentTime = paymentTime;
    }

    public String getNotifyId() {
        return notifyId;
    }

    public void setNotifyId(String notifyId) {
        this.notifyId = notifyId;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public String getTradeNo() {
        return tradeNo;
    }

    public void setTradeNo(String tradeNo) {
        this.tradeNo = tradeNo;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getPaymentSourceId() {
        return paymentSourceId;
    }

    public void setPaymentSourceId(Integer paymentSourceId) {
        this.paymentSourceId = paymentSourceId;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }
}
  • 支付数据类
public class PaymentData {

    private String paymentType;
    private String paymentValue;
    private String paymentFee;
    private String password;
    private Integer paymentSourceId;
    private String remark;
    private Integer orderItemId;

    public String getPaymentType() {
        return paymentType;
    }

    public void setPaymentType(String paymentType) {
        this.paymentType = paymentType;
    }

    public String getPaymentValue() {
        return paymentValue;
    }

    public void setPaymentValue(String paymentValue) {
        this.paymentValue = paymentValue;
    }

    public String getPaymentFee() {
        return paymentFee;
    }

    public void setPaymentFee(String paymentFee) {
        this.paymentFee = paymentFee;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getPaymentSourceId() {
        return paymentSourceId;
    }

    public void setPaymentSourceId(Integer paymentSourceId) {
        this.paymentSourceId = paymentSourceId;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    public Integer getOrderItemId() {
        return orderItemId;
    }

    public void setOrderItemId(Integer orderItemId) {
        this.orderItemId = orderItemId;
    }
}
  • 订单记录类
public class MemberOrderRecord extends BaseEntity implements
        java.io.Serializable {

    private static final long serialVersionUID = 5245312106507078315L;
    private String orderSn;
    private String pickMethod;
    private ConfigOrderType orderType;
    private Integer memberId;
    private Integer checkStatus;
    private Integer orderStatus;
    private Integer paymentStatus;
    private Integer managerId;
    private Long orderTime;
    private Long paymentTime;
    private String description;
    private String remark;
    private Integer mallId;
    private List<MemberOrderItem> orderItems;
    private List<MemberOrderPaymentList> orderPaymentLists;
    private MemberOrderDelivery orderDelivery;
    private Long invalidTime;
    private Integer isRefund = 0;
    private Integer invoiced = 0;
    private String clientSource;
    private String outSerialNo;// 外部交易序列号，目前用在erp中
    private String orderHelperType;
    private String orderUndoSn;// 交易撤销编号
    private String tradeFlag; // 交易标记，判断是否成功
    private String tradeMessage;// 交易消息
    private String auditMessage; // 审核消息
    private Integer auditManagerId; // 审核管理员
    private MallInfo pickMallInfo;  //提货门店

    @Column(name = "order_sn", unique = true, nullable = false, length = 100)
    public String getOrderSn() {
        return this.orderSn;
    }

    public void setOrderSn(String orderSn) {
        this.orderSn = orderSn;
    }

    @Column(name = "pick_method", nullable = false, length = 25)
    public String getPickMethod() {
        return this.pickMethod;
    }

    public void setPickMethod(String pickMethod) {
        this.pickMethod = pickMethod;
    }

    @Column(name = "member_id", nullable = false)
    public Integer getMemberId() {
        return this.memberId;
    }

    public void setMemberId(Integer memberId) {
        this.memberId = memberId;
    }

    @Column(name = "order_status", nullable = false)
    public Integer getOrderStatus() {
        return orderStatus;
    }

    public void setOrderStatus(Integer orderStatus) {
        this.orderStatus = orderStatus;
    }

    @Column(name = "payment_status", nullable = false)
    public Integer getPaymentStatus() {
        if (paymentStatus != OrderConstants.ORDER_PAYMENT_STATUS_PAYED
                && paymentStatus != OrderConstants.ORDER_PAYMENT_STATUS_CLOSED) {
            // 未支付的情况下根据各个支付方式的支付记录得到支付状态
            int status = OrderConstants.ORDER_PAYMENT_STATUS_WAIT_PAY;
            boolean hasPayed = false;
            boolean hasWaitpay = false;
            boolean hasVerify = false;
            int closeCount = 0;
            List<MemberOrderPaymentList> paymentLists = getOrderPaymentLists();
            if (paymentLists != null && !paymentLists.isEmpty()) {

                for (MemberOrderPaymentList memberOrderPaymentList : paymentLists) {
                    if (memberOrderPaymentList.getStatus() == OrderConstants.ORDER_PAYMENT_STATUS_WAIT_PAY) {
                        hasWaitpay = true;
                    } else if (memberOrderPaymentList.getStatus() == OrderConstants.ORDER_PAYMENT_STATUS_PAYED
                            || memberOrderPaymentList.getStatus() == OrderConstants.ORDER_PAYMENT_STATUS_FINISHED) {
                        hasPayed = true;
                    } else if (memberOrderPaymentList.getStatus() == OrderConstants.ORDER_PAYMENT_STATUS_CLOSED) {
                        closeCount++;
                    } else if (memberOrderPaymentList.getStatus()
                            == OrderConstants.ORDER_PAYMENT_STATUS_PAY_VERIFYING) {
                        hasVerify = true;
                    }
                }
                if (hasWaitpay) {
                    // 在未支付状态下，有支付或支付确认中，则为部分支付
                    if (hasPayed || hasVerify) {
                        status = OrderConstants.ORDER_PAYMENT_STATUS_PARTIAL_PAYED;
                    }

                } else if (hasPayed) {
                    // 有支付完成，有关闭，则为取消中，非退款，退款处理时，订单状态不变
                    if (closeCount > 0) {
                        status = OrderConstants.ORDER_PAYMENT_STATUS_PARTIAL_CLOSED;
                    } else {
                        // 在有支付完成的状态下，有支付确认中，且没有取消，则为支付确认中。
                        if (hasVerify) {
                            status = OrderConstants.ORDER_PAYMENT_STATUS_PAY_VERIFYING;
                        } else {
                            status = OrderConstants.ORDER_PAYMENT_STATUS_PAYED;
                        }
                    }
                } else if (closeCount == paymentLists.size()) {
                    // 订单关闭
                    status = OrderConstants.ORDER_PAYMENT_STATUS_CLOSED;
                } else if (hasVerify) {
                    // 仅剩支付确认中
                    status = OrderConstants.ORDER_PAYMENT_STATUS_PAY_VERIFYING;
                }

                paymentStatus = status;
            } else {
                paymentStatus = OrderConstants.ORDER_PAYMENT_STATUS_WAIT_PAY;
            }
        }
        return paymentStatus;
    }

    public void setPaymentStatus(Integer paymentStatus) {
        this.paymentStatus = paymentStatus;
    }

    @Column(name = "manager_id")
    public Integer getManagerId() {
        return this.managerId;
    }

    public void setManagerId(Integer managerId) {
        this.managerId = managerId;
    }

    @Column(name = "order_time", nullable = false)
    public Long getOrderTime() {
        return this.orderTime;
    }

    public void setOrderTime(Long orderTime) {
        this.orderTime = orderTime;
    }

    @Column(name = "payment_time")
    public Long getPaymentTime() {
        return this.paymentTime;
    }

    public void setPaymentTime(Long paymentTime) {
        this.paymentTime = paymentTime;
    }

    @Column(name = "description")
    public String getDescription() {
        return this.description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    @Column(name = "remark")
    public String getRemark() {
        return this.remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    @ManyToOne
    @JoinColumn(name = "order_type")
    public ConfigOrderType getOrderType() {
        return orderType;
    }

    public void setOrderType(ConfigOrderType orderType) {
        this.orderType = orderType;
    }

    @Column(name = "check_status")
    public Integer getCheckStatus() {
        return checkStatus;
    }

    public void setCheckStatus(Integer checkStatus) {
        this.checkStatus = checkStatus;
    }

    public Integer getMallId() {
        return mallId;
    }

    public void setMallId(Integer mallId) {
        this.mallId = mallId;
    }

    @OneToMany(cascade = CascadeType.ALL, mappedBy = "orderRecord", fetch = FetchType.LAZY)
    public List<MemberOrderItem> getOrderItems() {
        return orderItems;
    }

    public void setOrderItems(List<MemberOrderItem> orderItems) {
        this.orderItems = orderItems;
    }

    @OneToMany(cascade = CascadeType.ALL, mappedBy = "orderRecord", fetch = FetchType.LAZY)
    public List<MemberOrderPaymentList> getOrderPaymentLists() {
        return orderPaymentLists;
    }

    public void setOrderPaymentLists(
            List<MemberOrderPaymentList> orderPaymentLists) {
        this.orderPaymentLists = orderPaymentLists;
    }

    @OneToOne(cascade = CascadeType.ALL, mappedBy = "orderRecord", fetch = FetchType.LAZY)
    public MemberOrderDelivery getOrderDelivery() {
        return orderDelivery;
    }

    public void setOrderDelivery(MemberOrderDelivery orderDelivery) {
        this.orderDelivery = orderDelivery;
    }

    public Long getInvalidTime() {
        return invalidTime;
    }

    public void setInvalidTime(Long invalidTime) {
        this.invalidTime = invalidTime;
    }

    public Integer getIsRefund() {
        return isRefund;
    }

    public void setIsRefund(Integer isRefund) {
        this.isRefund = isRefund;
    }

    public Integer getInvoiced() {
        return invoiced;
    }

    public void setInvoiced(Integer invoiced) {
        this.invoiced = invoiced;
    }

    public String getClientSource() {
        return clientSource;
    }

    public void setClientSource(String clientSource) {
        this.clientSource = clientSource;
    }

    public String getOutSerialNo() {
        return outSerialNo;
    }

    public void setOutSerialNo(String outSerialNo) {
        this.outSerialNo = outSerialNo;
    }

    public String getOrderHelperType() {
        return orderHelperType;
    }

    public void setOrderHelperType(String orderHelperType) {
        this.orderHelperType = orderHelperType;
    }

    public String getOrderUndoSn() {
        return orderUndoSn;
    }

    public void setOrderUndoSn(String orderUndoSn) {
        this.orderUndoSn = orderUndoSn;
    }

    public String getTradeFlag() {
        return tradeFlag;
    }

    public void setTradeFlag(String tradeFlag) {
        this.tradeFlag = tradeFlag;
    }

    public String getTradeMessage() {
        return tradeMessage;
    }

    public void setTradeMessage(String tradeMessage) {
        this.tradeMessage = tradeMessage;
    }

    public String getAuditMessage() {
        return auditMessage;
    }

    public void setAuditMessage(String auditMessage) {
        this.auditMessage = auditMessage;
    }

    public Integer getAuditManagerId() {
        return auditManagerId;
    }

    public void setAuditManagerId(Integer auditManagerId) {
        this.auditManagerId = auditManagerId;
    }

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "pick_mall_id")
    public MallInfo getPickMallInfo() {
        return pickMallInfo;
    }

    public void setPickMallInfo(MallInfo pickMallInfo) {
        this.pickMallInfo = pickMallInfo;
    }

    @Transient
    public Integer getTotalPaymentFee() {
        List<MemberOrderPaymentList> paymentLists = getOrderPaymentLists();
        if (paymentLists != null && !paymentLists.isEmpty()) {
            int totalFee = 0;
            boolean hasFee = false;
            for (MemberOrderPaymentList memberOrderPaymentList : paymentLists) {
                // 只有fee时按fee计算
                if (memberOrderPaymentList.getPaymentFee() != null) {
                    totalFee += memberOrderPaymentList.getPaymentFee();
                    hasFee = true;
                }
            }
            return hasFee ? totalFee : null;
        } else {
            return null;
        }
    }

    @Transient
    public Integer getTotalPaymentValue() {
        List<MemberOrderPaymentList> paymentLists = getOrderPaymentLists();
        if (paymentLists != null && !paymentLists.isEmpty()) {
            int totalValue = 0;
            boolean hasValue = false;
            for (MemberOrderPaymentList memberOrderPaymentList : paymentLists) {
                // 仅有value时才按value值累计
                if (memberOrderPaymentList.getPaymentValue() != null
                        && memberOrderPaymentList.getPaymentFee() == null) {
                    totalValue += memberOrderPaymentList.getPaymentValue();
                    hasValue = true;
                }
            }
            return hasValue ? totalValue : null;
        } else {
            return null;
        }
    }

    @Transient
    public Integer getItemsTotalFee() {
        List<MemberOrderItem> orderItems = getOrderItems();
        if (orderItems != null && !orderItems.isEmpty()) {
            int totalFee = 0;
            boolean hasFee = false;
            for (MemberOrderItem memberOrderItem : orderItems) {
                if (memberOrderItem.getTotalFee() != null) {
                    totalFee += memberOrderItem.getTotalFee();
                    hasFee = true;
                }
            }
            return hasFee ? totalFee : null;
        } else {
            return null;
        }
    }

    @Transient
    public Integer getItemsTotalValue() {
        List<MemberOrderItem> orderItems = getOrderItems();
        if (orderItems != null && !orderItems.isEmpty()) {
            int totalValue = 0;
            boolean hasValue = false;
            for (MemberOrderItem memberOrderItem : orderItems) {
                if (memberOrderItem.getTotalValue() != null) {
                    totalValue += memberOrderItem.getTotalValue();
                    hasValue = true;
                }
            }
            return hasValue ? totalValue : null;
        } else {
            return null;
        }
    }

    @Transient
    public MemberOrderPaymentList getOrderPaymentList(String paymentType) {
        List<MemberOrderPaymentList> paymentLists = getOrderPaymentLists();
        if (paymentLists != null && !paymentLists.isEmpty()) {
            for (MemberOrderPaymentList memberOrderPaymentList : paymentLists) {
                if (memberOrderPaymentList.getPaymentType().equals(paymentType)) {
                    return memberOrderPaymentList;
                }
            }
        }
        return null;
    }

    @Transient
    public int getOrderPaymentListIndex(String paymentType) {
        List<MemberOrderPaymentList> paymentLists = getOrderPaymentLists();
        if (paymentLists != null && !paymentLists.isEmpty()) {
            int index = 0;
            for (MemberOrderPaymentList memberOrderPaymentList : paymentLists) {
                if (memberOrderPaymentList.getPaymentType().equals(paymentType)) {
                    return index;
                }
                index++;
            }
        }
        return 0;
    }

    @Transient
    public boolean canInvoice() {
        // 先判断订单类型是否可以开发票，在判断支付清单中是否可以开发票
        // 已开发票后不能再开
        ConfigOrderType orderType = getOrderType();
        if (invoiced == 0 && orderType.getCanInvoice() == 1) {
            List<MemberOrderPaymentList> paymentLists = getOrderPaymentLists();
            if (paymentLists != null && !paymentLists.isEmpty()) {
                for (MemberOrderPaymentList memberOrderPaymentList : paymentLists) {
                    if (memberOrderPaymentList.getCanInvoice() == 1) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    @Transient
    public boolean canRefund() {
        ConfigOrderType orderType = getOrderType();
        return orderType.getCanRefund() == 1;
    }

    @Transient
    public int getCommentStatus() {
        int commentedCount = 0;
        List<MemberOrderItem> orderItems = getOrderItems();
        for (MemberOrderItem memberOrderItem : orderItems) {
            if (memberOrderItem.getCommentStatus() == OrderConstants.ORDER_ITEM_COMMENT_STATUS_WAIT_COMMENT) {
                return OrderConstants.ORDER_ITEM_COMMENT_STATUS_WAIT_COMMENT;
            } else if (memberOrderItem.getCommentStatus() == OrderConstants.ORDER_ITEM_COMMENT_STATUS_COMMENTED) {
                commentedCount++;
            }
        }
        if (commentedCount == orderItems.size()) {
            return OrderConstants.ORDER_ITEM_COMMENT_STATUS_COMMENTED;
        } else {
            return OrderConstants.ORDER_ITEM_COMMENT_STATUS_UNAVAILABLE;
        }
    }
  • 订单支付类
public class MemberOrderPaymentList extends BaseEntity implements
        java.io.Serializable {

    // Fields

    /**
     * 
     */
    private static final long serialVersionUID = -4484332339445481397L;
    private MemberOrderRecord orderRecord;
    private String orderSn;
    private String paymentType;
    private String paymentSn;
    private Integer paymentTypeValue;
    private Integer paymentTypeFee;
    private Long paymentTime;
    private String notifyId;
    private Integer status;
    private String tradeNo;
    private String appTradeStatus;
    private String remark;
    private Integer priority;
    private Integer canInvoice;
    private String password;
    private String undoTradeNo;
    private String paymentSource; // 支付类型来源
    private Integer paymentSourceId; // 支付类型的来源Id，可以用来保存优惠券、停车券等的Id

    @JsonIgnore
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "order_id", nullable = false)
    public MemberOrderRecord getOrderRecord() {
        return orderRecord;
    }

    public void setOrderRecord(MemberOrderRecord orderRecord) {
        this.orderRecord = orderRecord;
    }

    @Column(name = "order_sn", nullable = false, length = 64)
    public String getOrderSn() {
        return this.orderSn;
    }

    public void setOrderSn(String orderSn) {
        this.orderSn = orderSn;
    }

    @Column(name = "payment_type", nullable = false, length = 20)
    public String getPaymentType() {
        return this.paymentType;
    }

    public void setPaymentType(String paymentType) {
        this.paymentType = paymentType;
    }

    @Column(name = "payment_sn", nullable = false, length = 64)
    public String getPaymentSn() {
        return this.paymentSn;
    }

    public void setPaymentSn(String paymentSn) {
        this.paymentSn = paymentSn;
    }

    @Column(name = "payment_type_value")
    public Integer getPaymentTypeValue() {
        return this.paymentTypeValue;
    }

    public void setPaymentTypeValue(Integer paymentTypeValue) {
        this.paymentTypeValue = paymentTypeValue;
    }

    @Column(name = "payment_type_fee")
    public Integer getPaymentTypeFee() {
        return this.paymentTypeFee;
    }

    public void setPaymentTypeFee(Integer paymentTypeFee) {
        this.paymentTypeFee = paymentTypeFee;
    }

    @Column(name = "payment_time")
    public Long getPaymentTime() {
        return this.paymentTime;
    }

    public void setPaymentTime(Long paymentTime) {
        this.paymentTime = paymentTime;
    }

    @Column(name = "notify_id", length = 100)
    public String getNotifyId() {
        return this.notifyId;
    }

    public void setNotifyId(String notifyId) {
        this.notifyId = notifyId;
    }

    @Column(name = "status", nullable = false)
    public Integer getStatus() {
        return this.status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    @Column(name = "trade_no", length = 100)
    public String getTradeNo() {
        return this.tradeNo;
    }

    public void setTradeNo(String tradeNo) {
        this.tradeNo = tradeNo;
    }

    public String getAppTradeStatus() {
        return appTradeStatus;
    }

    public void setAppTradeStatus(String appTradeStatus) {
        this.appTradeStatus = appTradeStatus;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    public Integer getPriority() {
        return priority;
    }

    public void setPriority(Integer priority) {
        this.priority = priority;
    }

    public Integer getCanInvoice() {
        return canInvoice;
    }

    public void setCanInvoice(Integer canInvoice) {
        this.canInvoice = canInvoice;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getUndoTradeNo() {
        return undoTradeNo;
    }

    public void setUndoTradeNo(String undoTradeNo) {
        this.undoTradeNo = undoTradeNo;
    }

    @Transient
    public Integer getPaymentFee() {
        return paymentTypeFee;
    }

    @Transient
    public Integer getPaymentValue() {
        return paymentTypeValue;
    }

    public String getPaymentSource() {
        return paymentSource;
    }

    public void setPaymentSource(String paymentSource) {
        this.paymentSource = paymentSource;
    }

    public Integer getPaymentSourceId() {
        return paymentSourceId;
    }

    public void setPaymentSourceId(Integer paymentSourceId) {
        this.paymentSourceId = paymentSourceId;
    }

}

下面开始进行业务处理
首先我们通过order的id取到数据库中的订单记录判断是否为空

   if (!memberOrderRecord.getMemberId().equals(
                addMemberOrderPaymentItemsRequest.getMemberId())
                || !memberOrderRecord.getId().equals(
                addMemberOrderPaymentItemsRequest.getOrderId())) {
            throw new OpenapiException("member order  not match",
                    OrderErrorCode.ERR_API_APP_MEMBER_ORDER_NOT_MATCH);

        }

接着我们取出订单记录中的订单支付类，然后判断支付方式是否存在，如果为空，则添加订单的支付方式，否则报出异常，订单已有支付方式

  List<MemberOrderPaymentList> memberOrderPaymentLists = memberOrderRecord
                .getOrderPaymentLists();
        if ((memberOrderPaymentLists == null || memberOrderPaymentLists
                .isEmpty())) {
            // 订单支付方式没有
            if (addMemberOrderPaymentItemsRequest == null
                    || addMemberOrderPaymentItemsRequest.getOrderPayments() == null
                    || addMemberOrderPaymentItemsRequest.getOrderPayments()
                    .isEmpty()) {
                throw new OpenapiException(
                        "member order payment items not set",
                        OrderErrorCode.ERR_API_APP_MEMBER_ORDER_PAYMENT_TYPE_NOT_SET);
            } else {
                / 添加订单支付方式
                List<OrderPaymentData> orderPaymentDatas = Lists.newArrayList();
                List<PaymentData> paymentDatas = addMemberOrderPaymentItemsRequest
                        .getOrderPayments();
                OrderDataUtils.setOrderPaymentData(orderPaymentDatas,
                        paymentDatas);
                        /**
                        public static void setOrderPaymentData(
            List<OrderPaymentData> orderPaymentDatas,
            List<PaymentData> paymentDatas) {
        for (PaymentData paymentData : paymentDatas) {
            OrderPaymentData orderPaymentData = new OrderPaymentData();
            orderPaymentData.setPaymentType(paymentData.getPaymentType());
            orderPaymentData.setPaymentTypeFee(PaymentConvertUtils
                    .convertFeeStringToInt(paymentData.getPaymentFee()));
            orderPaymentData.setPaymentTypeValue(PaymentConvertUtils
                    .convertCreditStringToInt(paymentData.getPaymentValue()));
            orderPaymentData
                    .setStatus(OrderConstants.ORDER_PAYMENT_STATUS_WAIT_PAY);
            orderPaymentData.setPassword(paymentData.getPassword());
            orderPaymentData.setPaymentSourceId(paymentData
                    .getPaymentSourceId());
            orderPaymentData.setRemark(paymentData.getRemark());
            orderPaymentDatas.add(orderPaymentData);
        }
    }
    **/

                try {
                    memberOrderRecordService.addOrderPaymentItems(
                            orderPaymentDatas, memberOrderRecord, false);
                } catch (OrderException e) {
                    logger.error("error", e);
                    throw new OpenapiException(
                            "member order add payment items failed",
                            OrderErrorCode.ERR_API_APP_MEMBER_ORDER_ADD_PAYMENT_TYPES_FAILED);
                }
            }
        } else {
            // 订单已有支付方式
            if (addMemberOrderPaymentItemsRequest != null
                    && addMemberOrderPaymentItemsRequest.getOrderPayments() != null
                    && !addMemberOrderPaymentItemsRequest.getOrderPayments()
                    .isEmpty()) {
                throw new OpenapiException(
                        "member order payment items has been set",
                        OrderErrorCode.ERR_API_APP_MEMBER_ORDER_PAYMENT_TYPE_HAS_BEEN_SET);
            }
        }
  • 其中涉及的方法在service层
    在其中，订单的值传过来后，赋值给订单支付类，订单支付类的值填充好后再加入到订单记录类中，保存订单记录类到数据库
 @Override
    @Transactional
    public boolean addOrderPaymentItems(
            List<OrderPaymentData> orderPaymentDatas,
            MemberOrderRecord orderRecord,
            boolean allowSamePaymentType) throws OrderException {
        // 订单支付
        if (orderPaymentDatas != null && !orderPaymentDatas.isEmpty()) {
            List<MemberOrderPaymentList> orderPaymentLists = createOrderPaymentItems(
                    orderPaymentDatas, orderRecord, allowSamePaymentType);
            if (orderRecord.getOrderPaymentLists() == null) {
                orderRecord.setOrderPaymentLists(orderPaymentLists);
            } else {
                orderRecord.getOrderPaymentLists().addAll(orderPaymentLists);
            }
            Integer allFee = orderRecord.getItemsTotalFee();
            Integer allValue = orderRecord.getItemsTotalValue();
            Integer paymentFee = orderRecord.getTotalPaymentFee();
            Integer paymentValue = orderRecord.getTotalPaymentValue();
            // 支付费用不能小于商品总价，可以大于。
            if ((allFee != null && (paymentFee == null || paymentFee < allFee))
                    || (allValue != null && (paymentValue == null || paymentValue < allValue))) {
                throw new OrderException("订单支付金额小于商品总价");
            }
            save(orderRecord);
            return true;
        } else {
            throw new OrderException("订单支付方式为空");
        }
    }

    private List<MemberOrderPaymentList> createOrderPaymentItems(
            List<OrderPaymentData> orderPaymentDatas,
            MemberOrderRecord orderRecord,
            boolean allowSamePaymentType) throws OrderException {
        OrderHelper orderHelper = orderHelperMap.get(orderRecord
                .getOrderHelperType());
        Set<String> orderPaymentTypes = Sets.newHashSet();
        if (orderPaymentDatas != null && !orderPaymentDatas.isEmpty()) {
            List<MemberOrderPaymentList> orderPaymentLists = Lists
                    .newArrayList();
            for (OrderPaymentData orderPaymentData : orderPaymentDatas) {
                if ((orderPaymentData.getPaymentTypeFee() == null || orderPaymentData
                        .getPaymentTypeFee() == 0)
                        && (orderPaymentData.getPaymentTypeValue() == null || orderPaymentData
                        .getPaymentTypeValue() == 0)) {
                    // 支付的fee和value都为0则忽略此支付方式的数据
                    continue;
                }
                String paymentType = orderPaymentData.getPaymentType();
                if (!allowSamePaymentType) {
                    Integer sourceId = orderPaymentData.getPaymentSourceId();
                    String key;
                    if (sourceId != null) {
                        // 使用paymentType+sourceId的方式判断是否重复
                        key = paymentType + sourceId;
                    } else {
                        key = paymentType;
                    }
                    if (orderPaymentTypes.contains(key)) {
                        throw new OrderException("订单支付方式重复", -1);
                    } else {
                        orderPaymentTypes.add(key);
                    }
                }
                MemberOrderPaymentList orderPaymentList = new MemberOrderPaymentList();
                orderPaymentList.setNotifyId(orderPaymentData.getNotifyId());
                orderPaymentList.setOrderRecord(orderRecord);
                orderPaymentList.setOrderSn(orderRecord.getOrderSn());
                orderPaymentList.setPaymentSn(orderHelper
                        .generatePaymentSn(paymentType));
                orderPaymentList.setPaymentTime(orderPaymentData
                        .getPaymentTime());
                orderPaymentList.setPaymentType(paymentType);
                // 默认情况source与type相同
                orderPaymentList.setPaymentSource(paymentType);
                orderPaymentList.setPaymentTypeFee(orderPaymentData
                        .getPaymentTypeFee());
                orderPaymentList.setPaymentTypeValue(orderPaymentData
                        .getPaymentTypeValue());
                orderPaymentList.setStatus(orderPaymentData.getStatus());
                orderPaymentList.setTradeNo(orderPaymentData.getTradeNo());
                ConfigPaymentType configPaymentType = configPaymentTypeService
                        .find(paymentType);
                orderPaymentList.setPriority(configPaymentType.getPriority());
                orderPaymentList.setCanInvoice(configPaymentType
                        .getCanInvoice());
                orderPaymentList.setPassword(orderPaymentData.getPassword());
                orderPaymentList.setPaymentSourceId(orderPaymentData
                        .getPaymentSourceId());
                orderPaymentList.setRemark(orderPaymentData.getRemark());
                checkAndExchangePaymentTypeVaueFee(orderRecord.getOrderType()
                        .getType(), orderPaymentList);
                checkPaymentItem(orderPaymentList);
                orderPaymentLists.add(orderPaymentList);
            }
            return orderPaymentLists;
        } else {
            return null;
        }
    }
  • 订单支付controller作为返回的api
    其中的bodyToObject（）方法是将请求来的json数据进行转化成AddMemberOrderPaymentItemsRequest 对象
// 支付会员订单
    @RequestMapping(value = "/{orderId}/payments", method = RequestMethod.POST, produces = "application/json;charset=UTF-8, text/plain;charset=UTF-8")
    public Object addOrderPayments(@PathVariable Integer orderId,
            HttpServletRequest request, HttpServletResponse response) {
        AddMemberOrderPaymentItemsRequest addMemberOrderPaymentItemsRequest = bodyToObject(
                AddMemberOrderPaymentItemsRequest.class, request);
        if (addMemberOrderPaymentItemsRequest == null) {
            return HttpErrorObject
                    .constructHttpErrorObject(OrderErrorCode.ERR_API_APP_ORDER_ADD_PAYMENTS_REQUEST_NULL);
        }
        return orderService.addOrderPayments(orderId,
                addMemberOrderPaymentItemsRequest);
    }

对于订单业务的理解，还需要多结合业务场景需求去完成，这儿只是订单支付的一个小程序
希望对你们有所帮助！

韩小文
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
【JavaWeb】网上蛋糕商城后台-订单管理
笔触狂放的博客
05-08 1555
以上代码中，接收浏览器的请求后，判断用户是否传递状态参数，如果没有传递，则默认查询所有订单，如果有传递状态参数，根据状态参数来查询“已付款”，“未付款”，“配送中”，“已完成”等不同状态的订单，接着需要获得用户是否传递页码，如果没有默认为查询第一页的订单，并将状态参数和页码参数作为条件传递给订单业务逻辑层执行操作。在订单管理功能中，不管处于任何状态，只要管理员点击删除按钮，则向服务器发出请求，执行删除当前订单操作。以上代码中，接收到浏览器的请求，并接收订单编号以及状态参数作为执行条件发送给业务逻辑。
购物车选择性下单的前后台实现
nylic的博客
09-21 1万+
需求是：在购物车中选择相应的商品下单，而不是所有的商品下单。 当点击去结算的时候，根据www.taotao.com/order/create.html找到后台资源，此时，可以在url后面传递选中的商品id。 首先看一下：create定位的controller，没有接受参数之前是这样的： 思路是：接收一个参数，itemIds，根据传递过来的itemId去查询，如果参数为空，
订单流程
oneslide
07-25 477
风险 1.选中支付方式和卡券信息环节，会将订单金额也POST到后台。 后台会根据orderID进行计算单价，防止恶意订单金额篡改。攻击者可选择的只有支付方式和卡券信息，后台也只需要这两个信息，即支付方式和被选中卡券的ID。 ...
购物车实现流程
w384694051的博客
08-03 1万+
1、购物车的实现流程 2、支付流程 3、下订单的业务 4、登录这个模块你考虑的是哪些业务 5、注册模块考虑的哪些方面 6、在写接口这块你会考虑到哪些问题 7.签到实现 8. 权限实现 9. API接口如何实现的  10、秒杀实现流程 11、什么样的页面需要静态缓 存对网站有利 12、商品下单后可以修改订单吗 13、用户在什么时候能评论 14、用户
一般电商的几种订单状态
热门推荐
likaibk的博客
09-18 3万+
今天又回顾起了电商里订单方面的几种状态，一下是本人自己的总结，大家多提点意见，一起学习进步 当用户点击“一键购买”或者是从购物车里点击 “去结算” ，会跳转到 “核实订单信息”  页面，当全部核实以后点击“提交订单按钮”，此时会跳转到支付页面，并且订单提交成功， 此时此刻才算刚刚开始： 订单提交成功    此时的订单状态默认为未确认 支付成功            此时订单状态为已确认
基于SpringBoot的物业管理小程序后台API设计源码
最新发布
05-28
本物业管理小程序后台API项目基于SpringBoot技术，包含66个文件，其中包括51个Java源文件、8个XML配置文件、1个Gitignore文件、1个JAR包、1个Properties文件、1个LICENSE文件、1个mvnw构建脚本、1个cmd命令文件和1个...
微信小程序后台数据API
09-10
微信小程序后台数据API是微信平台提供的一套用于微信小程序与服务器进行数据交互的接口，它使得开发者能够构建功能丰富的微信小程序应用。在实现智能饲喂后台数据对接、用户登录、注册以及数据查询等功能时，这些API...
基于FastAPI和Vue3的Python管理后台设计源码
03-29
该项目是一个快速开发的管理后台，采用了流行的技术栈，包括Python3、FastAPI、Vue3、vite2和Element Plus1.2（ElementUI）。适合用于个人学习和实践Python、JavaScript、Vue、CSS、TypeScript和HTML的开发技术。
API后台截图.rar
04-04
总结来说，这个“API后台截图.rar”压缩包提供了一个用易语言编写的后台截图功能的源代码实现，涵盖了Windows API调用、屏幕捕获、资源管理等多个方面，对于学习易语言编程和API使用的人来说具有一定的参考价值。
纯Python编写的Dash-FastAPI-Admin中后台管理系统源码
03-25
项目概述：这是一款纯Python实现的后台管理系统——Dash-FastAPI-Admin，整合了Dash和FastAPI框架，旨在为用户提供高效、便捷的中后台管理解决方案。项目主要采用Python语言编写，同时包含了JavaScript和CSS以支持...
电商系统之订单系统
emprere的博客
12-18 8900
相关阅读：如何看待 2017 年 12 月 10 日中兴通讯 42 岁研发负责人坠楼事件？【重大改革】吴恩达：孩子会识字后立马教她Python！互联网技术(java框架、...
Java开发淘宝订单系统
太匆匆
01-07 4764
话不多说，看我上传的代码 这里有源代码
后端接口开发－订单管理模块
weixin_43404791的博客
05-10 1370
第一部分: 前台接口 1. 方法范例 请求路径:　/cart/list.do 请求方法：GET 请求参数： 无 响应成功 响应失败 根据收货地址创建订单 请求路径:　/order/create.do 请求方法：POST 请求参数： shppingId,也就是收货地址编号 响应成功 { "status": 0, "data": { "orderNo": 1589034101339,　//订单编号，尽量避免并发重复 "pay
java开发关于订单如何删除问题
ajax_mck的博客
07-06 2658
在删除订单的时候,可能会包括多个订单项,这样的话就是可能会在删除的时候,有外键约束问题,解决这样的问题,如下:所以:先查询订单,然后去遍历订单,将订单中的多个订单项删除后,再删除订单.controller: /*** * * 删除用户订单信息全部信息 * * */ @RequestMapping("/del") public String delInfo(@Reque...
vue电商后台管理系统订单管理流程图
06-11
抱歉，我是一名自然语言处理模型，无法提供图片或流程图。但我可以为您提供文字描述： 1. 用户登录系统，进入订单管理模块。 2. 系统显示所有订单列表，包括订单编号、下单时间、订单状态等信息。 3. 用户可以根据订单状态筛选订单列表，如未付款、已付款、已发货等。 4. 用户可以查看每个订单的详细信息，包括订单编号、下单时间、收货人信息、商品信息、订单金额等。 5. 用户可以对订单进行操作，包括取消订单、发货、确认收货等。 6. 取消订单：用户可以在订单状态为未付款或已付款的情况下取消订单，系统会自动将该笔订单置为取消状态。 7. 发货：用户在订单状态为已付款的情况下可以进行发货操作，输入物流信息，系统会将该笔订单置为已发货状态。 8. 确认收货：用户在订单状态为已发货的情况下可以进行确认收货操作，系统会将该笔订单置为已完成状态。 9. 系统会自动将已完成的订单归档，用户可以在历史订单中查看已完成的订单。 10. 系统会对每个订单进行状态跟踪，自动更新订单状态，保证订单管理的实时性和准确性。 以上是一个简单的订单管理流程，具体实现可能会因不同的系统而有所不同。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值