01 - 项目初始化与架构设计

🎯 目标 : 从零开始设计一个流程编排框架的整体架构。项目地址：github.com/nemoob/simp...

🤔 为什么需要流程编排框架？

在现代软件开发中，我们经常遇到这样的场景：

📋 复杂业务流程: 用户注册、订单处理、数据同步等
🔄 重复性任务: 批处理、定时任务、数据迁移等
🌐 微服务编排: 多个服务之间的协调调用
🔀 条件分支: 根据不同条件执行不同的业务逻辑

传统的代码实现方式往往导致：

😵 代码耦合度高，难以维护
🔄 重复代码多，缺乏复用性
🐛 错误处理复杂，调试困难
📈 扩展性差，难以应对变化

🎯 设计目标

我们的流程编排框架需要满足以下目标：

🚀 核心目标

简单易用: 提供直观的API，降低学习成本
灵活扩展: 支持自定义步骤和执行器
高性能: 支持并行执行和异步处理
可靠性: 完善的错误处理和重试机制

🛠️ 技术目标

零依赖核心: 核心模块不依赖第三方库
框架集成: 支持Spring Boot等主流框架
多种定义方式: 注解、配置文件、编程式API
生产就绪: 监控、日志、调试等完善的运维能力

🏗️ 整体架构设计

graph TB subgraph "API层 🎨" A1[注解API] A2[配置API] A3[编程API] end subgraph "核心层 ⚙️" B1[流程引擎] B2[执行器管理] B3[上下文管理] B4[事件系统] end subgraph "执行层 🚀" C1[串行执行器] C2[并行执行器] C3[条件执行器] C4[脚本执行器] end subgraph "扩展层 🔧" D1[Spring集成] D2[监控集成] D3[持久化集成] end A1 --> B1 A2 --> B1 A3 --> B1 B1 --> B2 B1 --> B3 B1 --> B4 B2 --> C1 B2 --> C2 B2 --> C3 B2 --> C4 B1 --> D1 B1 --> D2 B1 --> D3

📦 模块划分

🎯 simple-flow-api

职责: 定义核心接口和数据模型

bash 复制代码

├── FlowDefinition      # 流程定义接口
├── StepDefinition      # 步骤定义接口
├── FlowContext         # 执行上下文接口
├── FlowEngine          # 流程引擎接口
└── StepExecutor        # 步骤执行器接口

⚙️ simple-flow-core

职责: 核心执行引擎实现

csharp 复制代码

├── engine/             # 流程引擎实现
├── executor/           # 步骤执行器实现
├── context/            # 上下文管理
├── event/              # 事件系统
└── exception/          # 异常处理

📝 simple-flow-expression

职责: 表达式和脚本支持

r 复制代码

├── script/             # 脚本引擎集成
├── expression/         # 表达式解析
└── condition/          # 条件判断

🌱 simple-flow-spring-boot-starter

职责: Spring Boot自动配置

bash 复制代码

├── autoconfigure/      # 自动配置类
├── annotation/         # 注解支持
└── properties/         # 配置属性

🎨 核心概念设计

📋 Flow（流程）

java 复制代码

public interface FlowDefinition {
    String getId();                    // 流程ID
    String getName();                  // 流程名称
    List<StepDefinition> getSteps();   // 步骤列表
    Map<String, Object> getMetadata(); // 元数据
}

🔧 Step（步骤）

java 复制代码

public interface StepDefinition {
    String getId();                    // 步骤ID
    String getName();                  // 步骤名称
    StepType getType();               // 步骤类型
    Map<String, Object> getConfig();  // 配置信息
}

📦 Context（上下文）

java 复制代码

public interface FlowContext {
    <T> T get(String key);            // 获取数据
    void put(String key, Object value); // 存储数据
    Map<String, Object> getAll();     // 获取所有数据
    FlowContext createChild();         // 创建子上下文
}

🚀 执行流程设计

sequenceDiagram participant Client participant Engine as FlowEngine participant Context as FlowContext participant Executor as StepExecutor Client->>Engine: execute(flow, context) Engine->>Context: 初始化上下文 loop 遍历步骤 Engine->>Engine: 选择执行器 Engine->>Executor: execute(step, context) Executor->>Context: 读取/写入数据 Executor-->>Engine: 返回结果 alt 步骤失败 Engine->>Engine: 错误处理 end end Engine-->>Client: 返回执行结果

📁 项目结构初始化

1️⃣ 创建Maven父项目

xml 复制代码

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>com.simpleflow</groupId>
    <artifactId>simple-flow</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    
    <name>Simple Flow</name>
    <description>轻量级流程编排框架</description>
    
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    
    <modules>
        <module>simple-flow-api</module>
        <module>simple-flow-core</module>
        <module>simple-flow-expression</module>
        <module>simple-flow-spring-boot-starter</module>
    </modules>
</project>

2️⃣ 定义版本管理

xml 复制代码

<dependencyManagement>
    <dependencies>
        <!-- 内部模块 -->
        <dependency>
            <groupId>com.simpleflow</groupId>
            <artifactId>simple-flow-api</artifactId>
            <version>${project.version}</version>
        </dependency>
        
        <!-- 第三方依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.7.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

🎯 设计原则

1️⃣ 单一职责原则

每个模块只负责一个特定的功能
接口定义清晰，职责明确

2️⃣ 开闭原则

对扩展开放：支持自定义执行器
对修改封闭：核心逻辑稳定不变

3️⃣ 依赖倒置原则

依赖抽象而非具体实现
通过接口定义契约

4️⃣ 最少知识原则

模块间耦合度最小
通过事件系统解耦

🔍 关键决策

❓ 为什么选择Java 8？

✅ 企业级应用的主流版本
✅ Lambda表达式支持函数式编程
✅ Stream API简化集合操作
✅ 兼容性好，部署简单

❓ 为什么采用多模块设计？

✅ 职责分离，便于维护
✅ 按需依赖，减少包大小
✅ 独立发布，版本管理灵活
✅ 团队协作，并行开发

❓ 为什么选择接口优先设计？

✅ 便于测试和Mock
✅ 支持多种实现方式
✅ 降低模块间耦合
✅ 便于后续扩展

🎉 小结

在这一章中，我们完成了：

🎯 明确了设计目标: 简单易用、灵活扩展、高性能、可靠性
🏗️ 设计了整体架构: 分层架构，职责清晰
📦 划分了核心模块: API、Core、Expression、Spring Boot Starter
🎨 定义了核心概念: Flow、Step、Context等核心抽象
📁 初始化了项目结构: Maven多模块项目

🚀 下一步

在下一章《核心模型设计》中，我们将：

📝 详细设计核心数据模型
🔧 定义关键接口和枚举
🎨 实现建造者模式的API
🧪 编写单元测试验证设计

💡 思考题:

你认为还有哪些设计原则需要考虑？
如果要支持分布式执行，架构需要如何调整？
如何设计才能让框架既简单又强大？