如何用 Spring AI 構(gòu)建 MCP Client - Server 架構(gòu)
在當(dāng)今這個科技飛速發(fā)展的時代，人工智能就像一陣狂風(fēng)，席卷了各個領(lǐng)域。而在 Java 開發(fā)的世界里，Spring 家族又添一員猛將 ——Spring AI。今天，咱們就來嘮嘮如何借助 Spring AI 這股 “東風(fēng)”，打造一個超酷的 MCP Client - Server 架構(gòu)。啥？你還不知道 MCP 是啥？別擔(dān)心，一會兒就給你講得明明白白，就像給你揭開一個神秘寶藏的面紗一樣。
啥是 MCP Client - Server 架構(gòu)
咱先來說說這個 MCP。MCP，全稱 Message - Centric Protocol，翻譯過來就是 “以消息為中心的協(xié)議”。你可以把它想象成一個超級忙碌的郵局，每天都有大量的信件（也就是消息）在里面進進出出。而 Client - Server 架構(gòu)呢，就好比是寄信人和收信人。
客戶端（Client）就像那個熱情的寄信人，有啥消息都一股腦地往服務(wù)器（Server）這個收信人那里送。服務(wù)器收到消息后，就會根據(jù)消息的內(nèi)容進行處理，然后再把處理結(jié)果反饋給客戶端，就像收信人看完信后給寄信人回信一樣。
這種架構(gòu)在很多場景都有應(yīng)用，比如在線聊天系統(tǒng)，你發(fā)的每一條消息就是通過 Client - Server 架構(gòu)，從你的客戶端飛到服務(wù)器，再從服務(wù)器飛到對方的客戶端。還有電商系統(tǒng)里的訂單處理，客戶端提交訂單消息，服務(wù)器處理訂單，然后返回訂單狀態(tài)給客戶端。
想象一下，你在網(wǎng)上下單買了一雙心儀的運動鞋，下單消息嗖地一下從你的手機（客戶端）飛到電商平臺的服務(wù)器，服務(wù)器忙著處理訂單，檢查庫存、計算價格，完事兒再把訂單處理結(jié)果，比如訂單已確認(rèn)、正在發(fā)貨等消息，又嗖地飛回到你的手機上，這背后就是 MCP Client - Server 架構(gòu)在默默運作。
Spring AI 閃亮登場
好了，了解了 MCP Client - Server 架構(gòu)，接下來主角 Spring AI 就要上場啦！Spring AI 就像是一個超級厲害的工匠，專門為咱們打造與人工智能相關(guān)的應(yīng)用。它提供了一系列的工具和組件，讓咱們在 Java 開發(fā)中使用人工智能變得像搭積木一樣簡單。
想象一下，你是一個建筑師，要蓋一座房子。以前，你得一塊磚一塊磚地慢慢壘，現(xiàn)在有了 Spring AI 這個神奇的工具，它給你提供了各種預(yù)制好的建筑模塊，你只需要按照自己的想法把它們組裝起來，就能快速蓋出一座漂亮的房子。Spring AI 就是這樣，它整合了各種流行的人工智能框架和技術(shù)，讓咱們這些 Java 開發(fā)者能輕松地把人工智能融入到自己的項目中。
比如說，你想在項目里實現(xiàn)智能客服功能，要是沒有 Spring AI，你可能得費好大勁去研究各種人工智能算法，自己搭建模型、訓(xùn)練數(shù)據(jù)，這過程就像從原材料開始自己造每一塊磚。但有了 Spring AI，它已經(jīng)把很多常用的人工智能功能封裝好了，你只需要像搭積木一樣，把相關(guān)的組件組合起來，就能快速讓智能客服跑起來，是不是超厲害！
搭建基礎(chǔ)環(huán)境
在開始搭建 MCP Client - Server 架構(gòu)之前，咱們得先把基礎(chǔ)環(huán)境準(zhǔn)備好，這就好比你要做飯，得先把鍋碗瓢盆、食材調(diào)料都準(zhǔn)備齊全。
首先，你得確保自己的開發(fā)環(huán)境里有 Java。要是沒有，趕緊去 Oracle 官網(wǎng)或者 OpenJDK 官網(wǎng)下載安裝，就像去超市采購必備的食材一樣。安裝好 Java 后，還得有一個趁手的開發(fā)工具，比如 IntelliJ IDEA 或者 Eclipse，這就像是廚師得有一把好用的菜刀。
接下來，就是引入 Spring AI 的相關(guān)依賴。如果你用的是 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>這就相當(dāng)于你給項目發(fā)了一份 “購物清單”，讓它去下載 Spring AI 的核心組件、客戶端組件和服務(wù)器組件。要是你用 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'有了這些依賴，咱們就可以開始搭建架構(gòu)啦！
構(gòu)建服務(wù)器端
咱們先從服務(wù)器端開始搭建，就像蓋房子得先打好地基一樣。
首先，創(chuàng)建一個 Spring Boot 項目。這一步很簡單，去 Spring Initializr 官網(wǎng)，按照提示選好項目的相關(guān)信息，比如項目名稱、包名、Spring Boot 版本，還有剛剛加的 Spring AI 依賴，然后下載項目壓縮包，解壓到你喜歡的地方。這就好比你在網(wǎng)上定制了一個房子的設(shè)計圖，然后把圖紙下載下來準(zhǔn)備開工。
打開你的開發(fā)工具，導(dǎo)入這個項目。接下來，創(chuàng)建一個服務(wù)器配置類，咱們就叫它ServerConfig吧。在這個類里，咱們要配置一些服務(wù)器相關(guān)的東西，就像給房子規(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 提供的一個基礎(chǔ)服務(wù)器實現(xiàn)。當(dāng)然，在實際項目中，你可能需要根據(jù)具體需求選擇更復(fù)雜的服務(wù)器實現(xiàn)，這就像你可以根據(jù)自己的喜好選擇不同風(fēng)格的房子。比如說，當(dāng)你的業(yè)務(wù)量特別大，需要處理海量消息時，可能就需要一個支持分布式部署、具備強大負(fù)載均衡能力的服務(wù)器實現(xiàn)，而不是簡單的SimpleAiServer。
接下來，咱們得讓服務(wù)器能處理客戶端發(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();
// 簡單處理，把消息內(nèi)容大寫后返回
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();
// 簡單處理，把消息內(nèi)容大寫后返回
String responseContent = content.toUpperCase();
returnnew AiMessage(responseContent);
}
}這個類實現(xiàn)了AiMessageHandler接口，里面的handle方法就是用來處理客戶端發(fā)來的消息的。在這個例子里，咱們簡單地把收到的消息內(nèi)容轉(zhuǎn)換成大寫后返回，就像你收到一封信，把信的內(nèi)容用大寫字母抄一遍再寄回去一樣。實際項目中，這里可以進行各種復(fù)雜的業(yè)務(wù)邏輯處理，比如調(diào)用人工智能模型進行數(shù)據(jù)分析、文本生成等等。
比如在一個智能營銷系統(tǒng)中，服務(wù)器收到用戶瀏覽商品的消息，就可以調(diào)用人工智能模型分析用戶的興趣偏好，然后根據(jù)分析結(jié)果給用戶推薦相關(guān)商品，再把推薦結(jié)果返回給客戶端。
最后，啟動咱們的服務(wù)器。在 Spring Boot 項目的主類里，有一個main方法，運行這個方法，服務(wù)器就啟動啦！就像你按下了房子的電源開關(guān)，所有的設(shè)備都開始運轉(zhuǎn)起來。
構(gòu)建客戶端
服務(wù)器搭好了，接下來就是客戶端啦。客戶端就像是房子的大門，負(fù)責(zé)把消息送出去，也負(fù)責(zé)接收服務(wù)器的回信。
同樣在項目里創(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 提供的基礎(chǔ)客戶端實現(xiàn)。
然后，創(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ā)送出去，再接收服務(wù)器返回的消息，最后把服務(wù)器返回的消息內(nèi)容返回給調(diào)用者。這就好比你寫好一封信，裝進信封，通過郵局寄出去，然后等著收信人的回信，收到回信后把信的內(nèi)容讀出來告訴別人。
現(xiàn)在，咱們可以在一個測試類里測試一下客戶端和服務(wù)器的通信啦。創(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ā)送的消息和服務(wù)器返回的消息。如果一切順利，你會看到服務(wù)器返回的消息是你發(fā)送的消息的大寫形式，這說明客戶端和服務(wù)器之間的通信成功啦！就像你成功地和遠(yuǎn)方的朋友通過信件交流了一樣。
深入優(yōu)化與擴展
到這里，咱們已經(jīng)搭建好了一個基本的 MCP Client - Server 架構(gòu)，并且能實現(xiàn)簡單的消息通信。但是，這就像你蓋好了一座毛坯房，還得進行裝修和擴建，才能讓它變得更舒適、更強大。
性能優(yōu)化
在實際應(yīng)用中，服務(wù)器可能會收到大量的消息，這時候性能就變得非常重要。咱們可以從幾個方面來優(yōu)化性能。
首先，緩存是個好東西。就像你在家里把常用的東西放在一個容易拿到的地方，服務(wù)器也可以把一些常用的處理結(jié)果緩存起來。比如，如果有一些消息處理的結(jié)果是固定不變的，或者在一段時間內(nèi)不會變，就可以把這些結(jié)果緩存起來，下次再收到相同的消息時，直接從緩存里取結(jié)果，不用再重新處理。
在 Spring AI 里，可以使用一些緩存框架，比如 Redis，來實現(xiàn)緩存功能。假設(shè)你的服務(wù)器經(jīng)常處理一些商品信息查詢的消息，而商品信息在一段時間內(nèi)基本不變，就可以把查詢結(jié)果緩存到 Redis 中。當(dāng)再次收到相同商品信息查詢的消息時，直接從 Redis 中獲取結(jié)果返回給客戶端，大大減少處理時間。
其次，多線程處理也能大大提高性能。就像一個餐廳有多個服務(wù)員同時服務(wù)顧客一樣，服務(wù)器也可以開啟多個線程來同時處理消息。Spring Boot 本身就對多線程有很好的支持，咱們可以通過配置線程池來管理線程。在服務(wù)器配置類里，可以這樣配置線程池：
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 個線程，任務(wù)隊列容量是 25。這樣，服務(wù)器就可以同時處理多個消息，提高處理效率。比如說，當(dāng)有大量用戶同時發(fā)送消息時，線程池里的多個線程可以同時處理這些消息，避免出現(xiàn)排隊等待時間過長的情況。
安全加固
在網(wǎng)絡(luò)世界里，安全就像房子的門鎖，非常重要。咱們得確保客戶端和服務(wù)器之間傳輸?shù)南⒉槐桓`取、篡改。
一種常見的方法是使用加密技術(shù)。就像你把重要的信件放在一個帶鎖的信封里一樣，咱們可以對消息進行加密后再傳輸。在 Spring AI 里，可以使用一些加密算法，比如 AES（高級加密標(biāo)準(zhǔn)）。可以創(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;
}
}在服務(wù)器端收到消息后，先對消息進行解密，處理完后再對返回的消息進行加密：
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);
}
}這樣，消息在傳輸過程中就更加安全啦。想象一下，如果沒有加密，黑客就有可能在消息傳輸途中截獲消息，篡改訂單金額、商品信息等重要內(nèi)容，后果不堪設(shè)想。而有了加密技術(shù)，就像給消息穿上了一層堅固的鎧甲，能有效保護消息的安全。
總結(jié)
到這里，我們已經(jīng)全面地了解了如何使用 Spring AI 構(gòu)建 MCP Client - Server 架構(gòu)。從基礎(chǔ)環(huán)境搭建，到服務(wù)器端與客戶端的構(gòu)建，再到性能優(yōu)化、安全加固，每一步都為我們打造強大而靈活的應(yīng)用系統(tǒng)奠定了堅實基礎(chǔ)。
通過 Spring AI 的助力，原本復(fù)雜的人工智能集成變得簡單高效，就像給我們的開發(fā)工作安裝了一個強力引擎。在未來的項目開發(fā)中，無論是構(gòu)建智能物聯(lián)網(wǎng)系統(tǒng)，讓設(shè)備間的消息交互更智能；還是打造智能金融風(fēng)控平臺，借助不同人工智能模型對風(fēng)險消息進行精準(zhǔn)分析，這個架構(gòu)都能發(fā)揮巨大作用。
希望大家在實際開發(fā)中，能夠充分運用今天所學(xué)的知識，將 Spring AI 與 MCP Client - Server 架構(gòu)巧妙融合，創(chuàng)造出更多創(chuàng)新且實用的應(yīng)用。說不定哪天，你用這個架構(gòu)搭建的智能應(yīng)用，就會像一陣旋風(fēng)，在行業(yè)里掀起新的技術(shù)潮流呢！加油，各位 Java 開發(fā)者們，去盡情釋放 Spring AI 與 MCP Client - Server 架構(gòu)的無限潛力吧！
