工作流引擎设计与Java实现

一、核心架构与UML类图

1. UML类图解析：

二、Java核心实现代码

1.流程定义（核心类）：

// 流程任务节点定义
public class TaskNode {
    private String nodeId;
    private NodeType type; // 节点类型：START/END/TASK/DECISION
    private Map<String, String> nextNodes = new HashMap<>(); // 条件分支

    public boolean execute(ExecutionContext context) {
        // 执行节点逻辑（可扩展）
        switch (type) {
            case START:
                System.out.println("流程启动");
                return true;
            case TASK:
                System.out.println("执行任务: " + nodeId);
                return true;
            case DECISION:
                String condition = (String) context.getVariable("condition");
                String nextNodeId = nextNodes.get(condition);
                context.setCurrentNodeId(nextNodeId);
                return true;
            case END:
                System.out.println("流程结束");
                return false;
            default:
                throw new IllegalStateException("未知节点类型");
        }
    }
}

// 流程定义存储
public class WorkflowDefinition {
    private String id;
    private List<TaskNode> nodes = new ArrayList<>();
    
    public void addNode(TaskNode node) {
        nodes.add(node);
    }
}

2. 流程实例管理：

// 流程实例
public class WorkflowInstance {
    private String instanceId;
    private WorkflowState state;
    private Map<String, Object> variables = new HashMap<>();
    private String currentNodeId;

    public List<TaskNode> getCurrentTasks(WorkflowDefinition definition) {
        return definition.getNodes().stream()
                .filter(node -> node.getNodeId().equals(currentNodeId))
                .collect(Collectors.toList());
    }
}

3. 引擎执行器:

public class WorkflowEngine {
    private Map<String, WorkflowDefinition> definitions = new HashMap<>();
    private Map<String, WorkflowInstance> instances = new HashMap<>();

    // 启动流程
    public String startWorkflow(String definitionId) {
        WorkflowDefinition definition = definitions.get(definitionId);
        WorkflowInstance instance = new WorkflowInstance();
        instance.setCurrentNodeId("START");
        instances.put(instance.getInstanceId(), instance);
        executeNextTask(instance);
        return instance.getInstanceId();
    }

    // 执行任务链
    private void executeNextTask(WorkflowInstance instance) {
        WorkflowDefinition definition = definitions.get(instance.getDefinitionId());
        List<TaskNode> currentTasks = instance.getCurrentTasks(definition);
        
        currentTasks.forEach(task -> {
            ExecutionContext context = new ExecutionContext(instance);
            boolean continueExecution = task.execute(context);
            if (continueExecution) {
                instance.setCurrentNodeId(task.getNextNodeId());
                executeNextTask(instance); // 递归执行
            } else {
                instance.setState(WorkflowState.COMPLETED);
            }
        });
    }
}

三、流程执行UML活动图:

四、典型流程示例

1. 审批流程定义:

public class ApprovalWorkflowDemo {
    public static void main(String[] args) {
        // 1. 定义流程
        WorkflowDefinition definition = new WorkflowDefinition("approval_flow");
        
        TaskNode start = new TaskNode("START", NodeType.START);
        start.addNextNode("SUBMIT", "submit_task");
        
        TaskNode submit = new TaskNode("submit_task", NodeType.TASK);
        submit.addNextNode("NEXT", "manager_approval");
        
        TaskNode approval = new TaskNode("manager_approval", NodeType.DECISION);
        approval.addNextNode("APPROVE", "end");
        approval.addNextNode("REJECT", "submit_task"); // 打回重填
        
        definition.addNode(start);
        definition.addNode(submit);
        definition.addNode(approval);

        // 2. 启动流程
        WorkflowEngine engine = new WorkflowEngine();
        String instanceId = engine.startWorkflow("approval_flow");
    }
}

2. 执行输出:

流程启动
执行任务: submit_task
执行决策节点: manager_approval
流程结束

五、扩展方向

1.持久化存储‌:

// 使用JPA实现流程状态存储
@Entity
public class WorkflowInstanceEntity {
    @Id
    private String instanceId;
    @Enumerated(EnumType.STRING)
    private WorkflowState state;
}

2.分布式任务调度‌:

// 集成RabbitMQ实现任务分发
@RabbitListener(queues = "workflow_tasks")
public void handleTask(TaskMessage message) {
    engine.executeTask(message.getInstanceId(), message.getTaskId());
}

3.附录：

总结:

通过本文的学习，我们了解了工作流引擎的基本概念及其在实际应用中的重要性。虽然我们构建了一个非常简化的版本，但它涵盖了工作流引擎的主要元素：流程定义、流程实例、活动和转移。对于更复杂的应用场景，可以考虑使用成熟的开源工作流引擎，如Activiti、Camunda等，它们提供了更多高级特性，如图形化编辑器、持久化支持等。