流程图状态机DEMO（附件wf-statemachine-demo.rar下载）

这是我写的一个DEOM，目的在于对 

 

jquery 简易的流程图编辑控件 新版（20100907）

的一个流程支持而写的状态机DEMO

 

表达式使用IK EXPRESSION，以后会支持EL，也可能会支持JS，或者其他的脚本语言

 

没有测试，默认实现还有错误，以后会更新稳定版本的

 

下面是其中的部分代码：

 

 

package keng.core.workflow.state.impl;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;
import java.util.concurrent.TimeoutException;

import keng.core.util.StringUtil;
import keng.core.workflow.state.ISMActionProcessor;
import keng.core.workflow.state.ISMContext;
import keng.core.workflow.state.ISMListener;
import keng.core.workflow.state.ISMNode;
import keng.core.workflow.state.ISMTransition;
import keng.core.workflow.state.ISMTransitionMatcher;
import keng.core.workflow.state.IStateMachine;
import keng.core.workflow.state.StateMachineException;

/**
 * 默认的状态机实现
 * 
 * @author 5Di
 * 
 */
public class DefaultStateMachine implements IStateMachine {

	/**
	 * 自动节点的默认动作
	 */
	public static final String ACTION_DEFAULT = "send";

	/**
	 * 进入循环后的最大循环次数
	 */
	public static final int MAX_DEEPTH = 6;

	// --------------------

	Stack<ISMNode> register = new Stack<ISMNode>();

	ISMTransitionMatcher matcher;

	ISMContext context;

	ISMActionProcessor processor;

	List<ISMListener> listeners;

	/**
	 * 根节点
	 */
	ISMNode nodeMap;

	boolean strict = false;

	public DefaultStateMachine(ISMNode nodeMap, ISMContext context) {
		this.context = context;
		this.nodeMap = nodeMap;
	}

	public DefaultStateMachine(ISMNode nodeMap, ISMContext context,
			ISMTransitionMatcher matcher) {
		this.nodeMap = nodeMap;
		this.context = context;
		this.matcher = matcher;
	}

	public DefaultStateMachine(ISMNode nodeMap, ISMContext context,
			ISMTransitionMatcher matcher, boolean strict) {
		this.context = context;
		this.nodeMap = nodeMap;
		this.matcher = matcher;
		this.strict = strict;
	}

	@Override
	public boolean transit(ISMNode node, String action, String state)
			throws StateMachineException, TimeoutException {
		if (action == null || action.isEmpty())
			throw new IllegalArgumentException("action can not be empty!");

		if (StringUtil.isEmpty(state))
			throw new IllegalArgumentException("state can not be empty!");

		if (node == null)
			throw new IllegalArgumentException("node can not be null!");

		List<ISMTransition> transitions = node.getTransitions();

		if (transitions == null || transitions.isEmpty())
			throw new StateMachineException("transitions can not be empty !");

		// 检查节点图，限制自动节点的转化深度
		if (node.isAuto())
			if (!checkNodeMap(node))
				throw new TimeoutException("die cycle");

		boolean b = false;
		for (ISMTransition transition : transitions) {
			boolean bool = transit(transition, action, state, node);

			if (bool) {
				b = true;
				if (register.indexOf(node) == -1)
					register.push(node);

				this.fireNodeTransit(node, state, transition.getToState());

				if (node.isAuto())
					this.fireAutoNodeTransit(node, state,
							transition.getToState());
			}
		}

		transitNextAutoNodes(node);

		return b;
	}

	/**
	 * 转换 parent的直接下级自动节点<br />
	 * 当遇到非自动节点时，自动结束
	 * 
	 * @param parent
	 * @throws StateMachineException
	 * @throws TimeoutException
	 */
	void transitNextAutoNodes(ISMNode parent) throws StateMachineException,
			TimeoutException {
		List<ISMNode> children = parent.getNextAutoNodes();
		if (children != null && !children.isEmpty()) {
			for (ISMNode child : children) {
				String action = child.getAction();

				if (action == null || action.isEmpty())
					action = ACTION_DEFAULT;

				transit(child, action, child.getState());
			}
		}
	}

	/**
	 * 
	 * @param transition
	 * @param action
	 * @param state
	 * @param node
	 * @return
	 * @throws StateMachineException
	 * @throws TimeoutException
	 * 
	 * @return 该transition 是否被执行
	 */
	boolean transit(ISMTransition transition, String action, String state,
			ISMNode node) throws StateMachineException, TimeoutException {
		boolean b = matcher.match(context, transition, action, state, strict);

		this.fireTransitionMatch(action, state, transition, b);

		if (!b)
			return false;
		else {
			this.fireTransitionMatched(action, state, transition);
		}

		// process action
		processor.process(transition);

		node.setState(transition.getToState());
		return true;
	}

	/**
	 * 检查节点图,防止进入死循环<br />
	 * 
	 * @param node
	 * @return 是否成功
	 */
	public boolean checkNodeMap(ISMNode node) {
		int i = 0;

		Iterator<ISMNode> it = register.iterator();
		while (it.hasNext()) {
			i = node.equals(it.next()) ? i + 1 : i;
		}

		return i <= MAX_DEEPTH;
	}

	@Override
	public boolean removeListener(ISMListener listener) {
		if (listeners == null || listeners.isEmpty())
			return false;

		if (!listeners.contains(listener))
			return false;

		listeners.remove(listener);

		return true;
	}

	@Override
	public void addListener(ISMListener listener) {
		if (listeners == null)
			listeners = new ArrayList<ISMListener>();

		listeners.add(listener);
	}

	@Override
	public boolean existsListener(ISMListener listener) {
		if (listeners == null || listeners.isEmpty())
			return false;

		return listeners.contains(listener);
	}

	/**
	 * 响应事件
	 * 
	 * @param node
	 * @param fromState
	 * @param toState
	 */
	void fireNodeTransit(ISMNode node, String fromState, String toState) {
		if (listeners == null || listeners.isEmpty())
			return;

		for (ISMListener listener : listeners)
			listener.onNodeTransit(node, fromState, toState);
	}

	/**
	 * 
	 * @param node
	 * @param fromState
	 * @param toState
	 */
	void fireAutoNodeTransit(ISMNode node, String fromState, String toState) {
		if (listeners == null || listeners.isEmpty())
			return;

		for (ISMListener listener : listeners)
			listener.onAutoNodeTransit(node, fromState, toState);
	}

	/**
	 * 响应事件
	 * 
	 * @param action
	 * @param state
	 * @param transition
	 * @param matched
	 */
	void fireTransitionMatch(String action, String state,
			ISMTransition transition, boolean matched) {
		if (listeners == null || listeners.isEmpty())
			return;

		for (ISMListener listener : listeners)
			listener.onTransitionMatch(action, state, transition, matched);
	}

	/**
	 * 响应事件
	 * 
	 * @param action
	 * @param state
	 * @param transition
	 */
	void fireTransitionMatched(String action, String state,
			ISMTransition transition) {
		if (listeners == null || listeners.isEmpty())
			return;

		for (ISMListener listener : listeners)
			listener.onTransitionMatched(action, state, transition);
	}
}

 

 

 

package keng.core.workflow.state;

import java.util.concurrent.TimeoutException;

/**
 * 状态机模型
 * 
 * @author 5Di
 * 
 */
public interface IStateMachine {

	/**
	 * 执行<br />
	 * 挨个try transition ，遇到第一个成功，理解返回<br />
	 * 执行逻辑：先匹配action 和 fromState ,然后calculate condition <br />
	 * 匹配策略，先匹配action,再匹配fromState，最后是condition<br />
	 * 
	 * @param action
	 *            当前执行的行为
	 * 
	 * @param state
	 *            当前的状态
	 * @param node
	 *            当前操作的节点
	 * 
	 * @return 是否被执行（如果自动执行的子节点返回了false，也会返回false），false并不说明没有成功，因为如果步骤进入了死循环（
	 *         系统自动执行的的步骤之间会进入死循环） ，在这种情况下不会抛出异常，而是直接返回false
	 */
	public boolean transit(String action, String state, ISMNode node)
			throws StateMachineException, TimeoutException;

}

 

 

 

package keng.core.workflow.state;

/**
 * 状态机条件
 * 
 * @author 5Di
 * 
 */
public interface ISMTransition {

	/**
	 * 条件
	 * 
	 * @return
	 */
	public ISMCondition getCondition();

	/**
	 * 动作
	 * 
	 * @return
	 */
	public String getAction();

	/**
	 * 处理器
	 * 
	 * @return
	 */
	public ISMActionProcessor getActionProcessor();

	/**
	 * 原始状态
	 * 
	 * @return
	 */
	public String getFromState();

	/**
	 * 目标状态
	 * 
	 * @return
	 */
	public String getToState();
}

 

package keng.core.workflow.state;

import java.util.Map;

import keng.core.workflow.model.WfStep;
import keng.core.workflow.model.WorkFlow;

/**
 * 上下文环境
 * @author 5Di
 *
 */
public interface ISMContext extends Map<String,Object>{

	public WorkFlow getWorkFlow();
	
	public String getAction();
	
	public WfStep getStep();
	
}

 package keng.core.workflow.state;

 

/**
 * Action处理器<br />
 * 当Transit Transition 的时候，会执行相应的Action处理器，一般实现类会执行特定的业务代码
 * 
 * @author 5Di
 * 
 */
public interface ISMActionProcessor {

	/**
	 * 处理
	 * 
	 * @return
	 */
	public Object process() throws StateMachineException;

	public void beforeProcess() throws StateMachineException;

	public void afterProcess() throws StateMachineException;
}

 

其他的还有：ISMNode.java,ISMCondition.java.. 就不贴出来了

 

下面是DefaultStateMachine.java 是IStateMachine.java的默认实现

 

 

package keng.core.workflow.state.impl;

import java.util.List;
import java.util.Stack;
import java.util.concurrent.TimeoutException;

import keng.core.util.StringUtil;
import keng.core.workflow.state.ISMActionProcessor;
import keng.core.workflow.state.ISMCondition;
import keng.core.workflow.state.ISMContext;
import keng.core.workflow.state.ISMNode;
import keng.core.workflow.state.ISMTransition;
import keng.core.workflow.state.ISMTransitionMatcher;
import keng.core.workflow.state.IStateMachine;
import keng.core.workflow.state.StateMachineException;

/**
 * 默认的状态机实现
 * 
 * @author 5Di
 * 
 */
public class DefaultStateMachine implements IStateMachine {

	Stack<ISMNode> register = new Stack<ISMNode>();

	ISMTransitionMatcher matcher;

	ISMContext context;

	/**
	 * 根节点
	 */
	ISMNode root;

	boolean strict = false;

	public DefaultStateMachine(ISMNode root, ISMContext context) {
		this.context = context;
		this.root = root;
	}

	public DefaultStateMachine(ISMNode root, ISMContext context,
			ISMTransitionMatcher matcher) {
		this.root = root;
		this.context = context;
		this.matcher = matcher;
	}

	public DefaultStateMachine(ISMNode root, ISMContext context,
			ISMTransitionMatcher matcher, boolean strict) {
		this.context = context;
		this.root = root;
		this.matcher = matcher;
		this.strict = strict;
	}

	@Override
	public boolean transit(String action, String state, ISMNode node)
			throws StateMachineException, TimeoutException {
		if (StringUtil.isEmpty(action))
			throw new IllegalArgumentException("action can not be empty!");

		if (StringUtil.isEmpty(state))
			throw new IllegalArgumentException("state can not be empty!");

		if (node == null)
			throw new IllegalArgumentException("node can not be null!");

		List<ISMTransition> transitions = node.getTransitions();

		if (transitions == null || transitions.isEmpty())
			throw new StateMachineException("transitions can not be empty !");

		// check che node
		if (checkNodeMap(node))
			return false;

		// Match the transition
		ISMTransition transition = matchTransition(action, state, transitions);

		boolean b = false;

		ISMCondition condition = transition.getCondition();
		if (condition == null)
			if (!strict)
				b = true;
			else
				throw new StateMachineException(
						"transition's condition can not be null!");

		b = condition.calculate(context, strict);

		if (!b)
			throw new TimeoutException("no transition was matched!");

		// process action
		ISMActionProcessor processor = transition.getActionProcessor();
		processor.process();

		register.push(node);

		// auto process next auto steps
		List<ISMNode> children = node.getChildren();
		if (children != null && !children.isEmpty()) {
			for (ISMNode child : children) {
				transit(action, state, child);
			}
		}

		node.setState(transition.getToState());

		return true;
	}

	/**
	 * 匹配transition <br />
	 * 使用<code>keng.core.workflow.state.ISMTransitionMatcher.match</code>匹配
	 * 
	 * @param action
	 * @param state
	 * @param transitions
	 * @return
	 */
	ISMTransition matchTransition(String action, String state,
			List<ISMTransition> transitions) {
		if (matcher == null)
			matcher = new DefaultSMTransitionMatcher();

		transitions = matcher.sort(transitions);

		int i, len = transitions.size();
		for (i = 0; i < len; i++) {
			ISMTransition transition = transitions.get(i);
			if (matcher.match(action, state, transition))
				return transition;
		}

		return null;
	}

	/**
	 * 检查节点图,是否进入了死循环<br />
	 * 目前还不完备，只是检查了已经执行过的node
	 * 
	 * @param node
	 * @return 如果已经执行，返回true
	 */
	public boolean checkNodeMap(ISMNode node) {
		return register.indexOf(node) != -1;
	}
}

 

 

目前还处于DEMO 状态，如果大家有想要说的，尽管拍砖，共同进步

最后，给大家提供两个工作流方面的资料

《工作流模型分析》和《工作流管理联盟规范》

 

评论

1 楼 ytqwz 2014-11-16  

楼主，现在完成的怎么样了