Spring AI 2.0 + Spring Boot 4 完全指南 [2026]

Spring AI 2.0 + Spring Boot 4 完全指南 [2026]

快速摘要：Spring AI 2.0 基于 Spring Boot 4 和 Java 21，为 Java 开发者带来了企业级 AI 能力。2025年12月11日发布，包含原生 OpenAI SDK、Redis 向量存储、Gemini 集成（支持 ThinkingLevel），以及熟悉的 Spring 模式（依赖注入、配置）。Python 和 Java 在 AI 开发领域的差距正在缩小。

TL;DR

Java 加入 AI 革命

多年来，Java 开发者看着 Python 主导 AI 领域。Spring AI 正在改变这一局面。

2025年12月11日，Spring 发布了 Spring AI 2.0.0-M1——基于 Spring Boot 4.0 和 Spring Framework 7.0。这不仅仅是增量更新，而是一个完整的企业级 Java AI 集成框架。

新特性：

• 原生 OpenAI SDK，默认使用 GPT-5-mini
• Redis 向量存储，增强版搜索
• ****，支持 ThinkingLevelGemini 集成
• Java 21 要求（虚拟线程、模式匹配）

什么是 Spring AI？

Spring AI 是一个将 AI 工程引入 Spring 生态的应用框架。可以把它看作"Spring Data for AI"——熟悉的模式、企业级就绪、生产优先。

核心能力：

• 对话补全（OpenAI、Anthropic、Google 等）
• 嵌入向量和向量存储
• RAG（检索增强生成）
• 函数调用/工具使用
• 结构化输出到 POJO
• 流式响应

支持的 AI 提供商

快速开始

环境要求

要求：
– Java 21+ (Spring AI 2.0 必需)
– Maven 或 Gradle
– Spring Boot 4.0+
– AI 提供商的 API 密钥

Maven 依赖

org.springframework.boot
spring-boot-starter-parent
4.0.0

org.springframework.ai
spring-ai-openai-spring-boot-starter
2.0.0-M1

org.springframework.ai
spring-ai-redis-store-spring-boot-starter
2.0.0-M1

配置

# application.yml
spring:
ai:
openai:
api-key: ${OPENAI_API_KEY}
chat:
model: gpt–5–mini # Spring AI 2.0 默认
temperature: 0.7
embedding:
model: text–embedding–3–large

基础对话实现

简单对话客户端

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.stereotype.Service;

@Service
public class ChatService {

private final ChatClient chatClient;

public ChatService(ChatClient.Builder builder) {
this.chatClient = builder.build();
}

public String chat(String message) {
return chatClient.prompt()
.user(message)
.call()
.content();
}
}

带系统提示词

@Service
public class AssistantService {

private final ChatClient chatClient;

public AssistantService(ChatClient.Builder builder) {
this.chatClient = builder
.defaultSystem("你是一个有用的编程助手，专精 Java 和 Spring。")
.build();
}

public String askCodingQuestion(String question) {
return chatClient.prompt()
.user(question)
.call()
.content();
}
}

流式响应

import reactor.core.publisher.Flux;

@Service
public class StreamingChatService {

private final ChatClient chatClient;

public Flux streamChat(String message) {
return chatClient.prompt()
.user(message)
.stream()
.content();
}
}

// 在控制器中
@GetMapping(value = "/chat/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux streamChat(@RequestParam String message) {
return chatService.streamChat(message);
}

结构化输出

映射到 POJO

public record BookRecommendation(
String title,
String author,
String genre,
String summary,
int rating
) {}

@Service
public class BookService {

private final ChatClient chatClient;

public List getRecommendations(String preferences) {
return chatClient.prompt()
.user("根据以下偏好推荐5本书：" + preferences)
.call()
.entity(new ParameterizedTypeReference>() {});
}
}

函数调用/工具使用

定义函数

import org.springframework.ai.chat.model.function.FunctionCallback;

@Configuration
public class FunctionConfig {

@Bean
public FunctionCallback weatherFunction() {
return FunctionCallback.builder()
.function("getWeather", this::getWeather)
.description("获取某个位置的当前天气")
.inputType(WeatherRequest.class)
.build();
}

private WeatherResponse getWeather(WeatherRequest request) {
// 调用天气 API
return new WeatherResponse(
request.location(),
"22°C",
"晴朗"
);
}
}

record WeatherRequest(String location) {}
record WeatherResponse(String location, String temperature, String condition) {}

在对话中使用函数

@Service
public class WeatherChatService {

private final ChatClient chatClient;

public WeatherChatService(ChatClient.Builder builder,
FunctionCallback weatherFunction) {
this.chatClient = builder
.defaultFunctions(weatherFunction)
.build();
}

public String askAboutWeather(String query) {
return chatClient.prompt()
.user(query) // "东京天气怎么样？"
.call()
.content();
// AI 自动调用 getWeather 函数
}
}

RAG 与向量存储

Redis 向量存储（2.0 新特性）

import org.springframework.ai.vectorstore.redis.RedisVectorStore;
import org.springframework.ai.document.Document;

@Service
public class DocumentService {

private final RedisVectorStore vectorStore;
private final EmbeddingModel embeddingModel;

public void addDocument(String content, Map metadata) {
Document doc = new Document(content, metadata);
vectorStore.add(List.of(doc));
}

public List search(String query, int topK) {
return vectorStore.similaritySearch(
SearchRequest.query(query).withTopK(topK)
);
}
}

RAG 模式实现

@Service
public class RagService {

private final ChatClient chatClient;
private final VectorStore vectorStore;

public String queryWithContext(String question) {
// 1. 搜索相关文档
List relevantDocs = vectorStore.similaritySearch(
SearchRequest.query(question).withTopK(5)
);

// 2. 从文档构建上下文
String context = relevantDocs.stream()
.map(Document::getContent)
.collect(Collectors.joining("
"));

// 3. 带上下文问 AI
return chatClient.prompt()
.system("基于以下上下文回答：
" + context)
.user(question)
.call()
.content();
}
}

Redis 聊天记忆（2.0 新特性）

import org.springframework.ai.chat.memory.redis.RedisChatMemory;

@Configuration
public class ChatMemoryConfig {

@Bean
public ChatMemory chatMemory(RedisConnectionFactory connectionFactory) {
return new RedisChatMemory(connectionFactory);
}
}

@Service
public class ConversationService {

private final ChatClient chatClient;
private final ChatMemory chatMemory;

public String chat(String sessionId, String message) {
return chatClient.prompt()
.advisors(new MessageChatMemoryAdvisor(chatMemory, sessionId, 10))
.user(message)
.call()
.content();
}
}

Google Gemini 集成

配置

spring:
ai:
google:
api-key: ${GOOGLE_AI_KEY}
chat:
model: gemini–3–pro
thinking-level: medium # 2.0 新特性：low, medium, high

使用 ThinkingLevel

import org.springframework.ai.google.gemini.GeminiChatModel;

@Service
public class GeminiService {

private final GeminiChatModel geminiModel;

public String complexReasoning(String problem) {
var options = GeminiChatOptions.builder()
.withModel("gemini-3-pro")
.withThinkingLevel(ThinkingLevel.HIGH) // 扩展推理
.build();

return geminiModel.call(
new Prompt(problem, options)
).getResult().getOutput().getContent();
}
}

Spring Boot 4 特性

模块化自动配置

org.springframework.ai
spring-ai-openai

虚拟线程（Java 21）

// Spring Boot 4 + Java 21 = 默认使用虚拟线程
@Async
public CompletableFuture asyncChat(String message) {
return CompletableFuture.completedFuture(
chatClient.prompt().user(message).call().content()
);
}

常见问题

Q: Spring AI 2.0 可以和 Java 17 一起用吗？

Java 21 是 Spring AI 2.0 的必需条件。它基于 Spring Boot 4.0，而 Spring Boot 4.0 要求 Java 21+ 以支持虚拟线程、模式匹配和其他现代特性。如果你在使用 Java 17 或更早版本，必须先升级到 Java 21。

Q: Spring AI 支持本地/开源模型吗？

Spring AI 同时支持商业 API（OpenAI、Anthropic、Google）和本地/开源模型（通过 Ollama 集成）。你可以本地运行 Llama、Mistral 或 Phi 等模型，无需 API 费用。这非常适合开发、测试或隐私敏感的应用。

Q: 如何从 Python AI 代码迁移到 Spring AI？

Spring AI 使用熟悉的模式，迁移很直接。Python 的 OpenAI 客户端映射到 Spring 的 ChatClient。嵌入向量和向量存储有类似的抽象。RAG 模式（检索→增强→生成）完全相同。主要区别：Spring 的依赖注入和配置使生产部署更容易。

Q: 可以在一个应用中同时使用多个 AI 提供商吗？

可以。Spring AI 支持同时使用多个提供商。使用 Spring 的 @Qualifier 注解注入特定模型，创建路由模式根据任务类型选择提供商，或构建在提供商之间切换的抽象层。

Q: Spring AI 已经可以用于生产环境了吗？

Spring AI 2.0.0-M1 是一个里程碑版本（M1 = 里程碑1），表示功能已完成但尚未最终发布。然而，Spring AI 从 1.x 版本起就已在生产中使用。2.0 版本增加了 Spring Boot 4 支持和新特性。生产使用时需实现适当的错误处理、限流和可观测性。

总结

Spring AI 2.0 为 Java 开发者带来了企业级 AI 能力。通过 Spring Boot 4、Java 21 和对所有主流 AI 提供商的支持，你现在可以使用熟悉的 Spring 模式构建生产级 AI 应用。

要点：

• Spring 模式 — 依赖注入、配置、测试
• 多提供商 — OpenAI、Anthropic、Google、AWS、Ollama
• 生产就绪 — 重试、限流、可观测性
• Java 21 — 虚拟线程、模式匹配、记录

Python 和 Java 在 AI 开发领域的差距正在缩小。Spring AI 2.0 是桥梁。

原文链接：Spring AI 2.0 + Spring Boot 4 Guide