lowflow/flow-common/flow-common-flowable-starter/src/main/java/com/flow/flowable/utils/ProcessElementUtil.java

package com.flow.flowable.utils;

import org.flowable.bpmn.model.FlowElement;
import org.flowable.bpmn.model.FlowNode;
import org.flowable.bpmn.model.SequenceFlow;
import org.flowable.editor.language.json.converter.util.CollectionUtils;

import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

public class ProcessElementUtil {

    /**
     * 递归查找所有子节点
     *
     * @param flowElement
     * @return
     */
    public static Set<FlowElement> findChildElements(FlowElement flowElement) {
        LinkedHashSet<FlowElement> elements = new LinkedHashSet<>();

        if (flowElement instanceof FlowNode) {
            FlowNode flowNode = (FlowNode) flowElement;
            List<SequenceFlow> outgoingFlows = flowNode.getOutgoingFlows();
            if (CollectionUtils.isNotEmpty(outgoingFlows)) {
                for (SequenceFlow sequenceFlow : outgoingFlows) {
                    FlowElement targetElement = sequenceFlow.getTargetFlowElement();
                    elements.add(targetElement);
                    Set<FlowElement> childElements = findChildElements(targetElement);
                    elements.addAll(childElements);
                }
            }
        }
        return elements;
    }

    /**
     * 递归查找所有父节点
     *
     * @param flowElement
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T extends FlowElement> Set<T> findParentElements(FlowElement flowElement, Class<T> clazz) {
        Set<FlowElement> parentElements = findParentElements(flowElement);
        Set<T> elements = new LinkedHashSet<>();
        for (FlowElement parentElement : parentElements) {
            if (clazz.isInstance(parentElement)) {
                elements.add(clazz.cast(parentElement));
            }
        }
        return elements;
    }

    /**
     * 递归查找所有父节点
     *
     * @param flowElement
     * @return
     */
    public static Set<FlowElement> findParentElements(FlowElement flowElement) {
        LinkedHashSet<FlowElement> elements = new LinkedHashSet<>();
        if (flowElement instanceof FlowNode) {
            FlowNode flowNode = (FlowNode) flowElement;
            List<SequenceFlow> incomingFlows = flowNode.getIncomingFlows();
            if (CollectionUtils.isNotEmpty(incomingFlows)) {
                for (SequenceFlow sequenceFlow : incomingFlows) {
                    FlowElement sourceElement = sequenceFlow.getSourceFlowElement();
                    if (sourceElement instanceof FlowNode) {
                        FlowElement sourceFlowElement = sequenceFlow.getSourceFlowElement();
                        elements.add(sourceElement);
                        Set<FlowElement> parentElements = findParentElements(sourceFlowElement);
                        elements.addAll(parentElements);
                    }
                }
            }
        }
        return elements;
    }

}