一个简单的状态机总结

工作中一个简单的状态机实现，总结如下。

定义状态：

public enum Qstate{
		ORDER(1),  
		CANCEL(2); 
		
		private int code;
		
		private Qstate(int code){
			this.code = code;
		}
		public int getCode(){
			return code;
		}
	}
	
	public enum Vstate{
		INIT(1),  
		ORDER(2), 
		CHECKSTOCK(3), 
		CANCEL_VENDOR(4), 
		CANCEL_USER(5), 
		OVER(6), 
		STARTSERVICE(7);
		private int code;
		private Vstate(int code){
			this.code = code;
		}
		public int getCode(){
			return code;
		}
	}

public enum State{
		ORDER_INIT(Qstate.ORDER, Vstate.INIT), 
		ORDER_ORDER(Qstate.ORDER, Vstate.ORDER), 
		ORDER_CHECKSTOCK(Qstate.ORDER, Vstate.CHECKSTOCK), 
		ORDER_STARTSERVICE(Qstate.ORDER, Vstate.STARTSERVICE), 
		ORDER_OVER(Qstate.ORDER, Vstate.OVER),  
		ORDER_VENDORCANCEL(Qstate.ORDER, Vstate.CANCEL_VENDOR), 
		CANCEL_ORDER(Qstate.CANCEL, Vstate.ORDER), 
		CANCEL_CHECKSTOCK(Qstate.CANCEL, Vstate.CHECKSTOCK), 
		CANCEL_USERCANCEL(Qstate.CANCEL, Vstate.CANCEL_USER); 
		
		private Qstate q;
		private Vstate v;
		
		private State(Qstate q, Vstate v){
			this.q = q;
			this.v = v;
		}
		public int getCode(){
			return (q.code * 100) + v.code;
		}
		public int getQCode() {
			return q.code;
		}
		public int getVCode() {
			return v.code;
		}
	}

 定义事件：

public enum Event{
		VORDER, 
		VORDER_AUTOCHECKHAVE,
		VORDER_AUTOCHECKNO,
		TIMEOUT_NOPAY,
		TIMEOUT_NOCHECKSTOCK,
		USER_CANCEL_ORDER, 
		V_CANCEL_ORDER, 
		CHECKSTOCK_HAVE,
		CHECKSTOCK_NO,
		APPLY_PAY,
		GET_CAR, 
		KEEP_ORDER,
		NOSHOW,
		RETURN_CAR; 
	}

 定义返回值：

public enum StateChgCode{
		OK_STATE_CHG, //状态流转
		OK_STATE_NO_CHG, //状态不流转
		ERROR; //状态错误不能流转
}

public class StateChgRet{
		private StateChgCode code;
		private State newState;
		
		public StateChgRet(StateChgCode code, State newState){
			this.code = code;
			this.newState = newState;
		}

		public StateChgCode getCode(){
			return code;
		}

		public State getNewState() {
			return newState;
		}
		
		@Override
		public String toString(){
			return String.valueOf(code) + "---" + String.valueOf(newState) + "---" + newState.getCode();
		}
	}

 获取当前状态：

public State getState(int qState, int vState){
			if (1 == qState){
				switch (vState){
				case 1:
					return State.ORDER_INIT;
				case 2:
					return State.ORDER_ORDER;
				case 3:
					return State.ORDER_CHECKSTOCK;
				case 4:
					return State.ORDER_VENDORCANCEL;
				case 6:
					return State.ORDER_OVER;
				case 7:
					return State.ORDER_STARTSERVICE;
				case 5:
					default:
						throw new IllegalStateException("invalid vState:" + vState);
				}
			}else if (2 == qState){
				switch (vState){
				case 2:
					return State.CANCEL_ORDER;
				case 3:
					return State.CANCEL_CHECKSTOCK;
				case 5:
					return State.CANCEL_USERCANCEL;
				case 1:
				case 4:
				case 6:
				case 7:
					default:
						throw new IllegalStateException("invalid vState:" + vState);
				}
			}
		throw new IllegalStateException("invalid qState:" + qState);
	}

 状态变更（当前状态+事件）：

public StateChgRet stateChg(State curState, Event event){
			if (null != curState && null != event){
				StateChgRet ret = null;
				switch(event){
				case VORDER:
					ret = onVorder(curState);
					break;
				case TIMEOUT_NOPAY:
					ret = onTimeOutNoPay(curState);
					break;
				case TIMEOUT_NOCHECKSTOCK:
					ret = onTimeOutNoCheckStock(curState);
					break;
				case USER_CANCEL_ORDER:
					ret = onUserCancelOrder(curState);
					break;
				case V_CANCEL_ORDER:
					ret = onVendorCancelOrder(curState);
					break;
				case CHECKSTOCK_HAVE:
					ret = onCheckStockHave(curState);
					break;
				case CHECKSTOCK_NO:
					ret = onCheckStockNo(curState);
					break;
				case APPLY_PAY:
					ret = onApplyPay(curState);
					break;
				case KEEP_ORDER:
					ret = onKeepOrder(curState);
					break;
				//...太长省略一部分
					default:
						throw new IllegalStateException("Illegal state:" + curState);
				}
				return ret;
			}
			throw new IllegalStateException("param error!");
	}

 触发操作方法，返回流转后的状态：

private StateChgRet onVorder(State curState){
		switch(curState){
		case ORDER_INIT:
			return baseMgr.new StateChgRet(StateChgCode.OK_STATE_CHG, State.ORDER_ORDER); //状态可流转，流转到State.ORDER_ORDER状态
		case ORDER_ORDER:
		case ORDER_CHECKSTOCK:
		case ORDER_STARTSERVICE:
		case ORDER_OVER:
		case CANCEL_ORDER:
		case CANCEL_CHECKSTOCK:
		case ORDER_VENDORCANCEL:
		case CANCEL_USERCANCEL://状态不流转
			return baseMgr.new StateChgRet(StateChgCode.ERROR, null);
			default:
				throw new IllegalStateException("Illegal state:" + curState);
		}
}
//...

操作方法不一一列出，其它方法与onVendor()方法类似。

这个状态机通过当前状态currentState及对应的事件Event，获取状态返回值StateChgRet，StateChgRet类中包含了状态是否可以流转，以及流转后的状态是什么。

但本状态机与设计模式中的状态模式其实关系不大，因为只是通过switch-case语句进行判断而已（与if-else其实一样）。

设计模式中的状态模式定义：把不同状态的操作分散到不同的状态对象中去完成。

见我的另一篇blog：设计模式回顾之七：状态模式(State)