diff --git a/src/main/java/neatlogic/framework/process/stephandler/core/ProcessMessageManager.java b/src/main/java/neatlogic/framework/process/stephandler/core/ProcessMessageManager.java index e272a26269368edadde2ca940d38f9716f6caa86..a53b68533c0602178807d8c1c42a272aca531a57 100644 --- a/src/main/java/neatlogic/framework/process/stephandler/core/ProcessMessageManager.java +++ b/src/main/java/neatlogic/framework/process/stephandler/core/ProcessMessageManager.java @@ -19,9 +19,9 @@ package neatlogic.framework.process.stephandler.core; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; -import neatlogic.framework.process.constvalue.ProcessFlowDirection; import neatlogic.framework.process.constvalue.ProcessStepHandlerType; import neatlogic.framework.process.dto.ProcessStepRelVo; +import neatlogic.framework.process.util.ProcessTaskUtil; import neatlogic.framework.restful.constvalue.OperationTypeEnum; import org.apache.commons.collections4.MapUtils; import org.apache.commons.lang3.StringUtils; @@ -89,19 +89,7 @@ public class ProcessMessageManager { endStepUuid = step.getString("uuid"); } } - List> routeList = new ArrayList<>(); - List routeStepList = new ArrayList<>(); - routeList.add(routeStepList); - getAllRouteList(startStepUuid, routeList, routeStepList, endStepUuid, allProcessStepRelList); - // 有效的步骤UUID列表 - effectiveStepUuidList = new ArrayList<>(); - for (List routeStepUuidList : routeList) { - for (String routeStepUuid : routeStepUuidList) { - if (!effectiveStepUuidList.contains(routeStepUuid)) { - effectiveStepUuidList.add(routeStepUuid); - } - } - } + effectiveStepUuidList = ProcessTaskUtil.getEffectivePostStepUuidList(startStepUuid, endStepUuid, allProcessStepRelList); List connectionList = new ArrayList<>(); for (ProcessStepRelVo processStepRelVo : allProcessStepRelList) { if (effectiveStepUuidList.contains(processStepRelVo.getFromStepUuid()) && effectiveStepUuidList.contains(processStepRelVo.getToStepUuid())) { @@ -150,36 +138,4 @@ public class ProcessMessageManager { return processStepRelList; } - /** - * - * @param stepUuid 当前步骤uuid - * @param routeList 收集所有后置路经列表 - * @param routeStepList 遍历过的步骤列表 - * @param endStepUuid 结束步骤uuid - * @param allProcessStepRelList 所有连线列表 - */ - private static void getAllRouteList(String stepUuid, List> routeList, List routeStepList, String endStepUuid, List allProcessStepRelList) { - if (!routeStepList.contains(stepUuid)) { - routeStepList.add(stepUuid); - if (!stepUuid.equals(endStepUuid)) { - List toStepUuidList = new ArrayList<>(); - for (ProcessStepRelVo processStepRelVo : allProcessStepRelList) { - if (Objects.equals(processStepRelVo.getFromStepUuid(), stepUuid) && Objects.equals(processStepRelVo.getType(), ProcessFlowDirection.FORWARD.getValue())) { - toStepUuidList.add(processStepRelVo.getToStepUuid()); - } - } - List tmpRouteStepList = new ArrayList<>(routeStepList); - for (int i = 0; i < toStepUuidList.size(); i++) { - String toStepUuid = toStepUuidList.get(i); - if (i == 0) { - getAllRouteList(toStepUuid, routeList, routeStepList, endStepUuid, allProcessStepRelList); - } else { - List newRouteStepList = new ArrayList<>(tmpRouteStepList); - routeList.add(newRouteStepList); - getAllRouteList(toStepUuid, routeList, newRouteStepList, endStepUuid, allProcessStepRelList); - } - } - } - } - } } diff --git a/src/main/java/neatlogic/framework/process/stephandler/core/ProcessStepHandlerBase.java b/src/main/java/neatlogic/framework/process/stephandler/core/ProcessStepHandlerBase.java index 01d5fe2fba6bd1e77cc63a419ea575d4826ec8dc..6f6c8ecf91f3b5ffd0cfc10d1ed06a766f6ad535 100644 --- a/src/main/java/neatlogic/framework/process/stephandler/core/ProcessStepHandlerBase.java +++ b/src/main/java/neatlogic/framework/process/stephandler/core/ProcessStepHandlerBase.java @@ -57,6 +57,7 @@ import neatlogic.framework.process.operationauth.core.IOperationType; import neatlogic.framework.process.operationauth.core.ProcessAuthManager; import neatlogic.framework.process.processtaskserialnumberpolicy.core.IProcessTaskSerialNumberPolicyHandler; import neatlogic.framework.process.processtaskserialnumberpolicy.core.ProcessTaskSerialNumberPolicyHandlerFactory; +import neatlogic.framework.process.util.ProcessTaskUtil; import neatlogic.framework.process.workerpolicy.core.IWorkerPolicyHandler; import neatlogic.framework.process.workerpolicy.core.WorkerPolicyHandlerFactory; import neatlogic.framework.service.AuthenticationInfoService; @@ -2745,70 +2746,6 @@ public abstract class ProcessStepHandlerBase implements IProcessStepHandler { doNext(processTaskStepThreadList); } -// private void resetConvergeInfo(ProcessTaskStepVo nextStepVo) { -// IProcessTaskCrossoverMapper processTaskCrossoverMapper = CrossoverServiceFactory.getApi(IProcessTaskCrossoverMapper.class); -// List stepList = processTaskCrossoverMapper.getProcessTaskStepByProcessTaskIdAndType(nextStepVo.getProcessTaskId(), ProcessStepType.END.getValue()); -// ProcessTaskStepVo endStepVo = null; -// if (stepList.size() == 1) { -// endStepVo = stepList.get(0); -// } -// // 重新插入汇聚数据 -// List> routeList = new ArrayList<>(); -// List routeStepList = new ArrayList<>(); -// routeList.add(routeStepList); -// -// getAllRouteList(nextStepVo.getId(), routeList, routeStepList, endStepVo); -// // 如果最后一个步骤不是结束节点的路由全部删掉，因为这是回环路由 -// Iterator> routeStepIt = routeList.iterator(); -// List convergeIdList = new ArrayList<>(); -// while (routeStepIt.hasNext()) { -// List rsList = routeStepIt.next(); -// if (!rsList.get(rsList.size() - 1).equals(endStepVo.getId())) { -// routeStepIt.remove(); -// } else { -// for (Long cid : rsList) { -// if (!convergeIdList.contains(cid) && !cid.equals(nextStepVo.getId())) { -// convergeIdList.add(cid); -// } -// } -// } -// } -// if (convergeIdList.size() > 0) { -// for (Long convergeId : convergeIdList) { -// ProcessTaskConvergeVo processTaskStepConvergeVo = new ProcessTaskConvergeVo(nextStepVo.getProcessTaskId(), nextStepVo.getId(), convergeId); -// if (processTaskCrossoverMapper.checkProcessTaskConvergeIsExists(processTaskStepConvergeVo) == 0) { -// processTaskCrossoverMapper.insertIgnoreProcessTaskConverge(processTaskStepConvergeVo); -// } -// } -// } -// } -// -// private void getAllRouteList(Long processTaskStepId, List> routeList, List routeStepList, ProcessTaskStepVo endStepVo) { -// if (!routeStepList.contains(processTaskStepId)) { -// routeStepList.add(processTaskStepId); -// List tmpRouteStepList = new ArrayList<>(routeStepList); -// if (!processTaskStepId.equals(endStepVo.getId())) { -// IProcessTaskCrossoverMapper processTaskCrossoverMapper = CrossoverServiceFactory.getApi(IProcessTaskCrossoverMapper.class); -// List convergeStepList = processTaskCrossoverMapper.getProcessTaskStepByConvergeId(processTaskStepId); -// List convergeStepIdList = convergeStepList.stream().map(ProcessTaskStepVo::getId).collect(Collectors.toList()); -// List toProcessTaskStepIdList = processTaskCrossoverMapper.getToProcessTaskStepIdListByFromIdAndType(processTaskStepId, ProcessFlowDirection.FORWARD.getValue()); -// for (int i = 0; i < toProcessTaskStepIdList.size(); i++) { -// Long toProcessTaskStepId = toProcessTaskStepIdList.get(i); -// /* 当前节点不是别人的汇聚节点时，才记录进路由，这是为了避免因为出现打回路径而产生错误的汇聚数据 **/ -// if (!convergeStepIdList.contains(toProcessTaskStepId)) { -// if (i > 0) { -// List newRouteStepList = new ArrayList<>(tmpRouteStepList); -// routeList.add(newRouteStepList); -// getAllRouteList(toProcessTaskStepId, routeList, newRouteStepList, endStepVo); -// } else { -// getAllRouteList(toProcessTaskStepId, routeList, routeStepList, endStepVo); -// } -// } -// } -// } -// } -// } - private void resetConvergeInfo(ProcessTaskStepVo nextStepVo) { IProcessTaskCrossoverMapper processTaskCrossoverMapper = CrossoverServiceFactory.getApi(IProcessTaskCrossoverMapper.class); List stepList = processTaskCrossoverMapper.getProcessTaskStepByProcessTaskIdAndType(nextStepVo.getProcessTaskId(), ProcessStepType.END.getValue()); @@ -2819,25 +2756,7 @@ public abstract class ProcessStepHandlerBase implements IProcessStepHandler { List allProcessTaskStepRelList = processTaskCrossoverMapper.getProcessTaskStepRelByProcessTaskId(nextStepVo.getProcessTaskId()); List allProcessTaskConvergeList = processTaskCrossoverMapper.getProcessTaskConvergeListByProcessTaskId(nextStepVo.getProcessTaskId()); // 重新插入汇聚数据 - List> routeList = new ArrayList<>(); - List routeStepList = new ArrayList<>(); - routeList.add(routeStepList); - getAllRouteList(nextStepVo.getId(), routeList, routeStepList, endStepVo, allProcessTaskStepRelList, allProcessTaskConvergeList); - // 如果最后一个步骤不是结束节点的路由全部删掉，因为这是回环路由 - Iterator> routeStepIt = routeList.iterator(); - List convergeIdList = new ArrayList<>(); - while (routeStepIt.hasNext()) { - List rsList = routeStepIt.next(); - if (!rsList.get(rsList.size() - 1).equals(endStepVo.getId())) { - routeStepIt.remove(); - } else { - for (Long cid : rsList) { - if (!convergeIdList.contains(cid) && !cid.equals(nextStepVo.getId())) { - convergeIdList.add(cid); - } - } - } - } + List convergeIdList = ProcessTaskUtil.getEffectivePostStepIdList(nextStepVo.getId(), endStepVo.getId(), allProcessTaskStepRelList, allProcessTaskConvergeList); if (!convergeIdList.isEmpty()) { List processTaskConvergeList = new ArrayList<>(); for (Long convergeId : convergeIdList) { @@ -2848,40 +2767,6 @@ public abstract class ProcessStepHandlerBase implements IProcessStepHandler { } } - private void getAllRouteList(Long processTaskStepId, List> routeList, List routeStepList, ProcessTaskStepVo endStepVo, List allProcessTaskStepRelList, List allProcessTaskConvergeList) { - if (!routeStepList.contains(processTaskStepId)) { - routeStepList.add(processTaskStepId); - List tmpRouteStepList = new ArrayList<>(routeStepList); - if (!processTaskStepId.equals(endStepVo.getId())) { - List convergeStepIdList = new ArrayList<>(); - for (ProcessTaskConvergeVo processTaskConvergeVo : allProcessTaskConvergeList) { - if (Objects.equals(processTaskConvergeVo.getConvergeId(), processTaskStepId)) { - convergeStepIdList.add(processTaskConvergeVo.getProcessTaskStepId()); - } - } - List toProcessTaskStepIdList = new ArrayList<>(); - for (ProcessTaskStepRelVo processTaskStepRelVo : allProcessTaskStepRelList) { - if (Objects.equals(processTaskStepRelVo.getFromProcessTaskStepId(), processTaskStepId) && Objects.equals(processTaskStepRelVo.getType(), ProcessFlowDirection.FORWARD.getValue())) { - toProcessTaskStepIdList.add(processTaskStepRelVo.getToProcessTaskStepId()); - } - } - for (int i = 0; i < toProcessTaskStepIdList.size(); i++) { - Long toProcessTaskStepId = toProcessTaskStepIdList.get(i); - /* 当前节点不是别人的汇聚节点时，才记录进路由，这是为了避免因为出现打回路径而产生错误的汇聚数据 **/ - if (!convergeStepIdList.contains(toProcessTaskStepId)) { - if (i > 0) { - List newRouteStepList = new ArrayList<>(tmpRouteStepList); - routeList.add(newRouteStepList); - getAllRouteList(toProcessTaskStepId, routeList, newRouteStepList, endStepVo, allProcessTaskStepRelList, allProcessTaskConvergeList); - } else { - getAllRouteList(toProcessTaskStepId, routeList, routeStepList, endStepVo, allProcessTaskStepRelList, allProcessTaskConvergeList); - } - } - } - } - } - } - protected abstract Set myGetNext(ProcessTaskStepVo currentProcessTaskStepVo, List nextStepIdList, Long nextStepId) throws ProcessTaskException; protected Set defaultGetNext(List nextStepIdList, Long nextStepId) throws ProcessTaskException { diff --git a/src/main/java/neatlogic/framework/process/stephandler/core/ProcessTaskStepThreadComparator.java b/src/main/java/neatlogic/framework/process/stephandler/core/ProcessTaskStepThreadComparator.java index afc49a82ae18f076893f269791dfb781f7af5308..008856511a197d88e0bf543319d0f86502807dde 100644 --- a/src/main/java/neatlogic/framework/process/stephandler/core/ProcessTaskStepThreadComparator.java +++ b/src/main/java/neatlogic/framework/process/stephandler/core/ProcessTaskStepThreadComparator.java @@ -17,10 +17,10 @@ package neatlogic.framework.process.stephandler.core; -import neatlogic.framework.process.constvalue.ProcessFlowDirection; import neatlogic.framework.process.constvalue.ProcessStepMode; import neatlogic.framework.process.constvalue.ProcessTaskStepOperationType; import neatlogic.framework.process.dto.ProcessTaskStepRelVo; +import neatlogic.framework.process.util.ProcessTaskUtil; import java.util.*; @@ -80,60 +80,8 @@ public class ProcessTaskStepThreadComparator implements Comparator> routeList = new ArrayList<>(); - List routeStepList = new ArrayList<>(); - routeList.add(routeStepList); - getAllRouteList(currentProcessTaskStepId, routeList, routeStepList, endProcessTaskStepId, processTaskStepRelList); - // 如果最后一个步骤不是结束节点的路由全部删掉，因为这是回环路由 - Iterator> routeStepIt = routeList.iterator(); - List subsequentStepIdList = new ArrayList<>(); - while (routeStepIt.hasNext()) { - List rsList = routeStepIt.next(); - if (!rsList.get(rsList.size() - 1).equals(endProcessTaskStepId)) { - routeStepIt.remove(); - } else { - for (Long id : rsList) { - if (!subsequentStepIdList.contains(id)) { - subsequentStepIdList.add(id); - } - } - } - } -// System.out.println(currentProcessTaskStep.getName() + " subsequentStepIdList = " + JSON.toJSONString(subsequentStepIdList)); + List subsequentStepIdList = ProcessTaskUtil.getEffectivePostStepIdList(currentProcessTaskStepId, endProcessTaskStepId, processTaskStepRelList); return subsequentStepIdList.contains(targetProcessTaskStepId); } - /** - * - * @param processTaskStepId 当前步骤ID - * @param routeList 收集所有后置路经列表 - * @param routeStepList 遍历过的步骤列表 - * @param endProcessTaskStepId 结束步骤ID - * @param allProcessTaskStepRelList 所有连线列表 - */ - private void getAllRouteList(Long processTaskStepId, List> routeList, List routeStepList, Long endProcessTaskStepId, List allProcessTaskStepRelList) { - if (!routeStepList.contains(processTaskStepId)) { - routeStepList.add(processTaskStepId); - if (!processTaskStepId.equals(endProcessTaskStepId)) { - List toProcessTaskStepIdList = new ArrayList<>(); - for (ProcessTaskStepRelVo processTaskStepRelVo : allProcessTaskStepRelList) { - if (Objects.equals(processTaskStepRelVo.getFromProcessTaskStepId(), processTaskStepId) && Objects.equals(processTaskStepRelVo.getType(), ProcessFlowDirection.FORWARD.getValue())) { - toProcessTaskStepIdList.add(processTaskStepRelVo.getToProcessTaskStepId()); - } - } - List tmpRouteStepList = new ArrayList<>(routeStepList); - for (int i = 0; i < toProcessTaskStepIdList.size(); i++) { - Long toProcessTaskStepId = toProcessTaskStepIdList.get(i); - if (i == 0) { - getAllRouteList(toProcessTaskStepId, routeList, routeStepList, endProcessTaskStepId, allProcessTaskStepRelList); - } else { - List newRouteStepList = new ArrayList<>(tmpRouteStepList); - routeList.add(newRouteStepList); - getAllRouteList(toProcessTaskStepId, routeList, newRouteStepList, endProcessTaskStepId, allProcessTaskStepRelList); - } - } - } - } - } - } diff --git a/src/main/java/neatlogic/framework/process/util/ProcessTaskUtil.java b/src/main/java/neatlogic/framework/process/util/ProcessTaskUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..4ef4b11cf8fce86f7163613f94b844b8ce52c759 --- /dev/null +++ b/src/main/java/neatlogic/framework/process/util/ProcessTaskUtil.java @@ -0,0 +1,245 @@ +/* + * Copyright (C) 2024 深圳极向量科技有限公司 All Rights Reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package neatlogic.framework.process.util; + +import com.alibaba.fastjson.JSONArray; +import neatlogic.framework.process.constvalue.ProcessFlowDirection; +import neatlogic.framework.process.dto.ProcessStepRelVo; +import neatlogic.framework.process.dto.ProcessTaskConvergeVo; +import neatlogic.framework.process.dto.ProcessTaskStepRelVo; +import neatlogic.framework.process.dto.ProcessTaskStepVo; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.collections4.MapUtils; +import org.apache.commons.lang3.StringUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.lang.Nullable; + +import java.util.*; + +public class ProcessTaskUtil { + + private final static Logger logger = LoggerFactory.getLogger(ProcessTaskUtil.class); + + public static List getEffectivePostStepIdList(Long startStepId, Long endStepId, List allProcessTaskStepRelList, @Nullable List allProcessTaskConvergeList) { + return getEffectivePostStepIdList(startStepId, endStepId, allProcessTaskStepRelList, allProcessTaskConvergeList, null); + } + + public static List getEffectivePostStepIdList(Long startStepId, Long endStepId, List allProcessTaskStepRelList) { + return getEffectivePostStepIdList(startStepId, endStepId, allProcessTaskStepRelList, null, null); + } + + public static List getEffectivePostStepUuidList(String startStepUuid, String endStepUuid, List allProcessStepRelList) { + return getEffectivePostStepUuidList(startStepUuid, endStepUuid, allProcessStepRelList, null, null); + } + + public static List getEffectivePostStepIdList(Long startStepId, Long endStepId, List allProcessTaskStepRelList, @Nullable List allProcessTaskConvergeList, List allProcessTaskStepList) { + Map id2UuidMap = new HashMap<>(); + Map uuid2IdMap = new HashMap<>(); + List allProcessStepRelList = new ArrayList<>(); + for (ProcessTaskStepRelVo processTaskStepRelVo : allProcessTaskStepRelList) { + ProcessStepRelVo processStepRelVo = new ProcessStepRelVo(); + processStepRelVo.setFromStepUuid(processTaskStepRelVo.getFromProcessStepUuid()); + processStepRelVo.setToStepUuid(processTaskStepRelVo.getToProcessStepUuid()); + processStepRelVo.setType(processTaskStepRelVo.getType()); + processStepRelVo.setName(processTaskStepRelVo.getName()); + allProcessStepRelList.add(processStepRelVo); + id2UuidMap.put(processTaskStepRelVo.getFromProcessTaskStepId(), processTaskStepRelVo.getFromProcessStepUuid()); + id2UuidMap.put(processTaskStepRelVo.getToProcessTaskStepId(), processTaskStepRelVo.getToProcessStepUuid()); + uuid2IdMap.put(processTaskStepRelVo.getFromProcessStepUuid(), processTaskStepRelVo.getFromProcessTaskStepId()); + uuid2IdMap.put(processTaskStepRelVo.getToProcessStepUuid(), processTaskStepRelVo.getToProcessTaskStepId()); + } + List> allProcessConvergeList = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(allProcessTaskConvergeList)) { + for (ProcessTaskConvergeVo processTaskConvergeVo : allProcessTaskConvergeList) { + Long convergeId = processTaskConvergeVo.getConvergeId(); + Long processTaskStepId = processTaskConvergeVo.getProcessTaskStepId(); + Map map = new HashMap<>(); + map.put("convergeUuid", id2UuidMap.get(convergeId)); + map.put("processStepUuid", id2UuidMap.get(processTaskStepId)); + allProcessConvergeList.add(map); + } + } + Map uuid2NameMap = new HashMap<>(); + if (CollectionUtils.isNotEmpty(allProcessTaskStepList)) { + for (ProcessTaskStepVo processTaskStepVo : allProcessTaskStepList) { + if (StringUtils.isNotBlank(processTaskStepVo.getProcessStepUuid()) && StringUtils.isNotBlank(processTaskStepVo.getName())) { + uuid2NameMap.put(processTaskStepVo.getProcessStepUuid(), processTaskStepVo.getName()); + } + } + } + String startStepUuid = id2UuidMap.get(startStepId); + String endStepUuid = id2UuidMap.get(endStepId); + List effectiveStepUuidList = getEffectivePostStepUuidList(startStepUuid, endStepUuid, allProcessStepRelList, allProcessConvergeList, uuid2NameMap); + List idList = new ArrayList<>(effectiveStepUuidList.size()); + for (String uuid : effectiveStepUuidList) { + Long id = uuid2IdMap.get(uuid); + if (id != null) { + idList.add(id); + } + } + return idList; + } + + /** + * 通过深度优先算法遍历流程图所有节点，找出开始节点的所有有效后置节点UUID列表 + * @param startStepUuid 开始节点UUID + * @param endStepUuid 结束节点UUID + * @param allProcessStepRelList 流程图所有连线列表 + * @param allProcessConvergeList + * @param uuid2NameMap 节点UUID与名称键值对 + * @return 返回所有有效后置节点UUID列表 + */ + public static List getEffectivePostStepUuidList(String startStepUuid, String endStepUuid, List allProcessStepRelList, @Nullable List> allProcessConvergeList, @Nullable Map uuid2NameMap) { + List effectiveStepUuidList = new ArrayList<>(); + int count = 0; + int stackSize = 0; + Stack stack = new Stack<>(); + // 将开始节点压入栈中 + stack.add(new StepRoute(startStepUuid)); + // 当栈不为空时，继续循环 + while(!stack.isEmpty()) { + count++; + stackSize = Math.max(stack.size(), stackSize); + // 弹出栈顶元素，即当前节点 + StepRoute current = stack.pop(); + // 当前节点的前置节点UUID列表 + List preStepUuidList = new ArrayList<>(); + if (CollectionUtils.isNotEmpty(allProcessConvergeList)) { + for (Map map : allProcessConvergeList) { + if (Objects.equals(map.get("convergeUuid"), current.getStepUuid())) { + preStepUuidList.add(map.get("processStepUuid")); + } + } + } + // 找出当前节点的所有下一个节点UUID列表 + List toStepUuidList = new ArrayList<>(); + for (ProcessStepRelVo processStepRelVo : allProcessStepRelList) { + if (Objects.equals(processStepRelVo.getFromStepUuid(), current.getStepUuid()) && Objects.equals(processStepRelVo.getType(), ProcessFlowDirection.FORWARD.getValue())) { + toStepUuidList.add(processStepRelVo.getToStepUuid()); + } + } + if (MapUtils.isNotEmpty(uuid2NameMap)) { + logger.debug("当前节点为: " + uuid2NameMap.get(current.getStepUuid())); + JSONArray toStepNameArray = new JSONArray(); + for (String toStepUuid : toStepUuidList) { + toStepNameArray.add(uuid2NameMap.get(toStepUuid)); + } + logger.debug("紧邻的下一个节点列表为: " + toStepNameArray); + logger.debug("开始遍历紧邻的下一个节点列表..."); + } + // 将下一个节点压入栈中 + for (String toStepUuid : toStepUuidList) { + // 如果下一个节点是结束节点，那么这整条路径上的节点都是有效节点 + if (Objects.equals(toStepUuid, endStepUuid)) { + List pathStepUniqueKeyList = current.getPathStepUuidList(); + for (String stepUuid : pathStepUniqueKeyList) { + if (!effectiveStepUuidList.contains(stepUuid)) { + effectiveStepUuidList.add(stepUuid); + } + } + if (MapUtils.isNotEmpty(uuid2NameMap)) { + logger.debug("节点: " + uuid2NameMap.get(toStepUuid) + " 是结束节点"); + JSONArray stepNameArray = new JSONArray(); + for (String stepUuid : pathStepUniqueKeyList) { + stepNameArray.add(uuid2NameMap.get(stepUuid)); + } + logger.debug("该路径上收集到有效节点列表为: " + stepNameArray); + } + continue; + } + // 如果下一个节点已经确定是有效节点时，那么从开始节点到下一个节点这段路径上的节点都是有效节点，这条路径后续节点就不用遍历了 + if (effectiveStepUuidList.contains(toStepUuid)) { + List pathStepUniqueKeyList = current.getPathStepUuidList(); + for (String stepUuid : pathStepUniqueKeyList) { + if (!effectiveStepUuidList.contains(stepUuid)) { + effectiveStepUuidList.add(stepUuid); + } + } + if (MapUtils.isNotEmpty(uuid2NameMap)) { + logger.debug("节点: " + uuid2NameMap.get(toStepUuid) + " 是已经遍历过的有效节点，不再继续遍历它的后置节点"); + JSONArray stepNameArray = new JSONArray(); + for (String stepUuid : pathStepUniqueKeyList) { + stepNameArray.add(uuid2NameMap.get(stepUuid)); + } + logger.debug("该路径上收集到有效节点列表为: " + stepNameArray); + } + continue; + } + if (current.checkIsPathLoop(toStepUuid)) { + if (MapUtils.isNotEmpty(uuid2NameMap)) { + logger.debug("节点: " + uuid2NameMap.get(toStepUuid) + " 是该路径上已经出现过的节点，说明该路径成回环路了，不再继续遍历该路径"); + } + continue; + } + if (preStepUuidList.contains(toStepUuid)) { + if (MapUtils.isNotEmpty(uuid2NameMap)) { + logger.debug("在processtask_converge表中，节点: " + uuid2NameMap.get(toStepUuid) + " 被标识当前节点: " + uuid2NameMap.get(current.getStepUuid()) + " 的前置节点，说明该路径成回环路了，不再继续遍历该路径"); + } + continue; + } + if (MapUtils.isNotEmpty(uuid2NameMap)) { + logger.debug("节点: " + uuid2NameMap.get(toStepUuid) + " 被压入栈中"); + } + stack.push(new StepRoute(toStepUuid, current)); + } + } + if (MapUtils.isNotEmpty(uuid2NameMap)) { + logger.debug("总共遍历节点次数为: " + count); + logger.debug("栈最大长度为: " + stackSize); + } + effectiveStepUuidList.add(endStepUuid); + return effectiveStepUuidList; + } + + private static class StepRoute { + // 当前节点唯一标识 + private final String stepUuid; + // 从开始节点到当前节点这段路径上所有节点唯一标识列表 + private final List pathStepUuidList; + + public StepRoute(String stepUuid) { + this.stepUuid = stepUuid; + this.pathStepUuidList = new ArrayList<>(); + this.pathStepUuidList.add(this.stepUuid); + } + + public StepRoute(String stepUuid, StepRoute route) { + this.stepUuid = stepUuid; + this.pathStepUuidList = route.getPathStepUuidList(); + this.pathStepUuidList.add(this.stepUuid); + } + + public String getStepUuid() { + return stepUuid; + } + + public List getPathStepUuidList() { + return new ArrayList<>(pathStepUuidList); + } + + /** + * 检查路径是否是成环路 + * @param stepUuid + * @return + */ + public boolean checkIsPathLoop(String stepUuid) { + return pathStepUuidList.contains(stepUuid); + } + } +}