java设计模式（十一）--状态模式

        早之前就研究过老大开发的订单框架，一直想把它的最核心部分用到的设计模式放到最后面来写，作为本系列博客的收官之作。这段时间决定把部门框架的演进之路作为一个系列的博客写出来，而新框架最核心的部分就是订单，在我们的金融系统里面，所有的业务请求，都被视为一笔订单。而订单的核心代码，其实就是一个状态机的实现，下面就让我以我们部门的订单状态机为例子，阐述下我对设计模式中状态模式的理解，仅供大家交流学习。

什么是状态模式？

       状态模式是指对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类，实际是转换到了另一个实现

使用场景

       1. 一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为；

       2. 一个操作中含有庞大的分支结构，并且这些分支决定于对象的装填。

类图（以当前我们的订单框架状态机为例）：

订单状态迁移路线如下：

代码结构：

在订单初始化后（将orderState初始化为init状态），进入状态机的循环，每个循环的过程不断通过状态执行器工厂OrderStateHandlerFactory获取到状态的执行器，从而去执行该执行器的execute方法，对应的状态机的循环的代码如下：

package order;

import logic.LogicRunner;
import logic.LogicType;
import orderStateHandler.OrderStateHandler;
import orderStateHandler.OrderStateHandlerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import bo.OrderContext;
import businessService.BusinessService;
import businessService.Impl.AbstractBusinessServiceImpl;

/*
 * 个人业务总入口
 */
public abstract class AbstractOrderService extends AbstractBusinessServiceImpl {
	OrderContext orderContext;

	@Override
	public void doIt(BusinessService businessService) {
		try {
			this.initOrderState();
			boolean IsInterrupt = false;
			
			while(IsInterrupt)
			{
				OrderStateHandler orderStateHandler = OrderStateHandlerFactory
						.getOrderStateHandler(businessService.getOrderContext()
								.getOrder().getOrderState().toString());

				IsInterrupt = orderStateHandler.execute(orderContext, businessService);
			}
		} catch (Exception e) 
		{
			// TODO: handle exception
		} 
		finally 
		{
			// finally
		}
	}

	private void initOrderState() {

		// 初始化bean容器
		ApplicationContext context = new ClassPathXmlApplicationContext(
				"Beans.xml");
		orderContext.setContext(context);

		// 初始化上下文
		orderContext.getOrder().setOrderState(OrderState.INIT);

		// 执行初始化logic
		LogicRunner.ChainExecutor(orderContext.getChainId(), LogicType.INIT);
	}

}

订单执行器的获取工厂实现：

package orderStateHandler;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class OrderStateHandlerFactory 
{
	public static OrderStateHandler getOrderStateHandler(String preBeanString) throws Exception 
	{
		// bean 名字的拼装,拼装规则：前置Bean名字+ServiceConvertor
		String HandlerBeanName = preBeanString + "OrderStateProcessor";

		ApplicationContext context = new ClassPathXmlApplicationContext(
				"Beans.xml");

		// 根据Bean名字，通过spring的IoC去获取实现并返回
		OrderStateHandler orderStateHandler = (OrderStateHandler) context
				.getBean(HandlerBeanName);

		// 取到哑实现，抛异常处理
		if (null == orderStateHandler) {
			throw new Exception();
		}

		return orderStateHandler;
	}

}

在获取到订单执行器后，接下来就是各个订单执行器之间跳转，以及何时从各个执行器跳转中退出的问题了，为了强制各个状态的执行器都能设置下一个状态的跳转（避免因为程序的实现忘记设置下一个跳转状态，会导致死循环的问题），同时把一些公共的处理都放到父类实现，从而避免代码重复率的问题，这里把模板方法设计模式给使用上了，写一个抽象类AbstractOrderStateHandler，把业务的公共处理都放到这里来，下个状态的设置写成一个抽象方法，这样每个状态去继承该抽象类的时候，就强制实现该抽象方法了：

package orderStateHandler;

import bo.OrderContext;
import businessService.BusinessService;

public abstract class AbstractOrderStateHandler implements OrderStateHandler
{
	// 状态执行器
	@Override
	public boolean execute(OrderContext orderContext,BusinessService businessService)
	{
		System.out.println("entering the handleOrderState:");
		
		try {
			// 各个状态的处理
			this.handle(businessService, orderContext);
			
			// 设置下个跳转节点
			this.setNextState(businessService);
			
		} catch (Exception e) {
			// TODO: handle exception
		}
		
		return orderContext.isInterruptFlow();
	}

	public abstract void handle(BusinessService businessService,OrderContext orderContext);
	public abstract void setNextState(BusinessService businessService);
}

各个状态的执行器我就不每个都贴出来了，这里只贴一个Init状态的执行器：

package orderStateHandler;

import order.OrderState;

import bo.OrderContext;
import businessService.BusinessService;

public class InitOrderStateProcessor extends AbstractOrderStateHandler
{

	@Override
	public void handle(BusinessService businessService,
			OrderContext orderContext) 
	{
		// TODO Auto-generated method stub
		System.out.println("Entering the CompleteOrderStateProcessor handle");
		
		businessService.preInit();
		
		createOrder(orderContext);
		
		InitialContext(orderContext);
		
		orderContext.setInterruptFlow(false);
	}

	@Override
	public void setNextState(BusinessService businessService) 
	{
		if(!businessService.getOrderContext().isInterruptFlow())
		{
			businessService.getOrderContext().getOrder().setOrderState(OrderState.PROCESS);
		}
	}
	
	private void createOrder(OrderContext orderContext)
	{
		System.out.println("Creating order:");
		
	}

	private void InitialContext(OrderContext orderContext)
	{
		System.out.println("Initing orderContext:");
	}
}

bean文件配置：

<?xml version="1.0" encoding="UTF-8"?>
 
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 
 		<bean id="InitOrderStateProcessor" 
			class="orderStateHandler.InitOrderStateProcessor">
 		</bean>
 	
    </beans>