Spring AI：Java 生态原生 AI 框架入门指南

5. 内置向量存储与 RAG 支持，激活私有知识库

Spring AI 集成了 PostgreSQL/pgvector、Pinecone、Qdrant、Redis、Weaviate 等主流向量数据库，提供元数据过滤、相似度检索能力；同时内置 ETL 流程，可快速搭建 RAG 系统，解决大模型'知识过期''不懂私有数据'痛点。

6. 工具调用能力，打通业务系统闭环

原生支持模型驱动的工具调用，可将 Spring Bean 注册为 AI 可调用工具，实现 AI 自动调用业务接口、查询数据库等操作，例如：

• 调用天气 API 获取实时气象数据
• 查询企业 CRM 系统获取客户详情
• 执行业务数据统计与分析操作

实现 AI 与业务流程深度融合，让 AI 从'对话工具'升级为'业务智能入口'，打通需求到执行的全闭环。

三、快速上手：环境准备与 Deepseek 对话案例

理论再多不如实际动手，下面我们将通过一个完整的案例，教大家搭建 Spring AI 环境，并实现与 Deepseek 模型的对话交互。

3.1 环境要求

Spring AI 构建在 Spring Boot 3.x 之上，对环境有明确要求：

• JDK：必须为 17 及以上版本（不支持 Java 8/11/16）
• Maven：3.6 及以上版本
• Spring Boot：3.x 系列（本文使用 3.5.0 版本）

3.2 创建 Spring Boot 项目

Step 1：访问 Spring Initializr 访问 https://start.spring.io/，或在 IDEA 中直接创建 New Module。项目配置如下：

• Name: spring-ai-demo
• Group: com.example
• Artifact: spring-ai-demo
• Package name: com.example.demo
• Language: Java
• JDK: 17
• Spring Boot: 3.5.3
• Packaging: Jar

Step 2：添加依赖 Spring Boot 版本选择 3.5.x，依赖选择：仅需添加「Spring Web」依赖（后续通过 Maven 引入 Spring AI 相关依赖）。

创建完成后的项目结构如下：

spring-ai-demo/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── demo/
│   │   │               └── DemoApplication.java
│   │   └── resources/
│   │       └── application.properties
│   └── test/
└── pom.xml

Step 3：配置 pom.xml 依赖 在 pom.xml 中添加 Spring AI 相关依赖，核心是导入 Spring AI BOM 统一管理版本，并引入 Deepseek 模型 starter：

<?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">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.example</groupId>
        <artifactId>spring-ai-parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>spring-ai-demo</artifactId>
    <name>spring-ai-demo</name>
    <description>Spring AI Quick Start</description>
    <properties>
        <java.version>17</java.version>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-starter-model-deepseek</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Step 4：配置 application.properties 在 src/main/resources/application.properties 中配置 Deepseek 模型的基础信息：

spring.application.name=spring-ai-demo
server.port=8080
# Deepseek URL
spring.ai.deepseek.base-url=https://api.deepseek.com
spring.ai.deepseek.api-key=你的 Deepseek appkey
spring.ai.deepseek.chat.options.model=deepseek-chat

注意：Deepseek API 密钥需要在 Deepseek 官网注册获取，替换配置中的占位符。

Step 5：编写 ChatController 创建 com.example.demo.controller 包，并编写 ChatController 类，实现与 Deepseek 模型的交互：

import org.springframework.ai.deepseek.DeepSeekChatModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/ai")
public class ChatController {

    @Autowired
    private DeepSeekChatModel chatModel;

    @PostMapping("/chat")
    public String chat(@RequestBody String message) {
        return chatModel.call(message);
    }
}

Step 6：启动并测试 运行 DemoApplication.java 启动项目。 浏览器访问：http://localhost:8080/ai/chat?message=你是谁，即可看到模型响应。

四、实战进阶：流式响应与可视化界面优化

前面使用 Spring AI 快速整合 DeepSeek，实现了与大模型对话的功能，但是，这个项目存在两个不足：

1. 无可视化交互界面；
2. AI 响应为一次性返回，缺乏实时感。 下面对项目进行优化升级。

Step 1：实现流式返回接口

在 ChatController 中，创建新接口 /ai/chatStream 接口。

@PostMapping("/chatStream")
public SseEmitter chatStream(@RequestBody String message) {
    SseEmitter emitter = new SseEmitter(Long.MAX_VALUE);
    Flux<String> stream = chatModel.stream(message);
    stream.subscribe(
        chunk -> {
            try {
                String json = objectMapper.writeValueAsString(chunk);
                emitter.send(SseEmitter.event().data(json).build());
            } catch (IOException e) {
                emitter.completeWithError(e);
            }
        },
        error -> { emitter.completeWithError(error); },
        () -> { emitter.complete(); }
    );
    return emitter;
}

Step 2：创建可视化聊天界面

为了更直观地与模型交互，我们可以在 src/main/resources/static 目录下创建 index.html，实现简单的聊天界面：

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AI 聊天助手（流式响应）</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); height: 100vh; display: flex; justify-content: center; align-items: center; }
        .chat-container { width: 800px; height: 600px; background: white; border-radius: 16px; box-shadow: 0 20px 60px rgba(0,0,0,0.3); display: flex; flex-direction: column; overflow: hidden; }
        .chat-header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 20px; color: white; }
        .chat-messages { flex: 1; padding: 20px; overflow-y: auto; background: #f5f5f5; }
        .message { margin-bottom: 16px; display: flex; align-items: flex-start; }
        .message.user { justify-content: flex-end; }
        .message.assistant { justify-content: flex-start; }
        .message-content { max-width: 70%; padding: 12px 16px; border-radius: 12px; line-height: 1.5; word-wrap: break-word; }
        .message.user .message-content { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-bottom-right-radius: 4px; }
        .message.assistant .message-content { background: white; color: #333; border-bottom-left-radius: 4px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); }
        .chat-input-container { padding: 20px; background: white; border-top: 1px solid #e0e0e0; }
        .chat-input-form { display: flex; gap: 12px; }
        #messageInput { flex: 1; padding: 12px 16px; border: 2px solid #e0e0e0; border-radius: 24px; font-size: 16px; outline: none; transition: border-color 0.3s; }
        #sendButton { padding: 12px 32px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border: none; border-radius: 24px; font-size: 16px; font-weight: 600; cursor: pointer; }
    </style>
</head>
<body>
<div class="chat-container">
    <div class="chat-header"><h1>AI 聊天助手</h1><p>基于 Spring AI 和 DeepSeek 的智能对话系统</p></div>
    <div class="chat-messages" id="chatMessages"></div>
    <div class="chat-input-container">
        <form class="chat-input-form" id="chatForm">
            <input type="text" id="messageInput" placeholder="输入您的问题..." autocomplete="off" required>
            <button type="submit" id="sendButton">发送</button>
        </form>
    </div>
</div>
<script>
    const chatMessages = document.getElementById('chatMessages');
    const chatForm = document.getElementById('chatForm');
    const messageInput = document.getElementById('messageInput');
    const sendButton = document.getElementById('sendButton');

    async function sendMessage(message) {
        addMessage(message, true);
        sendButton.disabled = true;
        try {
            const response = await fetch('/ai/chatStream', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ message: message })
            });
            if (!response.ok) throw new Error('网络请求失败');
            const reader = response.body.getReader();
            const decoder = new TextDecoder();
            let fullText = ;
             () {
                 { done, value } =  reader.();
                 (done) ;
                 chunk = decoder.(value, { :  });
                 lines = chunk.().( line.());
                 ( line  lines) {
                     {
                         cleanLine = line.(, ).();
                         (!cleanLine) ;
                         data = .(cleanLine);
                         (data.) { fullText += data.; }
                    }  (e) { .(, e); }
                }
                (fullText, );
            }
        }  (error) {
            ( + error., );
        }  {
            sendButton. = ;
            messageInput.();
        }
    }

     () {
         messageDiv = .();
        messageDiv. = ;
         messageContent = .();
        messageContent. = ;
        messageContent. = content;
        messageDiv.(messageContent);
        chatMessages.(messageDiv);
        chatMessages. = chatMessages.;
    }

    chatForm.(,  (e) => {
        e.();
         message = messageInput..();
         (!message) ;
        messageInput. = ;
         (message);
    });
</script>
</body>
</html>

Step 3：启动并测试

重启项目后，访问 http://localhost:8080，即可通过可视化界面与 AI 聊天，例如输入'你好'，模型会流式返回。

总结

本文我们从 Spring AI 的核心概念出发，详细介绍了它的核心特性，并通过一个完整的 Deepseek 对话案例，带大家完成了环境搭建、依赖配置、代码编写与测试的全流程。Spring AI 的核心优势在于'原生集成 Spring 生态'与'统一抽象接口'，让 Java 开发者无需跨生态就能快速接入 AI 能力，极大降低了 AI 应用的开发门槛。