【微服务】Spring AI 使用详解：让微服务无缝集成 AI 能力

在微服务架构主导企业级开发的今天，AI 技术的落地已从“可选”变为“刚需”。无论是智能客服、内容生成，还是数据分析、风险管控，开发者都希望能在熟悉的微服务体系中快速集成 AI 能力，无需跨越技术栈鸿沟。Spring AI 的出现，恰好解决了这一痛点——作为 Spring 生态官方推出的 AI 工程化框架，它延续了 Spring“约定优于配置”的核心思想，让 Java 微服务开发者能像使用 Spring Boot、Spring Cloud 一样，轻松对接各类 AI 模型，实现 AI 能力与微服务的无缝融合。

本文将从微服务视角出发，全面解析 Spring AI 的核心价值、基础搭建、核心功能实操、微服务适配技巧及实战案例，助力开发者快速上手，将 AI 能力高效嵌入微服务体系，打造智能化微服务应用。

一、Spring AI 核心定位与微服务适配优势

在深入实操前，我们先明确一个核心问题：为什么微服务架构下，Spring AI 是最优选择？相较于 Python 生态的 LangChain、Dify 等框架，Spring AI 的核心优势完全贴合微服务的开发痛点与企业级需求。

1.1 核心定位

Spring AI 并非一个 AI 模型，而是一个“AI 集成框架”——它将 Spring 生态的设计原则（可移植性、模块化、依赖注入）延伸至 AI 领域，通过统一的抽象层封装不同 AI 厂商的 API，解决了 AI 集成中的技术碎片化、工程化断层、运维复杂等核心痛点，让开发者无需关注底层模型的调用细节，专注于业务逻辑开发即可实现 AI 能力落地。

其核心目标是：让 Java 微服务开发者“零门槛”使用 AI，让 AI 能力像 Spring Bean 一样可注入、可配置、可扩展，完美融入微服务的服务治理体系。

1.2 微服务适配核心优势

• 生态无缝衔接：与 Spring Boot、Spring Cloud 深度集成，支持自动配置、依赖注入、服务注册发现、熔断降级等微服务核心特性，无需额外引入陌生技术栈，降低开发与运维成本。对于已有 Spring 微服务体系的企业，可实现“零侵入”集成 AI 能力。
• 统一 API 抽象：封装了 OpenAI、Anthropic、阿里云通义千问等主流 AI 厂商的接口，提供统一的 ChatClient、ImageClient 等 API，实现“一次开发，多模型适配”，避免因切换 AI 厂商导致的代码重构，适配微服务“多服务、多场景”的灵活需求。
• 企业级特性完备：内置全链路监控、安全审计、成本控制、异常处理等生产级能力，支持微服务架构下的高并发、高可用需求，解决 AI 原型难以落地生产的行业痛点。
• 轻量级与可扩展性：采用模块化设计，可根据微服务的实际需求（如仅需文本生成、或需多模态能力）引入对应依赖，避免冗余；同时支持自定义组件扩展，适配微服务“按需拆分、灵活扩展”的架构理念。

简单来说，Spring AI 就是微服务架构的“AI 插件”，无需重构现有微服务体系，即可快速为各个微服务模块赋能 AI 能力。

二、前置准备：微服务环境下 Spring AI 基础搭建

本次实操基于 Spring Boot 3.2.x（微服务主流版本）、Spring AI 1.0.3（稳定版），以对接 OpenAI 为例（其他 AI 厂商适配逻辑一致），完成基础环境搭建。

2.1 环境要求

• JDK 17+（Spring AI 1.0+ 最低要求，贴合微服务主流 JDK 版本）
• Spring Boot 3.2.x
• Maven 3.8+
• AI 厂商 API Key（如 OpenAI API Key，需提前注册获取）

2.2 依赖引入（Maven）

在微服务模块（如智能对话服务、内容生成服务）的 pom.xml 中引入 Spring AI 核心依赖与 OpenAI 适配器依赖，无需额外引入其他 AI 相关依赖，Spring AI 会自动完成自动配置。

<!-- Spring AI 核心依赖 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-core</artifactId>
    <version>1.0.3</version>
</dependency>
<!-- OpenAI 适配器依赖（对接OpenAI模型） -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai</artifactId>
    <version>1.0.3</version>
</dependency>
<!-- 可选：Spring Web 依赖（微服务接口暴露） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

2.3 核心配置（application.yml）

在配置文件中配置 AI 厂商的 API Key、模型参数等信息，Spring AI 会通过自动配置机制，自动创建 ChatClient 等核心 Bean，无需手动实例化。配置支持多环境隔离，适配微服务 dev/test/prod 环境切换需求。

spring:
  ai:
    openai:
      # AI厂商API Key（建议通过环境变量注入，避免硬编码，符合微服务安全规范）
      api-key: ${OPENAI_API_KEY:你的API Key}
      # 聊天模型配置（可根据需求切换gpt-3.5-turbo、gpt-4等）
      chat:
        model: gpt-3.5-turbo
        # 模型超参数配置（温度值，0-1，值越高生成越灵活）
        temperature: 0.7
        # 最大生成token数
        max-tokens: 1024
      # 可选：嵌入模型配置（用于RAG、文本相似度计算等场景）
      embedding:
        model: text-embedding-ada-002

2.4 基础测试：验证 AI 调用

搭建完成后，编写一个简单的测试接口，验证 Spring AI 是否能正常调用 OpenAI 模型，快速确认环境搭建成功。

import org.springframework.ai.chat.ChatClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import jakarta.annotation.Resource;
@RestController
public class AIChatController {
    // 自动注入Spring AI 自动配置的ChatClient（无需手动创建）
    @Resource
    private ChatClient chatClient;
    /**
     * 简单AI对话接口（微服务对外暴露的AI能力接口）
     * @param message 用户提问
     * @return AI回复
     */
    @GetMapping("/ai/chat")
    public String chat(@RequestParam String message) {
        // 调用AI模型，获取回复（一行代码完成调用）
        return chatClient.prompt(message).call().content();
    }
}

启动微服务，访问接口 http://localhost:8080/ai/chat?message=介绍Spring AI，若能正常返回 AI 生成的回复，说明基础环境搭建成功。

三、核心功能详解：微服务场景下的 Spring AI 实操

Spring AI 的核心功能围绕“AI 模型调用、结构化输出、工具调用、RAG、多模态”展开，这些功能均能完美适配微服务的各类场景（如智能客服、内容生成、数据分析等）。以下重点讲解微服务中最常用的核心功能，结合代码实操说明。

3.1 核心功能 1：聊天对话（最常用场景）

聊天对话是微服务中最常见的 AI 场景（如智能客服、智能助手），Spring AI 通过 ChatClient 提供了简洁的 API，支持单轮对话、多轮对话、流式响应等核心能力，适配微服务高并发、低延迟的需求。

3.1.1 单轮对话（基础用法）

即单次提问-回复，适用于简单的 AI 咨询场景（如产品咨询、简单问答），代码如 2.4 节所示，核心是通过 ChatClient 的 prompt()方法传入用户消息，call()方法获取同步回复。

3.1.2 多轮对话（会话上下文管理）

微服务中的智能客服等场景，需要保持会话上下文（如用户连续提问，AI 能记住上一轮对话内容）。Spring AI 通过 Conversation 对象管理会话历史，无需手动维护上下文，简化开发。

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.Conversation;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import jakarta.annotation.Resource;
import java.util.Map;
@RestController
public class MultiRoundChatController {
    @Resource
    private ChatClient chatClient;
    // 会话上下文管理（微服务中可结合Redis存储，支持分布式会话）
    private final Conversation conversation = new Conversation();
    /**
     * 多轮对话接口
     * @param request 包含会话ID、用户消息
     * @return AI回复
     */
    @PostMapping("/ai/chat/multi-round")
    public String multiRoundChat(@RequestBody Map<String, String> request) {
        String message = request.get("message");
        // 将用户消息加入会话上下文
        conversation.add(new UserMessage(message));
        // 调用AI模型，传入整个会话上下文
        var response = chatClient.call(conversation);
        // 将AI回复加入会话上下文，用于下一轮对话
        conversation.add(response.getResult().getOutput());
        return response.getResult().getOutput().getContent();
    }
}

注意：微服务是分布式架构，若需要多实例共享会话上下文，需将 Conversation 对象存储在 Redis 等分布式存储中，避免会话丢失。

3.1.3 流式响应（优化用户体验）

微服务中，当 AI 回复内容较长时，同步等待会导致接口响应延迟，影响用户体验。Spring AI 支持流式响应（SSE 协议），实现“边生成、边返回”，适配微服务高可用、优体验的需求。

import org.springframework.ai.chat.StreamingChatClient;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import jakarta.annotation.Resource;
import java.io.IOException;
@RestController
public class StreamingChatController {
    // 注入流式聊天客户端
    @Resource
    private StreamingChatClient streamingChatClient;
    /**
     * 流式对话接口（SSE协议）
     * @param message 用户提问
     * @return SSE流式响应
     */
    @GetMapping("/ai/chat/stream")
    public SseEmitter streamChat(@RequestParam String message) {
        SseEmitter emitter = new SseEmitter(-1L); // 无超时限制
        // 流式调用AI模型，逐段返回结果
        streamingChatClient.stream(new UserMessage(message))
                .doOnNext(chunk -> {
                    try {
                        // 逐段发送AI回复（SSE事件）
                        emitter.send(chunk.getContent());
                    } catch (IOException e) {
                        emitter.completeWithError(e);
                    }
                })
                .doOnComplete(emitter::complete) // 生成完成，关闭连接
                .doOnError(emitter::completeWithError) // 异常处理
                .subscribe();
        return emitter;
    }
}

3.2 核心功能 2：结构化输出（微服务数据交互）

微服务中，AI 生成的结果往往需要与其他服务进行数据交互（如返回 JSON 格式、映射到 Java 实体类），Spring AI 支持结构化输出，可直接将 AI 回复映射为 POJO，无需手动解析字符串，避免解析异常，提升开发效率。

示例：让 AI 生成用户信息，并直接映射为 User 实体类。

3.2.1 定义实体类

// 微服务中常用的实体类，与其他服务交互
public class User {
    private String name;
    private Integer age;
    private String email;
    private String address;
    // getter/setter/toString 省略
}

3.2.2 结构化输出调用

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.ai.openai.OpenAiChatClient;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class SpringAiDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringAiDemoApplication.class, args);
    }
    // 结构化输出测试
    @Bean
    CommandLineRunner structuredOutputTest(ChatClient chatClient) {
        return args -> {
            // 1. 定义Prompt模板，指定输出格式为User实体类
            String promptTemplate = "生成一个用户信息，要求：name为3-5个中文字符，age为18-30，email符合规范，address为国内城市。" +
                    "输出格式必须是JSON，可直接映射到Java的User类，不要多余内容：{user}";
            PromptTemplate prompt = new PromptTemplate(promptTemplate);
            // 2. 调用AI模型，指定输出类型为User.class
            User user = chatClient.prompt(prompt.create())
                    .call()
                    .getResult()
                    .getOutput()
                    .mapTo(User.class); // 直接映射为User实体类
            // 3. 输出结果（可直接用于微服务间数据交互）
            System.out.println("结构化输出的用户信息：" + user);
        };
    }
}

核心优势：无需手动解析 JSON 字符串，Spring AI 自动完成映射，避免因 AI 回复格式不规范导致的解析异常，适配微服务“数据标准化”的需求。

3.3 核心功能 3：工具调用（微服务能力扩展）

微服务中，AI 往往需要调用微服务的其他能力（如查询数据库、调用第三方 API、执行本地方法），Spring AI 通过 @AiFunction 注解实现工具调用，让 AI 能根据用户需求，自动触发微服务的业务方法，实现“AI 决策 + 业务执行”的闭环。

示例：AI 根据用户需求，自动调用“查询天气”的工具方法，返回实时天气信息。

3.3.1 定义工具方法

import org.springframework.ai.core.AiFunction;
import org.springframework.stereotype.Component;
// 微服务中的工具类，提供天气查询能力（可对接真实天气API）
@Component
public class WeatherTool {
    /**
     * 天气查询工具方法，用@AiFunction注解标记，让Spring AI识别为可调用工具
     * @param city 城市名称
     * @return 天气信息
     */
    @AiFunction(description = "查询指定城市的实时天气，参数为城市中文名称（如北京、上海）")
    public String getWeather(String city) {
        // 模拟调用天气API，返回天气信息（实际开发中可对接第三方天气服务）
        return city + "当前天气：晴，气温25℃，微风，适宜出行";
    }
}

3.3.2 AI 调用工具

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.tools.Tool;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import jakarta.annotation.Resource;
import java.util.List;
@Configuration
public class AiToolConfig {
    @Resource
    private ChatClient chatClient;
    @Resource
    private WeatherTool weatherTool;
    // AI调用工具测试
    @Bean
    CommandLineRunner toolCallTest() {
        return args -> {
            // 1. 将工具类包装为Tool对象，交给Spring AI
            List<Tool> tools = List.of(Tool.from(weatherTool));
            // 2. 用户提问：查询北京天气
            UserMessage userMessage = new UserMessage("查询一下北京的天气");
            // 3. 调用AI模型，传入工具列表，AI会自动判断是否需要调用工具
            var response = chatClient.call(userMessage, tools);
            // 4. 输出结果（AI会调用getWeather方法，返回天气信息）
            System.out.println("AI回复：" + response.getResult().getOutput().getContent());
        };
    }
}

应用场景：智能客服中，用户询问“我的订单状态”，AI 可自动调用订单服务的查询方法；数据分析场景中，AI 可自动调用数据服务的统计方法，实现 AI 与微服务业务能力的深度融合。

3.4 核心功能 4：RAG（检索增强生成，企业级核心场景）

在企业级微服务中，AI 往往需要基于企业内部知识库（如产品文档、用户手册、行业规范）进行回复，避免“一本正经地胡说八道”。Spring AI 支持 RAG（Retrieval-Augmented Generation），通过向量数据库将知识库向量化，AI 先检索相关知识，再生成回复，确保回复的准确性和专业性。

核心流程：知识库导入 → 文本向量化 → 向量存储 → 用户提问 → 检索相关知识 → AI 结合知识生成回复。

3.4.1 依赖引入（向量数据库以 Redis 为例）

<!-- Redis 向量存储依赖（Spring AI 支持多种向量数据库） -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-redis</artifactId>
    <version>1.0.3</version>
</dependency>
<!-- Redis 客户端依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

3.4.2 配置向量数据库与 RAG

spring:
  # Redis 配置（向量存储）
  redis:
    host: localhost
    port: 6379
    password: 123456
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      embedding:
        model: text-embedding-ada-002 # 用于文本向量化的模型
    # RAG 配置
    vectorstore:
      redis:
        index-name: knowledge_base # 向量索引名称
        dimension: 1536 # 与embedding模型维度一致（text-embedding-ada-002为1536）

3.4.3 RAG 实操（导入知识库 + 检索生成）

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.document.Document;
import org.springframework.ai.embedding.EmbeddingClient;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import jakarta.annotation.Resource;
import java.util.List;
@Configuration
public class RagConfig {
    @Resource
    private VectorStore vectorStore;
    @Resource
    private EmbeddingClient embeddingClient;
    @Resource
    private ChatClient chatClient;
    // 1. 导入知识库（模拟企业内部产品文档）
    @Bean
    CommandLineRunner importKnowledgeBase() {
        return args -> {
            // 知识库内容（可从PDF、Word等文件中读取，Spring AI支持多种文档解析）
            List<Document> documents = List.of(
                    new Document("Spring AI 是Spring生态的AI集成框架，支持微服务无缝集成AI能力，适配OpenAI、通义千问等主流模型。"),
                    new Document("Spring AI 1.0.3 版本支持RAG、工具调用、多模态等核心功能，最低要求JDK 17+。"),
                    new Document("微服务中使用Spring AI，可通过自动配置快速集成，无需手动实例化AI客户端。")
            );
            // 将知识库向量化并存储到Redis向量数据库
            vectorStore.add(documents);
        };
    }
    // 2. RAG检索生成（结合知识库回复用户提问）
    @Bean
    CommandLineRunner ragTest() {
        return args -> {
            // 用户提问：Spring AI 支持哪些AI模型？
            String userQuestion = "Spring AI 支持哪些AI模型？";
            // 第一步：检索知识库中与问题相关的内容
            List<Document> relevantDocs = vectorStore.similaritySearch(userQuestion, 2); // 检索前2条相关知识
            // 第二步：构建Prompt，结合检索到的知识
            String prompt = String.format("结合以下知识，回答用户问题：\n%s\n用户问题：%s",
                    relevantDocs.stream().map(Document::getContent).reduce("", (a, b) -> a + "\n" + b),
                    userQuestion);
            // 第三步：调用AI模型，生成回复
            var response = chatClient.prompt(new UserMessage(prompt)).call();
            System.out.println("RAG回复：" + response.getResult().getOutput().getContent());
        };
    }
}

应用场景：企业内部智能问答系统（基于员工手册、技术文档）、产品智能客服（基于产品文档）、行业知识库问答等，是企业级微服务 AI 落地的核心场景。

四、微服务架构下 Spring AI 最佳实践

Spring AI 在微服务中使用时，需结合微服务的架构特性（分布式、高并发、服务治理），遵循以下最佳实践，确保 AI 能力稳定、高效落地。

4.1 服务拆分：AI 能力独立部署

将 AI 相关能力拆分到独立的微服务（如 ai-service），避免与业务服务耦合。例如：

• ai-chat-service：负责聊天对话、流式响应等核心 AI 交互能力
• ai-rag-service：负责知识库管理、RAG 检索生成
• ai-tool-service：负责工具调用、第三方 API 集成

这样拆分的优势：便于独立扩展、灰度发布、故障隔离，符合微服务“单一职责”原则。

4.2 服务治理：融入微服务生态

• 服务注册发现：将 AI 服务注册到 Nacos、Eureka 等注册中心，让其他业务服务能通过服务名调用 AI 能力。
• 熔断降级：集成 Resilience4j、Sentinel 等组件，当 AI 厂商 API 不可用或响应超时，自动熔断，避免影响整个微服务集群；同时提供降级方案（如返回预设回复）。
• 限流控制：针对 AI 服务设置限流（如每秒最多调用 100 次），避免因高并发导致 AI 厂商 API 超限，同时保护自身服务稳定性。
• 监控告警：集成 Spring Boot Actuator、Prometheus、Grafana，监控 AI 服务的调用次数、响应时间、错误率等指标；当出现异常（如 API 调用失败），及时告警。

4.3 安全与合规

• API Key 管理：通过环境变量、配置中心（如 Nacos）注入 API Key，避免硬编码；不同环境使用不同的 API Key，便于权限管控。
• 输入输出过滤：对用户输入进行过滤（如过滤敏感词），避免 AI 生成违规内容；对 AI 输出进行审核，确保符合企业合规要求。
• 数据安全：用户对话数据、知识库数据需加密存储，尤其是涉及企业机密、用户隐私的数据，避免数据泄露。

4.4 性能优化

• 缓存优化：对高频 AI 请求（如常见问题回复）进行缓存（Redis），减少 AI 模型调用次数，降低延迟和成本。
• 异步调用：对于非实时场景（如批量内容生成），使用 Spring Async 实现异步调用，避免阻塞微服务主线程。
• 模型选择：根据业务场景选择合适的 AI 模型（如简单问答用 gpt-3.5-turbo，复杂推理用 gpt-4），平衡性能与成本。

五、实战案例：微服务 +Spring AI 实现智能客服

结合前文内容，实现一个简单的智能客服微服务，具备以下功能：多轮对话、知识库检索（RAG）、工具调用（查询订单），完整演示 Spring AI 在微服务中的落地流程。

5.1 架构设计

拆分两个微服务：

1. ai-chat-service：智能客服核心服务，集成 Spring AI，提供多轮对话、RAG、工具调用能力，注册到 Nacos。
2. order-service：订单服务，提供订单查询接口，供 AI 工具调用。

5.2 核心代码实现（ai-chat-service）

5.2.1 工具类（调用订单服务）

import org.springframework.ai.core.AiFunction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
// 调用订单服务的工具类
@Component
public class OrderTool {
    @Autowired
    private RestTemplate restTemplate;
    // 订单服务地址（从注册中心获取，此处简化为固定地址）
    private static final String ORDER_SERVICE_URL = "http://order-service/order/query";
    /**
     * 工具方法：查询订单状态
     * @param orderId 订单ID
     * @return 订单状态信息
     */
    @AiFunction(description = "查询指定订单的状态，参数为订单ID（纯数字）")
    public String queryOrderStatus(String orderId) {
        // 调用订单服务接口
        return restTemplate.getForObject(ORDER_SERVICE_URL + "?orderId=" + orderId, String.class);
    }
}

5.2.2 智能客服接口

import org.springframework.ai.chat.Conversation;
import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.tools.Tool;
import org.springframework.ai.document.Document;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import jakarta.annotation.Resource;
import java.util.List;
import java.util.Map;
@RestController
public class CustomerServiceController {
    @Resource
    private ChatClient chatClient;
    @Resource
    private VectorStore vectorStore;
    @Resource
    private OrderTool orderTool;
    // 多轮对话上下文（分布式场景下用Redis存储）
    private final Conversation conversation = new Conversation();
    /**
     * 智能客服接口
     * @param request 包含用户消息、会话ID
     * @return AI回复
     */
    @PostMapping("/customer-service/chat")
    public String chat(@RequestBody Map<String, String> request) {
        String userMessage = request.get("message");
        conversation.add(new UserMessage(userMessage));
        // 1. 检索知识库相关内容（客服话术、产品知识）
        List<Document> relevantDocs = vectorStore.similaritySearch(userMessage, 2);
        String knowledge = relevantDocs.stream().map(Document::getContent).reduce("", (a, b) -> a + "\n" + b);
        // 2. 构建Prompt，结合知识库
        String prompt = String.format("结合知识库内容：%s，以客服语气回答用户问题，语气亲切、简洁。", knowledge);
        conversation.add(new UserMessage(prompt));
        // 3. 传入工具（订单查询），AI自动判断是否需要调用
        List<Tool> tools = List.of(Tool.from(orderTool));
        var response = chatClient.call(conversation, tools);
        // 4. 更新会话上下文
        conversation.add(response.getResult().getOutput());
        return response.getResult().getOutput().getContent();
    }
}

5.3 测试场景

1. 用户：“你们的产品支持哪些 AI 模型？” → AI 结合知识库回复（RAG）。
2. 用户：“我的订单状态是什么？订单 ID 是 123456” → AI 调用订单服务，返回订单状态（工具调用）。
3. 用户：“那这个订单什么时候发货？” → AI 记住上一轮订单 ID，继续调用订单服务查询（多轮对话）。

六、常见问题与解决方案

6.1 AI 模型调用超时

问题：微服务调用 AI 模型时，因网络延迟、模型响应慢导致接口超时。

解决方案：1. 配置超时时间（通过 application.yml 设置 spring.ai.openai.timeout）；2. 启用流式响应，减少等待时间；3. 集成熔断降级组件，超时后返回降级回复；4. 对高频请求进行缓存。

6.2 会话上下文丢失（分布式场景）

问题：微服务多实例部署时，会话上下文存储在本地内存，导致切换实例后会话丢失。

解决方案：将 Conversation 对象存储在 Redis 等分布式存储中，通过会话 ID 关联，实现多实例共享会话上下文。

6.3 AI 回复格式不规范（结构化输出失败）

问题：AI 生成的回复不符合预期格式，导致无法映射为 POJO。

解决方案：1. 优化 Prompt 模板，明确指定输出格式（如“必须是 JSON，无多余内容”）；2. 使用 Spring AI 的 OutputParser 接口，自定义解析逻辑；3. 对 AI 回复进行格式校验，校验失败则重新调用模型。

6.4 向量数据库检索准确率低

问题：RAG 场景中，检索到的知识库内容与用户问题相关性低。

解决方案：1. 优化知识库拆分（将长文本拆分为短片段，提升相关性）；2. 更换更合适的 embedding 模型；3. 调整检索参数（如 similaritySearch 的 topK 值）；4. 结合 BM25 等算法，提升检索准确率。

七、总结与展望

Spring AI 的出现，彻底打破了“AI 开发依赖 Python”的壁垒，让 Java 微服务开发者能在熟悉的生态中，快速集成 AI 能力，实现微服务的智能化升级。其核心价值在于“统一抽象、生态无缝、企业级就绪”，完美适配微服务的分布式、高可用、可扩展需求。

本文从微服务视角出发，详细讲解了 Spring AI 的基础搭建、核心功能实操、最佳实践及实战案例，覆盖了微服务中最常用的 AI 场景（聊天对话、结构化输出、工具调用、RAG）。对于企业而言，无需重构现有微服务体系，即可通过 Spring AI 快速为各个业务模块赋能，降低 AI 落地成本，提升业务效率。

未来，Spring AI 将持续完善对更多 AI 模型、向量数据库、工具的支持，进一步深化与 Spring Cloud 的集成，推动 AI 与微服务的深度融合。对于开发者而言，掌握 Spring AI，将成为微服务智能化时代的核心竞争力。

后续将持续更新 Spring AI 的进阶用法（如多模态开发、自定义 AI 组件、微服务集群下的 AI 负载均衡），欢迎关注交流！

关注我的CSDN： https://blog.csdn.net/qq30095907?spm=1011.2266.3001.5343