用Mediator Pattern + Queue 解决 订单处理流程

　　对旅游电子商务来说，订单处理系统是个复杂的系统，它围绕 产品，供应商，支付，配送等要素形成一套复杂的流程。

　　它涉及到不同类型的产品，如机票，酒店，门票。以价格为例 机票价格直接通过中航信系统进行确认；对于香港酒店需要实时确认价格，国内酒店则是每天确认一次；如果门票，从代理商拿的价格和从景点拿到价格是不一样的。

　　更不用说支付和配送。机票可以采用信用卡支付和Post机；酒店一般是面付+预付；门票可能是拿着换购券到景区买票。

　　面对这些复杂的问题，有没有可以行的办法。让我们分析一下。订单处理系统围绕下几个要素进行的：流程、操作、状态。

　　订单的处理流程 主要由 订单和产品决定的，同时订单流程走到哪，操作就走到哪。通常来说，我们通常此采用简单的状态机来应对，在那些状态下允许那些操作，不允许那些操作。随着业务发展会遇到各种问题：如上下游节点耦合，流程变化引起的更变点多。

　　如何解决这个问题。我的方案就是使用 Mediator Pattern + Queue.

　　OperationQueue是 订单操作队列，存放 需要进行某种操作的订单。比如比如payQueue 说明 订单可以进行支付；deliverQueue说明可以进行配送。它的实现方式有很多种，根据不要的需要可以存在JVM，DB，Cached。

　　OperationQueue的核心方法为：

　　　　getName()：返回队列名称。

　　　　addOrderToQueue：把订单添加到队列中。

　　　　removeOrder：订单要在各种操作队列中转移，需要删除队列中的旧订单。

　　　　findOrder：获取指定订单。

　　OrderFlowMediator 根据各种状态，决定order应该到哪种操作队列中。　　

　　　　核心方法：dispathOrder(Order)，转发订单到不同的操作队列中，他必须在业务操作完成之后才能调用，简单的说法，就是业务数据持久化后，才能调用。

 

　　相关代码如下：

package com.ming.article.pattern.order.mediator;

import com.ming.article.pattern.order.Order;

public interface OperationQueue {

    public String getName();

    public void addOrderToQueue(Order order);

    public void removeOrder(Order order);

    public Order findOrder(Order order);

}

 

package com.ming.article.pattern.order.mediator;

import java.util.LinkedList;

import com.ming.article.pattern.order.Order;


public class MemoryOperationQueue implements OperationQueue {

    private String name ;
    private LinkedList<Order> list = new LinkedList<Order>();
    
    public MemoryOperationQueue(String name){
        this.name = name;
    }
    @Override
    public String getName() {
        return name;
    }
    @Override
    public void addOrderToQueue(Order order) {
        list.addLast(order);
    }

    @Override
    public void removeOrder(Order order) {
        list.remove(order);
        
    }
    @Override
    public Order findOrder(Order order) {
        for(Order o:list){
            if(o.equals(order)) return o;
        }
        return null;
    }

}

 

package com.ming.article.pattern.order.mediator;
/**
 * 订单操作队列
 * @author martin.chen
 *
 */
public class OrderOperationQueue {
    /**
     * 与客户确认订单队列
     * 客户下完订单后，需要确认 出行人的各种信息
     */
    private OperationQueue confrimCustomer =new MemoryOperationQueue("confrimCustomer");
    
    /**
     * 与供应商资源队列
     * 客户预订的订单后，还需要跟供应商确认产品是否可以提供
     */
    private OperationQueue confirmResoruce =new MemoryOperationQueue("confrimResource");
    
    /**
     * 进行支付队列
     * 确认客户和供应商之后，才可以进行付款
     */
    private OperationQueue payQueue =new MemoryOperationQueue("pay");
    
    /**
     * 配送产品队列
     * 付款成功后，就可以进行配送
     */
    private OperationQueue deliverQueue = new MemoryOperationQueue("delivery");

    public OperationQueue getConfrimCustomer() {
        return confrimCustomer;
    }

    public OperationQueue getConfirmResoruce() {
        return confirmResoruce;
    }

    public OperationQueue getPayQueue() {
        return payQueue;
    }

    public OperationQueue getDeliverQueue() {
        return deliverQueue;
    }

}

 

package com.ming.article.pattern.order.mediator;


import com.ming.article.pattern.order.Order;
import com.ming.article.pattern.order.OrderStatus;

public class OrderFlowMediator {

    
    OrderOperationQueue operatioinQueue = new OrderOperationQueue();
            
    /**
     * 转发订单到不同的队列
     * @param order
     */
    public void dispathOrder(Order order){
        
        
        //清楚
        if(order.getOrderStatus().equals(OrderStatus.Commited) && !order.isConfirmCustomer()){
        
            operatioinQueue.getConfrimCustomer().addOrderToQueue(order);
            return;
        }
        
        if(order.getOrderStatus().equals(OrderStatus.Commited) && !order.isConfirmResource()){
            operatioinQueue.getConfirmResoruce().addOrderToQueue(order);
            operatioinQueue.getConfrimCustomer().removeOrder(order);
            return;
        }
        
        if(order.getOrderStatus().equals(OrderStatus.Commited) 
                && order.isConfirmCustomer() && order.isConfirmResource()
                && !order.isPaid()){
            operatioinQueue.getPayQueue().addOrderToQueue(order);
            operatioinQueue.getConfirmResoruce().removeOrder(order);

            return;
        }
        if(order.getOrderStatus().equals(OrderStatus.Commited) 
                && !order.isDelivered()){
            operatioinQueue.getDeliverQueue().addOrderToQueue(order);
            operatioinQueue.getPayQueue().removeOrder(order);

            return;
        }
        
    }

    public OrderOperationQueue getQueue(){
        return operatioinQueue;
    }

}

 

package com.ming.article.pattern.order;

import com.ming.article.pattern.order.mediator.OrderFlowMediator;


public class OrderDCI {

    private OrderFlowMediator mediator;
    
    public OrderDCI(OrderFlowMediator mediator){
        this.mediator =  mediator;
    }
    public void confirmCustomer(Order order,Object params) {
        order.setConfirmCustomer(true);
        System.out.println("确认客户成功");
        mediator.dispathOrder(order);
    }

    public void confirmResource(Order order,Object params) {
        
        order.setConfirmResource(true);
        System.out.println("确认资源成功");    
        mediator.dispathOrder(order);
    }

    public void payOrder(Order order,Object params) {
        order.setPaid(true);
        System.out.println("支付成功");    
        mediator.dispathOrder(order);
        
    }

    public void deliveryOrder(Order order,Object params) {
        order.setDelivered(true);
        System.out.println("配送成功");    
        mediator.dispathOrder(order);
        
    }
}

 

package com.ming.article.pattern.order;
public class Order {

    private OrderStatus  orderStatus = OrderStatus.Draft;
    private boolean confirmResource = false;
    private boolean confirmCustomer = false;
    private boolean paid  = false;
    private boolean delivered = false;
    public OrderStatus getOrderStatus() {
        return orderStatus;
    }
    public void setOrderStatus(OrderStatus orderStatus) {
        this.orderStatus = orderStatus;
    }
    public boolean isConfirmResource() {
        return confirmResource;
    }
    public void setConfirmResource(boolean confirmResource) {
        this.confirmResource = confirmResource;
    }
    public boolean isConfirmCustomer() {
        return confirmCustomer;
    }
    public void setConfirmCustomer(boolean confirmCustomer) {
        this.confirmCustomer = confirmCustomer;
    }
    public boolean isPaid() {
        return paid;
    }
    public void setPaid(boolean paid) {
        this.paid = paid;
    }
    public boolean isDelivered() {
        return delivered;
    }
    public void setDelivered(boolean delivered) {
        this.delivered = delivered;
    }

}

 

package com.ming.article.pattern.order;
public enum OrderStatus {

    Draft,//草稿
    Commited,//提交
    Finish;//完成
}

　　测试代码如下：

package com.ming.article.pattern.order;

import org.junit.Test;

import com.ming.article.pattern.order.mediator.OrderFlowMediator;

public class OrderMediatorTest {

    private OrderFlowMediator mediator = new OrderFlowMediator();
    private OrderDCI dci = new OrderDCI(mediator);

    @Test
    public void test() {
        // 提交订单
        Order order = new Order();
        order.setOrderStatus(OrderStatus.Commited);
        mediator.dispathOrder(order);

        // 确认客户
        Order order1 = mediator.getQueue().getConfrimCustomer()
                .findOrder(order);
        dci.confirmCustomer(order1, "Tom");

        Order order2 = mediator.getQueue().getConfirmResoruce()
                .findOrder(order);
        dci.confirmResource(order2, null);

        // 支付
        Order order3 = mediator.getQueue().getPayQueue().findOrder(order);
        dci.payOrder(order3, null);

        // 支付
        Order order4 = mediator.getQueue().getDeliverQueue().findOrder(order);
        dci.deliveryOrder(order4, null);

    }
}