用MediatorPattern+Queue解决订单处理流程

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 list &＃61; new LinkedList();

public MemoryOperationQueue(String name){
this.name &＃61; name;
}
&＃64;Override
public String getName() {
return name;
}
&＃64;Override
public void addOrderToQueue(Order order) {
list.addLast(order);
}

&＃64;Override
public void removeOrder(Order order) {
list.remove(order);

}
&＃64;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;
/**
* 订单操作队列
* &＃64;author martin.chen
*
*/
public class OrderOperationQueue {
/**
* 与客户确认订单队列
* 客户下完订单后&＃xff0c;需要确认 出行人的各种信息
*/
private OperationQueue confrimCustomer &＃61;new MemoryOperationQueue("confrimCustomer");

/**
* 与供应商资源队列
* 客户预订的订单后&＃xff0c;还需要跟供应商确认产品是否可以提供
*/
private OperationQueue confirmResoruce &＃61;new MemoryOperationQueue("confrimResource");

/**
* 进行支付队列
* 确认客户和供应商之后&＃xff0c;才可以进行付款
*/
private OperationQueue payQueue &＃61;new MemoryOperationQueue("pay");

/**
* 配送产品队列
* 付款成功后&＃xff0c;就可以进行配送
*/
private OperationQueue deliverQueue &＃61; 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 &＃61; new OrderOperationQueue();

/**
* 转发订单到不同的队列
* &＃64;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 &＃61; 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 &＃61; OrderStatus.Draft;
private boolean confirmResource &＃61; false;
private boolean confirmCustomer &＃61; false;
private boolean paid &＃61; false;
private boolean delivered &＃61; false;
public OrderStatus getOrderStatus() {
return orderStatus;
}
public void setOrderStatus(OrderStatus orderStatus) {
this.orderStatus &＃61; orderStatus;
}
public boolean isConfirmResource() {
return confirmResource;
}
public void setConfirmResource(boolean confirmResource) {
this.confirmResource &＃61; confirmResource;
}
public boolean isConfirmCustomer() {
return confirmCustomer;
}
public void setConfirmCustomer(boolean confirmCustomer) {
this.confirmCustomer &＃61; confirmCustomer;
}
public boolean isPaid() {
return paid;
}
public void setPaid(boolean paid) {
this.paid &＃61; paid;
}
public boolean isDelivered() {
return delivered;
}
public void setDelivered(boolean delivered) {
this.delivered &＃61; 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 &＃61; new OrderFlowMediator();
private OrderDCI dci &＃61; new OrderDCI(mediator);

&＃64;Test
public void test() {
// 提交订单
Order order &＃61; new Order();
order.setOrderStatus(OrderStatus.Commited);
mediator.dispathOrder(order);

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

Order order2 &＃61; mediator.getQueue().getConfirmResoruce()
.findOrder(order);
dci.confirmResource(order2, null);

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

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

}
}