# abstract-flow-engine

**Repository Path**: panda_student/abstract-flow-engine

## Basic Information

- **Project Name**: abstract-flow-engine
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-11-10
- **Last Updated**: 2025-11-10

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 抽象审批流程引擎框架

一个基于Java的轻量级、可扩展的审批流程引擎框架，采用面向对象设计，遵循SOLID原则，支持自定义审批节点和流程定义。

## 功能特性

- ✅ 流程定义管理
- ✅ 流程实例执行
- ✅ 审批节点抽象
- ✅ 流程状态管理
- ✅ 节点历史记录
- ✅ 单元测试覆盖
- ✅ 可扩展架构

## 快速开始

### 1. 添加依赖

```xml
<dependency>
    <groupId>com.flowengine</groupId>
    <artifactId>abstract-flow-engine</artifactId>
    <version>1.0.0</version>
</dependency>
```

### 2. 创建自定义审批节点

```java
package com.example;

import com.flowengine.*;

/**
 * 自定义审批节点示例
 */
public class CustomApprovalNode extends AbstractApprovalNode {
    
    private final String nextNodeId;
    
    public CustomApprovalNode(String nodeId, String nodeName, String nextNodeId) {
        super(nodeId, nodeName, "custom");
        this.nextNodeId = nextNodeId;
    }
    
    @Override
    protected NodeResult doExecute(FlowContext context) {
        // 实现自定义审批逻辑
        String amount = (String) context.getVariable("amount");
        
        if (amount != null && Integer.parseInt(amount) <= 1000) {
            // 金额小于等于1000，自动审批通过
            return createSuccessResult("金额在限额内，自动审批通过");
        } else {
            // 需要人工审批
            return createNeedReapprovalResult("金额超过限额，需要人工审批");
        }
    }
    
    @Override
    public String getNextNodeId(FlowContext context) {
        return nextNodeId;
    }
    
    @Override
    public String getAssignee(FlowContext context) {
        // 根据业务逻辑动态分配处理人
        String department = (String) context.getVariable("department");
        if ("技术部".equals(department)) {
            return "tech-approver";
        } else {
            return "default-approver";
        }
    }
}
```

### 3. 创建自定义流程引擎

```java
package com.example;

import com.flowengine.*;
import java.util.*;

/**
 * 自定义流程引擎示例
 */
public class CustomFlowEngine extends AbstractFlowEngine {
    
    @Override
    protected String generateFlowInstanceId() {
        return "flow-" + UUID.randomUUID().toString().substring(0, 8);
    }
    
    @Override
    protected String getStartNodeId(String flowDefinitionId) {
        // 根据流程定义ID返回起始节点ID
        switch (flowDefinitionId) {
            case "expense-approval":
                return "start-expense";
            case "leave-approval":
                return "start-leave";
            default:
                return "start-default";
        }
    }
    
    @Override
    protected FlowContext createFlowContext(FlowInstance instance) {
        return new DefaultFlowContext(
            instance.getFlowInstanceId(),
            instance.getFlowDefinitionId(),
            instance.getInitiator(),
            instance.getVariables()
        );
    }
    
    @Override
    protected void recordNodeHistory(FlowInstance instance, ApprovalNode node, NodeResult result) {
        NodeHistory history = new NodeHistory(
            node.getNodeId(),
            node.getNodeName(),
            node.getNodeType(),
            result.getStatus(),
            instance.getCurrentAssignee(),
            new Date(),
            instance.getApprovalComment(),
            result.getMessage()
        );
        instance.addHistory(history);
    }
    
    /**
     * 初始化流程定义
     */
    public void initializeFlowDefinitions() {
        // 创建费用审批流程
        createExpenseApprovalFlow();
        // 创建请假审批流程
        createLeaveApprovalFlow();
    }
    
    private void createExpenseApprovalFlow() {
        // 创建节点
        CustomApprovalNode startNode = new CustomApprovalNode("start-expense", "费用申请开始", "amount-check");
        CustomApprovalNode amountCheckNode = new CustomApprovalNode("amount-check", "金额检查", "manager-approval");
        CustomApprovalNode managerNode = new CustomApprovalNode("manager-approval", "经理审批", "finance-approval");
        CustomApprovalNode financeNode = new CustomApprovalNode("finance-approval", "财务审批", null);
        
        // 注册节点
        registerNode(startNode);
        registerNode(amountCheckNode);
        registerNode(managerNode);
        registerNode(financeNode);
        
        // 创建流程定义
        FlowDefinition definition = new FlowDefinition(
            "expense-approval",
            "费用审批流程",
            "员工费用报销审批流程",
            "start-expense",
            Arrays.asList(
                new NodeDefinition("start-expense", "费用申请开始", "start", null, "amount-check", new HashMap<>()),
                new NodeDefinition("amount-check", "金额检查", "custom", null, "manager-approval", new HashMap<>()),
                new NodeDefinition("manager-approval", "经理审批", "custom", null, "finance-approval", new HashMap<>()),
                new NodeDefinition("finance-approval", "财务审批", "custom", null, null, new HashMap<>())
            ),
            "1.0"
        );
        
        registerFlowDefinition(definition);
    }
    
    private void createLeaveApprovalFlow() {
        // 创建请假审批流程节点...
        // 类似费用审批流程的实现
    }
}
```

### 4. 使用流程引擎

```java
package com.example;

import java.util.*;

public class FlowEngineDemo {
    
    public static void main(String[] args) {
        // 创建流程引擎实例
        CustomFlowEngine flowEngine = new CustomFlowEngine();
        flowEngine.initializeFlowDefinitions();
        
        // 启动费用审批流程
        Map<String, Object> variables = new HashMap<>();
        variables.put("amount", "800");
        variables.put("department", "技术部");
        variables.put("reason", "项目差旅费用");
        
        String flowInstanceId = flowEngine.startFlow("expense-approval", "employee123", variables);
        System.out.println("流程启动成功，实例ID: " + flowInstanceId);
        
        // 执行流程
        FlowResult result = flowEngine.executeFlow(flowInstanceId);
        System.out.println("流程执行结果: " + result.isSuccess());
        
        // 获取当前节点信息
        NodeInfo currentNode = flowEngine.getCurrentNode(flowInstanceId);
        if (currentNode != null) {
            System.out.println("当前节点: " + currentNode.getNodeName());
        }
        
        // 审批通过当前节点
        FlowResult approveResult = flowEngine.approve(flowInstanceId, "manager1", "同意报销");
        System.out.println("审批结果: " + approveResult.getMessage());
        
        // 获取流程历史
        List<NodeHistory> history = flowEngine.getFlowHistory(flowInstanceId);
        for (NodeHistory record : history) {
            System.out.println("节点: " + record.getNodeName() + ", 状态: " + record.getStatus());
        }
    }
}
```

## 核心类说明

### 主要接口

- `FlowEngine` - 流程引擎核心接口
- `ApprovalNode` - 审批节点接口
- `FlowContext` - 流程上下文接口

### 主要抽象类

- `AbstractFlowEngine` - 抽象流程引擎基类
- `AbstractApprovalNode` - 抽象审批节点基类

### 主要实体类

- `FlowDefinition` - 流程定义
- `FlowInstance` - 流程实例
- `NodeDefinition` - 节点定义
- `NodeHistory` - 节点历史记录
- `FlowResult` - 流程执行结果
- `NodeResult` - 节点执行结果

## 测试

项目包含完整的单元测试，确保框架功能的正确性：

```bash
mvn test
```

## 扩展指南

### 自定义审批节点

1. 继承 `AbstractApprovalNode` 类
2. 实现 `doExecute()` 方法，编写审批逻辑
3. 重写 `getNextNodeId()` 方法，定义节点路由
4. 重写 `getAssignee()` 方法，动态分配处理人

### 自定义流程引擎

1. 继承 `AbstractFlowEngine` 类
2. 实现抽象方法：
   - `generateFlowInstanceId()` - 生成流程实例ID
   - `getStartNodeId()` - 获取起始节点ID
   - `createFlowContext()` - 创建流程上下文
   - `recordNodeHistory()` - 记录节点历史

## 最佳实践

1. **节点设计**：每个节点职责单一，避免复杂逻辑
2. **错误处理**：在节点执行中妥善处理异常情况
3. **状态管理**：合理使用流程状态和节点状态
4. **历史记录**：记录完整的审批历史便于审计
5. **测试覆盖**：为自定义节点编写单元测试

## 版本信息

- 当前版本：1.0.0
- Java版本：8+
- 测试框架：JUnit 5
- 构建工具：Maven

## 许可证

MIT License