getNodeDetailByProcessDefinitionKey(@RequestParam String processDefinitionKey) {
+ return processService.getNodeDetailByProcessDefinitionKey(processDefinitionKey);
+ }
+
+ /**
+ * 完成人工节点任务
+ *
+ * @param req
+ * @return
+ */
+ @PostMapping("/completeManualTasks")
+ public void completeManualTasks(@RequestBody CompleteTaskReq req) {
+ processService.completeManualTasks(req);
+ }
+
+ /**
+ * 异步任务回调接口，用于唤醒等待的流程实例
+ *
+ * @param request 包含异步任务ID和执行结果的请求对象
+ */
+ @PostMapping("/asyncCallback")
+ public void asyncCallback(@RequestBody AsyncCallbackRequest request) {
+ // 发送信号唤醒流程实例中等待的节点
+ universalDelegate.signalByTaskId(request);
+ }
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/dao/AsyncTaskRecordMapper.java b/flowable/src/main/java/com/sdm/flowable/dao/AsyncTaskRecordMapper.java
new file mode 100644
index 00000000..b62774e6
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/dao/AsyncTaskRecordMapper.java
@@ -0,0 +1,16 @@
+package com.sdm.flowable.dao;
+
+import com.sdm.flowable.entity.AsyncTaskRecord;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ *
+ * 异步任务执行记录表 Mapper 接口
+ *
+ *
+ * @author author
+ * @since 2025-11-26
+ */
+public interface AsyncTaskRecordMapper extends BaseMapper {
+
+}
diff --git a/flowable/src/main/java/com/sdm/flowable/dao/ProcessNodeParamMapper.java b/flowable/src/main/java/com/sdm/flowable/dao/ProcessNodeParamMapper.java
new file mode 100644
index 00000000..fd4c1285
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/dao/ProcessNodeParamMapper.java
@@ -0,0 +1,16 @@
+package com.sdm.flowable.dao;
+
+import com.sdm.flowable.entity.ProcessNodeParam;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ *
+ * 流程节点输入参数表 Mapper 接口
+ *
+ *
+ * @author author
+ * @since 2025-11-25
+ */
+public interface ProcessNodeParamMapper extends BaseMapper {
+
+}
diff --git a/flowable/src/main/java/com/sdm/flowable/delegate/UniversalDelegate.java b/flowable/src/main/java/com/sdm/flowable/delegate/UniversalDelegate.java
new file mode 100644
index 00000000..aa64405f
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/delegate/UniversalDelegate.java
@@ -0,0 +1,94 @@
+package com.sdm.flowable.delegate;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.sdm.flowable.config.executeConfig.BaseExecuteConfig;
+import com.sdm.flowable.constants.FlowableConfig;
+import com.sdm.flowable.delegate.handler.ExecutionHandler;
+import com.sdm.flowable.dto.req.AsyncCallbackRequest;
+import com.sdm.flowable.service.IAsyncTaskRecordService;
+import com.sdm.flowable.service.IProcessNodeParamService;
+import lombok.extern.slf4j.Slf4j;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.delegate.JavaDelegate;
+import org.flowable.engine.RuntimeService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+
+/**
+ * 通用执行器，用于处理不同类型的节点（如 userTask, serviceTask）的执行逻辑。
+ */
+@Component("universalDelegate")
+@Slf4j
+public class UniversalDelegate implements JavaDelegate {
+ @Autowired
+ private ObjectMapper objectMapper;
+
+ @Autowired
+ private IProcessNodeParamService paramService;
+
+ @Autowired
+ private IAsyncTaskRecordService asyncTaskRecordService;
+
+ @Autowired
+ private Map handlerMap; // 执行器映射
+
+ @Override
+ public void execute(DelegateExecution execution) {
+ try {
+ // 1. 获取当前节点信息
+ String procInstId = execution.getProcessInstanceId();
+ String nodeId = execution.getCurrentActivityId();
+ String nodeName = execution.getCurrentFlowElement().getName();
+
+ // 2. 读取输入参数
+ Map params = paramService.getParam(procInstId, nodeId);
+
+ log.info("==== 节点执行日志 ====\n流程实例ID：{}\n节点ID：{}\n节点名称：{}\n输入参数：{}\n====================",
+ procInstId, nodeId, nodeName, params);
+
+ // 检查是否有扩展元素配置
+ if (execution.getCurrentFlowElement().getExtensionElements() != null &&
+ execution.getCurrentFlowElement().getExtensionElements().get(FlowableConfig.EXECUTECONFIG) != null) {
+
+ String extensionElement = execution
+ .getCurrentFlowElement()
+ .getExtensionElements()
+ .get(FlowableConfig.EXECUTECONFIG).get(0).getElementText();
+
+ BaseExecuteConfig config =
+ objectMapper.readValue(extensionElement, BaseExecuteConfig.class);
+
+ String executeType = config.getExecuteType();
+ ExecutionHandler handler = handlerMap.get(executeType);
+ if (handler == null) {
+ throw new RuntimeException("不支持的执行方式：" + executeType);
+ }
+
+ // 执行具体的任务处理逻辑
+ handler.execute(execution, params, config);
+ } else {
+ // 对于没有配置 executeConfig 的节点（如 userTask），直接完成任务
+ log.info("节点 {} 没有执行配置，直接完成任务", nodeName);
+ }
+ } catch (JsonProcessingException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * 外部系统回调接口，用于唤醒等待的流程实例
+ * @param processInstanceId 流程实例ID
+ * @param nodeId 节点ID
+ * @param resultData 结果数据
+ */
+ /**
+ * HPC 回调接口，用于唤醒等待的流程
+ */
+ public void signalByTaskId(AsyncCallbackRequest request) {
+ asyncTaskRecordService.completeAsyncTask(request);
+ }
+
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/delegate/handler/CloudAppHandler.java b/flowable/src/main/java/com/sdm/flowable/delegate/handler/CloudAppHandler.java
new file mode 100644
index 00000000..6c65a54f
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/delegate/handler/CloudAppHandler.java
@@ -0,0 +1,16 @@
+package com.sdm.flowable.delegate.handler;
+
+import com.sdm.flowable.config.executeConfig.BaseExecuteConfig;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+
+// 云应用处理器（executeType=cloudApp）
+@Component("cloudApp")
+public class CloudAppHandler implements ExecutionHandler {
+ @Override
+ public void execute(DelegateExecution execution, Map params, BaseExecuteConfig config) {
+ // 实现云应用处理逻辑...
+ }
+}
diff --git a/flowable/src/main/java/com/sdm/flowable/delegate/handler/DataProcessHandler.java b/flowable/src/main/java/com/sdm/flowable/delegate/handler/DataProcessHandler.java
new file mode 100644
index 00000000..e2f76ced
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/delegate/handler/DataProcessHandler.java
@@ -0,0 +1,16 @@
+package com.sdm.flowable.delegate.handler;
+
+import com.sdm.flowable.config.executeConfig.BaseExecuteConfig;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+
+// 数据处理执行器（executeType=data_process）
+@Component("dataProcess")
+public class DataProcessHandler implements ExecutionHandler {
+ @Override
+ public void execute(DelegateExecution execution, Map params, BaseExecuteConfig config) {
+ // 实现数据处理逻辑...
+ }
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/delegate/handler/ExecutionHandler.java b/flowable/src/main/java/com/sdm/flowable/delegate/handler/ExecutionHandler.java
new file mode 100644
index 00000000..726246b1
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/delegate/handler/ExecutionHandler.java
@@ -0,0 +1,10 @@
+package com.sdm.flowable.delegate.handler;
+
+import com.sdm.flowable.config.executeConfig.BaseExecuteConfig;
+import org.flowable.engine.delegate.DelegateExecution;
+
+import java.util.Map;
+
+public interface ExecutionHandler {
+ void execute(DelegateExecution execution, Map params, BaseExecuteConfig config);
+}
diff --git a/flowable/src/main/java/com/sdm/flowable/delegate/handler/HpcHandler.java b/flowable/src/main/java/com/sdm/flowable/delegate/handler/HpcHandler.java
new file mode 100644
index 00000000..99a643ed
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/delegate/handler/HpcHandler.java
@@ -0,0 +1,36 @@
+package com.sdm.flowable.delegate.handler;
+
+import com.sdm.flowable.config.executeConfig.BaseExecuteConfig;
+import com.sdm.flowable.service.IAsyncTaskRecordService;
+import lombok.extern.slf4j.Slf4j;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.Map;
+
+// HPC(executeType=HPC)
+@Slf4j
+@Component("HPC")
+public class HpcHandler implements ExecutionHandler {
+ @Autowired
+ private IAsyncTaskRecordService asyncTaskRecordService;
+
+ @Override
+ public void execute(DelegateExecution execution, Map params, BaseExecuteConfig config) {
+ // 实现HPC处理逻辑...
+ // 1. 调用 HPC 平台提交任务
+ // String hpcTaskId = submitHpcTask(params);
+ String hpcTaskId = "";
+ // 2. 存数据库（提交状态 + 外部任务ID）
+ asyncTaskRecordService.registerAsyncTask(
+ execution,
+ config.getCallbackNodeId(), // ReceiveTask ID
+ "HPC", // handlerType
+ new HashMap<>()
+ );
+
+ log.info("HPC 任务 {} 已提交", hpcTaskId);
+ }
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/delegate/handler/HttpHandler.java b/flowable/src/main/java/com/sdm/flowable/delegate/handler/HttpHandler.java
new file mode 100644
index 00000000..93f21121
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/delegate/handler/HttpHandler.java
@@ -0,0 +1,17 @@
+package com.sdm.flowable.delegate.handler;
+
+import com.sdm.flowable.config.executeConfig.BaseExecuteConfig;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+
+// HTTP请求执行器（executeType=HTTP）
+@Component("http")
+public class HttpHandler implements ExecutionHandler {
+
+ @Override
+ public void execute(DelegateExecution execution, Map params, BaseExecuteConfig config) {
+ // 实现HTTP请求逻辑...
+ }
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/delegate/handler/LocalAppHandler.java b/flowable/src/main/java/com/sdm/flowable/delegate/handler/LocalAppHandler.java
new file mode 100644
index 00000000..ae74d7ff
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/delegate/handler/LocalAppHandler.java
@@ -0,0 +1,16 @@
+package com.sdm.flowable.delegate.handler;
+
+import com.sdm.flowable.config.executeConfig.BaseExecuteConfig;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+
+// 本地应用处理器（executeType=localApp）
+@Component("localApp")
+public class LocalAppHandler implements ExecutionHandler {
+ @Override
+ public void execute(DelegateExecution execution, Map params, BaseExecuteConfig config) {
+ // 实现本地应用处理逻辑...
+ }
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/dto/ExtensionElementsDTO.java b/flowable/src/main/java/com/sdm/flowable/dto/ExtensionElementsDTO.java
new file mode 100644
index 00000000..95e416f9
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/dto/ExtensionElementsDTO.java
@@ -0,0 +1,15 @@
+package com.sdm.flowable.dto;
+
+import com.sdm.flowable.config.executeConfig.BaseExecuteConfig;
+import lombok.Data;
+
+/**
+ * 扩展配置DTO（serviceTask等需要执行配置的节点使用）
+ */
+@Data
+public class ExtensionElementsDTO {
+ /**
+ * 执行配置（核心字段，对应executeConfig）
+ */
+ private BaseExecuteConfig executeConfig;
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/dto/FlowElementDTO.java b/flowable/src/main/java/com/sdm/flowable/dto/FlowElementDTO.java
new file mode 100644
index 00000000..ec4722dd
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/dto/FlowElementDTO.java
@@ -0,0 +1,34 @@
+package com.sdm.flowable.dto;
+
+import lombok.Data;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.util.List;
+
+/**
+ * 流元素DTO（统一接收节点和连线，通过type区分）
+ */
+@Data
+@JsonIgnoreProperties(ignoreUnknown = true) // 忽略不同类型的多余字段（关键）
+public class FlowElementDTO {
+ // ------------------------------ 所有流元素通用字段 ------------------------------
+ /** 元素唯一ID（流程内不重复） */
+ private String id;
+ /** 元素类型：startEvent/serviceTask/userTask/endEvent/sequenceFlow */
+ private String type;
+ /** 元素显示名称 */
+ private String name;
+
+ // ------------------------------ 节点专属字段（startEvent/serviceTask/userTask/endEvent） ------------------------------
+ /** 入连线ID集合（仅节点有） */
+ private List incomingFlows;
+ /** 出连线ID集合（仅节点有） */
+ private List outgoingFlows;
+ /** 扩展配置（serviceTask等需要执行配置的节点使用） */
+ private ExtensionElementsDTO extensionElements;
+
+ // ------------------------------ 连线专属字段（sequenceFlow） ------------------------------
+ /** 源节点ID（仅连线有） */
+ private String sourceRef;
+ /** 目标节点ID（仅连线有） */
+ private String targetRef;
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/dto/ProcessDTO.java b/flowable/src/main/java/com/sdm/flowable/dto/ProcessDTO.java
new file mode 100644
index 00000000..93760dc0
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/dto/ProcessDTO.java
@@ -0,0 +1,14 @@
+package com.sdm.flowable.dto;
+
+import lombok.Data;
+
+/**
+ * 流程基础信息DTO（对应JSON中的process字段）
+ */
+@Data
+public class ProcessDTO {
+ /** 流程唯一ID（必填） */
+ private String id;
+ /** 流程名称（必填） */
+ private String name;
+}
diff --git a/flowable/src/main/java/com/sdm/flowable/dto/ProcessDefinitionDTO.java b/flowable/src/main/java/com/sdm/flowable/dto/ProcessDefinitionDTO.java
new file mode 100644
index 00000000..5fb36c2b
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/dto/ProcessDefinitionDTO.java
@@ -0,0 +1,15 @@
+package com.sdm.flowable.dto;
+
+import lombok.Data;
+import java.util.List;
+
+/**
+ * 流程定义顶层DTO（对应整个JSON）
+ */
+@Data
+public class ProcessDefinitionDTO {
+ /** 流程核心信息 */
+ private ProcessDTO process;
+ /** 所有节点+连线集合 */
+ private List flowElements;
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/dto/req/AsyncCallbackRequest.java b/flowable/src/main/java/com/sdm/flowable/dto/req/AsyncCallbackRequest.java
new file mode 100644
index 00000000..e36d553a
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/dto/req/AsyncCallbackRequest.java
@@ -0,0 +1,24 @@
+package com.sdm.flowable.dto.req;
+
+import com.alibaba.fastjson2.JSONObject;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * 异步任务回调请求参数
+ */
+@Data
+public class AsyncCallbackRequest implements Serializable {
+ private static final long serialVersionUID = 1L;
+
+ /**
+ * 异步任务ID
+ */
+ private String asyncTaskId;
+
+ /**
+ * 任务执行结果数据
+ */
+ private String resultJson;
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/dto/req/CompleteTaskReq.java b/flowable/src/main/java/com/sdm/flowable/dto/req/CompleteTaskReq.java
new file mode 100644
index 00000000..be29de1b
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/dto/req/CompleteTaskReq.java
@@ -0,0 +1,13 @@
+package com.sdm.flowable.dto.req;
+
+import lombok.Data;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Data
+public class CompleteTaskReq {
+ private String processInstanceId;
+ private String taskDefinitionKey;
+ private Map variables = new HashMap<>();
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/dto/req/DeployFlowableJsonReq.java b/flowable/src/main/java/com/sdm/flowable/dto/req/DeployFlowableJsonReq.java
new file mode 100644
index 00000000..5cefdf52
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/dto/req/DeployFlowableJsonReq.java
@@ -0,0 +1,8 @@
+package com.sdm.flowable.dto.req;
+
+import lombok.Data;
+
+@Data
+public class DeployFlowableJsonReq {
+ String flowableJson;
+}
diff --git a/flowable/src/main/java/com/sdm/flowable/dto/resp/ProcessInstanceResp.java b/flowable/src/main/java/com/sdm/flowable/dto/resp/ProcessInstanceResp.java
new file mode 100644
index 00000000..13d291a7
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/dto/resp/ProcessInstanceResp.java
@@ -0,0 +1,18 @@
+package com.sdm.flowable.dto.resp;
+
+import lombok.Data;
+
+import java.util.Date;
+
+@Data
+public class ProcessInstanceResp {
+ private String id; // 流程实例ID
+ private String processDefinitionId; // 流程定义ID
+ private String processDefinitionKey; // 流程定义Key
+ private String processDefinitionName;// 流程定义名称
+ private int processDefinitionVersion; // 流程定义版本
+ private String businessKey; // 业务Key
+ private String startUserId; // 启动用户
+ private Date startTime; // 启动时间
+ private boolean suspended; // 是否挂起
+}
diff --git a/flowable/src/main/java/com/sdm/flowable/entity/AsyncTaskRecord.java b/flowable/src/main/java/com/sdm/flowable/entity/AsyncTaskRecord.java
new file mode 100644
index 00000000..21bcaf8d
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/entity/AsyncTaskRecord.java
@@ -0,0 +1,66 @@
+package com.sdm.flowable.entity;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import java.time.LocalDateTime;
+import java.io.Serializable;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+/**
+ *
+ * 异步任务执行记录表
+ *
+ *
+ * @author author
+ * @since 2025-11-26
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Accessors(chain = true)
+@TableName("async_task_record")
+@ApiModel(value="AsyncTaskRecord对象", description="异步任务执行记录表")
+public class AsyncTaskRecord implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @ApiModelProperty(value = "主键ID，自增")
+ @TableId(value = "id", type = IdType.AUTO)
+ private Long id;
+
+ @ApiModelProperty(value = "异步任务唯一标识，全局唯一，用于定位单个异步任务")
+ private String asyncTaskId;
+
+ @ApiModelProperty(value = "流程实例ID，关联工作流引擎的流程实例（如Camunda的processInstanceId）")
+ private String processInstanceId;
+
+ @ApiModelProperty(value = "流程执行ID，关联工作流引擎的执行实例（如Camunda的executionId）")
+ private String executionId;
+
+ @ApiModelProperty(value = "接收任务ID，关联工作流中接收任务节点的ID（用于异步回调触发流程继续）")
+ private String receiveTaskId;
+
+ @ApiModelProperty(value = "业务处理器类型，标识任务对应的业务处理逻辑，例如：HPC(高性能计算)/OCR(图文识别)/AI(智能分析)")
+ private String handlerType;
+
+ @ApiModelProperty(value = "任务请求参数，JSON格式字符串，存储触发异步任务时的入参信息")
+ private String requestJson;
+
+ @ApiModelProperty(value = "任务执行结果，JSON格式字符串，存储异步任务完成后的返回数据（成功/失败均记录）")
+ private String resultJson;
+
+ @ApiModelProperty(value = "任务状态：INIT(初始化)/RUNNING(执行中)/SUCCESS(执行成功)/FAIL(执行失败)")
+ private String status;
+
+ @ApiModelProperty(value = "任务创建时间，默认当前时间")
+ private LocalDateTime createTime;
+
+ @ApiModelProperty(value = "任务更新时间，数据变更时自动更新为当前时间")
+ private LocalDateTime updateTime;
+
+
+}
diff --git a/flowable/src/main/java/com/sdm/flowable/entity/ProcessNodeParam.java b/flowable/src/main/java/com/sdm/flowable/entity/ProcessNodeParam.java
new file mode 100644
index 00000000..011dbaa6
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/entity/ProcessNodeParam.java
@@ -0,0 +1,54 @@
+package com.sdm.flowable.entity;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import java.time.LocalDateTime;
+import java.io.Serializable;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+/**
+ *
+ * 流程节点输入参数表
+ *
+ *
+ * @author author
+ * @since 2025-11-25
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Accessors(chain = true)
+@TableName("process_node_param")
+@ApiModel(value="ProcessNodeParam对象", description="流程节点输入参数表")
+public class ProcessNodeParam implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @TableId(value = "id", type = IdType.AUTO)
+ private Long id;
+
+ @ApiModelProperty(value = "流程定义ID")
+ @TableField("processDefinitionId")
+ private String processDefinitionId;
+
+ @ApiModelProperty(value = "节点ID")
+ @TableField("nodeId")
+ private String nodeId;
+
+ @ApiModelProperty(value = "输入参数JSON")
+ @TableField("paramJson")
+ private String paramJson;
+
+ @TableField("createTime")
+ private LocalDateTime createTime;
+
+ @TableField("updateTime")
+ private LocalDateTime updateTime;
+
+
+}
diff --git a/flowable/src/main/java/com/sdm/flowable/enums/FlowElementTypeEnums.java b/flowable/src/main/java/com/sdm/flowable/enums/FlowElementTypeEnums.java
new file mode 100644
index 00000000..0f71d9a0
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/enums/FlowElementTypeEnums.java
@@ -0,0 +1,28 @@
+package com.sdm.flowable.enums;
+
+public enum FlowElementTypeEnums {
+ STARTEVENT("startEvent"),
+ ENDEVENT("endEvent"),
+ USERTASK("userTask"),
+ SERVICETASK("serviceTask"),
+ EXCLUSIVEGATEWAY("exclusiveGateway"),
+ PARALLELGATEWAY("parallelGateway"),
+ SEQUENCEFLOW("sequenceFlow");
+ private final String type;
+
+ FlowElementTypeEnums(String startEvent) {
+ this.type = startEvent;
+ }
+ public String getType() {
+ return type;
+ }
+
+ public static FlowElementTypeEnums fromString(String type) {
+ for (FlowElementTypeEnums flowElementType : FlowElementTypeEnums.values()) {
+ if (flowElementType.type.equals(type)) {
+ return flowElementType;
+ }
+ }
+ throw new IllegalArgumentException("Unknown type: " + type);
+ }
+}
diff --git a/flowable/src/main/java/com/sdm/flowable/process/ProcessService.java b/flowable/src/main/java/com/sdm/flowable/process/ProcessService.java
new file mode 100644
index 00000000..fb0b9e4a
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/process/ProcessService.java
@@ -0,0 +1,509 @@
+package com.sdm.flowable.process;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.sdm.flowable.dto.ProcessDefinitionDTO;
+import com.sdm.flowable.util.Dto2BpmnConverter;
+import com.sdm.flowable.constants.FlowableConfig;
+import com.sdm.flowable.dto.req.CompleteTaskReq;
+import org.flowable.bpmn.model.*;
+import org.flowable.bpmn.model.Process;
+import org.flowable.engine.HistoryService;
+import org.flowable.engine.RepositoryService;
+import org.flowable.engine.RuntimeService;
+import org.flowable.engine.TaskService;
+import org.flowable.engine.history.HistoricActivityInstance;
+import org.flowable.engine.history.HistoricProcessInstance;
+import org.flowable.engine.repository.Deployment;
+import org.flowable.engine.repository.ProcessDefinition;
+import org.flowable.engine.repository.ProcessDefinitionQuery;
+import org.flowable.engine.runtime.ProcessInstance;
+import org.flowable.task.api.Task;
+import org.flowable.validation.ProcessValidator;
+import org.flowable.validation.ProcessValidatorFactory;
+import org.flowable.validation.ValidationError;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+
+@Service
+public class ProcessService {
+ @Autowired
+ private RepositoryService repositoryService;
+
+ @Autowired
+ private RuntimeService runtimeService;
+
+ @Autowired
+ private HistoryService historyService;
+
+ @Autowired
+ private TaskService taskService;
+
+ @Autowired
+ private Dto2BpmnConverter dto2BpmnConverter;
+
+ // 部署流程（前端传入Flowable标准JSON）
+ public Deployment deploy(ProcessDefinitionDTO processDTO) throws Exception {
+ BpmnModel bpmnModel = dto2BpmnConverter.convert(processDTO);
+ // 检查BPMN模型是否有效
+ if (bpmnModel.getProcesses().isEmpty()) {
+ throw new RuntimeException("无效的BPMN模型：未找到任何流程定义");
+ }
+
+ // 验证BPMN模型
+ ProcessValidator validator = new ProcessValidatorFactory().createDefaultProcessValidator();
+ List validationErrors = validator.validate(bpmnModel);
+ if (!validationErrors.isEmpty()) {
+ StringBuilder errorMsg = new StringBuilder("BPMN模型验证失败:");
+ for (ValidationError error : validationErrors) {
+ errorMsg.append("\n - ").append(error.toString());
+ }
+ throw new RuntimeException(errorMsg.toString());
+ }
+
+ return repositoryService.createDeployment()
+ .addBpmnModel("industrial_process.bpmn", bpmnModel)
+ .name("工业并行部署流程")
+ .deploy();
+ }
+
+ public List> listAllDeployments() {
+ return repositoryService.createDeploymentQuery()
+ .list()
+ .stream()
+ .map(deployment -> {
+ Map deploymentInfo = new HashMap<>();
+
+ deploymentInfo.put("id", deployment.getId());
+ deploymentInfo.put("name", deployment.getName());
+ deploymentInfo.put("deploymentTime", deployment.getDeploymentTime());
+ deploymentInfo.put("category", deployment.getCategory());
+ return deploymentInfo;
+ })
+ .collect(Collectors.toList());
+ }
+
+ public List> listPorcessDefinitionsByDeploymentId(String deploymentId) {
+
+ List processDefinitions =
+ repositoryService.createProcessDefinitionQuery()
+ .deploymentId(deploymentId)
+ .orderByProcessDefinitionVersion().asc()
+ .list();
+
+ return processDefinitions.stream()
+ .map(def -> {
+ Map map = new HashMap<>();
+ map.put("id", def.getId());
+ map.put("key", def.getKey());
+ map.put("name", def.getName());
+ map.put("resourceName", def.getResourceName());
+ map.put("diagramResourceName", def.getDiagramResourceName());
+ map.put("version", def.getVersion());
+ map.put("suspended", def.isSuspended());
+ map.put("deploymentId", def.getDeploymentId());
+ return map;
+ })
+ .collect(Collectors.toList());
+ }
+
+ public Map listProcessDefinitionsMetaInfo(
+ String processDefinitionKey,
+ boolean latest,
+ String order,
+ int page,
+ int size) {
+
+ ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery();
+
+ // 可选流程 key
+ if (processDefinitionKey != null && !processDefinitionKey.isEmpty()) {
+ query.processDefinitionKey(processDefinitionKey);
+ }
+
+ // 是否只查最新版本
+ if (latest) {
+ query.latestVersion();
+ }
+
+ // 排序
+ if ("desc".equalsIgnoreCase(order)) {
+ query.orderByProcessDefinitionVersion().desc();
+ } else {
+ query.orderByProcessDefinitionVersion().asc();
+ }
+
+ // 总记录数
+ long total = query.count();
+
+ // 分页查询
+ List list = query.listPage(page * size, size);
+
+ // 转换成 DTO
+ List> data = list.stream()
+ .map(pd -> {
+ Map info = new HashMap<>();
+ info.put("id", pd.getId());
+ info.put("key", pd.getKey());
+ info.put("name", pd.getName());
+ info.put("version", pd.getVersion());
+ info.put("deploymentId", pd.getDeploymentId());
+ info.put("resourceName", pd.getResourceName());
+ info.put("diagramResourceName", pd.getDiagramResourceName());
+ info.put("suspended", pd.isSuspended());
+
+ // 获取部署时间
+ Deployment dep = repositoryService.createDeploymentQuery()
+ .deploymentId(pd.getDeploymentId())
+ .singleResult();
+ info.put("deploymentTime", dep != null ? dep.getDeploymentTime() : null);
+
+ return info;
+ })
+ .collect(Collectors.toList());
+
+ // 返回分页信息
+ Map result = new HashMap<>();
+ result.put("total", total);
+ result.put("page", page);
+ result.put("size", size);
+ result.put("data", data);
+
+ return result;
+ }
+
+ public List> listNodesByProcessDefinitionKey(
+ String processDefinitionKey, Integer processDefinitionVersion) {
+
+ ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery()
+ .processDefinitionKey(processDefinitionKey);
+
+ ProcessDefinition processDefinition;
+
+ if (processDefinitionVersion == null) {
+ // ⭐ 未指定版本 → 查最新版本
+ processDefinition = query.latestVersion().singleResult();
+ } else {
+ // ⭐ 指定版本 → 查询对应版本
+ processDefinition = query
+ .processDefinitionVersion(processDefinitionVersion)
+ .singleResult();
+ }
+
+ if (processDefinition == null) {
+ return Collections.emptyList();
+ }
+
+ return getFlowStructureWithExtensions(processDefinition.getId());
+ }
+
+ /**
+ * 根据流程定义ID获取节点信息
+ */
+ public List> getNodesByProcessDefinitionId(String processDefinitionId) {
+ return getFlowStructureWithExtensions(processDefinitionId);
+ }
+
+ /**
+ * 带 extensionElements 的流程结构解析
+ *
+ * @param processDefinitionId
+ * @return
+ */
+ public List> getFlowStructureWithExtensions(String processDefinitionId) {
+
+ BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
+ if (bpmnModel == null) return Collections.emptyList();
+
+ Process process = bpmnModel.getMainProcess();
+
+ // 找开始事件
+ StartEvent startEvent = process.findFlowElementsOfType(StartEvent.class, false)
+ .stream().findFirst().orElse(null);
+
+ if (startEvent == null) return Collections.emptyList();
+
+ List> result = new ArrayList<>();
+ Queue queue = new LinkedList<>();
+ Set visited = new HashSet<>();
+
+ queue.add(startEvent);
+
+ while (!queue.isEmpty()) {
+ FlowNode node = queue.poll();
+ if (!visited.add(node.getId())) continue;
+
+ Map info = new LinkedHashMap<>();
+ info.put("id", node.getId());
+ info.put("name", node.getName());
+ info.put("type", node.getClass().getSimpleName());
+
+ // 后继节点
+ List nextNodeIds = node.getOutgoingFlows()
+ .stream().map(SequenceFlow::getTargetRef).collect(Collectors.toList());
+ info.put("next", nextNodeIds);
+
+ // ⭐ 添加扩展属性 extensionElements ⭐
+ info.put("extensionElements", parseExtensionElements(node.getExtensionElements()));
+
+ result.add(info);
+
+ // BFS 的推进逻辑
+ for (String nextId : nextNodeIds) {
+ FlowElement nextElement = process.getFlowElement(nextId);
+ if (nextElement instanceof FlowNode nextNode) {
+ queue.add(nextNode);
+ }
+ }
+ }
+
+ return result;
+ }
+
+ // 将 extensionElements 转成可阅读的 map
+ private Object parseExtensionElements(Map> extMap) {
+ if (extMap == null || extMap.isEmpty()) return Collections.emptyMap();
+
+ Map result = new LinkedHashMap<>();
+
+ extMap.forEach((key, extList) -> {
+ List> values = new ArrayList<>();
+
+ for (ExtensionElement ext : extList) {
+ Map item = new LinkedHashMap<>();
+ item.put("name", ext.getName());
+ item.put("namespace", ext.getNamespacePrefix());
+ item.put("elementText", ext.getElementText());
+ item.put("attributes", ext.getAttributes());
+
+ values.add(item);
+ }
+
+ result.put(key, values);
+ });
+
+ return result;
+ }
+
+
+
+
+
+
+ public void deleteAllDeployments() {
+ repositoryService.createDeploymentQuery()
+ .list()
+ .forEach(deployment
+ -> repositoryService.deleteDeployment(deployment.getId(), true));
+ }
+
+
+ // 启动流程实例
+ public ProcessInstance startByProcessDefinitionKey(String processDefinitionKey) {
+ return runtimeService.startProcessInstanceByKey(processDefinitionKey);
+ }
+
+ public ProcessInstance startByProcessDefinitionId(String processDefinitionId, Map variables) {
+ if (variables == null) {
+ variables = Collections.emptyMap();
+ }
+
+ return runtimeService.startProcessInstanceById(processDefinitionId, variables);
+ }
+
+ // 获取BPMN模型用于调试和验证
+ public BpmnModel getBpmnModel(ProcessDefinitionDTO processDTO) throws JsonProcessingException {
+ return dto2BpmnConverter.convert(processDTO);
+ }
+
+ // 验证并返回模型验证错误信息
+ public List validateModel(ProcessDefinitionDTO processDTO) throws JsonProcessingException {
+ BpmnModel bpmnModel = dto2BpmnConverter.convert(processDTO);
+ ProcessValidator validator = new ProcessValidatorFactory().createDefaultProcessValidator();
+ return validator.validate(bpmnModel);
+ }
+
+
+
+ public HistoricProcessInstance getLatestProcessInstance(String processDefinitionKey) {
+
+ // 查询最新版本流程定义
+ ProcessDefinition latestProcDef = repositoryService
+ .createProcessDefinitionQuery()
+ .processDefinitionKey(processDefinitionKey)
+ .latestVersion()
+ .singleResult();
+
+ if (latestProcDef == null) {
+ return null;
+ }
+
+ // 优先查正在运行的
+ ProcessInstance running = runtimeService.createProcessInstanceQuery()
+ .processDefinitionId(latestProcDef.getId())
+ .orderByStartTime()
+ .desc()
+ .listPage(0, 1)
+ .stream()
+ .findFirst()
+ .orElse(null);
+
+ if (running != null) {
+ return historyService.createHistoricProcessInstanceQuery()
+ .processInstanceId(running.getId())
+ .singleResult();
+ }
+
+ // 查最近的历史实例（已结束）
+ return historyService.createHistoricProcessInstanceQuery()
+ .processDefinitionId(latestProcDef.getId())
+ .orderByProcessInstanceStartTime()
+ .desc()
+ .listPage(0, 1)
+ .stream()
+ .findFirst()
+ .orElse(null);
+ }
+
+
+ /**
+ * 查询流程的所有节点状态
+ *
+ * @param processInstanceId
+ * @return
+ */
+ public Map getProcessNodeDetail(String processInstanceId) {
+ return buildProcessNodeDetail(processInstanceId);
+ }
+
+ public Map getNodeDetailByProcessDefinitionKey(String processDefinitionKey) {
+ HistoricProcessInstance processInstance = getLatestProcessInstance(processDefinitionKey);
+
+ if (processInstance == null) {
+ throw new RuntimeException("流程不存在或未运行过: " + processDefinitionKey);
+ }
+
+ return buildProcessNodeDetail(processInstance.getId());
+ }
+
+ /**
+ * 根据流程实例ID构建流程节点状态（支持 UserTask 任务信息和扩展属性）
+ */
+ private Map buildProcessNodeDetail(String processInstanceId) {
+
+ Map result = new HashMap<>();
+
+ // 1. 查询流程实例历史信息
+ HistoricProcessInstance processInstance =
+ historyService.createHistoricProcessInstanceQuery()
+ .processInstanceId(processInstanceId)
+ .singleResult();
+
+ if (processInstance == null) {
+ throw new RuntimeException("流程实例不存在: " + processInstanceId);
+ }
+
+ String processDefinitionId = processInstance.getProcessDefinitionId();
+
+ // 2. 获取 BPMN 模型
+ BpmnModel model = repositoryService.getBpmnModel(processDefinitionId);
+ Process process = model.getMainProcess();
+ Collection flowElements = process.getFlowElements();
+
+ // 3. 查询正在执行的节点
+ // 判断流程是否正在运行中
+ boolean isRunning = runtimeService.createProcessInstanceQuery()
+ .processInstanceId(processInstanceId)
+ .singleResult() != null;
+
+ List activeIds;
+ Map activeTaskMap = new HashMap<>();
+ if (isRunning) {
+ activeIds = runtimeService.getActiveActivityIds(processInstanceId);
+
+ // 查询当前活跃任务（UserTask）
+ List tasks = taskService.createTaskQuery()
+ .processInstanceId(processInstanceId)
+ .list();
+ activeTaskMap = tasks.stream().collect(Collectors.toMap(org.flowable.task.api.Task::getTaskDefinitionKey, task -> task));
+
+ } else {
+ activeIds = Collections.emptyList();
+ }
+
+ // 4. 查询已完成节点
+ List finished =
+ historyService.createHistoricActivityInstanceQuery()
+ .processInstanceId(processInstanceId)
+ .finished()
+ .list();
+
+ Set finishedIds = finished.stream()
+ .map(HistoricActivityInstance::getActivityId)
+ .collect(Collectors.toSet());
+
+ // 5. 组装节点状态
+ List> nodeList = new ArrayList<>();
+
+ for (FlowElement element : flowElements) {
+ if (!(element instanceof FlowNode)) continue;
+
+ FlowNode node = (FlowNode) element;
+
+ Map nodeInfo = new HashMap<>();
+ nodeInfo.put("id", node.getId());
+ nodeInfo.put("name", node.getName());
+ nodeInfo.put("type", node.getClass().getSimpleName());
+
+ // 节点状态
+ if (activeIds.contains(node.getId())) {
+ nodeInfo.put("status", "active");
+
+ // 如果是 UserTask，返回任务信息
+ if (node instanceof UserTask && activeTaskMap.containsKey(node.getId())) {
+ org.flowable.task.api.Task task = activeTaskMap.get(node.getId());
+ nodeInfo.put("taskId", task.getId());
+ nodeInfo.put("taskName", task.getName());
+ nodeInfo.put("assignee", task.getAssignee()); // 可能为 null
+ }
+ } else if (finishedIds.contains(node.getId())) {
+ nodeInfo.put("status", "finished");
+ } else {
+ nodeInfo.put("status", "pending");
+ }
+
+ // 读取扩展属性（executeConfig）
+ if (node.getExtensionElements() != null && node.getExtensionElements().containsKey(FlowableConfig.EXECUTECONFIG)) {
+ List elements = node.getExtensionElements().get(FlowableConfig.EXECUTECONFIG);
+ if (elements != null && !elements.isEmpty()) {
+ nodeInfo.put("executeConfig", elements.get(0).getElementText());
+ }
+ }
+
+ nodeList.add(nodeInfo);
+ }
+
+ result.put("processInstanceId", processInstanceId);
+ result.put("nodes", nodeList);
+ return result;
+ }
+
+ public void completeManualTasks(@RequestBody CompleteTaskReq req) {
+ Task task = taskService.createTaskQuery()
+ .processInstanceId(req.getProcessInstanceId())
+ .taskDefinitionKey(req.getTaskDefinitionKey())
+ .singleResult();
+
+ if (task != null) {
+ taskService.complete(task.getId(), req.getVariables());
+ } else {
+ throw new RuntimeException("找不到任务！");
+ }
+
+ }
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/service/IAsyncTaskRecordService.java b/flowable/src/main/java/com/sdm/flowable/service/IAsyncTaskRecordService.java
new file mode 100644
index 00000000..5f61b23d
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/service/IAsyncTaskRecordService.java
@@ -0,0 +1,28 @@
+package com.sdm.flowable.service;
+
+import com.sdm.flowable.dto.req.AsyncCallbackRequest;
+import com.sdm.flowable.entity.AsyncTaskRecord;
+import com.baomidou.mybatisplus.extension.service.IService;
+import org.flowable.engine.delegate.DelegateExecution;
+
+import java.util.Map;
+
+/**
+ *
+ * 异步任务执行记录表 服务类
+ *
+ *
+ * @author author
+ * @since 2025-11-26
+ */
+public interface IAsyncTaskRecordService extends IService {
+ /**
+ * 注册异步任务
+ */
+ String registerAsyncTask(DelegateExecution execution, String receiveTaskId, String handlerType, Map bizParams);
+
+ /**
+ * 异步回调恢复流程
+ */
+ void completeAsyncTask(AsyncCallbackRequest request);
+}
diff --git a/flowable/src/main/java/com/sdm/flowable/service/IProcessNodeParamService.java b/flowable/src/main/java/com/sdm/flowable/service/IProcessNodeParamService.java
new file mode 100644
index 00000000..f2949924
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/service/IProcessNodeParamService.java
@@ -0,0 +1,19 @@
+package com.sdm.flowable.service;
+
+import com.sdm.flowable.entity.ProcessNodeParam;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import java.util.Map;
+
+/**
+ *
+ * 流程节点输入参数表 服务类
+ *
+ *
+ * @author author
+ * @since 2025-11-25
+ */
+public interface IProcessNodeParamService extends IService {
+ void saveParamByDefinitionId(String processDefinitionId, String nodeId, Map params);
+ Map getParam(String procInstId, String nodeId);
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/service/impl/AsyncTaskRecordServiceImpl.java b/flowable/src/main/java/com/sdm/flowable/service/impl/AsyncTaskRecordServiceImpl.java
new file mode 100644
index 00000000..23dd2d00
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/service/impl/AsyncTaskRecordServiceImpl.java
@@ -0,0 +1,71 @@
+package com.sdm.flowable.service.impl;
+
+import com.alibaba.fastjson2.JSON;
+import com.sdm.flowable.dto.req.AsyncCallbackRequest;
+import com.sdm.flowable.entity.AsyncTaskRecord;
+import com.sdm.flowable.dao.AsyncTaskRecordMapper;
+import com.sdm.flowable.service.IAsyncTaskRecordService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.flowable.engine.RuntimeService;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.runtime.Execution;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ *
+ * 异步任务执行记录表 服务实现类
+ *
+ *
+ * @author author
+ * @since 2025-11-26
+ */
+@Service
+public class AsyncTaskRecordServiceImpl extends ServiceImpl implements IAsyncTaskRecordService {
+ @Autowired
+ private RuntimeService runtimeService;
+
+ /**
+ * 注册异步任务
+ */
+ public String registerAsyncTask(DelegateExecution execution, String receiveTaskId, String handlerType, Map bizParams) {
+ String asyncTaskId = UUID.randomUUID().toString();
+
+ AsyncTaskRecord record = new AsyncTaskRecord();
+ record.setAsyncTaskId(asyncTaskId);
+ record.setProcessInstanceId(execution.getProcessInstanceId());
+ record.setExecutionId(execution.getId());
+ record.setReceiveTaskId(receiveTaskId);
+ record.setHandlerType(handlerType);
+ record.setRequestJson(JSON.toJSONString(bizParams));
+ record.setStatus("INIT");
+ this.save( record);
+ return asyncTaskId;
+ }
+
+ /**
+ * 异步回调恢复流程
+ */
+ public void completeAsyncTask(AsyncCallbackRequest request) {
+ AsyncTaskRecord record = this.lambdaQuery().eq(AsyncTaskRecord::getAsyncTaskId, request.getAsyncTaskId()).one();
+ if (record == null) {
+ throw new RuntimeException("AsyncTask not found: " + request);
+ }
+ record.setStatus("SUCCESS");
+ record.setResultJson(request.getResultJson());
+ this.updateById(record);
+ Execution exec = runtimeService.createExecutionQuery()
+ .processInstanceId(record.getProcessInstanceId())
+ .activityId(record.getReceiveTaskId())
+ .singleResult();
+
+ if (exec == null) {
+ throw new RuntimeException("ReceiveTask 已不在等待状态");
+ }
+
+ runtimeService.trigger(exec.getId());
+ }
+}
diff --git a/flowable/src/main/java/com/sdm/flowable/service/impl/ProcessNodeParamServiceImpl.java b/flowable/src/main/java/com/sdm/flowable/service/impl/ProcessNodeParamServiceImpl.java
new file mode 100644
index 00000000..64912960
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/service/impl/ProcessNodeParamServiceImpl.java
@@ -0,0 +1,78 @@
+package com.sdm.flowable.service.impl;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.sdm.flowable.entity.ProcessNodeParam;
+import com.sdm.flowable.dao.ProcessNodeParamMapper;
+import com.sdm.flowable.service.IProcessNodeParamService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.flowable.engine.RuntimeService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ *
+ * 流程节点输入参数表 服务实现类
+ *
+ *
+ * @author author
+ * @since 2025-11-25
+ */
+@Service
+public class ProcessNodeParamServiceImpl extends ServiceImpl implements IProcessNodeParamService {
+
+
+ @Autowired
+ private ObjectMapper objectMapper;
+
+ @Autowired
+ private RuntimeService runtimeService;
+
+ // 保存节点输入参数（按流程定义ID保存，用于参数模板）
+ public void saveParamByDefinitionId(String processDefinitionId, String nodeId, Map params) {
+ ProcessNodeParam param = new ProcessNodeParam();
+ param.setProcessDefinitionId(processDefinitionId);
+ param.setNodeId(nodeId);
+ try {
+ param.setParamJson(objectMapper.writeValueAsString(params));
+ } catch (JsonProcessingException e) {
+ throw new RuntimeException("参数序列化失败", e);
+ }
+ // 存在则更新，不存在则插入
+ ProcessNodeParam existing = this.lambdaQuery().eq(ProcessNodeParam::getProcessDefinitionId, processDefinitionId).eq(ProcessNodeParam::getNodeId, nodeId).one();
+ if (existing != null) {
+ param.setId(existing.getId());
+ this.updateById(param);
+ } else {
+ this.save(param);
+ }
+ }
+
+ // 查询节点输入参数（流程执行时调用）
+ public Map getParam(String procInstId, String nodeId) {
+ // 获取流程实例对应的流程定义ID
+ String processDefinitionId = runtimeService.createProcessInstanceQuery()
+ .processInstanceId(procInstId)
+ .singleResult()
+ .getProcessDefinitionId();
+
+ ProcessNodeParam param = this.lambdaQuery().eq(ProcessNodeParam::getProcessDefinitionId, processDefinitionId)
+ .eq(ProcessNodeParam::getNodeId, nodeId)
+ .one();
+
+ if (param == null) {
+ // 当未配置参数时不抛出异常，而是返回空Map
+ return new HashMap<>();
+ }
+ try {
+ return objectMapper.readValue(param.getParamJson(), new TypeReference>() {});
+ } catch (JsonProcessingException e) {
+ throw new RuntimeException("参数反序列化失败", e);
+ }
+ }
+}
\ No newline at end of file
diff --git a/flowable/src/main/java/com/sdm/flowable/util/Dto2BpmnConverter.java b/flowable/src/main/java/com/sdm/flowable/util/Dto2BpmnConverter.java
new file mode 100644
index 00000000..f73aa106
--- /dev/null
+++ b/flowable/src/main/java/com/sdm/flowable/util/Dto2BpmnConverter.java
@@ -0,0 +1,378 @@
+package com.sdm.flowable.util;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.sdm.flowable.dto.FlowElementDTO;
+import com.sdm.flowable.dto.ProcessDefinitionDTO;
+import com.sdm.flowable.config.executeConfig.BaseExecuteConfig;
+import com.sdm.flowable.constants.FlowableConfig;
+import com.sdm.flowable.dto.FlowElementDTO;
+import com.sdm.flowable.dto.ProcessDefinitionDTO;
+import com.sdm.flowable.enums.FlowElementTypeEnums;
+import org.flowable.bpmn.model.*;
+import org.flowable.bpmn.model.Process;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * DTO → Flowable BpmnModel 映射工具类（核心）
+ */
+@Component
+public class Dto2BpmnConverter {
+
+ @Autowired
+ private ObjectMapper objectMapper;
+
+ /**
+ * 核心映射方法
+ */
+ public BpmnModel convert(ProcessDefinitionDTO dto) throws JsonProcessingException {
+ // 1. 初始化 Flowable 顶层对象
+ BpmnModel bpmnModel = new BpmnModel();
+ Process process = new Process();
+ process.setId(dto.getProcess().getId()); // 流程ID=DTO的process.id
+ process.setName(dto.getProcess().getName()); // 流程名称=DTO的process.name
+ bpmnModel.addProcess(process);
+
+ // 2. 分离 DTO 中的「节点」和「连线」
+ List allElements = dto.getFlowElements();
+ List nodeDtos = allElements.stream()
+ .filter(e -> !FlowElementTypeEnums.SEQUENCEFLOW.getType().equals(e.getType()))
+ .collect(Collectors.toList());
+ List flowDtos = allElements.stream()
+ .filter(e -> FlowElementTypeEnums.SEQUENCEFLOW.getType().equals(e.getType()))
+ .collect(Collectors.toList());
+
+ // 3. 存储异步任务映射关系（原节点ID → wait节点ID）
+ Map asyncTaskMap = new HashMap<>(); // 异步任务映射（原节点→wait节点）
+
+ // 4. 存储并行网关映射关系（原节点ID → 网关ID）
+ Map splitGatewayMap = new HashMap<>(); // 拆分网关（原拆分节点→拆分网关）
+ Map joinGatewayMap = new HashMap<>(); // 汇总网关（原汇总节点→汇总网关）
+
+ // 5. 先创建所有节点（实际节点+等待任务节点+网关节点）
+ for (FlowElementDTO nodeDto : nodeDtos) {
+ // 处理异步任务，创建等待节点,放在穿件实际节点之前是为了构造asyncTaskMap，后面createActualNode的时候才能设置回调等待节点
+ handleAsyncTasks(process, nodeDto, asyncTaskMap);
+ // 创建实际节点
+ createActualNode(process, nodeDto,asyncTaskMap);
+ // 处理并行网关，创建拆分和汇聚节点
+ addRequiredGateways(process, nodeDto, flowDtos, joinGatewayMap, splitGatewayMap);
+ }
+
+ // 6. 创建连线
+ createConnections(process, flowDtos, asyncTaskMap, joinGatewayMap, splitGatewayMap);
+
+ return bpmnModel;
+ }
+
+ /**
+ * 处理异步任务节点
+ */
+ private void handleAsyncTasks(Process process, FlowElementDTO nodeDto, Map asyncTaskMap) {
+ // 检查节点是否为服务任务或用户任务且标记为异步回调
+ if ((FlowElementTypeEnums.SERVICETASK.getType().equals(nodeDto.getType()) ||
+ FlowElementTypeEnums.USERTASK.getType().equals(nodeDto.getType())) &&
+ nodeDto.getExtensionElements() != null &&
+ nodeDto.getExtensionElements().getExecuteConfig() != null &&
+ nodeDto.getExtensionElements().getExecuteConfig().isAsyncCallback()) {
+
+ // 创建接收任务节点
+ String originalNodeId = nodeDto.getId();
+ String waitNodeId = originalNodeId + "_wait";
+ ReceiveTask receiveTask = new ReceiveTask();
+ receiveTask.setId(waitNodeId);
+ receiveTask.setName(nodeDto.getName() + "等待结果");
+ process.addFlowElement(receiveTask);
+
+ // 记录映射关系
+ asyncTaskMap.put(originalNodeId, waitNodeId);
+ }
+ }
+
+ /**
+ * 添加必要的网关（并行拆分网关和并行汇聚网关）
+ */
+ private void addRequiredGateways(Process process, FlowElementDTO nodeDto, List flowDtos,
+ Map joinGatewayMap, Map splitGatewayMap) {
+ String nodeId = nodeDto.getId();
+
+ // 计算入度和出度
+ long incomingCount = flowDtos.stream().filter(f -> f.getTargetRef().equals(nodeId)).count();
+ long outgoingCount = flowDtos.stream().filter(f -> f.getSourceRef().equals(nodeId)).count();
+
+ // 检查是否需要添加汇聚网关（入度>1）
+ if (incomingCount > 1) {
+ // 如果入度>1，则在节点前插入汇聚网关
+ String joinGatewayId = "join_gw_" + nodeId;
+ ParallelGateway joinGateway = new ParallelGateway();
+ joinGateway.setId(joinGatewayId);
+ joinGateway.setName("并行汇聚-" + nodeDto.getName());
+ process.addFlowElement(joinGateway);
+ joinGatewayMap.put(nodeId, joinGatewayId);
+ }
+
+ // 检查是否需要添加拆分网关（出度>1）
+ if (outgoingCount > 1) {
+ // 如果出度>1，则在节点后插入拆分网关
+ String splitGatewayId = "split_gw_" + nodeId;
+ ParallelGateway splitGateway = new ParallelGateway();
+ splitGateway.setId(splitGatewayId);
+ splitGateway.setName("并行拆分-" + nodeDto.getName());
+ process.addFlowElement(splitGateway);
+ splitGatewayMap.put(nodeId, splitGatewayId);
+ }
+ }
+
+ /**
+ * 全新的连线构造逻辑
+ */
+ private void createConnections(Process process,
+ List flowDtos,
+ Map asyncTaskMap,
+ Map joinGatewayMap,
+ Map splitGatewayMap) {
+
+ // ====================================================================================
+ // ① 第一阶段：先把所有 DTO 原始连线直接画出来（不考虑网关和等待节点）
+ // ====================================================================================
+ createInitialConnections(process, flowDtos);
+
+ // ====================================================================================
+ // ② 第二阶段：网关处理（删除原始连线 → 使用网关替代）
+ // ====================================================================================
+ handleGatewayConnections(process, flowDtos, joinGatewayMap, splitGatewayMap);
+
+ // ====================================================================================
+ // ③ 第三阶段：处理异步任务（等待节点）
+ // 原逻辑：原节点 → wait → 原本下游
+ // ====================================================================================
+ handleAsyncTaskConnections(process, asyncTaskMap);
+ }
+
+ /**
+ * 第一阶段：创建初始连接
+ * 遍历所有流程元素DTO，根据源引用和目标引用创建基本的顺序流连接
+ */
+ private void createInitialConnections(Process process, List flowDtos) {
+ for (FlowElementDTO flowDto : flowDtos) {
+ String source = flowDto.getSourceRef();
+ String target = flowDto.getTargetRef();
+
+ SequenceFlow flow = createSequenceFlow(source, target, flowDto.getName());
+ process.addFlowElement(flow);
+ }
+ }
+
+ /**
+ * 第二阶段：处理网关连接
+ * 包括删除需要被网关替代的原始连线以及重建涉及汇聚网关和拆分网关的连接关系
+ */
+ private void handleGatewayConnections(Process process,
+ List flowDtos,
+ Map joinGatewayMap,
+ Map splitGatewayMap) {
+ // Step 2.1 删除所有不该存在的连线（因为网关将替代）
+ List toRemove = new ArrayList<>();
+
+ for (FlowElement ele : process.getFlowElements()) {
+ if (ele instanceof SequenceFlow) {
+ SequenceFlow sf = (SequenceFlow) ele;
+
+ // 目标节点有汇聚网关 → 删除原连线
+ if (joinGatewayMap.containsKey(sf.getTargetRef())) {
+ toRemove.add(sf);
+ }
+
+ // 源节点有拆分网关 → 删除原连线
+ if (splitGatewayMap.containsKey(sf.getSourceRef())) {
+ toRemove.add(sf);
+ }
+ }
+ }
+ toRemove.forEach(e -> process.removeFlowElement(e.getId()));
+
+
+ // Step 2.2 重建汇聚网关连线（incoming：所有入线 → joinGW → 原节点）
+ for (String nodeId : joinGatewayMap.keySet()) {
+
+ String joinGW = joinGatewayMap.get(nodeId);
+
+ // 1. 所有"指向 nodeId 的原始入度" → joinGW
+ List incomingSources = flowDtos.stream()
+ .filter(f -> f.getTargetRef().equals(nodeId))
+ .map(FlowElementDTO::getSourceRef)
+ .toList();
+
+ for (String src : incomingSources) {
+ process.addFlowElement(createSequenceFlow(src, joinGW, null));
+ }
+
+ // 2. joinGW → nodeId
+ process.addFlowElement(createSequenceFlow(joinGW, nodeId, null));
+ }
+
+
+ // Step 2.3 重建拆分网关连线（node → splitGW → 所有原本出度）
+ for (String nodeId : splitGatewayMap.keySet()) {
+
+ String splitGW = splitGatewayMap.get(nodeId);
+
+ // 1. nodeId → splitGW
+ process.addFlowElement(createSequenceFlow(nodeId, splitGW, null));
+
+ // 2. splitGW → 所有 target
+ List outgoingTargets = flowDtos.stream()
+ .filter(f -> f.getSourceRef().equals(nodeId))
+ .map(FlowElementDTO::getTargetRef)
+ .toList();
+
+ for (String target : outgoingTargets) {
+ process.addFlowElement(createSequenceFlow(splitGW, target, null));
+ }
+ }
+ }
+
+ /**
+ * 第三阶段：处理异步任务连接
+ * 针对已标记为异步回调的任务节点，将其连接重构为'原节点 → 等待节点 → 原目标节点'的模式
+ */
+ private void handleAsyncTaskConnections(Process process, Map asyncTaskMap) {
+ for (String originalNodeId : asyncTaskMap.keySet()) {
+
+ String waitNodeId = asyncTaskMap.get(originalNodeId);
+
+ // Step 3.1 找出所有"原节点 → target"的连线，并删除
+ List removeLines = new ArrayList<>();
+
+ List targets = new ArrayList<>();
+
+ for (FlowElement ele : process.getFlowElements()) {
+ if (ele instanceof SequenceFlow) {
+ SequenceFlow sf = (SequenceFlow) ele;
+ if (sf.getSourceRef().equals(originalNodeId)) {
+ targets.add(sf.getTargetRef());
+ removeLines.add(sf);
+ }
+ }
+ }
+
+ removeLines.forEach(f -> process.removeFlowElement(f.getId()));
+
+
+ // Step 3.2 添加：original → wait
+ process.addFlowElement(createSequenceFlow(originalNodeId, waitNodeId, null));
+
+ // Step 3.3 添加：wait → 原目标
+ for (String target : targets) {
+ process.addFlowElement(createSequenceFlow(waitNodeId, target, null));
+ }
+ }
+ }
+
+ /**
+ * 创建实际的流程节点
+ */
+ private void createActualNode(Process process, FlowElementDTO nodeDto, Map asyncTaskMap) throws JsonProcessingException {
+ FlowElementTypeEnums elementType = FlowElementTypeEnums.fromString(nodeDto.getType());
+
+ switch (elementType) {
+ case STARTEVENT:
+ // 开始事件：直接映射
+ StartEvent startEvent = new StartEvent();
+ startEvent.setId(nodeDto.getId());
+ startEvent.setName(nodeDto.getName());
+ process.addFlowElement(startEvent);
+ break;
+
+ case ENDEVENT:
+ // 结束事件：直接映射
+ EndEvent endEvent = new EndEvent();
+ endEvent.setId(nodeDto.getId());
+ endEvent.setName(nodeDto.getName());
+ process.addFlowElement(endEvent);
+ break;
+
+ case USERTASK:
+ // 用户任务：映射为 Flowable UserTask
+ UserTask userTask = new UserTask();
+ userTask.setId(nodeDto.getId());
+ userTask.setName(nodeDto.getName());
+
+ // 绑定控制参数（和 ServiceTask 类似）
+ BaseExecuteConfig userTaskExecuteConfig = nodeDto.getExtensionElements().getExecuteConfig();
+ // 设置异步回调节点ID
+ userTaskExecuteConfig.setCallbackNodeId(asyncTaskMap.getOrDefault(nodeDto.getId(), null));
+ if (userTaskExecuteConfig != null) {
+ String configJson = objectMapper.writeValueAsString(userTaskExecuteConfig);
+ ExtensionElement extensionElement = createFlowableElement(
+ FlowableConfig.EXECUTECONFIG, configJson);
+ userTask.getExtensionElements()
+ .computeIfAbsent(FlowableConfig.EXECUTECONFIG, k -> new ArrayList<>())
+ .add(extensionElement);
+ }
+ // 设置用户任务的属性，使其可以被任何人处理
+ // 不设置 assignee 或 candidateUsers，这样任何人都可以处理任务
+
+ // 可选：绑定 TaskListener，在任务完成时触发逻辑
+ userTask.getTaskListeners();
+
+ process.addFlowElement(userTask);
+ break;
+
+ case SERVICETASK:
+ // 服务任务：映射为 Flowable ServiceTask，绑定自定义执行器
+ ServiceTask serviceTask = new ServiceTask();
+ serviceTask.setId(nodeDto.getId());
+ serviceTask.setName(nodeDto.getName());
+ // 绑定执行器（Bean名称：customTaskExecutor）
+ serviceTask.setImplementation("${universalDelegate}");
+ serviceTask.setImplementationType(ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION);
+
+ // 添加 Flowable 扩展属性
+ BaseExecuteConfig serviceTaskExecuteConfig = nodeDto.getExtensionElements().getExecuteConfig();
+ // 设置异步回调节点ID
+ serviceTaskExecuteConfig.setCallbackNodeId(asyncTaskMap.getOrDefault(nodeDto.getId(), null));
+ if (serviceTaskExecuteConfig != null) {
+ String configJson = objectMapper.writeValueAsString(serviceTaskExecuteConfig);
+ ExtensionElement extensionElement = createFlowableElement(FlowableConfig.EXECUTECONFIG, configJson);
+ serviceTask.getExtensionElements().computeIfAbsent(FlowableConfig.EXECUTECONFIG, k -> new ArrayList<>())
+ .add(extensionElement);
+ }
+
+ process.addFlowElement(serviceTask);
+ break;
+
+ default:
+ // 对于未支持的类型，可以选择抛出异常或者忽略
+ throw new IllegalArgumentException("Unsupported element type: " + nodeDto.getType());
+ }
+ }
+
+ private ExtensionElement createFlowableElement(String name, String value) {
+ ExtensionElement element = new ExtensionElement();
+ element.setName(name);
+ element.setNamespace("http://flowable.org/bpmn");
+ element.setNamespacePrefix("flowable");
+ element.setElementText(value);
+ return element;
+ }
+
+ /**
+ * 辅助方法：创建 Flowable 连线（SequenceFlow）
+ */
+ private SequenceFlow createSequenceFlow(String sourceRef, String targetRef, String name) {
+ SequenceFlow flow = new SequenceFlow();
+ // 确保生成的ID符合NCName规范（以字母开头）
+ flow.setId("s" + UUID.randomUUID().toString().replace("-", ""));
+ flow.setSourceRef(sourceRef); // 源节点ID
+ flow.setTargetRef(targetRef); // 目标节点ID
+ if (name != null) {
+ flow.setName(name);
+ }
+ return flow;
+ }
+}
\ No newline at end of file
diff --git a/flowable/src/main/resources/application.yml b/flowable/src/main/resources/application.yml
new file mode 100644
index 00000000..5cd33827
--- /dev/null
+++ b/flowable/src/main/resources/application.yml
@@ -0,0 +1,36 @@
+server:
+ port: 7106
+spring:
+ application:
+ name: flowable
+ datasource:
+ url: jdbc:mysql://192.168.65.161:3306/flowable?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
+ username: root
+ password: mysql
+ driver-class-name: com.mysql.cj.jdbc.Driver
+ flowable:
+ # ?????????
+ database-schema-update: true
+ # ??????JOB
+ async-executor-activate: true
+ cloud:
+ nacos:
+ discovery:
+ server-addr: 192.168.65.161:8848
+ group: LOCAL_GROUP
+ enabled: true
+
+logging:
+ level:
+ org:
+ flowable: INFO
+
+mybatis-plus:
+ mapper-locations: classpath*:/mapper/**/*.xml
+ type-aliases-package: com.sdm.flowable.model.entity
+ configuration:
+ map-underscore-to-camel-case: true
+ global-config:
+ db-config:
+ id-type: auto
+
diff --git a/flowable/src/main/resources/flow.json b/flowable/src/main/resources/flow.json
new file mode 100644
index 00000000..98b64ee9
--- /dev/null
+++ b/flowable/src/main/resources/flow.json
@@ -0,0 +1,160 @@
+{
+ "process": {
+ "id": "auto_process_001",
+ "name": "网关串并行+人工节点+异步回调混合流程"
+ },
+ "flowElements": [
+ {
+ "id": "start",
+ "type": "startEvent",
+ "name": "第1步-流程启动",
+ "outgoingFlows": ["flow1"]
+ },
+ {
+ "id": "task_script",
+ "type": "serviceTask",
+ "name": "第2步-HPC异步执行",
+ "incomingFlows": ["flow1"],
+ "outgoingFlows": ["flow2"],
+ "extensionElements": {
+ "executeConfig": {
+ "executeType": "HPC",
+ "asyncCallback": true
+ }
+ }
+ },
+ {
+ "id": "task_http",
+ "type": "serviceTask",
+ "name": "第3步-HTTP请求",
+ "incomingFlows": ["flow2"],
+ "outgoingFlows": ["flow3", "flow4"],
+ "extensionElements": {
+ "executeConfig": {
+ "executeType": "http"
+ }
+ }
+ },
+ {
+ "id": "task_backup",
+ "type": "serviceTask",
+ "name": "第3步后-并行分支1-数据备份",
+ "incomingFlows": ["flow3"],
+ "outgoingFlows": ["flow5"],
+ "extensionElements": {
+ "executeConfig": {
+ "executeType": "http"
+ }
+ }
+ },
+ {
+ "id": "task_log",
+ "type": "serviceTask",
+ "name": "第3步后-并行第分支2-日志记录",
+ "incomingFlows": ["flow4"],
+ "outgoingFlows": ["flow6"],
+ "extensionElements": {
+ "executeConfig": {
+ "executeType": "http"
+ }
+ }
+ },
+ {
+ "id": "task_parallel_join",
+ "type": "serviceTask",
+ "name": "第4步-并行汇总",
+ "incomingFlows": ["flow5", "flow6"],
+ "outgoingFlows": ["flow7"],
+ "extensionElements": {
+ "executeConfig": {
+ "executeType": "dataProcess"
+ }
+ }
+ },
+ {
+ "id": "task_manual_approval",
+ "type": "userTask",
+ "name": "第5步-人工操作节点-数据确认",
+ "incomingFlows": ["flow7"],
+ "outgoingFlows": ["flow8"],
+ "extensionElements": {
+ "executeConfig": {
+ "executeType": "manual",
+ "description": "人工确认数据处理"
+ }
+ }
+ },
+ {
+ "id": "task_data_process",
+ "type": "serviceTask",
+ "name": "第6步-数据处理",
+ "incomingFlows": ["flow8"],
+ "outgoingFlows": ["flow9"],
+ "extensionElements": {
+ "executeConfig": {
+ "executeType": "dataProcess"
+ }
+ }
+ },
+ {
+ "id": "end",
+ "type": "endEvent",
+ "name": "第7步-流程结束",
+ "incomingFlows": ["flow9"]
+ },
+ {
+ "id": "flow1",
+ "type": "sequenceFlow",
+ "sourceRef": "start",
+ "targetRef": "task_script"
+ },
+ {
+ "id": "flow2",
+ "type": "sequenceFlow",
+ "sourceRef": "task_script",
+ "targetRef": "task_http"
+ },
+ {
+ "id": "flow3",
+ "type": "sequenceFlow",
+ "sourceRef": "task_http",
+ "targetRef": "task_backup"
+ },
+ {
+ "id": "flow4",
+ "type": "sequenceFlow",
+ "sourceRef": "task_http",
+ "targetRef": "task_log"
+ },
+ {
+ "id": "flow5",
+ "type": "sequenceFlow",
+ "sourceRef": "task_backup",
+ "targetRef": "task_parallel_join"
+ },
+ {
+ "id": "flow6",
+ "type": "sequenceFlow",
+ "sourceRef": "task_log",
+ "targetRef": "task_parallel_join"
+ },
+ {
+ "id": "flow7",
+ "type": "sequenceFlow",
+ "sourceRef": "task_parallel_join",
+ "targetRef": "task_manual_approval"
+ },
+ {
+ "id": "flow8",
+ "type": "sequenceFlow",
+ "sourceRef": "task_manual_approval",
+ "targetRef": "task_data_process"
+ },
+ {
+ "id": "flow9",
+ "type": "sequenceFlow",
+ "sourceRef": "task_data_process",
+ "targetRef": "end"
+ }
+ ]
+}
diff --git a/flowable/src/main/resources/mapper/AsyncTaskRecordMapper.xml b/flowable/src/main/resources/mapper/AsyncTaskRecordMapper.xml
new file mode 100644
index 00000000..765d27b9
--- /dev/null
+++ b/flowable/src/main/resources/mapper/AsyncTaskRecordMapper.xml
@@ -0,0 +1,5 @@
+
+
+
+
+
diff --git a/flowable/src/main/resources/mapper/ProcessNodeParamMapper.xml b/flowable/src/main/resources/mapper/ProcessNodeParamMapper.xml
new file mode 100644
index 00000000..fbc20076
--- /dev/null
+++ b/flowable/src/main/resources/mapper/ProcessNodeParamMapper.xml
@@ -0,0 +1,5 @@
+
+
+
+
+
diff --git a/flowable/src/test/java/com/sdm/flowable/FlowableApplicationTests.java b/flowable/src/test/java/com/sdm/flowable/FlowableApplicationTests.java
new file mode 100644
index 00000000..47bac115
--- /dev/null
+++ b/flowable/src/test/java/com/sdm/flowable/FlowableApplicationTests.java
@@ -0,0 +1,13 @@
+package com.sdm.flowable;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class FlowableApplicationTests {
+
+ @Test
+ void contextLoads() {
+ }
+
+}