activiti获取可回退的节点

在处理流程回退时，需要获取某个节点当前可以回退到的节点，简单分析下：

1. 只支持回退到userTask。

2. 如果流程流转过某节点时生成了多个任务，从其中某一个任务回退到该节点后，不处理另外的任务。

3. 只能回退到当前节点前已经处理过的节点。

基于这个考虑，获取哪些节点可以回退按如下处理：

1. 从历史任务表查当前节点所在流程实例已经完成过的所有任务，有可能包括当前节点以后的任务（比如当前节点本来就是由后面节点回退的）

2. 判断任务是不是当前节点以前的userTask节点任务，如果是，加入返回列表。

3. 同一个节点只返回一次。

在这种处理前提下，需要获取流程中所有userTask节点的前后关系。我用深度优先的方式对流程的所有节点进行了一个遍历，把所有节点的前后关系保存在一个map里，map的内容为：

key: 前面的节点编号#后面的节点编号

value：从前面节点到后面节点中间要经过几个节点。

如果一个节点前有多个节点，比如 流程是 A-->B-->C-->D，那么 map的数据类似：

{A#B:1,A#C:2,A#D:3,B#C:1,B#D:2,C#D:1}

在这种情况下，所有的可能性都存储了一份，但是在后面判断节点的前后关系时相对比较容易，只要把要判断的节点和当前节点编号拼接在一起，判断 要判断的节点#当前节点 是不是在map里存在就好了。

一般来说，流程的节点数不会太多，这样已经够用了。

由于回退不是在流程上通过划线处理的，所以一般不会出现环状的流程图，因此用深度优先方式遍历也适用，感觉上应该用广度优先的方式遍历更合适一点。

附部分代码：

private static Map<String,Map<String,Object>> PROCESS_NODE_MAP = null;
private Map getFlowNodeRel(String processDefKey){
        if (null == PROCESS_NODE_MAP){
            PROCESS_NODE_MAP = new HashMap<String, Map<String, Object>>();
        }
        if(null == PROCESS_NODE_MAP.get(processDefKey)){
            ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
            List<Process> processList = engine.getRepositoryService().getBpmnModel(processDefKey).getProcesses();
            Process process = null;
            if(processList.size()>0){
                process = processList.get(0);
                Map relationMap = new HashMap<String,Integer>();
                setFlowNodeRel(process,relationMap);
                PROCESS_NODE_MAP.put(processDefKey, relationMap);
            }
        }
        return PROCESS_NODE_MAP.get(processDefKey);
    }

    //根据process往relationMap里写入UserTask之间的前后关系，从start开始遍历节点，不循环
    private void setFlowNodeRel(Process process,Map relationMap){
        Iterator<FlowElement> iterator = process.getFlowElements().iterator();
        HashMap nodeMap = new HashMap<String,FlowElement>();
        setFlowNodeMap(process,nodeMap);
        //获取start节点
        StartEvent startEvent = (StartEvent) nodeMap.get("startEvent");
        //处理节点关系
        setFlowNodeRel("","startEvent",nodeMap,relationMap,1);
    }

    //根据节点ID设置关系
    private void setFlowNodeRel(String parentKey,String nodeId,Map<String,FlowElement> nodeMap,Map relationMap,int level){
        FlowElement element = nodeMap.get(nodeId);
        if(element instanceof UserTask){
            relationMap.put(nodeId, element);
        }
        if(!(element  instanceof FlowNode)){
            return;
        }

        List<SequenceFlow> outFlows = ((FlowNode)element).getOutgoingFlows();
        if(outFlows.size() == 0){
            return;
        }

        //采用深度遍历
        for(int index=0;index < outFlows.size();index++){
            SequenceFlow tmpSequence = outFlows.get(index);
            String target = tmpSequence.getTargetRef();
            String key = nodeId + "#" + target;

            String loopKey = target + "#" + nodeId;

            FlowElement tmpElement = nodeMap.get(target);
            //只是源和目标都是 用户任务 才写入
            if(relationMap.containsKey(loopKey) || relationMap.containsKey(key)){
                continue;
            }
            if(tmpElement instanceof UserTask && element instanceof UserTask){
                setRelMapValue(relationMap,parentKey,target, level);
            }
            //递归找下一个任务的关系
            setFlowNodeRel(parentKey+"#"+target,target,nodeMap,relationMap,level+1);
        }
    }

    private void setRelMapValue(Map relationMap,String parentKey,String nodeKey,int level){
        if(parentKey.length() > 0){
            String[] parentArr = parentKey.split("#");
            for(String parent:parentArr){
                if(StringUtils.isNotEmpty(parent)){
                    String key = parent + "#" + nodeKey;
                    String loopKey = nodeKey + "#" + parent;
                    if(relationMap.containsKey(loopKey) || relationMap.containsKey(key)){
                        continue;
                    }else{
                        relationMap.put(key, level);
                    }
                }
            }
        }
    }

    //把流程节点设置到map属性里
    private void setFlowNodeMap(Process process,Map<String,FlowElement> nodeMap){
        Iterator<FlowElement> iterator = process.getFlowElements().iterator();

        while(iterator.hasNext()){
            FlowElement element = iterator.next();
            if(element instanceof StartEvent){
                nodeMap.put("startEvent", element);
            }else{
                nodeMap.put(element.getId(),element);
            }
        }
    }