1788 lines
51 KiB
Markdown
1788 lines
51 KiB
Markdown
# 后端技术设计文档
|
||
|
||
**版本**: v1.0
|
||
**关联**: 01-架构总览.md
|
||
|
||
---
|
||
|
||
## 一、技术栈详细说明
|
||
|
||
### 1.1 核心依赖
|
||
|
||
```xml
|
||
<!-- pom.xml -->
|
||
<dependencies>
|
||
<!-- Spring Boot (WebFlux，仅使用 WebClient) -->
|
||
<dependency>
|
||
<groupId>org.springframework.boot</groupId>
|
||
<artifactId>spring-boot-starter-webflux</artifactId>
|
||
<version>3.2.0</version>
|
||
</dependency>
|
||
|
||
<!-- Flowable -->
|
||
<dependency>
|
||
<groupId>org.flowable</groupId>
|
||
<artifactId>flowable-spring-boot-starter</artifactId>
|
||
<version>7.0.1</version>
|
||
</dependency>
|
||
|
||
<!-- MySQL -->
|
||
<dependency>
|
||
<groupId>com.mysql</groupId>
|
||
<artifactId>mysql-connector-j</artifactId>
|
||
<version>8.3.0</version>
|
||
</dependency>
|
||
|
||
<!-- Redis -->
|
||
<dependency>
|
||
<groupId>org.springframework.boot</groupId>
|
||
<artifactId>spring-boot-starter-data-redis</artifactId>
|
||
</dependency>
|
||
|
||
<!-- JSON处理 -->
|
||
<dependency>
|
||
<groupId>com.fasterxml.jackson.core</groupId>
|
||
<artifactId>jackson-databind</artifactId>
|
||
</dependency>
|
||
|
||
<!-- 表达式引擎 (JUEL - Jakarta EL) -->
|
||
<dependency>
|
||
<groupId>jakarta.el</groupId>
|
||
<artifactId>jakarta.el-api</artifactId>
|
||
<version>5.0.0</version>
|
||
</dependency>
|
||
<dependency>
|
||
<groupId>org.glassfish</groupId>
|
||
<artifactId>jakarta.el</artifactId>
|
||
<version>5.0.0</version>
|
||
</dependency>
|
||
|
||
<!-- 邮件 -->
|
||
<dependency>
|
||
<groupId>org.springframework.boot</groupId>
|
||
<artifactId>spring-boot-starter-mail</artifactId>
|
||
</dependency>
|
||
</dependencies>
|
||
```
|
||
|
||
### 1.2 配置文件
|
||
|
||
```yaml
|
||
# application.yml
|
||
spring:
|
||
application:
|
||
name: workflow-platform
|
||
|
||
# 数据源配置（外部 MySQL，不使用 Docker）
|
||
datasource:
|
||
url: jdbc:mysql://172.22.222.111:3306/flowable-devops?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
|
||
username: root # 请按实际用户名填写
|
||
password: ${SPRING_DATASOURCE_PASSWORD} # 请通过环境变量安全注入密码
|
||
driver-class-name: com.mysql.cj.jdbc.Driver
|
||
hikari:
|
||
maximum-pool-size: 20
|
||
minimum-idle: 5
|
||
connection-timeout: 30000
|
||
|
||
# Redis配置（外部 Redis，不使用 Docker）
|
||
redis:
|
||
host: 172.22.222.111
|
||
port: 6379
|
||
database: 5
|
||
password: ${SPRING_REDIS_PASSWORD}
|
||
timeout: 5000
|
||
|
||
# 邮件配置
|
||
mail:
|
||
host: smtp.example.com
|
||
port: 587
|
||
username: noreply@example.com
|
||
password: ${SMTP_PASSWORD}
|
||
properties:
|
||
mail.smtp.auth: true
|
||
mail.smtp.starttls.enable: true
|
||
|
||
# Flowable配置（MVP 为同步执行，关闭全局异步执行器）
|
||
flowable:
|
||
process-definition-location-prefix: classpath*:/processes/
|
||
database-schema-update: true
|
||
async-executor-activate: false
|
||
|
||
# 应用配置
|
||
app:
|
||
workflow:
|
||
expression-cache-size: 1000
|
||
node-execution-timeout: 300
|
||
enable-execution-logging: true
|
||
```
|
||
|
||
---
|
||
|
||
## 二、数据模型设计
|
||
|
||
### 2.1 业务表设计（非Flowable表）
|
||
|
||
#### 表1: workflow_definitions（工作流定义）
|
||
|
||
```sql
|
||
CREATE TABLE workflow_definitions (
|
||
id VARCHAR(64) PRIMARY KEY,
|
||
name VARCHAR(255) NOT NULL,
|
||
description TEXT,
|
||
|
||
-- 工作流定义（JSON格式）⭐
|
||
definition JSON NOT NULL,
|
||
/* JSON 结构:
|
||
{
|
||
"nodes": [
|
||
{
|
||
"id": "node1",
|
||
"type": "http_request",
|
||
"name": "Get User",
|
||
"position": {"x": 100, "y": 100},
|
||
"config": {
|
||
"url": "https://api.example.com",
|
||
"method": "GET"
|
||
}
|
||
}
|
||
],
|
||
"edges": [
|
||
{"source": "node1", "target": "node2"}
|
||
],
|
||
"variables": {}
|
||
}
|
||
*/
|
||
|
||
-- Flowable流程定义ID（转换后）
|
||
flowable_process_definition_id VARCHAR(64),
|
||
flowable_deployment_id VARCHAR(64),
|
||
|
||
-- 状态
|
||
status VARCHAR(20) DEFAULT 'draft', -- draft, active, archived
|
||
|
||
-- 元数据
|
||
created_by VARCHAR(100),
|
||
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||
|
||
-- 索引
|
||
CONSTRAINT chk_status CHECK (status IN ('draft', 'active', 'archived'))
|
||
);
|
||
|
||
-- 索引
|
||
CREATE INDEX idx_workflow_status ON workflow_definitions(status);
|
||
CREATE INDEX idx_workflow_created_at ON workflow_definitions(created_at);
|
||
```
|
||
|
||
#### 表2: node_types（节点类型元数据）
|
||
|
||
```sql
|
||
CREATE TABLE node_types (
|
||
id VARCHAR(64) PRIMARY KEY,
|
||
name VARCHAR(255) NOT NULL,
|
||
display_name VARCHAR(255) NOT NULL,
|
||
category VARCHAR(50), -- api, database, logic, notification
|
||
icon VARCHAR(100),
|
||
description TEXT,
|
||
|
||
-- 字段定义（JSON Schema）⭐
|
||
fields JSON NOT NULL,
|
||
/* JSON 结构:
|
||
[
|
||
{
|
||
"name": "url",
|
||
"label": "URL",
|
||
"type": "text",
|
||
"required": true,
|
||
"supportsExpression": true,
|
||
"placeholder": "https://api.example.com"
|
||
},
|
||
{
|
||
"name": "method",
|
||
"label": "Method",
|
||
"type": "select",
|
||
"options": ["GET", "POST", "PUT", "DELETE"],
|
||
"defaultValue": "GET"
|
||
}
|
||
]
|
||
*/
|
||
|
||
-- 输出结构定义（JSON Schema）⭐
|
||
output_schema JSON,
|
||
/* JSON 结构:
|
||
{
|
||
"type": "object",
|
||
"properties": {
|
||
"statusCode": {"type": "number"},
|
||
"body": {"type": "object"},
|
||
"headers": {"type": "object"}
|
||
}
|
||
}
|
||
*/
|
||
|
||
-- Java实现类
|
||
implementation_class VARCHAR(255) NOT NULL,
|
||
|
||
-- 是否启用
|
||
enabled BOOLEAN DEFAULT true,
|
||
|
||
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
||
);
|
||
|
||
-- 内置节点类型初始数据
|
||
INSERT INTO node_types (id, name, display_name, category, icon, fields, output_schema, implementation_class) VALUES
|
||
('http_request', 'httpRequest', 'HTTP Request', 'api', 'api',
|
||
'[{"name":"url","label":"URL","type":"text","required":true,"supportsExpression":true}]',
|
||
'{"type":"object","properties":{"statusCode":{"type":"number"},"body":{"type":"object"}}}',
|
||
'com.workflow.nodes.HttpRequestNode');
|
||
```
|
||
|
||
#### 表3: workflow_executions（工作流执行记录扩展）
|
||
|
||
```sql
|
||
CREATE TABLE workflow_executions (
|
||
id VARCHAR(64) PRIMARY KEY,
|
||
workflow_id VARCHAR(64) NOT NULL,
|
||
workflow_definition_id VARCHAR(64) NOT NULL,
|
||
|
||
-- Flowable流程实例ID
|
||
flowable_process_instance_id VARCHAR(64) NOT NULL,
|
||
|
||
-- 输入参数
|
||
input JSON,
|
||
|
||
-- 执行状态
|
||
status VARCHAR(20) DEFAULT 'running', -- running, completed, failed, cancelled
|
||
|
||
-- 开始/结束时间
|
||
started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||
ended_at TIMESTAMP,
|
||
|
||
-- 错误信息
|
||
error_message TEXT,
|
||
error_stack TEXT,
|
||
|
||
-- 触发方式
|
||
trigger_type VARCHAR(20), -- manual, cron, webhook
|
||
triggered_by VARCHAR(100),
|
||
|
||
FOREIGN KEY (workflow_definition_id) REFERENCES workflow_definitions(id),
|
||
CONSTRAINT chk_execution_status CHECK (status IN ('running', 'completed', 'failed', 'cancelled'))
|
||
);
|
||
|
||
-- 索引
|
||
CREATE INDEX idx_execution_workflow ON workflow_executions(workflow_definition_id);
|
||
CREATE INDEX idx_execution_status ON workflow_executions(status);
|
||
CREATE INDEX idx_execution_started_at ON workflow_executions(started_at);
|
||
```
|
||
|
||
#### 表4: node_execution_logs（节点执行日志）
|
||
|
||
```sql
|
||
CREATE TABLE node_execution_logs (
|
||
id BIGSERIAL PRIMARY KEY,
|
||
execution_id VARCHAR(64) NOT NULL,
|
||
node_id VARCHAR(64) NOT NULL,
|
||
node_name VARCHAR(255),
|
||
node_type VARCHAR(64),
|
||
|
||
-- 输入/输出
|
||
input JSON,
|
||
output JSON,
|
||
|
||
-- 状态
|
||
status VARCHAR(20), -- success, failed, skipped
|
||
|
||
-- 时间
|
||
started_at TIMESTAMP,
|
||
ended_at TIMESTAMP,
|
||
duration_ms INTEGER,
|
||
|
||
-- 错误
|
||
error_message TEXT,
|
||
|
||
FOREIGN KEY (execution_id) REFERENCES workflow_executions(id)
|
||
);
|
||
|
||
-- 索引
|
||
CREATE INDEX idx_node_log_execution ON node_execution_logs(execution_id);
|
||
CREATE INDEX idx_node_log_status ON node_execution_logs(status);
|
||
```
|
||
|
||
### 2.2 Flowable表说明（不需要创建，自动生成）
|
||
|
||
```sql
|
||
-- Flowable会自动创建这些表，我们只需要知道它们的用途
|
||
|
||
-- 流程定义相关
|
||
ACT_RE_DEPLOYMENT -- 部署信息
|
||
ACT_RE_PROCDEF -- 流程定义
|
||
ACT_RE_MODEL -- 模型信息
|
||
|
||
-- 运行时数据
|
||
ACT_RU_EXECUTION -- 流程实例/执行
|
||
ACT_RU_TASK -- 任务（User Task）⭐
|
||
ACT_RU_VARIABLE -- 流程变量（我们的上下文数据）⭐
|
||
ACT_RU_JOB -- 异步任务
|
||
|
||
-- 历史数据
|
||
ACT_HI_PROCINST -- 流程实例历史
|
||
ACT_HI_TASKINST -- 任务历史
|
||
ACT_HI_VARINST -- 变量历史
|
||
ACT_HI_ACTINST -- 活动历史（每个节点的执行记录）⭐
|
||
```
|
||
|
||
---
|
||
|
||
## 三、核心模块实现
|
||
|
||
### 3.1 节点类型注册系统
|
||
|
||
#### NodeTypeRegistry.java
|
||
|
||
```java
|
||
package com.workflow.registry;
|
||
|
||
import com.workflow.model.NodeTypeMetadata;
|
||
import com.workflow.nodes.WorkflowNode;
|
||
import com.workflow.repository.NodeTypeRepository;
|
||
import org.springframework.beans.factory.annotation.Autowired;
|
||
import org.springframework.context.ApplicationContext;
|
||
import org.springframework.stereotype.Service;
|
||
|
||
import javax.annotation.PostConstruct;
|
||
import java.util.*;
|
||
import java.util.concurrent.ConcurrentHashMap;
|
||
|
||
/**
|
||
* 节点类型注册中心
|
||
*
|
||
* 职责：
|
||
* 1. 扫描并注册所有节点类型
|
||
* 2. 提供节点类型查询
|
||
* 3. 管理节点元数据
|
||
*/
|
||
@Service
|
||
public class NodeTypeRegistry {
|
||
|
||
private final Map<String, NodeTypeMetadata> nodeTypes = new ConcurrentHashMap<>();
|
||
private final Map<String, WorkflowNode> nodeInstances = new ConcurrentHashMap<>();
|
||
|
||
@Autowired
|
||
private ApplicationContext applicationContext;
|
||
|
||
@Autowired
|
||
private NodeTypeRepository repository;
|
||
|
||
/**
|
||
* 启动时自动扫描注册
|
||
*/
|
||
@PostConstruct
|
||
public void init() {
|
||
// 1. 扫描所有WorkflowNode实现类
|
||
Map<String, WorkflowNode> beans = applicationContext.getBeansOfType(WorkflowNode.class);
|
||
|
||
for (WorkflowNode node : beans.values()) {
|
||
registerNode(node);
|
||
}
|
||
|
||
// 2. 从数据库加载（支持动态注册）
|
||
List<NodeTypeMetadata> dbNodeTypes = repository.findAll();
|
||
for (NodeTypeMetadata metadata : dbNodeTypes) {
|
||
nodeTypes.put(metadata.getId(), metadata);
|
||
}
|
||
|
||
System.out.println("✅ 已注册 " + nodeTypes.size() + " 个节点类型");
|
||
}
|
||
|
||
/**
|
||
* 注册单个节点
|
||
*/
|
||
private void registerNode(WorkflowNode node) {
|
||
NodeTypeMetadata metadata = node.getMetadata();
|
||
|
||
// 验证必填字段
|
||
if (metadata.getId() == null || metadata.getImplementationClass() == null) {
|
||
throw new IllegalArgumentException("节点元数据不完整: " + metadata);
|
||
}
|
||
|
||
// 保存元数据
|
||
nodeTypes.put(metadata.getId(), metadata);
|
||
nodeInstances.put(metadata.getId(), node);
|
||
|
||
// 持久化到数据库
|
||
repository.save(metadata);
|
||
|
||
System.out.println(" - " + metadata.getDisplayName() + " (" + metadata.getId() + ")");
|
||
}
|
||
|
||
/**
|
||
* 获取节点元数据
|
||
*/
|
||
public NodeTypeMetadata getMetadata(String typeId) {
|
||
return nodeTypes.get(typeId);
|
||
}
|
||
|
||
/**
|
||
* 获取节点实例（用于执行）
|
||
*/
|
||
public WorkflowNode getNodeInstance(String typeId) {
|
||
return nodeInstances.get(typeId);
|
||
}
|
||
|
||
/**
|
||
* 获取所有节点类型（给前端用）
|
||
*/
|
||
public List<NodeTypeMetadata> getAllNodeTypes() {
|
||
return new ArrayList<>(nodeTypes.values());
|
||
}
|
||
|
||
/**
|
||
* 按分类获取节点类型
|
||
*/
|
||
public List<NodeTypeMetadata> getNodeTypesByCategory(String category) {
|
||
return nodeTypes.values().stream()
|
||
.filter(meta -> category.equals(meta.getCategory()))
|
||
.toList();
|
||
}
|
||
}
|
||
```
|
||
|
||
### 3.2 表达式引擎
|
||
|
||
#### ExpressionEngine.java
|
||
|
||
```java
|
||
package com.workflow.engine;
|
||
|
||
import org.flowable.engine.delegate.DelegateExecution;
|
||
import org.springframework.stereotype.Service;
|
||
|
||
import jakarta.el.*;
|
||
import java.util.Map;
|
||
import java.util.concurrent.ConcurrentHashMap;
|
||
import java.util.regex.Matcher;
|
||
import java.util.regex.Pattern;
|
||
|
||
/**
|
||
* 表达式解析引擎
|
||
*
|
||
* 支持语法:
|
||
* ${nodes.node1.output.body.email}
|
||
* ${workflow.input.username}
|
||
* ${env.API_KEY}
|
||
* ${nodes.step1.output.count > 10 ? 'high' : 'low'}
|
||
*/
|
||
@Service
|
||
public class ExpressionEngine {
|
||
|
||
private final ExpressionFactory expressionFactory;
|
||
|
||
// 表达式编译缓存（性能优化）⭐
|
||
private final Map<String, ValueExpression> expressionCache = new ConcurrentHashMap<>();
|
||
|
||
public ExpressionEngine() {
|
||
this.expressionFactory = ExpressionFactory.newInstance();
|
||
}
|
||
|
||
/**
|
||
* 解析单个表达式
|
||
*
|
||
* @param expression 表达式字符串，例如: "${nodes.node1.output.body.email}"
|
||
* @param execution Flowable执行上下文
|
||
* @return 解析后的值
|
||
*/
|
||
public Object evaluate(String expression, DelegateExecution execution) {
|
||
if (expression == null) {
|
||
return null;
|
||
}
|
||
|
||
// 快速路径：无表达式，直接返回 ⭐
|
||
if (!expression.contains("${")) {
|
||
return expression;
|
||
}
|
||
|
||
// 提取所有表达式: ${...}
|
||
Pattern pattern = Pattern.compile("\\$\\{([^}]+)\\}");
|
||
Matcher matcher = pattern.matcher(expression);
|
||
|
||
// 如果是纯表达式（整个字符串就是一个表达式）
|
||
if (matcher.matches()) {
|
||
return evaluateSingle(expression, execution);
|
||
}
|
||
|
||
// 混合字符串，替换所有表达式
|
||
StringBuffer result = new StringBuffer();
|
||
while (matcher.find()) {
|
||
String fullExpr = matcher.group(0); // ${...}
|
||
Object value = evaluateSingle(fullExpr, execution);
|
||
matcher.appendReplacement(result, Matcher.quoteReplacement(String.valueOf(value)));
|
||
}
|
||
matcher.appendTail(result);
|
||
|
||
return result.toString();
|
||
}
|
||
|
||
/**
|
||
* 解析单个完整表达式
|
||
*/
|
||
private Object evaluateSingle(String expression, DelegateExecution execution) {
|
||
try {
|
||
// 尝试从缓存获取
|
||
ValueExpression expr = expressionCache.get(expression);
|
||
|
||
if (expr == null) {
|
||
// 编译表达式
|
||
StandardELContext context = createContext(execution);
|
||
expr = expressionFactory.createValueExpression(context, expression, Object.class);
|
||
|
||
// 缓存（限制大小）
|
||
if (expressionCache.size() < 1000) {
|
||
expressionCache.put(expression, expr);
|
||
}
|
||
}
|
||
|
||
// 求值
|
||
StandardELContext context = createContext(execution);
|
||
return expr.getValue(context);
|
||
|
||
} catch (Exception e) {
|
||
throw new ExpressionEvaluationException(
|
||
"表达式解析失败: " + expression + ", 错误: " + e.getMessage(),
|
||
e
|
||
);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 创建EL上下文（注入变量）⭐⭐⭐
|
||
*/
|
||
private StandardELContext createContext(DelegateExecution execution) {
|
||
StandardELContext context = new StandardELContext(expressionFactory);
|
||
|
||
// 1. 注入 nodes（节点输出）
|
||
Map<String, Object> nodesData = (Map<String, Object>) execution.getVariable("nodes");
|
||
if (nodesData != null) {
|
||
ValueExpression nodesExpr = expressionFactory.createValueExpression(
|
||
nodesData, Map.class
|
||
);
|
||
context.getVariableMapper().setVariable("nodes", nodesExpr);
|
||
}
|
||
|
||
// 2. 注入 workflow（工作流输入和变量）
|
||
Map<String, Object> workflowData = (Map<String, Object>) execution.getVariable("workflow");
|
||
if (workflowData != null) {
|
||
ValueExpression workflowExpr = expressionFactory.createValueExpression(
|
||
workflowData, Map.class
|
||
);
|
||
context.getVariableMapper().setVariable("workflow", workflowExpr);
|
||
}
|
||
|
||
// 3. 注入 env（环境变量）
|
||
ValueExpression envExpr = expressionFactory.createValueExpression(
|
||
System.getenv(), Map.class
|
||
);
|
||
context.getVariableMapper().setVariable("env", envExpr);
|
||
|
||
return context;
|
||
}
|
||
|
||
/**
|
||
* 批量解析对象中的所有表达式（递归）
|
||
*/
|
||
public Map<String, Object> resolveObject(Map<String, Object> input, DelegateExecution execution) {
|
||
Map<String, Object> result = new HashMap<>();
|
||
|
||
for (Map.Entry<String, Object> entry : input.entrySet()) {
|
||
Object value = entry.getValue();
|
||
|
||
if (value instanceof String) {
|
||
// 解析字符串表达式
|
||
result.put(entry.getKey(), evaluate((String) value, execution));
|
||
|
||
} else if (value instanceof Map) {
|
||
// 递归解析嵌套对象
|
||
result.put(entry.getKey(), resolveObject((Map<String, Object>) value, execution));
|
||
|
||
} else if (value instanceof List) {
|
||
// 解析数组
|
||
List<?> list = (List<?>) value;
|
||
List<Object> resolvedList = new ArrayList<>();
|
||
for (Object item : list) {
|
||
if (item instanceof String) {
|
||
resolvedList.add(evaluate((String) item, execution));
|
||
} else if (item instanceof Map) {
|
||
resolvedList.add(resolveObject((Map<String, Object>) item, execution));
|
||
} else {
|
||
resolvedList.add(item);
|
||
}
|
||
}
|
||
result.put(entry.getKey(), resolvedList);
|
||
|
||
} else {
|
||
// 其他类型直接返回
|
||
result.put(entry.getKey(), value);
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 表达式解析异常
|
||
*/
|
||
class ExpressionEvaluationException extends RuntimeException {
|
||
public ExpressionEvaluationException(String message, Throwable cause) {
|
||
super(message, cause);
|
||
}
|
||
}
|
||
```
|
||
|
||
### 3.3 JSON → BPMN 转换器
|
||
|
||
#### WorkflowConverter.java
|
||
|
||
```java
|
||
package com.workflow.converter;
|
||
|
||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||
import com.workflow.model.*;
|
||
import org.flowable.bpmn.BpmnAutoLayout;
|
||
import org.flowable.bpmn.model.*;
|
||
import org.flowable.bpmn.model.Process;
|
||
import org.springframework.stereotype.Service;
|
||
|
||
import java.nio.charset.StandardCharsets;
|
||
import java.util.*;
|
||
|
||
/**
|
||
* 工作流转换器：JSON ↔ BPMN XML
|
||
*
|
||
* 核心职责：
|
||
* 1. 将前端的JSON工作流定义转换为Flowable的BPMN XML
|
||
* 2. 将BPMN XML转换回JSON（用于编辑）
|
||
*/
|
||
@Service
|
||
public class WorkflowConverter {
|
||
|
||
private final ObjectMapper objectMapper = new ObjectMapper();
|
||
|
||
/**
|
||
* JSON → BPMN XML
|
||
*
|
||
* @param workflow JSON格式的工作流定义
|
||
* @return BPMN 2.0 XML字符串
|
||
*/
|
||
public String convertToBpmn(WorkflowDefinition workflow) {
|
||
// 1. 创建BPMN模型
|
||
BpmnModel bpmnModel = new BpmnModel();
|
||
|
||
// 2. 创建流程
|
||
Process process = new Process();
|
||
process.setId(workflow.getId());
|
||
process.setName(workflow.getName());
|
||
|
||
// 3. 添加开始事件
|
||
StartEvent startEvent = new StartEvent();
|
||
startEvent.setId("start");
|
||
startEvent.setName("开始");
|
||
process.addFlowElement(startEvent);
|
||
|
||
// 4. 转换节点
|
||
Map<String, FlowElement> elementMap = new HashMap<>();
|
||
for (WorkflowNode node : workflow.getNodes()) {
|
||
FlowElement element = convertNode(node);
|
||
process.addFlowElement(element);
|
||
elementMap.put(node.getId(), element);
|
||
}
|
||
|
||
// 5. 添加结束事件
|
||
EndEvent endEvent = new EndEvent();
|
||
endEvent.setId("end");
|
||
endEvent.setName("结束");
|
||
process.addFlowElement(endEvent);
|
||
|
||
// 6. 转换连线
|
||
convertEdges(workflow, process, elementMap);
|
||
|
||
// 7. 添加流程到模型
|
||
bpmnModel.addProcess(process);
|
||
|
||
// 8. 自动布局（可选）
|
||
new BpmnAutoLayout(bpmnModel).execute();
|
||
|
||
// 9. 转换为XML
|
||
return convertBpmnModelToXml(bpmnModel);
|
||
}
|
||
|
||
/**
|
||
* 转换单个节点
|
||
*/
|
||
private FlowElement convertNode(WorkflowNode node) {
|
||
// 根据节点类型创建不同的BPMN元素
|
||
|
||
// User Task（审批节点）
|
||
if ("approval".equals(node.getType()) || "user_task".equals(node.getType())) {
|
||
return createUserTask(node);
|
||
}
|
||
|
||
// Service Task（普通节点）
|
||
return createServiceTask(node);
|
||
}
|
||
|
||
/**
|
||
* 创建Service Task
|
||
*/
|
||
private ServiceTask createServiceTask(WorkflowNode node) {
|
||
ServiceTask task = new ServiceTask();
|
||
task.setId(node.getId());
|
||
task.setName(node.getName());
|
||
|
||
// 使用通用执行器
|
||
task.setImplementationType(ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION);
|
||
task.setImplementation("${genericNodeExecutor}");
|
||
|
||
// 通过Field Extension传递节点配置 ⭐⭐⭐
|
||
List<FieldExtension> fields = new ArrayList<>();
|
||
|
||
// 节点类型
|
||
FieldExtension typeField = new FieldExtension();
|
||
typeField.setFieldName("nodeType");
|
||
typeField.setStringValue(node.getType());
|
||
fields.add(typeField);
|
||
|
||
// 节点配置（JSON）
|
||
try {
|
||
String configJson = objectMapper.writeValueAsString(node.getConfig());
|
||
FieldExtension configField = new FieldExtension();
|
||
configField.setFieldName("nodeConfig");
|
||
configField.setStringValue(configJson);
|
||
fields.add(configField);
|
||
} catch (Exception e) {
|
||
throw new RuntimeException("序列化节点配置失败: " + node.getId(), e);
|
||
}
|
||
|
||
task.setFieldExtensions(fields);
|
||
|
||
return task;
|
||
}
|
||
|
||
/**
|
||
* 创建User Task（审批节点）
|
||
*/
|
||
private UserTask createUserTask(WorkflowNode node) {
|
||
UserTask task = new UserTask();
|
||
task.setId(node.getId());
|
||
task.setName(node.getName());
|
||
|
||
// 审批人（支持表达式）
|
||
String assignee = (String) node.getConfig().get("assignee");
|
||
if (assignee != null) {
|
||
task.setAssignee(assignee);
|
||
}
|
||
|
||
// 候选组
|
||
List<String> candidateGroups = (List<String>) node.getConfig().get("candidateGroups");
|
||
if (candidateGroups != null) {
|
||
task.setCandidateGroups(candidateGroups);
|
||
}
|
||
|
||
// 表单字段
|
||
List<FormProperty> formProperties = new ArrayList<>();
|
||
List<Map<String, Object>> formFields =
|
||
(List<Map<String, Object>>) node.getConfig().get("formFields");
|
||
|
||
if (formFields != null) {
|
||
for (Map<String, Object> field : formFields) {
|
||
FormProperty prop = new FormProperty();
|
||
prop.setId((String) field.get("id"));
|
||
prop.setName((String) field.get("label"));
|
||
prop.setType((String) field.get("type"));
|
||
prop.setRequired((Boolean) field.getOrDefault("required", false));
|
||
formProperties.add(prop);
|
||
}
|
||
}
|
||
|
||
task.setFormProperties(formProperties);
|
||
|
||
return task;
|
||
}
|
||
|
||
/**
|
||
* 转换连线
|
||
*/
|
||
private void convertEdges(
|
||
WorkflowDefinition workflow,
|
||
Process process,
|
||
Map<String, FlowElement> elementMap
|
||
) {
|
||
// 按拓扑排序连接节点
|
||
List<WorkflowNode> sortedNodes = topologicalSort(workflow);
|
||
|
||
// 连接 start → 第一个节点
|
||
if (!sortedNodes.isEmpty()) {
|
||
WorkflowNode firstNode = sortedNodes.get(0);
|
||
addSequenceFlow(process, "start", firstNode.getId());
|
||
}
|
||
|
||
// 连接节点间的边
|
||
for (WorkflowEdge edge : workflow.getEdges()) {
|
||
SequenceFlow flow = addSequenceFlow(process, edge.getSource(), edge.getTarget());
|
||
if (edge.getCondition() != null && !edge.getCondition().isBlank()) {
|
||
flow.setConditionExpression(edge.getCondition());
|
||
}
|
||
}
|
||
|
||
// 连接 最后一个节点 → end
|
||
if (!sortedNodes.isEmpty()) {
|
||
// 找到所有出度为0的节点（没有出边的节点）
|
||
Set<String> targetNodes = workflow.getEdges().stream()
|
||
.map(WorkflowEdge::getTarget)
|
||
.collect(Collectors.toSet());
|
||
|
||
for (WorkflowNode node : workflow.getNodes()) {
|
||
if (!targetNodes.contains(node.getId())) {
|
||
// 这是最后的节点
|
||
addSequenceFlow(process, node.getId(), "end");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 添加序列流
|
||
*/
|
||
private SequenceFlow addSequenceFlow(Process process, String sourceId, String targetId) {
|
||
SequenceFlow flow = new SequenceFlow();
|
||
flow.setId("flow_" + sourceId + "_" + targetId);
|
||
flow.setSourceRef(sourceId);
|
||
flow.setTargetRef(targetId);
|
||
process.addFlowElement(flow);
|
||
return flow;
|
||
}
|
||
|
||
/**
|
||
* 拓扑排序（确保节点执行顺序正确）
|
||
*/
|
||
private List<WorkflowNode> topologicalSort(WorkflowDefinition workflow) {
|
||
// 实现拓扑排序算法
|
||
Map<String, WorkflowNode> nodeMap = workflow.getNodes().stream()
|
||
.collect(Collectors.toMap(WorkflowNode::getId, n -> n));
|
||
|
||
Map<String, Integer> inDegree = new HashMap<>();
|
||
Map<String, List<String>> adjacency = new HashMap<>();
|
||
|
||
// 初始化
|
||
for (WorkflowNode node : workflow.getNodes()) {
|
||
inDegree.put(node.getId(), 0);
|
||
adjacency.put(node.getId(), new ArrayList<>());
|
||
}
|
||
|
||
// 构建图
|
||
for (WorkflowEdge edge : workflow.getEdges()) {
|
||
adjacency.get(edge.getSource()).add(edge.getTarget());
|
||
inDegree.put(edge.getTarget(), inDegree.get(edge.getTarget()) + 1);
|
||
}
|
||
|
||
// BFS
|
||
Queue<String> queue = new LinkedList<>();
|
||
for (Map.Entry<String, Integer> entry : inDegree.entrySet()) {
|
||
if (entry.getValue() == 0) {
|
||
queue.offer(entry.getKey());
|
||
}
|
||
}
|
||
|
||
List<WorkflowNode> result = new ArrayList<>();
|
||
while (!queue.isEmpty()) {
|
||
String nodeId = queue.poll();
|
||
result.add(nodeMap.get(nodeId));
|
||
|
||
for (String neighbor : adjacency.get(nodeId)) {
|
||
inDegree.put(neighbor, inDegree.get(neighbor) - 1);
|
||
if (inDegree.get(neighbor) == 0) {
|
||
queue.offer(neighbor);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 检测环
|
||
if (result.size() != workflow.getNodes().size()) {
|
||
throw new IllegalArgumentException("工作流存在环，无法执行");
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* BPMN Model → XML
|
||
*/
|
||
private String convertBpmnModelToXml(BpmnModel bpmnModel) {
|
||
BpmnXMLConverter converter = new BpmnXMLConverter();
|
||
byte[] xmlBytes = converter.convertToXML(bpmnModel);
|
||
return new String(xmlBytes, StandardCharsets.UTF_8);
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 四、节点实现示例
|
||
|
||
### 4.1 节点接口定义
|
||
|
||
```java
|
||
package com.workflow.nodes;
|
||
|
||
import com.workflow.model.*;
|
||
|
||
/**
|
||
* 工作流节点接口
|
||
*
|
||
* 所有节点必须实现此接口
|
||
*/
|
||
public interface WorkflowNode {
|
||
|
||
/**
|
||
* 获取节点元数据（字段定义、输出结构等）
|
||
*/
|
||
NodeTypeMetadata getMetadata();
|
||
|
||
/**
|
||
* 执行节点
|
||
*
|
||
* @param input 输入参数（已解析表达式）
|
||
* @param context 执行上下文
|
||
* @return 执行结果
|
||
*/
|
||
NodeExecutionResult execute(NodeInput input, NodeExecutionContext context);
|
||
}
|
||
```
|
||
|
||
### 4.2 HTTP Request 节点
|
||
|
||
```java
|
||
package com.workflow.nodes;
|
||
|
||
import com.workflow.model.*;
|
||
import org.springframework.http.*;
|
||
import org.springframework.stereotype.Component;
|
||
import org.springframework.web.client.RestTemplate;
|
||
|
||
import java.time.Instant;
|
||
import java.util.*;
|
||
|
||
/**
|
||
* HTTP请求节点
|
||
*/
|
||
@Component
|
||
public class HttpRequestNode implements WorkflowNode {
|
||
|
||
private final RestTemplate restTemplate = new RestTemplate();
|
||
|
||
@Override
|
||
public NodeTypeMetadata getMetadata() {
|
||
return NodeTypeMetadata.builder()
|
||
.id("http_request")
|
||
.name("httpRequest")
|
||
.displayName("HTTP Request")
|
||
.category("api")
|
||
.icon("api")
|
||
.description("发送HTTP请求到指定URL")
|
||
.fields(List.of(
|
||
// URL字段
|
||
FieldDefinition.builder()
|
||
.name("url")
|
||
.label("URL")
|
||
.type(FieldType.TEXT)
|
||
.required(true)
|
||
.supportsExpression(true)
|
||
.placeholder("https://api.example.com/users")
|
||
.build(),
|
||
|
||
// 请求方法
|
||
FieldDefinition.builder()
|
||
.name("method")
|
||
.label("Method")
|
||
.type(FieldType.SELECT)
|
||
.required(true)
|
||
.options(List.of("GET", "POST", "PUT", "DELETE", "PATCH"))
|
||
.defaultValue("GET")
|
||
.build(),
|
||
|
||
// 请求头
|
||
FieldDefinition.builder()
|
||
.name("headers")
|
||
.label("Headers")
|
||
.type(FieldType.KEY_VALUE)
|
||
.supportsFieldMapping(true)
|
||
.build(),
|
||
|
||
// 请求体
|
||
FieldDefinition.builder()
|
||
.name("body")
|
||
.label("Request Body")
|
||
.type(FieldType.CODE)
|
||
.language("json")
|
||
.supportsExpression(true)
|
||
.build(),
|
||
|
||
// 超时设置
|
||
FieldDefinition.builder()
|
||
.name("timeout")
|
||
.label("Timeout (ms)")
|
||
.type(FieldType.NUMBER)
|
||
.defaultValue(30000)
|
||
.build()
|
||
))
|
||
.outputSchema(Map.of(
|
||
"type", "object",
|
||
"properties", Map.of(
|
||
"statusCode", Map.of("type", "number", "description", "HTTP状态码"),
|
||
"body", Map.of("type", "object", "description", "响应体"),
|
||
"headers", Map.of("type", "object", "description", "响应头"),
|
||
"elapsed", Map.of("type", "number", "description", "耗时(ms)")
|
||
)
|
||
))
|
||
.implementationClass("com.workflow.nodes.HttpRequestNode")
|
||
.build();
|
||
}
|
||
|
||
@Override
|
||
public NodeExecutionResult execute(NodeInput input, NodeExecutionContext context) {
|
||
Instant startTime = Instant.now();
|
||
|
||
try {
|
||
// 1. 获取参数（表达式已被解析）⭐
|
||
String url = input.getStringRequired("url");
|
||
String method = input.getString("method", "GET");
|
||
Map<String, String> headers = input.getMap("headers", new HashMap<>());
|
||
String body = input.getString("body");
|
||
Integer timeout = input.getInteger("timeout", 30000);
|
||
|
||
// 2. 构建HTTP请求
|
||
HttpHeaders httpHeaders = new HttpHeaders();
|
||
headers.forEach(httpHeaders::set);
|
||
|
||
HttpEntity<String> entity = new HttpEntity<>(body, httpHeaders);
|
||
|
||
// 3. 发送请求
|
||
ResponseEntity<String> response = restTemplate.exchange(
|
||
url,
|
||
HttpMethod.valueOf(method),
|
||
entity,
|
||
String.class
|
||
);
|
||
|
||
// 4. 解析响应体（尝试JSON）
|
||
Object responseBody;
|
||
try {
|
||
responseBody = new ObjectMapper().readValue(
|
||
response.getBody(),
|
||
Object.class
|
||
);
|
||
} catch (Exception e) {
|
||
// 不是JSON，返回原始文本
|
||
responseBody = response.getBody();
|
||
}
|
||
|
||
// 5. 构建输出
|
||
Instant endTime = Instant.now();
|
||
long elapsed = endTime.toEpochMilli() - startTime.toEpochMilli();
|
||
|
||
Map<String, Object> output = new HashMap<>();
|
||
output.put("statusCode", response.getStatusCodeValue());
|
||
output.put("body", responseBody);
|
||
output.put("headers", response.getHeaders().toSingleValueMap());
|
||
output.put("elapsed", elapsed);
|
||
|
||
return NodeExecutionResult.success(output, startTime, endTime);
|
||
|
||
} catch (Exception e) {
|
||
Instant endTime = Instant.now();
|
||
return NodeExecutionResult.failed(
|
||
e.getMessage(),
|
||
e.getClass().getSimpleName(),
|
||
startTime,
|
||
endTime
|
||
);
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
### 4.3 通用节点执行器
|
||
|
||
```java
|
||
package com.workflow.executor;
|
||
|
||
import com.fasterxml.jackson.core.type.TypeReference;
|
||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||
import com.workflow.engine.ExpressionEngine;
|
||
import com.workflow.model.*;
|
||
import com.workflow.nodes.WorkflowNode;
|
||
import com.workflow.registry.NodeTypeRegistry;
|
||
import org.flowable.engine.delegate.DelegateExecution;
|
||
import org.flowable.engine.delegate.JavaDelegate;
|
||
import org.springframework.beans.factory.annotation.Autowired;
|
||
import org.springframework.stereotype.Component;
|
||
|
||
import java.time.Instant;
|
||
import java.util.HashMap;
|
||
import java.util.Map;
|
||
|
||
/**
|
||
* 通用节点执行器
|
||
*
|
||
* 所有Service Task都使用这个执行器
|
||
* 根据节点类型动态调用对应的实现类
|
||
*/
|
||
@Component("genericNodeExecutor")
|
||
public class GenericNodeExecutor implements JavaDelegate {
|
||
|
||
@Autowired
|
||
private NodeTypeRegistry nodeTypeRegistry;
|
||
|
||
@Autowired
|
||
private ExpressionEngine expressionEngine;
|
||
|
||
private final ObjectMapper objectMapper = new ObjectMapper();
|
||
|
||
@Override
|
||
public void execute(DelegateExecution execution) {
|
||
String nodeId = execution.getCurrentActivityId();
|
||
|
||
try {
|
||
// 1. 获取节点类型和配置（从Field Extension）⭐
|
||
String nodeType = getFieldValue(execution, "nodeType");
|
||
String nodeConfigJson = getFieldValue(execution, "nodeConfig");
|
||
|
||
Map<String, Object> nodeConfig = objectMapper.readValue(
|
||
nodeConfigJson,
|
||
new TypeReference<Map<String, Object>>() {}
|
||
);
|
||
|
||
// 2. 解析表达式（处理数据映射）⭐⭐⭐
|
||
Map<String, Object> resolvedConfig = expressionEngine.resolveObject(
|
||
nodeConfig,
|
||
execution
|
||
);
|
||
|
||
// 3. 获取节点实现类
|
||
WorkflowNode nodeImpl = nodeTypeRegistry.getNodeInstance(nodeType);
|
||
if (nodeImpl == null) {
|
||
throw new RuntimeException("未找到节点实现: " + nodeType);
|
||
}
|
||
|
||
// 4. 构建执行上下文
|
||
NodeExecutionContext context = buildContext(execution, nodeId);
|
||
|
||
// 5. 执行节点 ⭐
|
||
NodeInput input = new NodeInput(resolvedConfig);
|
||
NodeExecutionResult result = nodeImpl.execute(input, context);
|
||
|
||
// 6. 保存节点输出到流程变量 ⭐⭐⭐
|
||
saveNodeOutput(execution, nodeId, resolvedConfig, result);
|
||
|
||
// 7. 记录日志
|
||
logExecution(execution, nodeId, nodeType, resolvedConfig, result);
|
||
|
||
} catch (Exception e) {
|
||
// 错误处理
|
||
handleError(execution, nodeId, e);
|
||
throw new RuntimeException("节点执行失败: " + nodeId, e);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 保存节点输出到流程变量（关键）⭐⭐⭐
|
||
*
|
||
* 结构:
|
||
* {
|
||
* "nodes": {
|
||
* "node1": {
|
||
* "status": "success",
|
||
* "input": {...},
|
||
* "output": {...},
|
||
* "startTime": "...",
|
||
* "endTime": "..."
|
||
* }
|
||
* }
|
||
* }
|
||
*/
|
||
private void saveNodeOutput(
|
||
DelegateExecution execution,
|
||
String nodeId,
|
||
Map<String, Object> input,
|
||
NodeExecutionResult result
|
||
) {
|
||
// 获取或创建nodes对象
|
||
Map<String, Object> nodesData =
|
||
(Map<String, Object>) execution.getVariable("nodes");
|
||
|
||
if (nodesData == null) {
|
||
nodesData = new HashMap<>();
|
||
}
|
||
|
||
// 构建节点数据
|
||
Map<String, Object> nodeData = new HashMap<>();
|
||
nodeData.put("status", result.getStatus().name().toLowerCase());
|
||
nodeData.put("input", input);
|
||
nodeData.put("output", result.getOutput());
|
||
nodeData.put("startTime", result.getStartTime().toString());
|
||
nodeData.put("endTime", result.getEndTime().toString());
|
||
|
||
if (result.getError() != null) {
|
||
nodeData.put("error", result.getError());
|
||
}
|
||
|
||
// 保存
|
||
nodesData.put(nodeId, nodeData);
|
||
execution.setVariable("nodes", nodesData);
|
||
}
|
||
|
||
/**
|
||
* 构建执行上下文
|
||
*/
|
||
private NodeExecutionContext buildContext(DelegateExecution execution, String nodeId) {
|
||
return NodeExecutionContext.builder()
|
||
.workflowId(execution.getProcessDefinitionId())
|
||
.executionId(execution.getProcessInstanceId())
|
||
.nodeId(nodeId)
|
||
.variables((Map<String, Object>) execution.getVariable("workflow"))
|
||
.nodes((Map<String, Object>) execution.getVariable("nodes"))
|
||
.env(System.getenv())
|
||
.build();
|
||
}
|
||
|
||
/**
|
||
* 记录执行日志
|
||
*/
|
||
private void logExecution(
|
||
DelegateExecution execution,
|
||
String nodeId,
|
||
String nodeType,
|
||
Map<String, Object> input,
|
||
NodeExecutionResult result
|
||
) {
|
||
// 保存到数据库
|
||
NodeExecutionLog log = new NodeExecutionLog();
|
||
log.setExecutionId(execution.getProcessInstanceId());
|
||
log.setNodeId(nodeId);
|
||
log.setNodeType(nodeType);
|
||
log.setInput(input);
|
||
log.setOutput(result.getOutput());
|
||
log.setStatus(result.getStatus());
|
||
log.setStartedAt(result.getStartTime());
|
||
log.setEndedAt(result.getEndTime());
|
||
|
||
if (result.getError() != null) {
|
||
log.setErrorMessage(result.getError());
|
||
}
|
||
|
||
// nodeExecutionLogRepository.save(log);
|
||
}
|
||
|
||
/**
|
||
* 错误处理
|
||
*/
|
||
private void handleError(DelegateExecution execution, String nodeId, Exception e) {
|
||
Map<String, Object> nodesData =
|
||
(Map<String, Object>) execution.getVariable("nodes");
|
||
|
||
if (nodesData == null) {
|
||
nodesData = new HashMap<>();
|
||
}
|
||
|
||
Map<String, Object> nodeData = new HashMap<>();
|
||
nodeData.put("status", "failed");
|
||
nodeData.put("error", e.getMessage());
|
||
nodeData.put("errorType", e.getClass().getSimpleName());
|
||
nodeData.put("endTime", Instant.now().toString());
|
||
|
||
nodesData.put(nodeId, nodeData);
|
||
execution.setVariable("nodes", nodesData);
|
||
}
|
||
|
||
/**
|
||
* 获取Field Extension的值
|
||
*/
|
||
private String getFieldValue(DelegateExecution execution, String fieldName) {
|
||
// 从当前 ServiceTask 的 FieldExtension 读取
|
||
org.flowable.bpmn.model.FlowElement fe = execution.getCurrentFlowElement();
|
||
if (fe instanceof org.flowable.bpmn.model.ServiceTask) {
|
||
org.flowable.bpmn.model.ServiceTask st = (org.flowable.bpmn.model.ServiceTask) fe;
|
||
return st.getFieldExtensions().stream()
|
||
.filter(f -> fieldName.equals(f.getFieldName()))
|
||
.map(org.flowable.bpmn.model.FieldExtension::getStringValue)
|
||
.findFirst()
|
||
.orElse(null);
|
||
}
|
||
return null;
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 五、REST API 设计
|
||
|
||
### 5.1 工作流管理 API
|
||
|
||
```java
|
||
package com.workflow.controller;
|
||
|
||
import com.workflow.model.*;
|
||
import com.workflow.service.WorkflowService;
|
||
import org.springframework.beans.factory.annotation.Autowired;
|
||
import org.springframework.http.ResponseEntity;
|
||
import org.springframework.web.bind.annotation.*;
|
||
|
||
import java.util.List;
|
||
import java.util.Map;
|
||
|
||
/**
|
||
* 工作流管理API
|
||
*/
|
||
@RestController
|
||
@RequestMapping("/api/workflows")
|
||
public class WorkflowController {
|
||
|
||
@Autowired
|
||
private WorkflowService workflowService;
|
||
|
||
/**
|
||
* 创建工作流
|
||
*/
|
||
@PostMapping
|
||
public ResponseEntity<WorkflowDefinition> createWorkflow(
|
||
@RequestBody WorkflowDefinition workflow
|
||
) {
|
||
WorkflowDefinition created = workflowService.create(workflow);
|
||
return ResponseEntity.ok(created);
|
||
}
|
||
|
||
/**
|
||
* 更新工作流
|
||
*/
|
||
@PutMapping("/{id}")
|
||
public ResponseEntity<WorkflowDefinition> updateWorkflow(
|
||
@PathVariable String id,
|
||
@RequestBody WorkflowDefinition workflow
|
||
) {
|
||
WorkflowDefinition updated = workflowService.update(id, workflow);
|
||
return ResponseEntity.ok(updated);
|
||
}
|
||
|
||
/**
|
||
* 获取工作流详情
|
||
*/
|
||
@GetMapping("/{id}")
|
||
public ResponseEntity<WorkflowDefinition> getWorkflow(@PathVariable String id) {
|
||
WorkflowDefinition workflow = workflowService.getById(id);
|
||
return ResponseEntity.ok(workflow);
|
||
}
|
||
|
||
/**
|
||
* 获取工作流列表
|
||
*/
|
||
@GetMapping
|
||
public ResponseEntity<List<WorkflowDefinition>> listWorkflows(
|
||
@RequestParam(required = false) String status
|
||
) {
|
||
List<WorkflowDefinition> workflows = workflowService.list(status);
|
||
return ResponseEntity.ok(workflows);
|
||
}
|
||
|
||
/**
|
||
* 删除工作流
|
||
*/
|
||
@DeleteMapping("/{id}")
|
||
public ResponseEntity<Void> deleteWorkflow(@PathVariable String id) {
|
||
workflowService.delete(id);
|
||
return ResponseEntity.noContent().build();
|
||
}
|
||
|
||
/**
|
||
* 执行工作流
|
||
*/
|
||
@PostMapping("/{id}/execute")
|
||
public ResponseEntity<WorkflowExecutionResult> executeWorkflow(
|
||
@PathVariable String id,
|
||
@RequestBody Map<String, Object> input
|
||
) {
|
||
WorkflowExecutionResult result = workflowService.execute(id, input);
|
||
return ResponseEntity.ok(result);
|
||
}
|
||
|
||
/**
|
||
* 获取执行记录
|
||
*/
|
||
@GetMapping("/{id}/executions")
|
||
public ResponseEntity<List<WorkflowExecutionRecord>> getExecutions(
|
||
@PathVariable String id
|
||
) {
|
||
List<WorkflowExecutionRecord> executions = workflowService.getExecutions(id);
|
||
return ResponseEntity.ok(executions);
|
||
}
|
||
|
||
/**
|
||
* 获取单个执行详情
|
||
*/
|
||
@GetMapping("/executions/{executionId}")
|
||
public ResponseEntity<WorkflowExecutionDetail> getExecutionDetail(
|
||
@PathVariable String executionId
|
||
) {
|
||
WorkflowExecutionDetail detail = workflowService.getExecutionDetail(executionId);
|
||
return ResponseEntity.ok(detail);
|
||
}
|
||
}
|
||
```
|
||
|
||
### 5.2 节点类型 API
|
||
|
||
```java
|
||
package com.workflow.controller;
|
||
|
||
import com.workflow.model.NodeTypeMetadata;
|
||
import com.workflow.registry.NodeTypeRegistry;
|
||
import org.springframework.beans.factory.annotation.Autowired;
|
||
import org.springframework.http.ResponseEntity;
|
||
import org.springframework.web.bind.annotation.*;
|
||
|
||
import java.util.List;
|
||
|
||
/**
|
||
* 节点类型API
|
||
*/
|
||
@RestController
|
||
@RequestMapping("/api/node-types")
|
||
public class NodeTypeController {
|
||
|
||
@Autowired
|
||
private NodeTypeRegistry nodeTypeRegistry;
|
||
|
||
/**
|
||
* 获取所有节点类型
|
||
*/
|
||
@GetMapping
|
||
public ResponseEntity<List<NodeTypeMetadata>> getAllNodeTypes() {
|
||
List<NodeTypeMetadata> nodeTypes = nodeTypeRegistry.getAllNodeTypes();
|
||
return ResponseEntity.ok(nodeTypes);
|
||
}
|
||
|
||
/**
|
||
* 获取单个节点类型
|
||
*/
|
||
@GetMapping("/{typeId}")
|
||
public ResponseEntity<NodeTypeMetadata> getNodeType(@PathVariable String typeId) {
|
||
NodeTypeMetadata metadata = nodeTypeRegistry.getMetadata(typeId);
|
||
return ResponseEntity.ok(metadata);
|
||
}
|
||
|
||
/**
|
||
* 按分类获取节点类型
|
||
*/
|
||
@GetMapping("/category/{category}")
|
||
public ResponseEntity<List<NodeTypeMetadata>> getNodeTypesByCategory(
|
||
@PathVariable String category
|
||
) {
|
||
List<NodeTypeMetadata> nodeTypes =
|
||
nodeTypeRegistry.getNodeTypesByCategory(category);
|
||
return ResponseEntity.ok(nodeTypes);
|
||
}
|
||
}
|
||
```
|
||
|
||
### 5.3 审批任务 API
|
||
|
||
```java
|
||
package com.workflow.controller;
|
||
|
||
import com.workflow.model.*;
|
||
import com.workflow.service.TaskService;
|
||
import org.springframework.beans.factory.annotation.Autowired;
|
||
import org.springframework.http.ResponseEntity;
|
||
import org.springframework.web.bind.annotation.*;
|
||
|
||
import java.util.List;
|
||
import java.util.Map;
|
||
|
||
/**
|
||
* 审批任务API
|
||
*/
|
||
@RestController
|
||
@RequestMapping("/api/tasks")
|
||
public class TaskController {
|
||
|
||
@Autowired
|
||
private TaskService taskService;
|
||
|
||
/**
|
||
* 获取待办任务列表
|
||
*/
|
||
@GetMapping
|
||
public ResponseEntity<List<TaskInfo>> getTasks(
|
||
@RequestParam(required = false) String assignee
|
||
) {
|
||
List<TaskInfo> tasks = taskService.getTasks(assignee);
|
||
return ResponseEntity.ok(tasks);
|
||
}
|
||
|
||
/**
|
||
* 获取任务详情
|
||
*/
|
||
@GetMapping("/{taskId}")
|
||
public ResponseEntity<TaskDetail> getTaskDetail(@PathVariable String taskId) {
|
||
TaskDetail detail = taskService.getTaskDetail(taskId);
|
||
return ResponseEntity.ok(detail);
|
||
}
|
||
|
||
/**
|
||
* 完成任务（审批）
|
||
*/
|
||
@PostMapping("/{taskId}/complete")
|
||
public ResponseEntity<Void> completeTask(
|
||
@PathVariable String taskId,
|
||
@RequestBody Map<String, Object> variables
|
||
) {
|
||
taskService.complete(taskId, variables);
|
||
return ResponseEntity.ok().build();
|
||
}
|
||
|
||
/**
|
||
* 获取任务表单
|
||
*/
|
||
@GetMapping("/{taskId}/form")
|
||
public ResponseEntity<TaskForm> getTaskForm(@PathVariable String taskId) {
|
||
TaskForm form = taskService.getTaskForm(taskId);
|
||
return ResponseEntity.ok(form);
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 六、关键实现细节（重要）
|
||
|
||
### 6.1 如何确保数据一致性？
|
||
|
||
**问题**：工作流执行过程中，如果服务重启怎么办？
|
||
|
||
**解决方案**：
|
||
```java
|
||
1. Flowable自动持久化
|
||
- 流程状态保存在ACT_RU_*表
|
||
- 变量保存在ACT_RU_VARIABLE表
|
||
- 任务保存在ACT_RU_TASK表
|
||
|
||
2. 服务重启后自动恢复
|
||
- Flowable的AsyncExecutor会自动重试未完成的任务
|
||
|
||
3. 幂等性设计
|
||
- 每个节点执行前检查是否已执行
|
||
- 使用节点ID作为幂等键
|
||
```
|
||
|
||
### 6.2 如何处理节点执行超时？
|
||
|
||
**实现**：
|
||
```java
|
||
@Component
|
||
public class TimeoutAwareNodeExecutor implements JavaDelegate {
|
||
|
||
@Override
|
||
public void execute(DelegateExecution execution) {
|
||
String nodeId = execution.getCurrentActivityId();
|
||
int timeout = getTimeout(execution); // 从配置获取
|
||
|
||
Future<NodeExecutionResult> future = executorService.submit(() -> {
|
||
return actuallyExecuteNode(execution);
|
||
});
|
||
|
||
try {
|
||
NodeExecutionResult result = future.get(timeout, TimeUnit.SECONDS);
|
||
saveNodeOutput(execution, nodeId, result);
|
||
|
||
} catch (TimeoutException e) {
|
||
future.cancel(true);
|
||
throw new RuntimeException("节点执行超时: " + nodeId);
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
### 6.3 如何防止表达式注入攻击？
|
||
|
||
**风险**：用户输入 `${Runtime.getRuntime().exec("rm -rf /")}`
|
||
|
||
**防护**：
|
||
```java
|
||
@Service
|
||
public class SecureExpressionEngine extends ExpressionEngine {
|
||
|
||
// 禁止访问的类
|
||
private static final Set<String> BLOCKED_CLASSES = Set.of(
|
||
"Runtime",
|
||
"ProcessBuilder",
|
||
"System",
|
||
"Class",
|
||
"ClassLoader"
|
||
);
|
||
|
||
@Override
|
||
public Object evaluate(String expression, DelegateExecution execution) {
|
||
// 1. 检查是否包含危险类
|
||
for (String blocked : BLOCKED_CLASSES) {
|
||
if (expression.contains(blocked)) {
|
||
throw new SecurityException("表达式包含禁止使用的类: " + blocked);
|
||
}
|
||
}
|
||
|
||
// 2. 限制表达式长度
|
||
if (expression.length() > 1000) {
|
||
throw new SecurityException("表达式过长");
|
||
}
|
||
|
||
// 3. 正常解析
|
||
return super.evaluate(expression, execution);
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 七、测试策略
|
||
|
||
### 7.1 单元测试
|
||
|
||
```java
|
||
@SpringBootTest
|
||
public class ExpressionEngineTest {
|
||
|
||
@Autowired
|
||
private ExpressionEngine expressionEngine;
|
||
|
||
@Mock
|
||
private DelegateExecution execution;
|
||
|
||
@Test
|
||
public void testSimpleExpression() {
|
||
// 准备上下文
|
||
Map<String, Object> nodes = Map.of(
|
||
"node1", Map.of(
|
||
"output", Map.of(
|
||
"body", Map.of("email", "test@example.com")
|
||
)
|
||
)
|
||
);
|
||
when(execution.getVariable("nodes")).thenReturn(nodes);
|
||
|
||
// 执行
|
||
String result = (String) expressionEngine.evaluate(
|
||
"${nodes.node1.output.body.email}",
|
||
execution
|
||
);
|
||
|
||
// 验证
|
||
assertEquals("test@example.com", result);
|
||
}
|
||
}
|
||
```
|
||
|
||
### 7.2 集成测试
|
||
|
||
```java
|
||
@SpringBootTest
|
||
public class WorkflowIntegrationTest {
|
||
|
||
@Autowired
|
||
private WorkflowService workflowService;
|
||
|
||
@Test
|
||
public void testCompleteWorkflow() {
|
||
// 1. 创建工作流
|
||
WorkflowDefinition workflow = createTestWorkflow();
|
||
WorkflowDefinition created = workflowService.create(workflow);
|
||
|
||
// 2. 执行
|
||
Map<String, Object> input = Map.of("username", "testuser");
|
||
WorkflowExecutionResult result = workflowService.execute(created.getId(), input);
|
||
|
||
// 3. 验证
|
||
assertEquals("completed", result.getStatus());
|
||
assertNotNull(result.getOutput());
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 八、部署配置
|
||
|
||
### 8.1 Docker Compose
|
||
|
||
```yaml
|
||
# docker-compose.yml
|
||
version: '3.8'
|
||
|
||
services:
|
||
mysql:
|
||
image: mysql:8
|
||
environment:
|
||
MYSQL_DATABASE: workflow_db
|
||
MYSQL_ROOT_PASSWORD: root
|
||
ports:
|
||
- "3306:3306"
|
||
command: ["--default-authentication-plugin=mysql_native_password", "--character-set-server=utf8mb4", "--collation-server=utf8mb4_unicode_ci"]
|
||
volumes:
|
||
- mysql_data:/var/lib/mysql
|
||
|
||
redis:
|
||
image: redis:7
|
||
ports:
|
||
- "6379:6379"
|
||
|
||
workflow-backend:
|
||
build: ./backend
|
||
ports:
|
||
- "8080:8080"
|
||
environment:
|
||
SPRING_DATASOURCE_URL: jdbc:mysql://mysql:3306/workflow_db?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
|
||
SPRING_DATASOURCE_USERNAME: root
|
||
SPRING_DATASOURCE_PASSWORD: root
|
||
SPRING_REDIS_HOST: redis
|
||
depends_on:
|
||
- mysql
|
||
- redis
|
||
|
||
volumes:
|
||
mysql_data:
|
||
```
|
||
|
||
### 8.2 生产环境配置
|
||
|
||
```yaml
|
||
# application-prod.yml
|
||
spring:
|
||
datasource:
|
||
hikari:
|
||
maximum-pool-size: 50
|
||
minimum-idle: 10
|
||
|
||
flowable:
|
||
async-executor-core-pool-size: 20
|
||
async-executor-max-pool-size: 100
|
||
|
||
logging:
|
||
level:
|
||
com.workflow: INFO
|
||
org.flowable: WARN
|
||
```
|
||
|
||
---
|
||
|
||
**下一步**：查看 03-前端技术设计.md
|
||
|