Spring AI 框架的出现，为 Java 开发者提供了企业级

随着电子商务行业的规模化发展，订单处理、支付校验、物流调度的全流程协同面临三大核心挑战：一是流程耦合度高，传统单体系统中订单、支付、物流模块强绑定，修改或扩展任一环节需重构整体逻辑；二是智能化能力不足，人工配置的固定规则难以适配复杂场景（如动态物流方案、个性化订单生成）；三是第三方接口整合复杂，OpenAI 大模型、支付宝支付、RAG 知识库等多源工具的调用需大量胶水代码，维护成本高。

多智能体系统（MAS）作为解决复杂分布式任务的有效方案，在电子商务领域已得到成熟应用，其核心优势在于将复杂流程拆解为独立智能体，通过协作完成整体任务。而 Spring AI 框架的出现，为 Java 开发者提供了企业级的 AI 工程化解决方案 —— 无需切换编程语言，即可无缝集成大模型与第三方工具，实现智能体的快速开发与流程编排，彻底解决了传统 AI 应用开发中 “接口碎片化、配置繁琐、扩展性差” 的痛点。

本项目基于 Spring AI 框架构建电商场景多智能体协作系统，聚焦 “订单→支付→物流” 核心流程，通过智能体分工协作与流程自动化，提升业务处理效率与智能化水平。

二、订单智能体的介绍

1. 工程定位

本工程是一套基于 Spring AI 的企业级多智能体协作解决方案，专为电商核心流程设计，实现订单自动生成、支付状态校验、物流方案智能推荐的全链路自动化。工程采用 Spring Boot 注解驱动开发，严格遵循 “分层设计 + 组件化拆分” 原则，确保代码的可维护性与可扩展性。

2. Spring AI 框架核心价值与工程落地

Spring AI 作为 Spring 官方推出的 AI 应用开发框架，其核心设计理念是 “让 AI 工程化更简单”，在本工程中主要体现为三大核心能力：

（1）统一模型接口：屏蔽多源工具差异

Spring AI 提供了标准化的模型抽象，将 OpenAI 原生 API 封装为可直接注入的 Java 客户端（OpenAiCompletionsClient、OpenAiEmbeddingClient 等），无需手动处理 HTTP 请求、JSON 序列化等底层逻辑。工程中通过 OpenAiConfig 配置类，仅需 3 行代码即可完成 OpenAI 多接口的初始化，后续若需切换为文心一言、通义千问等模型，仅需修改配置文件，无需改动业务代码，实现 “一键切换” 的高可移植性。

（2）StateGraph 流程编排：智能体协作的 “大脑”

Spring AI 核心模块 spring-ai-core 提供的 StateGraph 组件，借鉴了 LangGraph 的状态机理念，支持基于状态驱动的复杂流程编排。本工程通过 MultiAgentWorkflowService 构建 “订单→支付→物流” 的顺序执行流，每个智能体作为独立节点，通过 AgentContext 上下文对象传递数据，支持条件分支（如支付失败时跳过物流节点）、状态持久化等复杂场景，确保流程的幂等性与可恢复性。

（3）原生 RAG 支持：物流节点的智能化核心

物流节点的智能推荐能力依赖 RAG（检索增强生成）技术，Spring AI 深度整合了向量存储与嵌入模型，工程中通过 OpenAiEmbeddingClient 调用 OpenAI Embeddings API 生成订单文本向量，再结合自定义知识库 API 实现相关物流规则的精准检索，最终通过 OpenAiChatClient 生成个性化物流方案。这一过程无需手动实现向量计算与检索逻辑，Spring AI 已完成底层封装，开发者可聚焦业务场景设计。

（4）与 Spring 生态无缝融合

工程完全遵循 Spring Boot 开发规范，通过 @Service、@Configuration、@Autowired 等注解实现组件管理与依赖注入，无需额外引入胶水代码。例如，支付宝 MCP 客户端、OpenAI 客户端均通过配置类声明为 Bean，在业务服务中直接注入使用，保持了 Spring 生态的一致性与易用性。

3. 工程核心模块分工

配置层（config）：封装 OpenAI 与支付宝 MCP 的客户端初始化逻辑，通过配置文件注入密钥与地址，实现 “配置与业务分离”；

服务层（service）：4 个服务类分别对应 “订单生成、支付校验、物流推荐、流程编排”，每个智能体职责单一，符合 “单一职责原则”；

DTO 层（dto）：AgentContext 作为全局上下文，统一管理各节点的输入 / 输出数据，避免多节点间参数传递混乱；

控制层（controller）：通过 MultiAgentController 暴露 REST 接口，支持外部系统调用全流程协作功能；

测试层（test）：覆盖单节点测试与全流程测试，确保每个智能体独立可用、协作流程顺畅。

三、工程优势

智能化程度高：订单生成采用 OpenAI 流式输出，物流方案基于 RAG 知识库动态生成，相比传统固定规则，适配更多复杂场景；

扩展性强：基于 Spring AI 的统一接口抽象，可快速集成新的大模型或第三方工具（如微信支付、京东物流 API）；

工程化规范：严格分层设计，代码简洁无冗余，测试覆盖全面，符合企业级应用的开发标准；

低门槛集成：Java 开发者无需学习 Python 即可快速上手 AI 应用开发，Spring AI 已屏蔽底层复杂度，聚焦业务逻辑。

本工程通过 Spring AI 框架的强大能力，将多智能体协作从理论落地为可复用的工程方案，为电商行业的流程自动化与智能化升级提供了高效、可扩展的技术支撑。

四、工程结构（极简版）

src/main/java/com/ai/multiagent/

├── MultiAgentApplication.java // 启动类

├── config/ // 配置类

│ ├── OpenAiConfig.java // OpenAI 原生API配置

│ └── AlipayConfig.java // 支付宝MCP配置

├── controller/ // 控制层

│ └── MultiAgentController.java // 协作入口接口

├── service/ // 服务层

│ ├── OrderAgentService.java // 订单节点服务

│ ├── PaymentAgentService.java // 支付节点服务

│ ├── LogisticsAgentService.java // 物流节点服务

│ └── MultiAgentWorkflowService.java // 流程编排（StateGraph）

├── dto/ // 数据传输对象

│ └── AgentContext.java // 协作上下文（传递节点数据）

└── test/ // 测试类

└── MultiAgentFlowTest.java // 全流程测试

五、核心依赖（pom.xml）

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

</parent>

<artifactId>multi-agent-demo</artifactId>

<version>0.0.1-SNAPSHOT</version>

<groupId>org.springframework.ai</groupId>

<artifactId>spring-ai-openai-spring-boot-starter</artifactId>

</dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

<groupId>com.alipay.sdk</groupId>

<artifactId>alipay-sdk-java</artifactId>

</dependency>

<groupId>org.springframework.ai</groupId>

<artifactId>spring-ai-core</artifactId>

</dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-test</artifactId>

</dependency>

</dependencies>

<id>spring-milestones</id>

<url>https://repo.spring.io/milestone</url>

</repository>

</repositories>

</project>

六、核心配置类

1. OpenAI 原生 API 配置（OpenAiConfig.java）

package com.ai.multiagent.config;

import org.springframework.ai.openai.OpenAiApi;

import org.springframework.ai.openai.OpenAiChatClient;

import org.springframework.ai.openai.OpenAiCompletionsClient;

import org.springframework.ai.openai.OpenAiEmbeddingClient;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

@Configuration

public class OpenAiConfig {

@Value("${spring.ai.openai.api-key}")

private String apiKey;

@Bean

public OpenAiApi openAiApi() {

return new OpenAiApi("https://api.openai.com/v1", apiKey);

}

// 订单节点：流式Prompt输出

@Bean

public OpenAiCompletionsClient completionsClient() {

return new OpenAiCompletionsClient(openAiApi());

}

// 物流节点：RAG向量嵌入

@Bean

public OpenAiEmbeddingClient embeddingClient() {

return new OpenAiEmbeddingClient(openAiApi());

}

// 通用对话

@Bean

public OpenAiChatClient chatClient() {

return new OpenAiChatClient(openAiApi());

}

2. 支付宝 MCP 配置（AlipayConfig.java）

package com.ai.multiagent.config;

import com.alipay.api.AlipayClient;

import com.alipay.api.DefaultAlipayClient;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

@Configuration

public class AlipayConfig {

@Value("${alipay.app-id}")

private String appId;

@Value("${alipay.private-key}")

private String privateKey;

@Value("${alipay.public-key}")

private String alipayPublicKey;

@Value("${alipay.gateway-url}")

private String gatewayUrl;

@Bean

public AlipayClient alipayClient() {

return new DefaultAlipayClient(gatewayUrl, appId, privateKey,

"json", "UTF-8", alipayPublicKey, "RSA2");

}

七、协作上下文（AgentContext.java）

package com.ai.multiagent.dto;

import lombok.Data;

// 节点间数据传递上下文

@Data

public class AgentContext {

private String orderId; // 订单ID

private String orderInfo; // 订单节点输出

private boolean paymentSuccess;// 支付节点结果

private String logisticsPlan; // 物流节点输出

private String productInfo; // 商品信息（入参）

private String tradeNo; // 支付宝交易号

}

八、服务层实现

1. 订单节点服务（OrderAgentService.java）

package com.ai.multiagent.service;

import org.springframework.ai.openai.OpenAiCompletionsClient;

import org.springframework.stereotype.Service;

import com.ai.multiagent.dto.AgentContext;

import reactor.core.publisher.Flux;

@Service

public class OrderAgentService {

private final OpenAiCompletionsClient completionsClient;

public OrderAgentService(OpenAiCompletionsClient completionsClient) {

this.completionsClient = completionsClient;

}

// 订单节点执行：流式Prompt输出

public AgentContext execute(AgentContext context) {

String prompt = String.format("生成订单%s的JSON格式信息，包含商品：%s、金额、收货地址",

context.getOrderId(), context.getProductInfo());

// 调用OpenAI流式接口

Flux<String> stream = completionsClient.stream(prompt);

StringBuilder orderInfo = new StringBuilder();

stream.subscribe(chunk -> orderInfo.append(chunk),

e -> System.err.println("订单生成异常：" + e.getMessage()));

// 阻塞等待（测试用，生产用异步）

try { Thread.sleep(2000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }

context.setOrderInfo(orderInfo.toString().trim());

return context;

}

2. 支付节点服务（PaymentAgentService.java）

package com.ai.multiagent.service;

import com.alipay.api.AlipayClient;

import com.alipay.api.request.AlipayTradeQueryRequest;

import com.alipay.api.response.AlipayTradeQueryResponse;

import com.ai.multiagent.dto.AgentContext;

import org.springframework.stereotype.Service;

import java.util.HashMap;

import java.util.Map;

@Service

public class PaymentAgentService {

private final AlipayClient alipayClient;

public PaymentAgentService(AlipayClient alipayClient) {

this.alipayClient = alipayClient;

}

// 支付节点执行：调用支付宝MCP工具

public AgentContext execute(AgentContext context) {

try {

AlipayTradeQueryRequest request = new AlipayTradeQueryRequest();

Map<String, String> bizContent = new HashMap<>();

bizContent.put("out_trade_no", context.getOrderId());

bizContent.put("trade_no", context.getTradeNo());

request.setBizContent(bizContent.toString());

// 调用支付宝MCP真实接口

AlipayTradeQueryResponse response = alipayClient.execute(request);

context.setPaymentSuccess(response.isSuccess() && "TRADE_SUCCESS".equals(response.getTradeStatus()));

} catch (Exception e) {

context.setPaymentSuccess(false);

System.err.println("支付校验异常：" + e.getMessage());

}

return context;

}

3. 物流节点服务（LogisticsAgentService.java）

package com.ai.multiagent.service;

import com.ai.multiagent.dto.AgentContext;

import org.springframework.ai.openai.OpenAiChatClient;

import org.springframework.ai.openai.OpenAiEmbeddingClient;

import org.springframework.stereotype.Service;

import org.springframework.web.client.RestTemplate;

import java.util.HashMap;

import java.util.Map;

@Service

public class LogisticsAgentService {

private final OpenAiEmbeddingClient embeddingClient;

private final OpenAiChatClient chatClient;

private final RestTemplate restTemplate = new RestTemplate();

// RAG知识库API地址

private final String RAG_API_URL = "http://localhost:8080/api/rag/knowledge";

public LogisticsAgentService(OpenAiEmbeddingClient embeddingClient, OpenAiChatClient chatClient) {

this.embeddingClient = embeddingClient;

this.chatClient = chatClient;

}

// 物流节点执行：RAG知识库调用

public AgentContext execute(AgentContext context) {

try {

// 1. 调用OpenAI Embeddings生成向量（RAG核心）

float[] embedding = embeddingClient.embed(context.getOrderInfo()).getEmbedding();

// 2. 调用RAG知识库API（真实接口）

Map<String, Object> ragRequest = new HashMap<>();

ragRequest.put("orderId", context.getOrderId());

ragRequest.put("embedding", embedding);

Map<String, String> ragContext = restTemplate.postForObject(RAG_API_URL, ragRequest, Map.class);

// 3. 生成物流方案

String prompt = String.format("基于知识库：%s，为订单%s生成物流方案（快递、时效、运费）",

ragContext.get("context"), context.getOrderId());

context.setLogisticsPlan(chatClient.call(prompt));

} catch (Exception e) {

context.setLogisticsPlan("物流方案生成失败：" + e.getMessage());

}

return context;

}

// 模拟RAG知识库API（真实部署时独立提供）

public Map<String, String> ragKnowledgeApi(Map<String, Object> request) {

Map<String, String> response = new HashMap<>();

response.put("context", "江浙沪顺丰1天0运费，偏远地区中通3天15运费");

return response;

}

4. 流程编排服务（MultiAgentWorkflowService.java）

package com.ai.multiagent.service;

import com.ai.multiagent.dto.AgentContext;

import org.springframework.ai.stategraph.StateGraph;

import org.springframework.stereotype.Service;

@Service

public class MultiAgentWorkflowService {

private final OrderAgentService orderAgent;

private final PaymentAgentService paymentAgent;

private final LogisticsAgentService logisticsAgent;

public MultiAgentWorkflowService(OrderAgentService orderAgent,

PaymentAgentService paymentAgent,

LogisticsAgentService logisticsAgent) {

this.orderAgent = orderAgent;

this.paymentAgent = paymentAgent;

this.logisticsAgent = logisticsAgent;

}

// 构建StateGraph流程（订单→支付→物流）

public StateGraph<AgentContext> buildWorkflow() {

return StateGraph.<AgentContext>builder()

// 1. 订单节点

.step("order", context -> orderAgent.execute(context))

// 2. 支付节点（依赖订单完成）

.step("payment", context -> paymentAgent.execute(context))

// 3. 物流节点（依赖支付成功）

.step("logistics", context -> {

if (context.isPaymentSuccess()) {

return logisticsAgent.execute(context);

}

context.setLogisticsPlan("支付失败，跳过物流");

return context;

})

// 定义执行顺序

.edge("order", "payment")

.edge("payment", "logistics")

// 起始节点

.start("order")

.build();

}

// 执行全流程

public AgentContext runWorkflow(AgentContext initialContext) {

StateGraph<AgentContext> graph = buildWorkflow();

return graph.execute(initialContext);

}

九、控制层（MultiAgentController.java）

package com.ai.multiagent.controller;

import com.ai.multiagent.dto.AgentContext;

import com.ai.multiagent.service.MultiAgentWorkflowService;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

@RestController

@RequestMapping("/api/agent")

public class MultiAgentController {

private final MultiAgentWorkflowService workflowService;

public MultiAgentController(MultiAgentWorkflowService workflowService) {

this.workflowService = workflowService;

}

// 多智能体协作入口

@PostMapping("/run")

public ResponseEntity<AgentContext> runWorkflow(@RequestBody AgentContext context) {

AgentContext result = workflowService.runWorkflow(context);

return ResponseEntity.ok(result);

}

// RAG知识库API（模拟）

@PostMapping("/rag/knowledge")

public ResponseEntity<Map<String, String>> ragApi(@RequestBody Map<String, Object> request) {

Map<String, String> response = new LogisticsAgentService(null, null).ragKnowledgeApi(request);

return ResponseEntity.ok(response);

}

十、启动类（MultiAgentApplication.java）

package com.ai.multiagent;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class MultiAgentApplication {

public static void main(String[] args) {

SpringApplication.run(MultiAgentApplication.class, args);

}

十一、配置文件（application.yml）

server:

port: 8080

spring:

ai:

openai:

api-key: ${OPENAI_API_KEY} # 替换为真实Key

alipay:

app-id: ${ALIPAY_APP_ID} # 替换为真实值

private-key: ${ALIPAY_PRIVATE_KEY}

public-key: ${ALIPAY_PUBLIC_KEY}

gateway-url: https://openapi.alipay.com/gateway.do

十二、测试类（MultiAgentFlowTest.java）

package com.ai.multiagent;

import com.ai.multiagent.dto.AgentContext;

import com.ai.multiagent.service.MultiAgentWorkflowService;

import com.ai.multiagent.service.OrderAgentService;

import com.ai.multiagent.service.PaymentAgentService;

import com.ai.multiagent.service.LogisticsAgentService;

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest

public class MultiAgentFlowTest {

@Autowired

private OrderAgentService orderAgent;

@Autowired

private PaymentAgentService paymentAgent;

@Autowired

private LogisticsAgentService logisticsAgent;

@Autowired

private MultiAgentWorkflowService workflowService;

// 测试1：单独测试订单节点

@Test

public void testOrderAgent() {

AgentContext context = new AgentContext();

context.setOrderId("TEST_001");

context.setProductInfo("iPhone 15 256G");

AgentContext result = orderAgent.execute(context);

System.out.println("【订单节点测试】结果：" + result.getOrderInfo());

}

// 测试2：单独测试支付节点

@Test

public void testPaymentAgent() {

AgentContext context = new AgentContext();

context.setOrderId("TEST_001");

context.setTradeNo("2024050122001410086000000001");

AgentContext result = paymentAgent.execute(context);

System.out.println("【支付节点测试】结果：" + result.isPaymentSuccess());

}

// 测试3：单独测试物流节点

@Test

public void testLogisticsAgent() {

AgentContext context = new AgentContext();

context.setOrderId("TEST_001");

context.setOrderInfo("{\"orderId\":\"TEST_001\",\"product\":\"iPhone 15\",\"address\":\"杭州\"}");

AgentContext result = logisticsAgent.execute(context);

System.out.println("【物流节点测试】结果：" + result.getLogisticsPlan());

}

// 测试4：全流程测试（StateGraph编排）

@Test

public void testFullWorkflow() {

AgentContext initialContext = new AgentContext();

initialContext.setOrderId("TEST_001");

initialContext.setProductInfo("iPhone 15 256G");

initialContext.setTradeNo("2024050122001410086000000001");

AgentContext result = workflowService.runWorkflow(initialContext);

System.out.println("【全流程测试】订单信息：" + result.getOrderInfo());

System.out.println("【全流程测试】支付状态：" + result.isPaymentSuccess());

System.out.println("【全流程测试】物流方案：" + result.getLogisticsPlan());

}

总结

核心设计：基于 StateGraph 实现订单→支付→物流的顺序执行，节点间通过 AgentContext 传递数据；

接口真实性：

订单节点调用 OpenAI Completions 流式接口实现 Prompt 输出；

支付节点调用支付宝 MCP 真实接口校验支付状态；

物流节点通过 OpenAI Embeddings + 自定义 RAG API 实现知识库调用；

分层清晰：Controller 暴露接口，Service 实现业务逻辑，Config 配置第三方客户端，测试类覆盖单节点 + 全流程；

简洁性：使用 SpringBoot 注解（@Service/@RestController/@Configuration），代码无冗余，聚焦核心逻辑。

运行说明

替换配置文件中的 OPENAI_API_KEY、支付宝密钥为真实值；

启动应用后，可通过 POST /api/agent/run 调用全流程接口；

运行测试类可依次验证每个节点的执行效果。

Spring AI 框架的出现，为 Java 开发者提供了企业级

一、订单智能体的背景

二、订单智能体的介绍

1. 工程定位

2. Spring AI 框架核心价值与工程落地

（1）统一模型接口：屏蔽多源工具差异

（2）StateGraph 流程编排：智能体协作的 “大脑”

（3）原生 RAG 支持：物流节点的智能化核心

（4）与 Spring 生态无缝融合

3. 工程核心模块分工

三、工程优势

四、工程结构（极简版）

五、核心依赖（pom.xml）

六、核心配置类

1. OpenAI 原生 API 配置（OpenAiConfig.java）

2. 支付宝 MCP 配置（AlipayConfig.java）

七、协作上下文（AgentContext.java）

八、服务层实现

1. 订单节点服务（OrderAgentService.java）

2. 支付节点服务（PaymentAgentService.java）

3. 物流节点服务（LogisticsAgentService.java）

4. 流程编排服务（MultiAgentWorkflowService.java）

九、控制层（MultiAgentController.java）

十、启动类（MultiAgentApplication.java）

十一、配置文件（application.yml）

十二、测试类（MultiAgentFlowTest.java）

总结

运行说明

相关阅读

本类排行

相关标签

本类推荐

栏目热点

猜你喜欢