Spring AI 极简入门：Java 开发者快速上手 AI 开发

Spring AI 是 Spring 官方推出的 AI 应用开发框架，让 Java 开发者用熟悉的 Spring Boot 方式，快速对接大模型，不用再死记不同 AI 平台的复杂 API，一套代码适配 OpenAI、通义千问、讯飞星火等主流模型。

一、核心优势（3 句话记住）

1. 统一接口：用 ChatClient 一套 API 调用所有大模型，切换模型只改配置，不动业务代码。
2. 零门槛集成：基于 Spring Boot 自动配置，引入依赖、配个密钥就能用。
3. 功能齐全：支持聊天对话、上下文记忆、向量嵌入、RAG 知识库、结构化输出，满足日常 AI 需求。

二、基础快速上手（5 分钟跑通）

1. Maven 基础依赖

<!-- OpenAI通用启动器 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>1.1.6</version>
</dependency>
<!-- 通义千问适配依赖 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-alibaba-spring-boot-starter</artifactId>
    <version>1.1.6</version>
</dependency>
<!-- 内存向量库（本地测试用） -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-chroma-store-spring-boot-starter</artifactId>
    <version>1.1.6</version>
</dependency>

2. OpenAI 基础配置 application.yml

spring:
  ai:
    openai:
      api-key: 你的OpenAI密钥
      chat:
        options:
          model: gpt-3.5-turbo

3. 基础对话接口

@RestController
@RequestMapping("/ai")
public class AiController {
    private final ChatClient chatClient;

    public AiController(ChatClient.Builder builder) {
        this.chatClient = builder.defaultSystem("你是友好的AI助手").build();
    }

    // 单次无记忆对话
    @GetMapping("/chat")
    public String chat(@RequestParam String msg) {
        return chatClient.prompt().user(msg).call().content();
    }
}

三、扩展 1：上下文记忆（多轮对话，AI 记住历史聊天）

默认单次对话无记忆，每次请求都是全新会话，Spring AI 自带MessageChatMemory实现会话记忆。

改造 Controller

@RestController
@RequestMapping("/ai")
public class AiController {
    private final ChatClient chatClient;
    // 内存会话存储，生产环境可换Redis持久化
    private final ChatMemory chatMemory = new InMemoryChatMemory();

    public AiController(ChatClient.Builder builder) {
        this.chatClient = builder
                .defaultSystem("你是友好的AI助手，记住我们之前的对话")
                .build();
    }

    // 带上下文多轮对话，sessionId区分不同用户会话
    @GetMapping("/chat/memory")
    public String chatWithMemory(@RequestParam String msg, @RequestParam String sessionId) {
        String res = chatClient.prompt()
                .user(msg)
                // 绑定会话记忆
                .chatMemory(chatMemory, sessionId)
                .call()
                .content();
        return res;
    }

    // 清空指定会话历史
    @DeleteMapping("/chat/clear")
    public String clearMemory(@RequestParam String sessionId) {
        chatMemory.clear(sessionId);
        return "会话" + sessionId + "历史已清空";
    }
}

使用示例

1. 第一次请求：/ai/chat/memory?sessionId=user001&msg=我叫小明
2. 第二次请求：/ai/chat/memory?sessionId=user001&msg=我叫什么名字？ AI 会读取历史消息，正确回答你叫小明。

四、扩展 2：向量数据库 + RAG 知识库（本地文档问答）

场景：上传本地文档，AI 只基于文档内容回答，不胡说（RAG 检索增强生成）

1. 配置 Chroma 内存向量库

spring:
  ai:
    chroma:
      client:
        host: localhost
        port: 8000

2. 向量工具类（文档入库、检索）

@Service
public class RagService {
    private final VectorStore vectorStore;
    private final ChatClient chatClient;

    public RagService(VectorStore vectorStore, ChatClient.Builder builder) {
        this.vectorStore = vectorStore;
        this.chatClient = builder.defaultSystem("只根据提供的文档内容回答，不知道就说没有相关信息").build();
    }

    // 加载本地txt文档写入向量库
    public void loadDoc(File file) {
        DocumentReader reader = new TextReader(file);
        List<Document> docs = reader.get();
        // 文档切片
        TokenTextSplitter splitter = new TokenTextSplitter();
        List<Document> splitDocs = splitter.split(docs);
        // 存入向量库
        vectorStore.add(splitDocs);
    }

    // RAG问答：先检索向量库再交给AI
    @GetMapping("/rag/query")
    public String ragQuery(@RequestParam String question) {
        // 相似度检索
        List<Document> similarDocs = vectorStore.similaritySearch(SearchRequest.query(question).withTopK(3));
        // 拼接检索到的文档内容
        String context = similarDocs.stream()
                .map(Document::getText)
                .collect(Collectors.joining("\n=====\n"));

        String prompt = """
                参考资料：
                {context}
                用户问题：{question}
                """;

        return chatClient.prompt()
                .user(u -> u.text(prompt).param("context", context).param("question", question))
                .call()
                .content();
    }
}

五、扩展 3：通义千问模型完整适配（阿里大模型切换）

1. application.yml 通义千问配置

spring:
  ai:
    alibaba:
      api-key: 阿里云百炼获取的api-key
      chat:
        options:
          model: qwen-turbo # 可选 qwen-plus、qwen-max

2. 通义千问专用对话接口（自动切换模型，代码无需大改）

@RestController
@RequestMapping("/ai/qwen")
public class QwenController {
    // 自动注入通义千问ChatClient，切换模型仅改配置
    private final ChatClient qwenChatClient;
    private final ChatMemory chatMemory = new InMemoryChatMemory();

    public QwenController(@Qualifier("alibabaChatClient") ChatClient.Builder builder) {
        this.qwenChatClient = builder.defaultSystem("你是通义千问AI助手").build();
    }

    // 通义千问多轮记忆对话
    @GetMapping("/chat")
    public String chat(@RequestParam String msg, @RequestParam String sessionId) {
        return qwenChatClient.prompt()
                .user(msg)
                .chatMemory(chatMemory, sessionId)
                .call()
                .content();
    }
}

多模型共存小技巧

项目同时引入 OpenAI 和通义千问依赖，通过@Qualifier("alibabaChatClient")区分模型客户端，一套项目同时调用多款大模型。

六、整体总结

1. 上下文记忆 ：依靠ChatMemory实现多轮对话，用 sessionId 隔离不同用户会话，生产可替换 Redis 持久化；
2. 向量数据库 RAG：文档向量化存入向量库，提问时先检索相关文档，解决 AI 幻觉、私有知识库问答；
3. 通义千问适配：Spring AI 阿里专用 starter，配置密钥即可切换国产大模型，业务代码几乎不用改动；

Spring AI 统一抽象层极大降低 Java 接入 AI 成本，先掌握基础对话，再拓展记忆、知识库、国产大模型，就能快速开发企业内部 AI 问答、智能客服、文档助手等业务。

补充小提示

1. InMemoryChatMemory 仅适合测试，线上使用 RedisChatMemory 持久化会话；
2. Chroma 适合本地开发，生产推荐 Milvus、PGVector 向量数据库；
3. 阿里云通义千问 API Key 在「阿里云百炼」平台申请，免费额度可用于学习测试。