如何用 Spring AI 構建 MCP Client - Server 架構
在當今這個科技飛速發(fā)展的時代，人工智能就像一陣狂風，席卷了各個領域。而在 Java 開發(fā)的世界里，Spring 家族又添一員猛將 ——Spring AI。今天，咱們就來嘮嘮如何借助 Spring AI 這股 “東風”，打造一個超酷的 MCP Client - Server 架構。啥？你還不知道 MCP 是啥？別擔心，一會兒就給你講得明明白白，就像給你揭開一個神秘寶藏的面紗一樣。
啥是 MCP Client - Server 架構
咱先來說說這個 MCP。MCP，全稱 Message - Centric Protocol，翻譯過來就是 “以消息為中心的協(xié)議”。你可以把它想象成一個超級忙碌的郵局，每天都有大量的信件（也就是消息）在里面進進出出。而 Client - Server 架構呢，就好比是寄信人和收信人。
客戶端（Client）就像那個熱情的寄信人，有啥消息都一股腦地往服務器（Server）這個收信人那里送。服務器收到消息后，就會根據消息的內容進行處理，然后再把處理結果反饋給客戶端，就像收信人看完信后給寄信人回信一樣。
這種架構在很多場景都有應用，比如在線聊天系統(tǒng)，你發(fā)的每一條消息就是通過 Client - Server 架構，從你的客戶端飛到服務器，再從服務器飛到對方的客戶端。還有電商系統(tǒng)里的訂單處理，客戶端提交訂單消息，服務器處理訂單，然后返回訂單狀態(tài)給客戶端。
想象一下，你在網上下單買了一雙心儀的運動鞋，下單消息嗖地一下從你的手機（客戶端）飛到電商平臺的服務器，服務器忙著處理訂單，檢查庫存、計算價格，完事兒再把訂單處理結果，比如訂單已確認、正在發(fā)貨等消息，又嗖地飛回到你的手機上，這背后就是 MCP Client - Server 架構在默默運作。
Spring AI 閃亮登場
好了，了解了 MCP Client - Server 架構，接下來主角 Spring AI 就要上場啦！Spring AI 就像是一個超級厲害的工匠，專門為咱們打造與人工智能相關的應用。它提供了一系列的工具和組件，讓咱們在 Java 開發(fā)中使用人工智能變得像搭積木一樣簡單。
想象一下，你是一個建筑師，要蓋一座房子。以前，你得一塊磚一塊磚地慢慢壘，現在有了 Spring AI 這個神奇的工具，它給你提供了各種預制好的建筑模塊，你只需要按照自己的想法把它們組裝起來，就能快速蓋出一座漂亮的房子。Spring AI 就是這樣，它整合了各種流行的人工智能框架和技術，讓咱們這些 Java 開發(fā)者能輕松地把人工智能融入到自己的項目中。
比如說，你想在項目里實現智能客服功能，要是沒有 Spring AI，你可能得費好大勁去研究各種人工智能算法，自己搭建模型、訓練數據，這過程就像從原材料開始自己造每一塊磚。但有了 Spring AI，它已經把很多常用的人工智能功能封裝好了，你只需要像搭積木一樣，把相關的組件組合起來，就能快速讓智能客服跑起來，是不是超厲害！
搭建基礎環(huán)境
在開始搭建 MCP Client - Server 架構之前，咱們得先把基礎環(huán)境準備好，這就好比你要做飯，得先把鍋碗瓢盆、食材調料都準備齊全。
首先，你得確保自己的開發(fā)環(huán)境里有 Java。要是沒有，趕緊去 Oracle 官網或者 OpenJDK 官網下載安裝，就像去超市采購必備的食材一樣。安裝好 Java 后，還得有一個趁手的開發(fā)工具，比如 IntelliJ IDEA 或者 Eclipse，這就像是廚師得有一把好用的菜刀。
接下來，就是引入 Spring AI 的相關依賴。如果你用的是 Maven，那就打開你的pom.xml文件，在里面加上這么一段：
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring - ai - core</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring - ai - client</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring - ai - server</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring - ai - core</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring - ai - client</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring - ai - server</artifactId>
<version>1.0.0</version>
</dependency>這就相當于你給項目發(fā)了一份 “購物清單”，讓它去下載 Spring AI 的核心組件、客戶端組件和服務器組件。要是你用 Gradle，那 “購物清單” 就得換個寫法：
implementation 'org.springframework.ai:spring - ai - core:1.0.0'
implementation 'org.springframework.ai:spring - ai - client:1.0.0'
implementation 'org.springframework.ai:spring - ai - server:1.0.0'
implementation 'org.springframework.ai:spring - ai - core:1.0.0'
implementation 'org.springframework.ai:spring - ai - client:1.0.0'
implementation 'org.springframework.ai:spring - ai - server:1.0.0'有了這些依賴，咱們就可以開始搭建架構啦！
構建服務器端
咱們先從服務器端開始搭建，就像蓋房子得先打好地基一樣。
首先，創(chuàng)建一個 Spring Boot 項目。這一步很簡單，去 Spring Initializr 官網，按照提示選好項目的相關信息，比如項目名稱、包名、Spring Boot 版本，還有剛剛加的 Spring AI 依賴，然后下載項目壓縮包，解壓到你喜歡的地方。這就好比你在網上定制了一個房子的設計圖，然后把圖紙下載下來準備開工。
打開你的開發(fā)工具，導入這個項目。接下來，創(chuàng)建一個服務器配置類，咱們就叫它ServerConfig吧。在這個類里，咱們要配置一些服務器相關的東西，就像給房子規(guī)劃布局一樣。
import org.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.ai.server.AiServer;
importorg.springframework.ai.server.SimpleAiServer;
@Configuration
public class ServerConfig {
@Bean
public AiServer aiServer() {
returnnewSimpleAiServer();
}
}這里咱們創(chuàng)建了一個簡單的AiServer實例，SimpleAiServer是 Spring AI 提供的一個基礎服務器實現。當然，在實際項目中，你可能需要根據具體需求選擇更復雜的服務器實現，這就像你可以根據自己的喜好選擇不同風格的房子。比如說，當你的業(yè)務量特別大，需要處理海量消息時，可能就需要一個支持分布式部署、具備強大負載均衡能力的服務器實現，而不是簡單的SimpleAiServer。
接下來，咱們得讓服務器能處理客戶端發(fā)來的消息。創(chuàng)建一個消息處理類，比如MessageHandler：
import org.springframework.ai.message.AiMessage;
import org.springframework.ai.message.AiMessageHandler;
import org.springframework.stereotype.Component;
@Component
publicclass MessageHandler implements AiMessageHandler {
@Override
public AiMessage handle(AiMessage message) {
// 這里處理收到的消息
String content = message.getContent();
// 簡單處理，把消息內容大寫后返回
String responseContent = content.toUpperCase();
returnnew AiMessage(responseContent);
}
}
import org.springframework.ai.message.AiMessage;
import org.springframework.ai.message.AiMessageHandler;
import org.springframework.stereotype.Component;
@Component
publicclass MessageHandler implements AiMessageHandler {
@Override
public AiMessage handle(AiMessage message) {
// 這里處理收到的消息
String content = message.getContent();
// 簡單處理，把消息內容大寫后返回
String responseContent = content.toUpperCase();
returnnew AiMessage(responseContent);
}
}這個類實現了AiMessageHandler接口，里面的handle方法就是用來處理客戶端發(fā)來的消息的。在這個例子里，咱們簡單地把收到的消息內容轉換成大寫后返回，就像你收到一封信，把信的內容用大寫字母抄一遍再寄回去一樣。實際項目中，這里可以進行各種復雜的業(yè)務邏輯處理，比如調用人工智能模型進行數據分析、文本生成等等。
比如在一個智能營銷系統(tǒng)中，服務器收到用戶瀏覽商品的消息，就可以調用人工智能模型分析用戶的興趣偏好，然后根據分析結果給用戶推薦相關商品，再把推薦結果返回給客戶端。
最后，啟動咱們的服務器。在 Spring Boot 項目的主類里，有一個main方法，運行這個方法，服務器就啟動啦！就像你按下了房子的電源開關，所有的設備都開始運轉起來。
構建客戶端
服務器搭好了，接下來就是客戶端啦。客戶端就像是房子的大門，負責把消息送出去，也負責接收服務器的回信。
同樣在項目里創(chuàng)建一個客戶端配置類，叫ClientConfig：
import org.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.ai.client.AiClient;
importorg.springframework.ai.client.SimpleAiClient;
@Configuration
public class ClientConfig {
@Bean
public AiClient aiClient() {
returnnewSimpleAiClient();
}
}
import org.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.ai.client.AiClient;
importorg.springframework.ai.client.SimpleAiClient;
@Configuration
public class ClientConfig {
@Bean
public AiClient aiClient() {
returnnewSimpleAiClient();
}
}這里創(chuàng)建了一個簡單的AiClient實例，SimpleAiClient是 Spring AI 提供的基礎客戶端實現。
然后，創(chuàng)建一個客戶端消息發(fā)送類，比如MessageSender：
import org.springframework.ai.client.AiClient;
import org.springframework.ai.message.AiMessage;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
publicclass MessageSender {
@Resource
private AiClient aiClient;
publicString sendMessage(String message) {
AiMessage aiMessage = new AiMessage(message);
AiMessage response = aiClient.send(aiMessage);
return response.getContent();
}
}
import org.springframework.ai.client.AiClient;
import org.springframework.ai.message.AiMessage;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
publicclass MessageSender {
@Resource
private AiClient aiClient;
publicString sendMessage(String message) {
AiMessage aiMessage = new AiMessage(message);
AiMessage response = aiClient.send(aiMessage);
return response.getContent();
}
}這個類里的sendMessage方法就是用來發(fā)送消息的。它先創(chuàng)建一個AiMessage對象，把要發(fā)送的消息放進去，然后通過AiClient把消息發(fā)送出去，再接收服務器返回的消息，最后把服務器返回的消息內容返回給調用者。這就好比你寫好一封信，裝進信封，通過郵局寄出去，然后等著收信人的回信，收到回信后把信的內容讀出來告訴別人。
現在，咱們可以在一個測試類里測試一下客戶端和服務器的通信啦。創(chuàng)建一個測試類，比如ClientServerTest：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
public class ClientServerTest {
@Autowired
private MessageSender messageSender;
public void testCommunication() {
String message = "Hello, Spring AI!";
String response = messageSender.sendMessage(message);
System.out.println("Sent: " + message);
System.out.println("Received: " + response);
}
}
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
public class ClientServerTest {
@Autowired
private MessageSender messageSender;
public void testCommunication() {
String message = "Hello, Spring AI!";
String response = messageSender.sendMessage(message);
System.out.println("Sent: " + message);
System.out.println("Received: " + response);
}
}運行這個測試方法，你會看到控制臺輸出你發(fā)送的消息和服務器返回的消息。如果一切順利，你會看到服務器返回的消息是你發(fā)送的消息的大寫形式，這說明客戶端和服務器之間的通信成功啦！就像你成功地和遠方的朋友通過信件交流了一樣。
深入優(yōu)化與擴展
到這里，咱們已經搭建好了一個基本的 MCP Client - Server 架構，并且能實現簡單的消息通信。但是，這就像你蓋好了一座毛坯房，還得進行裝修和擴建，才能讓它變得更舒適、更強大。
性能優(yōu)化
在實際應用中，服務器可能會收到大量的消息，這時候性能就變得非常重要。咱們可以從幾個方面來優(yōu)化性能。
首先，緩存是個好東西。就像你在家里把常用的東西放在一個容易拿到的地方，服務器也可以把一些常用的處理結果緩存起來。比如，如果有一些消息處理的結果是固定不變的，或者在一段時間內不會變，就可以把這些結果緩存起來，下次再收到相同的消息時，直接從緩存里取結果，不用再重新處理。
在 Spring AI 里，可以使用一些緩存框架，比如 Redis，來實現緩存功能。假設你的服務器經常處理一些商品信息查詢的消息，而商品信息在一段時間內基本不變，就可以把查詢結果緩存到 Redis 中。當再次收到相同商品信息查詢的消息時，直接從 Redis 中獲取結果返回給客戶端，大大減少處理時間。
其次，多線程處理也能大大提高性能。就像一個餐廳有多個服務員同時服務顧客一樣，服務器也可以開啟多個線程來同時處理消息。Spring Boot 本身就對多線程有很好的支持，咱們可以通過配置線程池來管理線程。在服務器配置類里，可以這樣配置線程池：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.ai.server.AiServer;
import org.springframework.ai.server.SimpleAiServer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
@Configuration
publicclass ServerConfig {
@Bean
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(5);
executor.setMaxPoolSize(10);
executor.setQueueCapacity(25);
executor.initialize();
return executor;
}
@Bean
public AiServer aiServer() {
returnnew SimpleAiServer();
}
}
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.ai.server.AiServer;
import org.springframework.ai.server.SimpleAiServer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
@Configuration
publicclass ServerConfig {
@Bean
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(5);
executor.setMaxPoolSize(10);
executor.setQueueCapacity(25);
executor.initialize();
return executor;
}
@Bean
public AiServer aiServer() {
returnnew SimpleAiServer();
}
}這里配置了一個線程池，有 5 個核心線程，最多可以擴展到 10 個線程，任務隊列容量是 25。這樣，服務器就可以同時處理多個消息，提高處理效率。比如說，當有大量用戶同時發(fā)送消息時，線程池里的多個線程可以同時處理這些消息，避免出現排隊等待時間過長的情況。
安全加固
在網絡世界里，安全就像房子的門鎖，非常重要。咱們得確保客戶端和服務器之間傳輸的消息不被竊取、篡改。
一種常見的方法是使用加密技術。就像你把重要的信件放在一個帶鎖的信封里一樣，咱們可以對消息進行加密后再傳輸。在 Spring AI 里，可以使用一些加密算法，比如 AES（高級加密標準）。可以創(chuàng)建一個加密工具類，對消息進行加密和解密：
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
publicclass EncryptionUtil {
privatestaticfinal String ALGORITHM = "AES";
privatestatic SecretKey secretKey;
static {
try {
KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
keyGenerator.init(256);
secretKey = keyGenerator.generateKey();
} catch (Exception e) {
e.printStackTrace();
}
}
public static String encrypt(String message) {
try {
Cipher cipher = Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] encryptedBytes = cipher.doFinal(message.getBytes(StandardCharsets.UTF_8));
return Base64.getEncoder().encodeToString(encryptedBytes);
} catch (Exception e) {
e.printStackTrace();
returnnull;
}
}
public static String decrypt(String encryptedMessage) {
try {
Cipher cipher = Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, secretKey);
byte[] decodedBytes = Base64.getDecoder().decode(encryptedMessage);
byte[] decryptedBytes = cipher.doFinal(decodedBytes);
returnnew String(decryptedBytes, StandardCharsets.UTF_8);
} catch (Exception e) {
e.printStackTrace();
returnnull;
}
}
}
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
publicclass EncryptionUtil {
privatestaticfinal String ALGORITHM = "AES";
privatestatic SecretKey secretKey;
static {
try {
KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
keyGenerator.init(256);
secretKey = keyGenerator.generateKey();
} catch (Exception e) {
e.printStackTrace();
}
}
public static String encrypt(String message) {
try {
Cipher cipher = Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] encryptedBytes = cipher.doFinal(message.getBytes(StandardCharsets.UTF_8));
return Base64.getEncoder().encodeToString(encryptedBytes);
} catch (Exception e) {
e.printStackTrace();
returnnull;
}
}
public static String decrypt(String encryptedMessage) {
try {
Cipher cipher = Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, secretKey);
byte[] decodedBytes = Base64.getDecoder().decode(encryptedMessage);
byte[] decryptedBytes = cipher.doFinal(decodedBytes);
returnnew String(decryptedBytes, StandardCharsets.UTF_8);
} catch (Exception e) {
e.printStackTrace();
returnnull;
}
}
}在客戶端發(fā)送消息前，先對消息進行加密：
import org.springframework.ai.client.AiClient;
import org.springframework.ai.message.AiMessage;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
publicclass MessageSender {
@Resource
private AiClient aiClient;
publicString sendMessage(String message) {
String encryptedMessage = EncryptionUtil.encrypt(message);
AiMessage aiMessage = new AiMessage(encryptedMessage);
AiMessage response = aiClient.send(aiMessage);
String decryptedResponse = EncryptionUtil.decrypt(response.getContent());
return decryptedResponse;
}
}
import org.springframework.ai.client.AiClient;
import org.springframework.ai.message.AiMessage;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
publicclass MessageSender {
@Resource
private AiClient aiClient;
publicString sendMessage(String message) {
String encryptedMessage = EncryptionUtil.encrypt(message);
AiMessage aiMessage = new AiMessage(encryptedMessage);
AiMessage response = aiClient.send(aiMessage);
String decryptedResponse = EncryptionUtil.decrypt(response.getContent());
return decryptedResponse;
}
}在服務器端收到消息后，先對消息進行解密，處理完后再對返回的消息進行加密：
import org.springframework.ai.message.AiMessage;
import org.springframework.ai.message.AiMessageHandler;
import org.springframework.stereotype.Component;
@Component
publicclass MessageHandler implements AiMessageHandler {
@Override
public AiMessage handle(AiMessage message) {
String encryptedContent = message.getContent();
String content = EncryptionUtil.decrypt(encryptedContent);
// 處理消息
String responseContent = content.toUpperCase();
String encryptedResponse = EncryptionUtil.encrypt(responseContent);
returnnew AiMessage(encryptedResponse);
}
}這樣，消息在傳輸過程中就更加安全啦。想象一下，如果沒有加密，黑客就有可能在消息傳輸途中截獲消息，篡改訂單金額、商品信息等重要內容，后果不堪設想。而有了加密技術，就像給消息穿上了一層堅固的鎧甲，能有效保護消息的安全。
總結
到這里，我們已經全面地了解了如何使用 Spring AI 構建 MCP Client - Server 架構。從基礎環(huán)境搭建，到服務器端與客戶端的構建，再到性能優(yōu)化、安全加固，每一步都為我們打造強大而靈活的應用系統(tǒng)奠定了堅實基礎。
通過 Spring AI 的助力，原本復雜的人工智能集成變得簡單高效，就像給我們的開發(fā)工作安裝了一個強力引擎。在未來的項目開發(fā)中，無論是構建智能物聯網系統(tǒng)，讓設備間的消息交互更智能；還是打造智能金融風控平臺，借助不同人工智能模型對風險消息進行精準分析，這個架構都能發(fā)揮巨大作用。
希望大家在實際開發(fā)中，能夠充分運用今天所學的知識，將 Spring AI 與 MCP Client - Server 架構巧妙融合，創(chuàng)造出更多創(chuàng)新且實用的應用。說不定哪天，你用這個架構搭建的智能應用，就會像一陣旋風，在行業(yè)里掀起新的技術潮流呢！加油，各位 Java 開發(fā)者們，去盡情釋放 Spring AI 與 MCP Client - Server 架構的無限潛力吧！
