org.jgrapht.graph.DagTemplate Maven / Gradle / Ivy

Go to download
package org.jgrapht.graph;

import java.util.Map;
import java.util.Objects;
import java.util.ServiceLoader;
import java.util.Set;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.jgrapht.graph.beans.DagVertex;
import org.jgrapht.graph.beans.DagWeave;
import org.jgrapht.graph.dagger.VertexDataset;
import org.jgrapht.graph.dagger.VertexStateful;
import org.jgrapht.graph.dagger.VertexStateless;
import org.jgrapht.graph.pipeline.DataPipeline;

import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;

import lombok.Data;

/**
 * DAG算子执行器
 */
@Data
public class DagTemplate {

    public static VertexDataset dataset(DagWeave dagWeave, Map context) {
        Preconditions.checkArgument(Objects.nonNull(dagWeave.getStartVertex()), "DAG入口结点为空");
        Preconditions.checkArgument(Objects.nonNull(dagWeave.getDirectedAcyclicGraph()), "DAG编排结构错误");
        return dataset(dagWeave, dagWeave.getStartVertex(), context);
    }

    // 执行结点
    private static VertexDataset dataset(DagVertex dagVertex, Map context) {
        ServiceLoader serviceLoader = ServiceLoader.load(DataPipeline.class);
        for(DataPipeline dataPipeline: serviceLoader){
            if(dataPipeline.getClass().getSimpleName().equalsIgnoreCase(dagVertex.getTypeName())){
                System.out.println("[DAG] 执行:" + dagVertex.getVertexId());
                return dataPipeline.pipeline(dagVertex.getVertexId(), context);
            }
        }
        throw new IllegalStateException("未找DAG数据算子");
    }

    // 执行结点
    private static VertexDataset dataset(DagWeave dagWeave, DagVertex dagVertex, Map context) {
        VertexDataset vertexDataset = dataset(dagVertex, context);
        DagStatus dagStatus = vertexDataset.getStatus();
        // 状态结束直接返回(执行到部分路径结束|执行到最终结点结束)
        if (DagStatus.FINISH == dagStatus) {
            return vertexDataset;
        }
        // 流程完结结点返回(严格判断结束结点，避免End结点处理遗漏)
        if (dagWeave.getStopVertex() == dagVertex) {
            vertexDataset.setStatus(DagStatus.FINISH);
            return vertexDataset;
        }
        // 无状态结点，直接执行出度边
        if (vertexDataset instanceof VertexStateless) {
            Set outgoingEdges = dagWeave.getDirectedAcyclicGraph().outgoingEdgesOf(dagVertex);
            Preconditions.checkArgument(CollectionUtils.size(outgoingEdges) == 1, "(DAG)无状态结点出度不为1");
            DagVertex outgoing = (DagVertex) Lists.newArrayList(outgoingEdges).get(0).getTarget();
            return dataset(dagWeave, outgoing, context);
        }
        // 有状态结点，选择状态路径
        if (vertexDataset instanceof VertexStateful) {
            VertexStateful vertexStateful = (VertexStateful) vertexDataset;
            Set outgoingEdges = dagWeave.getDirectedAcyclicGraph().outgoingEdgesOf(dagVertex);
            DagVertex outgoing = outgoingEdges.stream()
                    .map(e -> (DagVertex) e.getTarget())
                    .filter(e -> StringUtils.isBlank(vertexStateful.getTargetVertexId()) || vertexStateful.getTargetVertexId().equals(e.getVertexId()))
                    .findFirst()
                    .orElse(null);
            Preconditions.checkArgument(Objects.nonNull(outgoing), "(DAG)有状态结点出度边未找到");
            return dataset(dagWeave, outgoing, context);
        }
        throw new IllegalStateException("无效执行结点状态");
    }

}