利用Antlr开发状态机
Antlr不用多介绍了，只想说此乃神器也~~~
进入正题，首先是Antlr定义的语法：
grammarStateMachine;
options{
output=AST;
ASTLabelType=CommonTree;
}
tokens{
RULE_ROOT;
STATE_DECLARATION;
CASE_CLAUSE;
CASE_DECLARATION;
}
@header{packagecompiler.statemachine;}
@lexer::header{packagecompiler.statemachine;}
ruleRoot
:
stateDeclaration*EOF
->^(RULE_ROOTstateDeclaration*)
;
stateDeclaration
:
Identifier'{'caseDeclaration*'}'';'?
->^(STATE_DECLARATIONIdentifier^(CASE_CLAUSEcaseDeclaration*))
;
caseDeclaration
:
Identifier'=>'Identifier';'
->^(CASE_DECLARATIONIdentifier+)
;
Identifier
:
('A'..'Z'|'a'..'z'|'_')('A'..'Z'|'a'..'z'|'0'..'9'|'_')*
;
COMMENT
:
'//'~('\n'|'\r')*'\r'?('\n'|EOF){$channel=HIDDEN;}
|
'/*'(options{greedy=false;}:.)*'*/'{$channel=HIDDEN;}
;
WS
:
(''|'\t'|'\r'|'\u000C'|'\n'){$channel=HIDDEN;}
;
从语法定义中可以看出，我们使用时候需要输入的格式为
状态{动作=>新状态}
比如我们有业务是，商务专员填写好报价单后，提交到招标经理，招标经理审批通过后，提交到大区经理。
现在来定义我们业务中所会用到的State和Action的枚举
package compiler.statemachine;
public enum RequestState {
UnInitialized,
CommercialApplying, // 商务申请报价单
BiddingManagerAuditing, //招标经理审批报价单
CDManagerAuditing //大区经理审批报价单
}
package compiler.statemachine;
public enum RequestAction {
CommercialCreate, //商务专员创建报价单
CommercialModify, //商务专员修改报价单
CommercialCommit, //商务专员提交报价单
BiddingManagerModify, //招标经理修改报价单
BiddingManagerApprove //招标经理审批通过报价单
}两个枚举根据实际业务可以自由修改，比如招标经理拒绝报价单等
接下来是重头戏，如何解析由Antlr生成的抽象语法树！
先定义StateMachine接口
package compiler.statemachine;
import java.util.Set;
public interface StateMachine<TState, TAction> {
Set<TState> getStates() ;
Set<TAction> getActions() ;
Set<TAction> getValidActions(TState state);
TState changeState(TState currentState, TAction action);
}然后编写实现类
package compiler.statemachine;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.antlr.runtime.ANTLRStringStream;
import org.antlr.runtime.CommonTokenStream;
import org.antlr.runtime.RecognitionException;
import org.antlr.runtime.tree.Tree;
public class StateMachineImpl<TState extends Enum<TState>, TAction extends Enum<TAction>> implements StateMachine<TState, TAction>{
private Class<TState> stateType;
private Class<TAction> actionType;
private String rule;
private Map<TState,Map<TAction,TState>> dict = new HashMap<TState,Map<TAction,TState>>();
public Class<TState> getStateType() {
return stateType;
}
public void setStateType(Class<TState> stateType) {
this.stateType = stateType;
}
public Class<TAction> getActionType() {
return actionType;
}
public void setActionType(Class<TAction> actionType) {
this.actionType = actionType;
}
public String getRule() {
return rule;
}
public void setRule(String rule) {
this.rule = rule;
}
public StateMachineImpl(){
}
public StateMachineImpl(Class<TState> state,Class<TAction> action){
this.stateType = state;
this.actionType = action;
}
public void complieRule(){
StateMachineLexer lexer = new StateMachineLexer(new ANTLRStringStream(rule));
CommonTokenStream tokens = new CommonTokenStream(lexer);
StateMachineParser parser = new StateMachineParser(tokens);
try {
Tree ruleRootNode = (Tree)parser.ruleRoot().getTree();
for(int i=0;i<ruleRootNode.getChildCount();i++){
Tree stateDeclarationNode = ruleRootNode.getChild(i);
String stateText = stateDeclarationNode.getChild(0).getText();
TState state;
state = (TState) Enum.valueOf(this.stateType, stateText);
System.out.println(state.getClass());
Map<TAction,TState> nestedDict = new HashMap<TAction,TState>();
dict.put(state, nestedDict);
for(int ii=0;ii<stateDeclarationNode.getChildCount();ii++){
Tree caseClauseNode = stateDeclarationNode.getChild(ii);
for(int iii=0;iii<caseClauseNode.getChildCount();iii++){
Tree caseDeclarationNode = caseClauseNode.getChild(iii);
String actionText = caseDeclarationNode.getChild(0).getText();
String targetStateText = caseDeclarationNode.getChild(1).getText();
TAction action;
TState targetState;
action = (TAction) Enum.valueOf(this.actionType, actionText);
targetState = (TState) Enum.valueOf(this.stateType, targetStateText);
nestedDict.put(action, targetState);
}
}
}
} catch (RecognitionException e) {
e.printStackTrace();
}
}
@Override
public Set<TState> getStates() {
return dict.keySet();
}
@Override
public Set<TAction> getActions() {
Set<TAction> actionsSet = new HashSet<TAction>();
for (Map<TAction, TState> map : dict.values()) {
actionsSet.addAll(map.keySet());
}
return actionsSet;
}
@Override
public Set<TAction> getValidActions(TState state) {
if(!dict.containsKey(state)){
throw new RuntimeException("State not in the system");
}
return dict.get(state).keySet();
}
@Override
public TState changeState(TState currentState, TAction action) {
if(!dict.containsKey(currentState)){
throw new IllegalArgumentException();
}
Map<TAction,TState> rules = dict.get(currentState);
TState returnState = rules.get(action);
if(returnState==null){
throw new UnsupportedOperationException();
}
return returnState;
}
}最主要的就是complieRule方法
解析Antlr生成的抽象语法树，把状态{动作=>新状态}这样格式的字符串，转换为
Map<TState,Map<TAction,TState>>dict=newHashMap<TState,Map<TAction,TState>>()
这样的一个Map
最后编写测试类
package test.statemachine;
import java.util.Map;
import java.util.Set;
import compiler.statemachine.EnumerationStateMechineLocalObject;
import compiler.statemachine.RequestAction;
import compiler.statemachine.RequestState;
import compiler.statemachine.StateMachineImpl;
public class StateMachineTest {
public static void main(String[] args) {
StateMachineTest();
}
public static void StateMachineTest() {
StateMachineImpl<RequestState, RequestAction> stateMachine = new StateMachineImpl<RequestState, RequestAction>();
stateMachine.setRule("UnInitialized { CommercialCreate => CommercialApplying;} CommercialApplying {CommercialModify => CommercialApplying;CommercialCommit => BiddingManagerAuditing;BiddingManagerModify => CommercialApplying; BiddingManagerApprove => CDManagerAuditing; }");
stateMachine.setStateType(RequestState.class);
stateMachine.setActionType(RequestAction.class);
stateMachine.complieRule();
RequestState requestState = RequestState.CommercialApplying;
Set<RequestAction> currentActions = stateMachine.getValidActions(requestState);
if(currentActions.contains(RequestAction.BiddingManagerApprove)){
requestState = stateMachine.changeState(requestState, RequestAction.BiddingManagerApprove);
}
Set<RequestAction> actions = stateMachine.getActions();
for (RequestAction requestAction : actions) {
System.out.println(requestAction);
}
System.out.println(requestState);
}
}从代码:
stateMachine.setRule("UnInitialized{CommercialCreate=>CommercialApplying;}CommercialApplying{CommercialModify=>CommercialApplying;CommercialCommit=>BiddingManagerAuditing;BiddingManagerModify=>CommercialApplying;BiddingManagerApprove=>CDManagerAuditing;}");
可以看出输入字符串
"UnInitialized{CommercialCreate=>CommercialApplying;}CommercialApplying{CommercialModify=>CommercialApplying;CommercialCommit=>BiddingManagerAuditing;BiddingManagerModify=>CommercialApplying;BiddingManagerApprove=>CDManagerAuditing;}"
调用stateMachine.complieRule();
通过stateMachine.getValidActions得到当前状态的报价单所对应的所有可以执行的Action
例如现在招标经理要将商务提交的报价单审批通过；
则通过Set<RequestAction>currentActions=stateMachine.getValidActions(requestState);
得到所有能够执行的Action
通过if(currentActions.contains(RequestAction.BiddingManagerApprove)){
requestState=stateMachine.changeState(requestState,RequestAction.BiddingManagerApprove);
}
来改变报价单的状态从RequestStaterequestState=RequestState.CommercialApplying;
报价单状态从，商务申请中变为，大区经理审批中CDManagerAuditing
实际运用中结合Spring可以优化
StateMachineImpl<RequestState,RequestAction>stateMachine=newStateMachineImpl<RequestState,RequestAction>();
stateMachine.setStateType(RequestState.class);
stateMachine.setActionType(RequestAction.class);
stateMachine.complieRule();