Java SpringBoot 調用大模型 AI 構建智能應用實戰指南

一、基礎知識

（一）Java基礎

Java是一種廣泛使用的高級編程語言，具有簡單、面向對象、分布式、解釋型、健壯、安全、架構中立、可移植、高性能、多線程和動態等特點。在構建基于Spring Boot的AI應用之前，您需要具備扎實的Java基礎。

基本語法

數據類型：了解Java的基本數據類型，包括整數、浮點數、布爾值、字符等，以及它們的存儲范圍和特點。例如，int類型用于表示整數，double類型用于表示浮點數。
變量與常量：掌握變量的聲明和初始化，以及如何使用final關鍵字聲明常量。例如：
```
int age = 25; // 變量聲明與初始化
final double PI = 3.14159; // 常量聲明
```
運算符：熟悉各種運算符，如算術運算符（+、-、*、/、%）、賦值運算符（=、+=、-=等）、關系運算符（>、<、==等）和邏輯運算符（&&、||、!）。

流程控制語句：掌握if、else、switch等條件語句，以及for、while、do-while等循環語句。例如：

if (age >= 18) {System.out.println("成年人");
} else {System.out.println("未成年人");
}for (int i = 0; i < 10; i++) {System.out.println(i);
}

面向對象編程

類與對象：理解類是對象的模板，對象是類的實例。掌握如何定義一個類，并創建對象。例如：

public class Person {String name;int age;public void sayHello() {System.out.println("Hello, my name is " + name);}
}public class Main {public static void main(String[] args) {Person person = new Person();person.name = "Alice";person.age = 30;person.sayHello();}
}

繼承：了解繼承的基本概念，子類可以繼承父類的屬性和方法。使用extends關鍵字實現繼承。例如：
```
public class Student extends Person {String school;public void study() {System.out.println("I am studying at " + school);}
}
```

多態：多態是指同一個接口可以被不同的實例實現。通過方法重載和方法覆蓋實現多態。例如：

public class Animal {public void makeSound() {System.out.println("Animal makes sound");}
}public class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("Dog barks");}
}public class Main {public static void main(String[] args) {Animal animal = new Dog();animal.makeSound(); // 輸出：Dog barks}
}

封裝：封裝是將類的成員變量私有化，并通過公共方法（如getter和setter）訪問和修改成員變量。例如：

public class Person {private String name;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

集合框架

集合接口：熟悉Collection、List、Set、Map等接口及其常用實現類。例如：
- List接口的實現類有ArrayList、LinkedList等。ArrayList基于動態數組實現，適合隨機訪問；LinkedList基于雙向鏈表實現，適合頻繁插入和刪除操作。
- Set接口的實現類有HashSet、TreeSet等。HashSet基于哈希表實現，不允許重復元素；TreeSet基于紅黑樹實現，可以對元素進行排序。
- Map接口的實現類有HashMap、TreeMap等。HashMap基于哈希表實現，鍵值對映射，鍵不允許重復；TreeMap基于紅黑樹實現，可以對鍵進行排序。

集合操作：掌握集合的基本操作，如添加元素、刪除元素、遍歷集合等。例如：

List<String> list = new ArrayList<>();
list.add("Alice");
list.add("Bob");
for (String name : list) {System.out.println(name);
}Set<String> set = new HashSet<>();
set.add("Alice");
set.add("Bob");
for (String name : set) {System.out.println(name);
}Map<String, Integer> map = new HashMap<>();
map.put("Alice", 25);
map.put("Bob", 30);
for (Map.Entry<String, Integer> entry : map.entrySet()) {System.out.println(entry.getKey() + ": " + entry.getValue());
}

異常處理

異常分類：了解Java中的異常分為兩類：Checked Exception（受檢查異常）和Unchecked Exception（非受檢查異常）。Checked Exception需要在方法簽名中聲明拋出異常，或者在方法體內捕獲異常；Unchecked Exception通常是由程序邏輯錯誤引起的，如NullPointerException、ArrayIndexOutOfBoundsException等。
異常處理機制：掌握try-catch-finally語句的使用。try塊中編寫可能會拋出異常的代碼，catch塊捕獲并處理異常，finally塊無論是否捕獲到異常都會執行，通常用于釋放資源。例如：
```
try {int result = 10 / 0;
} catch (ArithmeticException e) {System.out.println("發生算術異常：" + e.getMessage());
} finally {System.out.println("finally塊執行");
}
```

（二）Spring Boot基礎

Spring Boot是一個基于Spring框架的開源Java基礎框架，用于創建獨立、生產級的基于Spring框架的應用程序。它簡化了Spring應用的初始搭建以及開發過程，提供了許多自動配置的特性。

核心概念

自動配置：Spring Boot會根據添加的依賴自動配置Spring和相關技術。例如，添加spring-boot-starter-web依賴后，Spring Boot會自動配置Tomcat和Spring MVC。

依賴注入：通過@Autowired注解或構造器注入，Spring容器會自動將依賴注入到組件中。例如：

@Service
public class UserService {@Autowiredprivate UserRepository userRepository;public User getUserById(Long id) {return userRepository.findById(id);}
}

注解：Spring Boot提供了許多注解，用于簡化開發。例如，@SpringBootApplication是一個組合注解，包含了@Configuration、@EnableAutoConfiguration和@ComponentScan等注解，用于啟動Spring Boot應用。
```
@SpringBootApplication
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}
```

項目創建與配置

使用Spring Initializr創建項目：Spring Initializr是一個在線工具，可以通過它快速創建Spring Boot項目。訪問Spring Initializr，選擇項目元數據（如項目名稱、依賴等），然后生成項目并下載。解壓下載的項目后，導入到IDE中。

添加依賴：在pom.xml文件中添加所需的依賴。例如，添加Spring Web依賴：

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency>

配置文件：Spring Boot的配置文件是application.yml或application.properties。通過配置文件可以設置應用的各種參數，如端口號、數據庫連接信息等。例如：
```
server:port: 8080
spring:datasource:url: jdbc:mysql://localhost:3306/mydbusername: rootpassword: password
```

控制器與服務

控制器（Controller）：控制器是Spring MVC的核心組件之一，用于處理用戶請求并返回響應。通過@RestController或@Controller注解定義控制器。例如：

@RestController
@RequestMapping("/users")
public class UserController {@Autowiredprivate UserService userService;@GetMapping("/{id}")public User getUserById(@PathVariable Long id) {return userService.getUserById(id);}
}

服務（Service）：服務層是業務邏輯的核心部分，通常包含數據的處理和操作。通過@Service注解定義服務。例如：

@Service
public class UserService {@Autowiredprivate UserRepository userRepository;public User getUserById(Long id) {return userRepository.findById(id);}
}

數據訪問

JPA與Spring Data：Spring Data JPA是一個簡化數據庫訪問的框架，通過定義接口繼承JpaRepository，可以自動生成數據訪問方法。例如：
```
public interface UserRepository extends JpaRepository<User, Long> {
}
```

數據庫連接：通過配置文件設置數據庫連接信息。例如，連接MySQL數據庫：

spring:datasource:url: jdbc:mysql://localhost:3306/mydbusername: rootpassword: passworddriver-class-name: com.mysql.cj.jdbc.Driver

（三）AI大模型基礎

AI大模型是近年來人工智能領域的重要發展成果，它們通過大量的數據訓練，能夠生成自然語言文本、圖像等內容。在構建基于Spring Boot的AI應用時，您需要了解AI大模型的基本原理和應用場景。

常見AI大模型

GPT（Generative Pre-trained Transformer）：由OpenAI開發的一系列生成式預訓練模型，能夠生成自然語言文本。例如，GPT-4是目前最先進的版本，支持多模態輸入和輸出。
LLaMA（Large Language Model Application）：由Meta開發的開源語言模型，具有高效的訓練和推理能力。
DeepSeek：由月之暗面科技有限公司開發的AI大模型，支持文本生成、多模態應用等功能。

API調用

HTTP請求與響應：了解HTTP協議的基本概念，包括請求方法（如GET、POST）、請求頭、請求體，以及響應狀態碼、響應頭、響應體。例如，使用curl工具發送HTTP請求：

curl -X POST https://api.openai.com/v1/chat/completions -H "Content-Type: application/json" -H "Authorization: Bearer YOUR_API_KEY" -d '{"model": "gpt-4","messages": [{"role": "user", "content": "Hello, how are you?"}]}'

API Key：API Key是用于身份驗證的密鑰，通常需要在請求頭中攜帶。例如，OpenAI的API Key需要在Authorization頭中以Bearer形式傳遞。

模型調用示例

文本生成：通過API調用AI大模型生成文本。例如，使用Java代碼調用OpenAI的GPT模型：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;public class OpenAIClient {private static final String API_URL = "https://api.openai.com/v1/chat/completions";private static final String API_KEY = "YOUR_API_KEY";public static void main(String[] args) throws Exception {URL url = new URL(API_URL);HttpURLConnection connection = (HttpURLConnection) url.openConnection();connection.setRequestMethod("POST");connection.setRequestProperty("Content-Type", "application/json");connection.setRequestProperty("Authorization", "Bearer " + API_KEY);connection.setDoOutput(true);String jsonInputString = "{"+ ""model": "gpt-4","+ ""messages": [{"role": "user", "content": "Hello, how are you?"}]"+ "}";try (var wr = new java.io.OutputStreamWriter(connection.getOutputStream(), StandardCharsets.UTF_8)) {wr.write(jsonInputString);}try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {StringBuilder response = new StringBuilder();String responseLine;while ((responseLine = br.readLine()) != null) {response.append(responseLine.trim());}System.out.println(response.toString());}}
}

二、環境搭建

（一）開發環境

在開始構建基于Spring Boot的AI應用之前，您需要搭建一個合適的開發環境。

安裝JDK

JDK（Java Development Kit）是Java開發工具包，包含了Java編譯器、運行時環境等。推薦安裝JDK 17或更高版本。可以從Oracle官網下載并安裝JDK。
安裝完成后，配置環境變量。在Windows系統中，將JDK的bin目錄添加到系統的PATH環境變量中。例如，如果JDK安裝在C:Program FilesJavajdk-17in，則將其添加到PATH。

驗證JDK是否安裝成功，打開命令行工具，輸入以下命令：

java -version

如果輸出類似以下信息，則表示JDK安裝成功：

java version "17.0.1" 2021-10-19 LTS
Java(TM) SE Runtime Environment (build 17.0.1+12-LTS-39)
Java HotSpot(TM) 64-Bit Server VM (build 17.0.1+12-LTS-39, mixed mode)

配置項目構建工具

Maven：Maven是一個流行的Java項目構建工具，用于依賴管理和項目構建。可以從Maven官網下載并安裝Maven。
Gradle：Gradle是另一種流行的Java項目構建工具，支持多種編程語言。可以從Gradle官網下載并安裝Gradle。
配置Maven或Gradle的環境變量。在Windows系統中，將Maven或Gradle的bin目錄添加到系統的PATH環境變量中。

驗證Maven是否安裝成功，打開命令行工具，輸入以下命令：

mvn -v

如果輸出類似以下信息，則表示Maven安裝成功：

Apache Maven 3.8.4 (9b656c72d54257dc5c184c05821c43f7e18a0b9a)
Maven home: C:Program Filesapache-maven-3.8.4
Java version: 17.0.1, vendor: Oracle Corporation, runtime: C:Program FilesJavajdk-17
Default locale: zh_CN, platform encoding: GBK
OS name: "windows 10", version: "10.0", arch: "amd64", family: "windows"

選擇IDE

IntelliJ IDEA：IntelliJ IDEA是一款功能強大的Java集成開發環境，提供了代碼編輯、調試、項目管理等功能。可以從JetBrains官網下載并安裝IntelliJ IDEA。
Eclipse：Eclipse是另一款流行的Java集成開發環境，具有豐富的插件生態系統。可以從Eclipse官網下載并安裝Eclipse。
安裝完成后，啟動IDE并導入Spring Boot項目。例如，在IntelliJ IDEA中，可以通過File -> Open菜單導入項目。

（二）Spring Boot項目創建

使用Spring Initializr快速創建Spring Boot項目，并添加所需的依賴。

訪問Spring Initializr

打開瀏覽器，訪問Spring Initializr。

配置項目元數據

Project Metadata：填寫項目元數據，包括項目名稱、項目描述、包名等。
Dependencies：添加所需的依賴。例如，添加Spring Web、Spring AI OpenAI Starter等依賴。Spring AI OpenAI Starter是一個用于集成OpenAI大模型的Spring Boot Starter，它提供了便捷的API調用功能。

生成項目

點擊“Generate”按鈕，下載生成的項目壓縮包。解壓下載的項目后，導入到IDE中。

配置文件

在application.yml文件中添加AI大模型的API Key和相關配置。例如：
```
spring:ai:openai:api-key: YOUR_API_KEYmodel: gpt-4
```

三、Spring AI框架集成

（一）Spring AI介紹

Spring AI是Spring框架的一個擴展，用于簡化AI應用的開發。它提供了與AI大模型的集成，支持智能對話、角色預設、流式響應等功能。

功能特點

模型調用：通過簡單的API調用，可以與各種AI大模型進行交互。
提示詞模板：支持定義提示詞模板，方便生成高質量的文本內容。
檢索增強生成（RAG）：結合外部數據源，實現更準確的回答。
多模態支持：支持文生圖、文生語音等多模態應用。

適用場景

智能客服：通過AI大模型生成自然語言回答，提升客服效率。
寫作助手：幫助用戶生成文章、文案等內容。
智能教育：提供個性化的學習建議和輔導。

（二）集成Spring AI

在Spring Boot項目中集成Spring AI框架，通過添加依賴和配置來實現。

添加依賴

在pom.xml文件中添加Spring AI的依賴。例如：

<dependency><groupId>org.springframework.ai</groupId><artifactId>spring-ai-openai-starter</artifactId><version>0.0.1-SNAPSHOT</version>
</dependency>

如果需要使用快照版本，需要配置Spring AI的倉庫地址。例如：

<repositories><repository><id>spring-ai-snapshots</id><url>https://repo.spring.io/snapshot</url></repository>
</repositories>

初始化ChatClient

使用Spring AI提供的ChatClient進行大模型的調用。ChatClient是與AI大模型交互的核心組件，可以通過配置默認的系統角色和提示詞模板來實現特定場景下的對話。

在Spring Boot的配置類中初始化ChatClient。例如：

@Configuration
public class AiConfig {@Beanpublic ChatClient chatClient() {return new ChatClient.Builder().defaultSystem("你是一個AI智能應用").build();}
}

（三）實現智能對話

通過ChatClient實現一個簡單的智能對話接口，接收用戶輸入并調用大模型生成回答。

創建控制器

創建一個控制器類，定義一個/chat接口，接收用戶輸入并調用ChatClient生成回答。例如：

@RestController
@RequestMapping("/ai")
public class ChatController {private final ChatClient chatClient;public ChatController(ChatClient chatClient) {this.chatClient = chatClient;}@GetMapping("/chat")public String chat(@RequestParam String message) {return chatClient.prompt().user(message).call().content();}
}

測試接口

啟動Spring Boot應用，使用Postman或curl工具測試/ai/chat接口。例如：
```
curl -X GET "http://localhost:8080/ai/chat?message=Hello, how are you?"
```
如果一切正常，您將收到AI大模型生成的回答。

（四）角色預設

通過配置ChatClient的默認系統角色，實現特定場景下的對話。例如，您可以將系統角色設置為“智能客服”，以便生成更符合客服場景的回答。

配置系統角色

在ChatClient的初始化中，配置默認的系統角色。例如：

@Bean
public ChatClient chatClient() {return new ChatClient.Builder().defaultSystem("你是一個智能客服，提供專業的服務").build();
}

測試角色預設

使用相同的/ai/chat接口測試角色預設的效果。例如：

curl -X GET "http://localhost:8080/ai/chat?message=我想咨詢一下產品信息"

您將收到更符合客服場景的回答。

（五）流式響應

實現流式響應，逐步顯示生成的文本內容。流式響應可以提升用戶體驗，尤其是在生成較長文本時。

修改控制器

修改/ai/chat接口，返回ServerSentEvent類型的數據，實現流式響應。例如：

@GetMapping("/chat/stream")
public Flux<ServerSentEvent<String>> chatStream(@RequestParam String message) {return Flux.create(sink -> {chatClient.prompt().user(message).stream().forEach(response -> {sink.next(ServerSentEvent.builder(response.content()).build());});});
}

測試流式響應

使用支持流式響應的客戶端工具測試/ai/chat/stream接口。例如，在瀏覽器中訪問http://localhost:8080/ai/chat/stream?message=Hello, how are you?，您將看到逐步生成的文本內容。

（六）檢索增強生成（RAG）

檢索增強生成（RAG）是一種結合外部數據源的技術，通過檢索相關數據并生成更準確的回答。

了解RAG原理

RAG的基本原理是：在生成回答之前，先從外部數據源（如向量數據庫）檢索與用戶問題相關的上下文信息，然后將這些信息作為提示詞的一部分傳遞給AI大模型，從而生成更準確的回答。

集成向量數據庫

選擇一個向量數據庫（如Milvus、Faiss等），并將其集成到Spring Boot項目中。例如，使用Milvus作為向量數據庫：
- 安裝Milvus服務，并啟動Milvus服務。
- 在Spring Boot項目中添加Milvus的客戶端依賴。例如：
```
<dependency><groupId>io.milvus</groupId><artifactId>milvus-sdk-java</artifactId><version>2.0.0</version>
</dependency>
```
- 初始化Milvus客戶端，并連接到Milvus服務。例如：
```
@Bean
public MilvusClient milvusClient() {return MilvusClient.builder().withHost("localhost").withPort(19530).build();
}
```

實現RAG

在ChatClient的調用中，結合Milvus檢索到的相關上下文信息生成回答。例如：

@GetMapping("/chat/rag")
public String chatRag(@RequestParam String message) {// 從Milvus檢索相關上下文信息List<String> contexts = milvusClient.search(message);// 將上下文信息作為提示詞的一部分傳遞給AI大模型return chatClient.prompt().system("你是一個AI智能應用").user(message).context(contexts).call().content();
}

四、功能實現

（一）智能對話

智能對話是AI應用的核心功能之一，通過與用戶進行自然語言交互，提供有用的信息和服務。

簡單對話

在前面的章節中，我們已經實現了一個簡單的智能對話接口/ai/chat。用戶可以通過發送HTTP請求與AI大模型進行對話。

多輪對話

為了實現多輪對話，需要在ChatClient中維護對話的歷史記錄。通過將歷史記錄作為提示詞的一部分傳遞給AI大模型，可以生成更連貫的回答。

修改ChatController，添加一個ChatSession類來維護對話歷史。例如：

@RestController
@RequestMapping("/ai")
public class ChatController {private final ChatClient chatClient;private final Map<String, ChatSession> sessions = new ConcurrentHashMap<>();public ChatController(ChatClient chatClient) {this.chatClient = chatClient;}@GetMapping("/chat")public String chat(@RequestParam String sessionId, @RequestParam String message) {ChatSession session = sessions.computeIfAbsent(sessionId, ChatSession::new);return session.sendMessage(message);}private static class ChatSession {private final List<Message> history = new ArrayList<>();public String sendMessage(String message) {// 將用戶消息添加到歷史記錄history.add(new Message("user", message));// 生成回答String response = chatClient.prompt().system("你是一個AI智能應用").messages(history).call().content();// 將AI回答添加到歷史記錄history.add(new Message("assistant", response));return response;}}
}

對話上下文管理

在多輪對話中，對話上下文的管理非常重要。可以通過設置上下文有效期、清理歷史記錄等方式優化對話體驗。

例如，設置上下文有效期為10輪對話：

private static class ChatSession {private final List<Message> history = new ArrayList<>();public String sendMessage(String message) {// 清理過期的歷史記錄if (history.size() > 20) {history.subList(0, 10).clear();}// 將用戶消息添加到歷史記錄history.add(new Message("user", message));// 生成回答String response = chatClient.prompt().system("你是一個AI智能應用").messages(history).call().content();// 將AI回答添加到歷史記錄history.add(new Message("assistant", response));return response;}
}

（二）角色預設

角色預設是通過配置AI大模型的系統角色，使其在特定場景下生成更符合角色的回答。

自定義角色

在前面的章節中，我們已經通過配置ChatClient的默認系統角色實現了角色預設。例如，將系統角色設置為“智能客服”：
```
@Bean
public ChatClient chatClient() {return new ChatClient.Builder().defaultSystem("你是一個智能客服，提供專業的服務").build();
}
```

動態角色切換

在某些場景下，可能需要根據用戶輸入動態切換角色。可以通過在接口中添加角色參數，動態設置系統角色。例如：

@GetMapping("/chat")
public String chat(@RequestParam String role, @RequestParam String message) {return chatClient.prompt().system(role).user(message).call().content();
}

角色模板

為了方便管理角色，可以定義角色模板。例如，定義一個“智能客服”角色模板：

public class RoleTemplates {public static final String SMART_CUSTOMER_SERVICE = "你是一個智能客服，提供專業的服務";
}

在接口中使用角色模板：

@GetMapping("/chat")
public String chat(@RequestParam String role, @RequestParam String message) {String systemRole = RoleTemplates.SMART_CUSTOMER_SERVICE;if ("writer".equals(role)) {systemRole = "你是一個寫作助手，幫助用戶生成文章";} else if ("teacher".equals(role)) {systemRole = "你是一個智能教育助手，提供學習建議";}return chatClient.prompt().system(systemRole).user(message).call().content();
}

（三）流式響應

流式響應可以逐步顯示生成的文本內容，提升用戶體驗。

流式響應的實現

在前面的章節中，我們已經通過Flux實現了流式響應。例如：

@GetMapping("/chat/stream")
public Flux<ServerSentEvent<String>> chatStream(@RequestParam String message) {return Flux.create(sink -> {chatClient.prompt().user(message).stream().forEach(response -> {sink.next(ServerSentEvent.builder(response.content()).build());});});
}

前端支持

在前端頁面中，可以通過EventSource接口接收流式響應。例如：

<!DOCTYPE html>
<html>
<head><title>AI Chat</title>
</head>
<body><h1>AI Chat</h1><input type="text" id="message" placeholder="Enter your message"><button onclick="sendMessage()">Send</button><div id="response"></div><script>function sendMessage() {const message = document.getElementById('message').value;const eventSource = new EventSource('/ai/chat/stream?message=' + encodeURIComponent(message));eventSource.onmessage = function(event) {const responseDiv = document.getElementById('response');responseDiv.innerHTML += event.data + '<br>';};eventSource.onerror = function(event) {console.error('EventSource failed:', event);eventSource.close();};}</script>
</body>
</html>

優化流式響應

在某些場景下，可能需要對流式響應進行優化，例如設置響應間隔、清理歷史記錄等。可以通過在ChatClient的流式調用中添加邏輯來實現。例如：

@GetMapping("/chat/stream")
public Flux<ServerSentEvent<String>> chatStream(@RequestParam String message) {return Flux.create(sink -> {chatClient.prompt().user(message).stream().forEach(response -> {// 設置響應間隔try {Thread.sleep(100);} catch (InterruptedException e) {Thread.currentThread().interrupt();}sink.next(ServerSentEvent.builder(response.content()).build());});});
}

（四）檢索增強生成（RAG）

檢索增強生成（RAG）是一種結合外部數據源的技術，通過檢索相關數據并生成更準確的回答。

RAG的實現

在前面的章節中，我們已經通過Milvus實現了RAG。例如：

@GetMapping("/chat/rag")
public String chatRag(@RequestParam String message) {// 從Milvus檢索相關上下文信息List<String> contexts = milvusClient.search(message);// 將上下文信息作為提示詞的一部分傳遞給AI大模型return chatClient.prompt().system("你是一個AI智能應用").user(message).context(contexts).call().content();
}

優化RAG

在RAG中，檢索相關上下文信息的準確性非常重要。可以通過優化向量數據庫的索引、調整檢索算法等方式提升檢索效果。

例如，優化Milvus的索引：

@Bean
public MilvusClient milvusClient() {return MilvusClient.builder().withHost("localhost").withPort(19530).build();
}@PostConstruct
public void initMilvus() {// 創建集合milvusClient.createCollection("my_collection", 128, 1024);// 創建索引milvusClient.createIndex("my_collection", "IVF_FLAT", 128, 1024);
}

結合多種數據源

在某些場景下，可能需要結合多種數據源進行RAG。例如，結合Milvus和Elasticsearch進行檢索：

@GetMapping("/chat/rag")
public String chatRag(@RequestParam String message) {// 從Milvus檢索相關上下文信息List<String> contexts = milvusClient.search(message);// 從Elasticsearch檢索相關上下文信息List<String> esContexts = elasticsearchClient.search(message);// 將上下文信息作為提示詞的一部分傳遞給AI大模型return chatClient.prompt().system("你是一個AI智能應用").user(message).context(contexts).context(esContexts).call().content();
}

（五）多模態應用

多模態應用是指結合文本、圖像、語音等多種模態的應用。通過調用支持多模態的大模型，可以實現更豐富的功能。

文生圖

通過調用大模型的文生圖功能，根據文本描述生成圖像。例如，使用OpenAI的DALL·E模型：

@GetMapping("/generate/image")
public String generateImage(@RequestParam String prompt) {// 調用OpenAI的DALL·E模型生成圖像String imageUrl = openaiClient.generateImage(prompt);return imageUrl;
}

文生語音

通過調用大模型的文生語音功能，根據文本生成語音。例如，使用Google Text-to-Speech API：

@GetMapping("/generate/voice")
public String generateVoice(@RequestParam String text) {// 調用Google Text-to-Speech API生成語音String voiceUrl = googleTtsClient.generateVoice(text);return voiceUrl;
}

多模態交互

在某些場景下，可能需要實現多模態交互。例如，用戶可以通過語音輸入，AI大模型生成文本回答并顯示圖像。可以通過結合語音識別、文本生成和圖像生成實現多模態交互：

@GetMapping("/multimodal/interaction")
public String multimodalInteraction(@RequestParam String voice) {// 調用語音識別API將語音轉換為文本String text = voiceRecognitionClient.recognize(voice);// 調用AI大模型生成文本回答String responseText = chatClient.prompt().system("你是一個AI智能應用").user(text).call().content();// 調用文生圖功能生成圖像String imageUrl = openaiClient.generateImage(responseText);// 返回文本回答和圖像鏈接return "Text: " + responseText + "
Image: " + imageUrl;
}

五、高級功能

（一）函數調用

函數調用是AI大模型的一個高級功能，允許模型調用外部函數來完成復雜的任務。

函數調用的實現

通過定義函數接口，允許AI大模型調用外部函數。例如，定義一個天氣查詢函數：

@Service
public class WeatherService {public String getWeather(String city) {// 調用天氣API獲取天氣信息return weatherApiClient.getWeather(city);}
}

在AI大模型的調用中，允許模型調用WeatherService的getWeather函數：

@GetMapping("/chat/function")
public String chatFunction(@RequestParam String message) {return chatClient.prompt().system("你是一個AI智能應用").user(message).function("getWeather", new WeatherService()).call().content();
}

函數調用的優化

在函數調用中，可能需要對調用結果進行優化，例如緩存結果、限制調用頻率等。可以通過在函數接口中添加邏輯來實現。例如：

@Service
public class WeatherService {private final Cache<String, String> cache = new LRUCache<>(100);public String getWeather(String city) {// 檢查緩存if (cache.containsKey(city)) {return cache.get(city);}// 調用天氣API獲取天氣信息String weather = weatherApiClient.getWeather(city);// 緩存結果cache.put(city, weather);return weather;}
}

（二）結構化輸出

結構化輸出是指將AI大模型的非結構化文本輸出轉換為結構化的數據格式，例如JSON、XML等。

結構化輸出的實現

通過定義結構化輸出的模板，將AI大模型的輸出轉換為結構化的數據。例如，定義一個JSON模板：

@GetMapping("/chat/structured")
public String chatStructured(@RequestParam String message) {String response = chatClient.prompt().system("你是一個AI智能應用").user(message).call().content();// 將文本輸出轉換為JSON格式Map<String, String> result = new HashMap<>();result.put("message", message);result.put("response", response);return new Gson().toJson(result);
}

結構化輸出的優化

在結構化輸出中，可能需要對輸出數據進行優化，例如提取關鍵信息、過濾無關內容等。可以通過在模板中添加邏輯來實現。例如：

@GetMapping("/chat/structured")
public String chatStructured(@RequestParam String message) {String response = chatClient.prompt().system("你是一個AI智能應用").user(message).call().content();// 提取關鍵信息String keyInfo = extractKeyInfo(response);// 將文本輸出轉換為JSON格式Map<String, String> result = new HashMap<>();result.put("message", message);result.put("response", response);result.put("keyInfo", keyInfo);return new Gson().toJson(result);
}private String extractKeyInfo(String response) {// 提取關鍵信息的邏輯return response.replaceAll("[^a-zA-Z0-9]", "");
}

（三）安全性

在構建AI應用時，安全性是非常重要的。需要保護API Key，防止惡意攻擊，并對用戶輸入進行過濾。

保護API Key

不要將API Key直接硬編碼在代碼中，而是通過配置文件或環境變量進行管理。例如，在application.yml文件中配置API Key：
```
spring:ai:openai:api-key: ${OPENAI_API_KEY}
```
在運行應用時，通過環境變量設置API Key：
```
export OPENAI_API_KEY=YOUR_API_KEY
```

防止惡意攻擊

對用戶輸入進行過濾，防止SQL注入、XSS攻擊等。可以通過使用正則表達式或安全庫來實現。例如：

@GetMapping("/chat")
public String chat(@RequestParam String message) {// 對用戶輸入進行過濾message = sanitizeInput(message);return chatClient.prompt().system("你是一個AI智能應用").user(message).call().content();
}private String sanitizeInput(String input) {// 使用正則表達式過濾特殊字符return input.replaceAll("[^a-zA-Z0-9]", "");
}

限制調用頻率

為了避免惡意用戶頻繁調用API，可以限制調用頻率。例如，使用RateLimiter庫限制調用頻率：

@Service
public class RateLimiterService {private final RateLimiter rateLimiter = RateLimiter.create(10); // 每秒最多10次調用public boolean tryAcquire() {return rateLimiter.tryAcquire();}
}

在接口中使用RateLimiterService：

@GetMapping("/chat")
public String chat(@RequestParam String message) {if (!rateLimiterService.tryAcquire()) {throw new TooManyRequestsException("Too many requests");}return chatClient.prompt().system("你是一個AI智能應用").user(message).call().content();
}

六、測試與優化

（一）接口測試

在開發過程中，需要對API接口進行測試，確保功能正常。

使用Postman測試

Postman是一款流行的API測試工具，支持發送HTTP請求、查看響應等功能。在Postman中創建一個請求，設置請求方法、URL、參數等，然后發送請求并查看響應。

使用curl測試

curl是一個命令行工具，用于發送HTTP請求。例如，測試/ai/chat接口：
```
curl -X GET "http://localhost:8080/ai/chat?message=Hello, how are you?"
```

編寫單元測試

使用JUnit等測試框架編寫單元測試，測試接口的功能。例如：

@SpringBootTest
@AutoConfigureMockMvc
public class ChatControllerTest {@Autowiredprivate MockMvc mockMvc;@Testpublic void testChat() throws Exception {mockMvc.perform(MockMvcRequestBuilders.get("/ai/chat").param("message", "Hello, how are you?")).andExpect(MockMvcResultMatchers.status().isOk()).andExpect(MockMvcResultMatchers.content().string(containsString("Hello")));}
}

（二）性能優化

在生產環境中，性能優化非常重要。需要優化API調用的性能，減少響應時間。

減少API調用次數

通過緩存結果、合并請求等方式減少API調用次數。例如，使用Cache庫緩存結果：

@Service
public class ChatService {private final Cache<String, String> cache = new LRUCache<>(100);public String chat(String message) {if (cache.containsKey(message)) {return cache.get(message);}String response = chatClient.prompt().system("你是一個AI智能應用").user(message).call().content();cache.put(message, response);return response;}
}

優化API調用性能

通過調整API調用的參數、優化網絡連接等方式提升API調用性能。例如，設置API調用的超時時間：

@Bean
public ChatClient chatClient() {return new ChatClient.Builder().defaultSystem("你是一個AI智能應用").timeout(5000) // 設置超時時間為5秒.build();
}

異步調用

在某些場景下，可以使用異步調用提升性能。例如，使用CompletableFuture實現異步調用：

@GetMapping("/chat/async")
public CompletableFuture<String> chatAsync(@RequestParam String message) {return CompletableFuture.supplyAsync(() -> {return chatClient.prompt().system("你是一個AI智能應用").user(message).call().content();});
}

（三）安全性

在生產環境中，安全性非常重要。需要保護API Key，防止惡意攻擊，并對用戶輸入進行過濾。

保護API Key

不要將API Key直接硬編碼在代碼中，而是通過配置文件或環境變量進行管理。例如，在application.yml文件中配置API Key：
```
spring:ai:openai:api-key: ${OPENAI_API_KEY}
```
在運行應用時，通過環境變量設置API Key：
```
export OPENAI_API_KEY=YOUR_API_KEY
```

防止惡意攻擊

對用戶輸入進行過濾，防止SQL注入、XSS攻擊等。可以通過使用正則表達式或安全庫來實現。例如：

@GetMapping("/chat")
public String chat(@RequestParam String message) {// 對用戶輸入進行過濾message = sanitizeInput(message);return chatClient.prompt().system("你是一個AI智能應用").user(message).call().content();
}private String sanitizeInput(String input) {// 使用正則表達式過濾特殊字符return input.replaceAll("[^a-zA-Z0-9]", "");
}

限制調用頻率

為了避免惡意用戶頻繁調用API，可以限制調用頻率。例如，使用RateLimiter庫限制調用頻率：

@Service
public class RateLimiterService {private final RateLimiter rateLimiter = RateLimiter.create(10); // 每秒最多10次調用public boolean tryAcquire() {return rateLimiter.tryAcquire();}
}

在接口中使用RateLimiterService：

@GetMapping("/chat")
public String chat(@RequestParam String message) {if (!rateLimiterService.tryAcquire()) {throw new TooManyRequestsException("Too many requests");}return chatClient.prompt().system("你是一個AI智能應用").user(message).call().content();
}

七、項目實踐

（一）構建完整的AI應用

在前面的章節中，我們已經學習了如何使用Spring Boot和Spring AI框架構建AI應用。現在，我們將通過一個完整的項目實踐，將這些知識應用到實際中。

1. 項目需求

假設我們需要構建一個智能客服系統，用戶可以通過發送文本消息與客服進行對話。系統需要支持以下功能：

智能對話：用戶可以發送文本消息，系統根據消息內容生成回答。
多輪對話：系統可以維護對話歷史，生成連貫的回答。
角色預設：系統可以根據用戶輸入動態切換角色，例如“智能客服”、“寫作助手”等。
流式響應：系統可以逐步顯示生成的文本內容。
檢索增強生成（RAG）：系統可以結合外部數據源生成更準確的回答。
多模態應用：系統可以支持文生圖、文生語音等功能。
函數調用：系統可以調用外部函數完成復雜任務。
結構化輸出：系統可以將非結構化文本輸出轉換為結構化的數據格式。

2. 項目設計

根據項目需求，我們可以設計以下模塊：

用戶接口模塊：提供用戶與系統交互的接口。
對話管理模塊：維護對話歷史，生成連貫的回答。
角色管理模塊：動態切換角色，生成符合角色的回答。
流式響應模塊：逐步顯示生成的文本內容。
RAG模塊：結合外部數據源生成更準確的回答。
多模態模塊：支持文生圖、文生語音等功能。
函數調用模塊：調用外部函數完成復雜任務。
結構化輸出模塊：將非結構化文本輸出轉換為結構化的數據格式。

3. 項目實現

以下是項目實現的代碼示例：

（1）用戶接口模塊

@RestController
@RequestMapping("/ai")
public class ChatController {private final ChatClient chatClient;private final RateLimiterService rateLimiterService;private final Map<String, ChatSession> sessions = new ConcurrentHashMap<>();public ChatController(ChatClient chatClient, RateLimiterService rateLimiterService) {this.chatClient = chatClient;this.rateLimiterService = rateLimiterService;}@GetMapping("/chat")public String chat(@RequestParam String sessionId, @RequestParam String message) {if (!rateLimiterService.tryAcquire()) {throw new TooManyRequestsException("Too many requests");}ChatSession session = sessions.computeIfAbsent(sessionId, ChatSession::new);return session.sendMessage(message);}@GetMapping("/chat/stream")public Flux<ServerSentEvent<String>> chatStream(@RequestParam String sessionId, @RequestParam String message) {if (!rateLimiterService.tryAcquire()) {throw new TooManyRequestsException("Too many requests");}ChatSession session = sessions.computeIfAbsent(sessionId, ChatSession::new);return Flux.create(sink -> {chatClient.prompt().system("你是一個智能客服，提供專業的服務").messages(session.getHistory()).stream().forEach(response -> {sink.next(ServerSentEvent.builder(response.content()).build());});});}
}

（2）對話管理模塊

public class ChatSession {private final List<Message> history = new ArrayList<>();public String sendMessage(String message) {// 將用戶消息添加到歷史記錄history.add(new Message("user", message));// 生成回答String response = chatClient.prompt().system("你是一個智能客服，提供專業的服務").messages(history).call().content();// 將AI回答添加到歷史記錄history.add(new Message("assistant", response));return response;}public List<Message> getHistory() {return history;}
}

（3）角色管理模塊

@GetMapping("/chat/role")
public String chatRole(@RequestParam String role, @RequestParam String message) {String systemRole = "你是一個智能客服，提供專業的服務";if ("writer".equals(role)) {systemRole = "你是一個寫作助手，幫助用戶生成文章";} else if ("teacher".equals(role)) {systemRole = "你是一個智能教育助手，提供學習建議";}return chatClient.prompt().system(systemRole).user(message).call().content();
}

（4）流式響應模塊

@GetMapping("/chat/stream")
public Flux<ServerSentEvent<String>> chatStream(@RequestParam String message) {return Flux.create(sink -> {chatClient.prompt().user(message).stream().forEach(response -> {sink.next(ServerSentEvent.builder(response.content()).build());});});
}

（5）RAG模塊

@GetMapping("/chat/rag")
public String chatRag(@RequestParam String message) {// 從Milvus檢索相關上下文信息List<String> contexts = milvusClient.search(message);// 將上下文信息作為提示詞的一部分傳遞給AI大模型return chatClient.prompt().system("你是一個AI智能應用").user(message).context(contexts).call().content();
}

（6）多模態模塊

@GetMapping("/generate/image")
public String generateImage(@RequestParam String prompt) {// 調用OpenAI的DALL·E模型生成圖像String imageUrl = openaiClient.generateImage(prompt);return imageUrl;
}@GetMapping("/generate/voice")
public String generateVoice(@RequestParam String text) {// 調用Google Text-to-Speech API生成語音String voiceUrl = googleTtsClient.generateVoice(text);return voiceUrl;
}

（7）函數調用模塊

@GetMapping("/chat/function")
public String chatFunction(@RequestParam String message) {return chatClient.prompt().system("你是一個AI智能應用").user(message).function("getWeather", new WeatherService()).call().content();
}

（8）結構化輸出模塊

@GetMapping("/chat/structured")
public String chatStructured(@RequestParam String message) {String response = chatClient.prompt().system("你是一個AI智能應用").user(message).call().content();// 將文本輸出轉換為JSON格式Map<String, String> result = new HashMap<>();result.put("message", message);result.put("response", response);return new Gson().toJson(result);
}