工作中一个简单的状态机实现,总结如下。
定义状态:
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)