Spring AI低代码平台：使用Flowable构建AI工作流

最新推荐文章于 2025-09-29 00:16:44 发布
原创 最新推荐文章于 2025-09-29 00:16:44 发布 · 320 阅读 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

Spring AI低代码平台：使用Flowable构建AI工作流

【免费下载链接】spring-ai An Application Framework for AI Engineering 【免费下载链接】spring-ai 项目地址: https://gitcode.com/GitHub_Trending/spr/spring-ai

引言：AI工作流自动化的痛点与解决方案

你是否还在为AI任务的流程编排而烦恼？当需要将文本分析、向量检索、多模型调用等AI能力串联成业务流程时，传统代码往往需要大量胶水代码来处理任务依赖、错误重试和状态管理。本文将展示如何通过Spring AI的低代码能力与Flowable工作流引擎的结合，以可视化方式构建企业级AI工作流，实现从"概念验证"到"生产部署"的无缝过渡。

读完本文你将掌握：

  • 基于Spring AI的组件化AI能力封装方法
  • Flowable BPMN 2.0流程引擎与Spring AI的集成模式
  • 构建包含RAG（检索增强生成）、多模型协作的工作流示例
  • 工作流中的AI任务监控与异常处理最佳实践

核心概念与技术架构

Spring AI与Flowable的技术互补性

Spring AI提供了标准化的AI能力抽象（如ChatClient、VectorStore、Tool），而Flowable则擅长流程建模、任务调度和状态管理。两者结合形成"AI能力组件化+流程可视化编排"的低代码开发模式：

mermaid

关键技术组件解析

  1. Spring AI核心组件

    • ChatClient：统一的LLM调用接口，支持流式响应和工具调用
    • RetrievalAugmentationAdvisor：实现RAG流程的顾问组件
    • Tool：AI模型可调用的外部工具抽象（如数据库查询、API调用）

  2. Flowable核心组件

    • 流程引擎(ProcessEngine)：负责流程定义解析和执行
    • BPMN 2.0规范：标准化的工作流建模语言
    • 任务处理器(TaskHandler)：自定义任务逻辑实现

  3. 集成关键点

    • AI能力的JavaDelegate封装：将Spring AI组件转换为Flowable服务任务
    • 流程变量与AI上下文的双向映射
    • 异步AI任务的状态回调机制

环境准备与项目搭建

开发环境配置

# 克隆仓库
git clone https://gitcode.com/GitHub_Trending/spr/spring-ai
cd spring-ai

# 添加Flowable依赖（pom.xml）
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-spring-boot-starter</artifactId>
    <version>7.0.1</version>
</dependency>

最小化配置示例

# application.yml
spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-4
          temperature: 0.7
  flowable:
    process:
      enabled: true
      database-schema-update: true
    async-executor:
      enabled: true  # 启用异步执行器处理AI长任务

构建AI工作流的核心步骤

步骤1：定义AI能力Bean

@Configuration
public class AiConfiguration {

    @Bean
    public ChatClient chatClient(ChatClient.Builder builder) {
        return builder
            .defaultAdvisors(new RetrievalAugmentationAdvisor(
                // 配置RAG检索器
                documentRetriever(),
                // 文档处理器链
                List.of(new MetadataFilterProcessor(), new TextSplitterProcessor())
            ))
            .build();
    }

    @Bean
    public VectorStore vectorStore() {
        return new RedisVectorStore(redisTemplate(), EmbeddingModel.builder()
            .model("text-embedding-ada-002")
            .build());
    }
}

步骤2：实现Flowable服务任务Delegate

public class AiChatTaskDelegate implements JavaDelegate {

    private final ChatClient chatClient;

    public AiChatTaskDelegate(ChatClient chatClient) {
        this.chatClient = chatClient;
    }

    @Override
    public void execute(DelegateExecution execution) {
        // 从流程变量获取输入
        String userQuery = (String) execution.getVariable("userQuery");
        List<Document> contextDocs = (List<Document>) execution.getVariable("contextDocuments");

        // 执行AI对话
        String response = chatClient.prompt()
            .user(userQuery)
            .advisors(new RetrievalAugmentationAdvisor(documentRetriever()))
            .call()
            .content();

        // 设置输出变量
        execution.setVariable("aiResponse", response);
        execution.setVariable("processingTime", System.currentTimeMillis() - 
            (Long) execution.getVariable("startTime"));
    }
}

步骤3：设计BPMN工作流

<!-- src/main/resources/processes/ai-workflow.bpmn20.xml -->
<process id="aiWorkflow" name="AI内容生成流程" isExecutable="true">
    <startEvent id="startEvent" />
    
    <sequenceFlow id="flow1" sourceRef="startEvent" targetRef="retrieveDocsTask" />
    
    <!-- 文档检索任务 -->
    <serviceTask id="retrieveDocsTask" 
                 name="检索知识库文档"
                 flowable:delegateExpression="${documentRetrievalDelegate}" />
    
    <sequenceFlow id="flow2" sourceRef="retrieveDocsTask" targetRef="generateContentTask" />
    
    <!-- AI内容生成任务 -->
    <serviceTask id="generateContentTask" 
                 name="AI内容生成"
                 flowable:delegateExpression="${aiChatTaskDelegate}" />
    
    <sequenceFlow id="flow3" sourceRef="generateContentTask" targetRef="reviewTask" />
    
    <!-- 人工审核任务 -->
    <userTask id="reviewTask" 
              name="内容审核"
              flowable:assignee="${reviewer}" />
    
    <sequenceFlow id="flow4" sourceRef="reviewTask" targetRef="endEvent" />
    
    <endEvent id="endEvent" />
</process>

步骤4：流程可视化与执行监控

@RestController
@RequestMapping("/ai-workflow")
public class WorkflowController {

    private final RuntimeService runtimeService;
    private final HistoryService historyService;

    // 启动工作流
    @PostMapping("/start")
    public String startWorkflow(@RequestParam String userQuery) {
        Map<String, Object> variables = new HashMap<>();
        variables.put("userQuery", userQuery);
        variables.put("startTime", System.currentTimeMillis());
        variables.put("reviewer", "content-reviewer@example.com");
        
        ProcessInstance instance = runtimeService.startProcessInstanceByKey(
            "aiWorkflow", variables);
        
        return "Workflow started with ID: " + instance.getId();
    }

    // 查询流程状态
    @GetMapping("/status/{processId}")
    public Map<String, Object> getStatus(@PathVariable String processId) {
        HistoricProcessInstance instance = historyService.createHistoricProcessInstanceQuery()
            .processInstanceId(processId)
            .singleResult();
            
        Map<String, Object> status = new HashMap<>();
        status.put("processId", processId);
        status.put("state", instance.getState());
        status.put("startTime", instance.getStartTime());
        
        // 查询最近完成的任务
        HistoricActivityInstance lastActivity = historyService.createHistoricActivityInstanceQuery()
            .processInstanceId(processId)
            .finished()
            .orderByHistoricActivityInstanceEndTime().desc()
            .listPage(0, 1)
            .get(0);
            
        status.put("lastActivity", lastActivity.getActivityName());
        status.put("lastActivityTime", lastActivity.getEndTime());
        
        return status;
    }
}

高级应用：带异常处理的RAG工作流

流程设计（含错误处理）

mermaid

错误处理实现

public class ErrorHandlingAiDelegate implements JavaDelegate {

    @Override
    public void execute(DelegateExecution execution) {
        try {
            // 执行AI任务
            String result = executeAiTask(execution);
            execution.setVariable("aiResult", result);
        } catch (ApiException e) {
            // API调用失败处理
            handleApiError(execution, e);
        } catch (DocumentRetrievalException e) {
            // 文档检索失败处理
            handleRetrievalError(execution, e);
        } catch (Exception e) {
            // 通用异常处理
            execution.setVariable("error", e.getMessage());
            throw new BpmnError("AI_PROCESSING_FAILED", "AI任务处理失败", e);
        }
    }

    private void handleApiError(DelegateExecution execution, ApiException e) {
        int retryCount = (Integer) execution.getVariableOrDefault("retryCount", 0);
        if (retryCount < 3) {
            execution.setVariable("retryCount", retryCount + 1);
            // 抛出可重试错误
            throw new BpmnError("API_CALL_FAILED", "API调用失败，将重试", e);
        } else {
            execution.setVariable("errorDetails", e.getResponseBody());
            throw new BpmnError("API_CALL_PERMANENT_FAILURE", "API调用永久失败");
        }
    }
}

BPMN错误事件定义

<process id="faultTolerantAiWorkflow" name="容错AI工作流">
    <!-- 主流程省略 -->
    
    <!-- 错误边界事件 -->
    <boundaryEvent id="apiErrorEvent" attachedToRef="generateContentTask">
        <errorEventDefinition errorRef="API_CALL_FAILED" />
    </boundaryEvent>
    
    <!-- 重试子流程 -->
    <subProcess id="retrySubProcess">
        <startEvent id="retryStart" />
        <serviceTask id="waitTask" name="等待5秒" 
                     flowable:delegateExpression="${delayDelegate}" />
        <endEvent id="retryEnd" />
    </subProcess>
    
    <!-- 错误处理流程 -->
    <sequenceFlow id="errorFlow" sourceRef="apiErrorEvent" targetRef="retrySubProcess" />
    <sequenceFlow id="retryFlow" sourceRef="retrySubProcess" targetRef="generateContentTask" />
    
    <!-- 终止错误事件 -->
    <boundaryEvent id="fatalErrorEvent" attachedToRef="generateContentTask">
        <errorEventDefinition errorRef="API_CALL_PERMANENT_FAILURE" />
    </boundaryEvent>
    <sequenceFlow id="fatalErrorFlow" sourceRef="fatalErrorEvent" targetRef="escalateTask" />
</process>

性能优化与最佳实践

1. 异步处理AI长任务

@Configuration
public class FlowableConfig {

    @Bean
    public ExecutorService aiTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        executor.setThreadNamePrefix("ai-task-");
        executor.setTaskDecorator(new ContextPropagatingTaskDecorator()); // 上下文传递
        executor.initialize();
        return executor;
    }

    @Bean
    public AsyncTaskExecutor asyncTaskExecutor() {
        return new ConcurrentTaskExecutor(aiTaskExecutor());
    }
}

2. 流程变量管理

// 使用类型安全的流程变量
public class WorkflowVariables {
    private String userQuery;
    private List<Document> contextDocuments;
    private String aiResponse;
    private LocalDateTime startTime;
    private Long processingTime;
    
    // 省略getter/setter
}

// 在Delegate中使用
WorkflowVariables variables = new WorkflowVariables();
variables.setUserQuery((String) execution.getVariable("userQuery"));
// ...处理变量

3. 监控与可观测性

@Component
public class AiWorkflowListener implements ExecutionListener {

    private final MeterRegistry meterRegistry;

    @Override
    public void notify(DelegateExecution execution) {
        String eventName = execution.getEventName();
        String activityId = (String) execution.getVariable("activityId");
        
        // 记录流程指标
        meterRegistry.counter("ai.workflow.events", 
            "event", eventName, 
            "processDefinition", execution.getProcessDefinitionId())
            .increment();
            
        // 记录AI任务执行时间
        if ("end".equals(eventName) && activityId.contains("generate")) {
            Long duration = (Long) execution.getVariable("processingTime");
            meterRegistry.timer("ai.task.duration", 
                "task", activityId)
                .record(duration, TimeUnit.MILLISECONDS);
        }
    }
}

总结与未来展望

本文展示了如何通过Spring AI与Flowable的集成，构建可视化、可编排的AI工作流系统。关键收获包括：

  1. 技术融合：Spring AI的AI能力抽象与Flowable的流程引擎形成互补，降低了复杂AI工作流的开发门槛
  2. 架构设计：通过JavaDelegate封装AI能力，实现低代码集成；利用BPMN 2.0标准化工作流定义
  3. 鲁棒性保障：实现错误处理、重试机制和异步执行，确保AI任务在生产环境的稳定性
  4. 可观测性：集成监控指标，实现AI工作流全链路追踪

未来发展方向：

  • AI任务自动编排：利用LLM自动生成工作流定义
  • 多模型协同优化：根据任务特性自动选择最优AI模型
  • 工作流智能调优：基于历史执行数据优化流程路径和参数

通过这种低代码方式，企业可以快速构建和迭代AI应用，将AI能力无缝融入现有业务流程，加速数字化转型。

附录：关键依赖版本

组件版本
Spring Boot3.2.0
Spring AI1.1.0-SNAPSHOT
Flowable7.0.1
Java17+
Maven3.8.6+

【免费下载链接】spring-ai An Application Framework for AI Engineering 【免费下载链接】spring-ai 项目地址: https://gitcode.com/GitHub_Trending/spr/spring-ai

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值