# Api接口编排

**Repository Path**: aleiliuwei/api-interface-orchestration

## Basic Information

- **Project Name**: Api接口编排
- **Description**: API 接口可视化编排平台，是通过编排Service代码生成一个新的API，而不是编排已经存在的API。通过 jsPlumb 拖拽配置 API 调用流程，支持 Groovy 脚本节点进行数据转换，提供版本管理和灰度发布能力。技术栈：Spring Boot + MySQL + Vue 3。可适用于以下场景：

1. 一个应用经过长时间的维护和积累，基本已经实现本领域内所有业务逻辑（Service），
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 1
- **Created**: 2026-05-15
- **Last Updated**: 2026-05-15

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# API Interface Orchestration

API 接口编排平台 - 通过可视化流程编排，将多个 API 接口、功能节点组合成复杂的业务流程，实现低代码/无代码的 API 编排和管理。

## 项目简介

本项目是一个低代码 API 编排平台，允许用户通过可视化拖拽的方式，将多个微服务 API 组合成复杂的业务流程。支持 Groovy 动态脚本处理数据、API 版本管理、功能节点复用等特性。

## 功能特性

- **API 管理** - 定义 API 名称、路径、请求方法、描述、状态
- **API 版本管理** - 支持多版本共存，自动版本号生成
- **功能节点管理** - 定义可复用的功能节点，支持 Groovy 脚本
- **可视化流程编排** - 使用 jsPlumb 实现拖拽式流程设计
- **动态 API 执行引擎** - SDK 拦截请求并执行编排的流程
- **版本路由** - 根据请求参数或请求头选择 API 版本

## 技术栈

### 后端 (backend/)

| 技术 | 版本 | 用途 |
|------|------|------|
| Spring Boot | 2.7.18 | Web 框架 |
| MyBatis | 2.3.1 | ORM 框架 |
| MySQL | 8.0.33 | 数据库 |
| Druid | 1.2.20 | 数据库连接池 |
| Lombok | - | 简化代码 |

### 前端 (frontend/)

| 技术 | 版本 | 用途 |
|------|------|------|
| Vue | 3.5.x | 前端框架 |
| TypeScript | 5.x | 类型安全 |
| Vite | 7.x | 构建工具 |
| Element Plus | 2.x | UI 组件库 |
| Vue Router | 4.x | 路由管理 |
| Pinia | 3.x | 状态管理 |
| jsPlumb | 2.15.6 | 流程图绘制 |
| CodeMirror | 6.x | 代码编辑器 |
| Axios | 1.x | HTTP 客户端 |

### SDK (sdk/)

| 技术 | 版本 | 用途 |
|------|------|------|
| Spring | 6.0.x | Spring 核心 |
| OpenFeign | 4.0.x | HTTP 客户端 |
| Groovy | 4.0.x | 动态脚本执行 |
| Jackson | 2.16.x | JSON 处理 |

## 项目结构

```
api-interface-orchestration/
├── backend/                           # 后端服务
│   ├── src/main/java/
│   │   └── com/xianyu/orchestration/
│   │       ├── controller/            # 控制器
│   │       ├── service/               # 服务层
│   │       ├── mapper/                # MyBatis Mapper
│   │       ├── entity/                # 实体类
│   │       └── OrchestrationApplication.java
│   └── src/main/resources/
│       └── application.yml            # 配置文件
├── frontend/                          # 前端界面
│   ├── src/
│   │   ├── views/                     # 页面组件
│   │   ├── components/                # 公共组件
│   │   ├── api/                       # API 接口
│   │   ├── router/                    # 路由配置
│   │   └── stores/                    # 状态管理
│   ├── package.json
│   └── vite.config.ts
└── sdk/                               # SDK 库
    └── src/main/java/
        └── com/xianyu/sdk/
            ├── core/                  # 核心执行引擎
            ├── model/                 # 数据模型
            └── util/                  # 工具类
```

## 快速开始

### 环境要求

- JDK 17+
- Node.js 18+
- MySQL 8.0+
- Maven 3.6+

### 后端启动

1. 创建数据库
   ```sql
   CREATE DATABASE api_orchestration DEFAULT CHARACTER SET utf8mb4;
   ```

2. 修改配置文件 `backend/src/main/resources/application.yml`
   ```yaml
   spring:
     datasource:
       url: jdbc:mysql://localhost:3306/api_orchestration
       username: root
       password: your_password
   ```

3. 启动后端服务
   ```bash
   cd backend
   mvn spring-boot:run
   ```

### 前端启动

```bash
cd frontend
npm install
npm run dev
```

访问 http://localhost:5173

## 核心概念

### 1. API 定义

定义一个对外暴露的 API 接口：
- API 名称
- API 路径（如 `/api/user/info`）
- 请求方法（GET/POST/PUT/DELETE）
- 描述
- 状态（启用/禁用）

### 2. API 版本

每个 API 可以有多个版本：
- 版本号（自动生成）
- 流程配置（JSON 格式）
- 版本描述
- 状态

### 3. 功能节点

可复用的处理单元：
- **开始节点** - 流程入口
- **结束节点** - 流程出口
- **编程节点** - 执行业务逻辑

节点配置包括：
- Bean 名称和类全路径
- 方法名
- 输入脚本（Groovy）
- 输出脚本（Groovy）

### 4. 流程编排

通过可视化界面：
1. 从节点库选择功能节点
2. 拖拽连线定义执行顺序
3. 配置节点的输入/输出脚本
4. 保存流程配置

## 工作流程

```
┌─────────────────────────────────────────────────────────────┐
│                      用户操作流程                            │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   1. 创建 API 定义 (名称、路径、方法)                         │
│              ↓                                               │
│   2. 创建 API 版本                                           │
│              ↓                                               │
│   3. 可视化编排流程                                           │
│      - 从节点库选择功能节点                                    │
│      - 拖拽连线定义执行顺序                                    │
│      - 配置节点的输入/输出脚本                                 │
│              ↓                                               │
│   4. 保存流程配置 (JSON 格式)                                 │
│              ↓                                               │
│   5. 发布 API 版本                                           │
│              ↓                                               │
│   6. 调用动态 API                                             │
│      - SDK 拦截请求                                           │
│      - 匹配 API 和版本                                        │
│      - 执行流程编排                                           │
│      - 返回结果                                               │
│                                                              │
└─────────────────────────────────────────────────────────────┘
```

## API 接口

### API 管理

| 方法 | 路径 | 描述 |
|------|------|------|
| GET | `/api/apis` | 获取所有 API 列表 |
| POST | `/api/apis` | 创建 API |
| PUT | `/api/apis/{id}` | 更新 API |
| DELETE | `/api/apis/{id}` | 删除 API |

### API 版本管理

| 方法 | 路径 | 描述 |
|------|------|------|
| GET | `/api/apis/{apiId}/versions` | 获取 API 版本列表 |
| POST | `/api/apis/{apiId}/versions` | 创建 API 版本 |
| PUT | `/api/versions/{id}` | 更新版本配置 |

### 功能节点管理

| 方法 | 路径 | 描述 |
|------|------|------|
| GET | `/api/nodes` | 获取所有功能节点 |
| POST | `/api/nodes` | 创建功能节点 |
| PUT | `/api/nodes/{id}` | 更新功能节点 |
| DELETE | `/api/nodes/{id}` | 删除功能节点 |

## 使用示例

### 创建功能节点

```java
@Service
public class UserService {
    
    public Map<String, Object> getUserInfo(Map<String, Object> input) {
        // 业务逻辑处理
        Long userId = (Long) input.get("userId");
        // 查询用户信息...
        return result;
    }
}
```

### 配置节点

1. 节点名称：获取用户信息
2. Bean 名称：userService
3. Bean 类：com.example.service.UserService
4. 方法名：getUserInfo
5. 输入脚本：
   ```groovy
   return [userId: context.requestBody.userId]
   ```
6. 输出脚本：
   ```groovy
   return [user: output, code: 200]
   ```

### 编排流程

通过可视化界面拖拽节点并连线，形成完整的业务流程。

## 适用场景

- **API 聚合编排** - 将多个微服务 API 组合成一个
- **业务流程自动化** - 定义复杂的业务处理流程
- **数据转换与处理管道** - 多步骤数据处理
- **灰度发布与版本管理** - 按版本号路由请求
- **快速原型开发** - 无需编码即可创建 API

## 扩展开发

### 添加自定义节点

1. 创建 Spring Bean 并实现业务方法
2. 在管理界面创建功能节点配置
3. 在流程编排中使用该节点

### 扩展执行引擎

SDK 提供了扩展点，可以自定义：
- 节点执行器
- 条件判断器
- 异常处理器

## 注意事项

1. Groovy 脚本执行需要考虑安全性，建议在沙箱环境中运行
2. 流程配置以 JSON 格式存储，注意字段大小
3. 版本发布后建议不可修改，保证 API 稳定性

## 许可证

本项目仅供学习和参考使用。

## 贡献

欢迎提交 Issue 和 Pull Request 来改进这个项目。

## 联系方式

如有问题或建议，请通过 Issue 反馈。