开源工作流Fireflow源码分析之启动流程实例二

/**
* 在获取工作流网实例的时候，调用createNetInstance方法，创建实例
* @param processId  流程定义ID
* @param version    流程版本号
* @return
* @throws KernelException
*/
public INetInstance getNetInstance(String processId, Integer version) throws KernelException {
INetInstance netInstance = this.netInstanceMap.get(processId + "_V_" + version);
if (netInstance == null) {
//数据流定义在runtimeContext初始化的时候，就被加载了，将流程定义的xml读入到内存中
WorkflowDefinition def = rtCtx.getDefinitionService().getWorkflowDefinitionByProcessIdAndVersionNumber(processId, version);
netInstance = this.createNetInstance(def);
}
return netInstance;
}

/**
* 创建一个工作流网实例
* @param workflowDef
* @return
* @throws KernelException
*/
public INetInstance createNetInstance(WorkflowDefinition workflowDef) throws KernelException {
if (workflowDef==null)return null;
WorkflowProcess workflowProcess = null;
//解析fpdl
workflowProcess = workflowDef.getWorkflowProcess();

if (workflowProcess == null ){
throw new KernelException(null,null,"The WorkflowProcess property of WorkflowDefinition[processId="+workflowDef.getProcessId()+"] is null. ");
}
//校验工作流定义是否有效
String validateMsg =  workflowProcess.validate();
if (validateMsg != null){
throw new KernelException(null,null,validateMsg);
}
NetInstance netInstance = new NetInstance(workflowProcess, kernelExtensions);
//设置版本号
netInstance.setVersion(workflowDef.getVersion());
//map的key的组成规则：流程定义ID_V_版本号
netInstanceMap.put(workflowDef.getProcessId() + "_V_" + workflowDef.getVersion(), netInstance);
return netInstance;
}

/**
* wangmj  初始化一个工作流网实例,将引擎的扩展属性，注入到对应的工作流元素中
* @param process
* @param kenelExtensions
* @throws KernelException
*/
public NetInstance(WorkflowProcess process, final Map<String, List<IKernelExtension>> kenelExtensions) throws KernelException{
this.workflowProcess = process;

//开始节点
StartNode startNode = workflowProcess.getStartNode();
//生成一个开始节点实例
startNodeInstance = new StartNodeInstance(startNode);
//得到开始节点的事件监听器，系统都有默认的事件监听器，也可以进行增加，增加的事件监听器在要spring中定义，
//在开源工作流Fireflow源码分析之事件驱动.doc中有进行说明
List<IKernelExtension> extensionList = kenelExtensions.get(startNodeInstance.getExtensionTargetName());
for (int i = 0; extensionList != null && i < extensionList.size(); i++) {
IKernelExtension extension = extensionList.get(i);
//注册开始节点实例的事件监听器
startNodeInstance.registExtension(extension);
}
//在工作流网实例中设置开始节点
this.setStartNodeInstance(startNodeInstance);
//将开始节点实例放到工作流网的实例Map中，方便以后的查找
wfElementInstanceMap.put(startNode.getId(), startNodeInstance);

//生成环节节点
//取到流程模型中定义的所有环节,并依次进行loop
List<Activity> activities = workflowProcess.getActivities();
for (int i = 0; i < activities.size(); i++) {
Activity activity = activities.get(i);
//实例化环节
ActivityInstance activityInstance = new ActivityInstance(activity);
//注册环节的事件监听器
extensionList = kenelExtensions.get(activityInstance.getExtensionTargetName());
for (int j = 0; extensionList != null && j < extensionList.size(); j++) {
IKernelExtension extension = extensionList.get(j);
activityInstance.registExtension(extension);
}
//将实例化环节放入到Map中
wfElementInstanceMap.put(activity.getId(), activityInstance);
}
//生成同步器节点
//取到流程模型中定义的所有同步器，并依次进行loop
List<Synchronizer> synchronizers = workflowProcess.getSynchronizers();
for (int i = 0; i < synchronizers.size(); i++) {
Synchronizer synchronizer = synchronizers.get(i);
//实例化一个同步器节点
SynchronizerInstance synchronizerInstance = new SynchronizerInstance(synchronizer);
//注册同步器的事件监听器
extensionList = kenelExtensions.get(synchronizerInstance.getExtensionTargetName());
for (int j = 0; extensionList != null && j < extensionList.size(); j++) {
IKernelExtension extension = extensionList.get(j);
synchronizerInstance.registExtension(extension);
}
//将同步器节点放入Map里
wfElementInstanceMap.put(synchronizer.getId(), synchronizerInstance);
}
//生成结束节点
//取到流程模型中定义的所有结束节点，并依次进行loop
List<EndNode> endNodes = workflowProcess.getEndNodes();

for (int i = 0; i < endNodes.size(); i++) {
EndNode endNode = endNodes.get(i);
//实例化一个节始结点
EndNodeInstance endNodeInstance = new EndNodeInstance(endNode);
//注册结束结点的事件监听器
extensionList = kenelExtensions.get(endNodeInstance.getExtensionTargetName());
for (int j = 0; extensionList != null && j < extensionList.size(); j++) {
IKernelExtension extension = extensionList.get(j);
endNodeInstance.registExtension(extension);
}
//将结束节点放入Map里
wfElementInstanceMap.put(endNode.getId(), endNodeInstance);
}
//转移线
//取到流程模型中定义的所有转移线，并依次进行loop
List<Transition> transitions = workflowProcess.getTransitions();
for (int i = 0; i < transitions.size(); i++) {
Transition transition = transitions.get(i);
//实例化一个转移线
TransitionInstance transitionInstance = new TransitionInstance(transition);
//取到转移线的from,
String fromNodeId = transition.getFromNode().getId();
if (fromNodeId != null) {
//从map中取到转移线进入节点的实例
INodeInstance enteringNodeInstance = (INodeInstance) wfElementInstanceMap.get(fromNodeId);
//如果实例不为null
if (enteringNodeInstance != null) {
//设置转移线进入节点实例的离开转移线
enteringNodeInstance.addLeavingTransitionInstance(transitionInstance);
//设置转移线的进入节点
transitionInstance.setEnteringNodeInstance(enteringNodeInstance);
}
}
//设置转移线的离开节点
//取到转移线的to
String toNodeId = transition.getToNode().getId();
if (toNodeId != null) {
//从map中取到转移线离开节点实例
INodeInstance leavingNodeInstance = (INodeInstance) wfElementInstanceMap.get(toNodeId);
if (leavingNodeInstance != null) {
//设置转移线离开节点的进入转移线
leavingNodeInstance.addEnteringTransitionInstance(transitionInstance);
//设置转移线的离开节点
transitionInstance.setLeavingNodeInstance(leavingNodeInstance);
}
}
//注册转移线事件监听器
extensionList = kenelExtensions.get(transitionInstance.getExtensionTargetName());
for (int j = 0; extensionList != null && j < extensionList.size(); j++) {
IKernelExtension extension = extensionList.get(j);
transitionInstance.registExtension(extension);
}
//将转移线放入Map中
wfElementInstanceMap.put(transitionInstance.getId(), transitionInstance);
}
//循环线
//取到流程模型中定义的所有循环线，并依次进行loop
List<Loop> loops = workflowProcess.getLoops();
for (int i = 0; i < loops.size(); i++) {
Loop loop = loops.get(i);
//实例化循环线
LoopInstance loopInstance = new LoopInstance(loop);
//取循环线from
String fromNodeId = loop.getFromNode().getId();
if (fromNodeId != null) {
//从map中取到循环线进入节点的实例
INodeInstance enteringNodeInstance = (INodeInstance) wfElementInstanceMap.get(fromNodeId);
if (enteringNodeInstance != null) {
//设置循环线的进入节点的循环线
enteringNodeInstance.addLeavingLoopInstance(loopInstance);
//设置循环线的进入节点
loopInstance.setEnteringNodeInstance(enteringNodeInstance);
}
}
//取循环线to
String toNodeId = loop.getToNode().getId();
if (toNodeId != null) {
//从map中取到循环线离开节点的实例
INodeInstance leavingNodeInstance = (INodeInstance) wfElementInstanceMap.get(toNodeId);
if (leavingNodeInstance != null) {
//设置循环线的离开节点的循环线
leavingNodeInstance.addEnteringLoopInstance(loopInstance);
//设置循环线的离开节点
loopInstance.setLeavingNodeInstance(leavingNodeInstance);
}
}
//注册循环线的事件监听器
extensionList = kenelExtensions.get(loopInstance.getExtensionTargetName());
for (int j = 0; extensionList != null && j < extensionList.size(); j++) {
IKernelExtension extension = extensionList.get(j);
loopInstance.registExtension(extension);
}
wfElementInstanceMap.put(loopInstance.getId(), loopInstance);
}
}