如何用 Spring AI 構建 MCP Client - Server 架構

作者：儒猿團隊 2025-03-28 09:33:11

我們已經全面地了解了如何使用 Spring AI 構建 MCP Client - Server 架構。從基礎環境搭建，到服務器端與客戶端的構建，再到性能優化、安全加固，每一步都為我們打造強大而靈活的應用系統奠定了堅實基礎。

在當今這個科技飛速發展的時代，人工智能就像一陣狂風，席卷了各個領域。而在 Java 開發的世界里，Spring 家族又添一員猛將 ——Spring AI。今天，咱們就來嘮嘮如何借助 Spring AI 這股 “東風”，打造一個超酷的 MCP Client - Server 架構。啥？你還不知道 MCP 是啥？別擔心，一會兒就給你講得明明白白，就像給你揭開一個神秘寶藏的面紗一樣。

啥是 MCP Client - Server 架構

咱先來說說這個 MCP。MCP，全稱 Message - Centric Protocol，翻譯過來就是 “以消息為中心的協議”。你可以把它想象成一個超級忙碌的郵局，每天都有大量的信件（也就是消息）在里面進進出出。而 Client - Server 架構呢，就好比是寄信人和收信人。

客戶端（Client）就像那個熱情的寄信人，有啥消息都一股腦地往服務器（Server）這個收信人那里送。服務器收到消息后，就會根據消息的內容進行處理，然后再把處理結果反饋給客戶端，就像收信人看完信后給寄信人回信一樣。

這種架構在很多場景都有應用，比如在線聊天系統，你發的每一條消息就是通過 Client - Server 架構，從你的客戶端飛到服務器，再從服務器飛到對方的客戶端。還有電商系統里的訂單處理，客戶端提交訂單消息，服務器處理訂單，然后返回訂單狀態給客戶端。

想象一下，你在網上下單買了一雙心儀的運動鞋，下單消息嗖地一下從你的手機（客戶端）飛到電商平臺的服務器，服務器忙著處理訂單，檢查庫存、計算價格，完事兒再把訂單處理結果，比如訂單已確認、正在發貨等消息，又嗖地飛回到你的手機上，這背后就是 MCP Client - Server 架構在默默運作。

Spring AI 閃亮登場

好了，了解了 MCP Client - Server 架構，接下來主角 Spring AI 就要上場啦！Spring AI 就像是一個超級厲害的工匠，專門為咱們打造與人工智能相關的應用。它提供了一系列的工具和組件，讓咱們在 Java 開發中使用人工智能變得像搭積木一樣簡單。

想象一下，你是一個建筑師，要蓋一座房子。以前，你得一塊磚一塊磚地慢慢壘，現在有了 Spring AI 這個神奇的工具，它給你提供了各種預制好的建筑模塊，你只需要按照自己的想法把它們組裝起來，就能快速蓋出一座漂亮的房子。Spring AI 就是這樣，它整合了各種流行的人工智能框架和技術，讓咱們這些 Java 開發者能輕松地把人工智能融入到自己的項目中。

比如說，你想在項目里實現智能客服功能，要是沒有 Spring AI，你可能得費好大勁去研究各種人工智能算法，自己搭建模型、訓練數據，這過程就像從原材料開始自己造每一塊磚。但有了 Spring AI，它已經把很多常用的人工智能功能封裝好了，你只需要像搭積木一樣，把相關的組件組合起來，就能快速讓智能客服跑起來，是不是超厲害！

搭建基礎環境

在開始搭建 MCP Client - Server 架構之前，咱們得先把基礎環境準備好，這就好比你要做飯，得先把鍋碗瓢盆、食材調料都準備齊全。

首先，你得確保自己的開發環境里有 Java。要是沒有，趕緊去 Oracle 官網或者 OpenJDK 官網下載安裝，就像去超市采購必備的食材一樣。安裝好 Java 后，還得有一個趁手的開發工具，比如 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>

這就相當于你給項目發了一份 “購物清單”，讓它去下載 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'

有了這些依賴，咱們就可以開始搭建架構啦！

構建服務器端

咱們先從服務器端開始搭建，就像蓋房子得先打好地基一樣。

首先，創建一個 Spring Boot 項目。這一步很簡單，去 Spring Initializr 官網，按照提示選好項目的相關信息，比如項目名稱、包名、Spring Boot 版本，還有剛剛加的 Spring AI 依賴，然后下載項目壓縮包，解壓到你喜歡的地方。這就好比你在網上定制了一個房子的設計圖，然后把圖紙下載下來準備開工。

打開你的開發工具，導入這個項目。接下來，創建一個服務器配置類，咱們就叫它ServerConfig吧。在這個類里，咱們要配置一些服務器相關的東西，就像給房子規劃布局一樣。

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();
    }
}

這里咱們創建了一個簡單的AiServer實例，SimpleAiServer是 Spring AI 提供的一個基礎服務器實現。當然，在實際項目中，你可能需要根據具體需求選擇更復雜的服務器實現，這就像你可以根據自己的喜好選擇不同風格的房子。比如說，當你的業務量特別大，需要處理海量消息時，可能就需要一個支持分布式部署、具備強大負載均衡能力的服務器實現，而不是簡單的SimpleAiServer。

接下來，咱們得讓服務器能處理客戶端發來的消息。創建一個消息處理類，比如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方法就是用來處理客戶端發來的消息的。在這個例子里，咱們簡單地把收到的消息內容轉換成大寫后返回，就像你收到一封信，把信的內容用大寫字母抄一遍再寄回去一樣。實際項目中，這里可以進行各種復雜的業務邏輯處理，比如調用人工智能模型進行數據分析、文本生成等等。

比如在一個智能營銷系統中，服務器收到用戶瀏覽商品的消息，就可以調用人工智能模型分析用戶的興趣偏好，然后根據分析結果給用戶推薦相關商品，再把推薦結果返回給客戶端。

最后，啟動咱們的服務器。在 Spring Boot 項目的主類里，有一個main方法，運行這個方法，服務器就啟動啦！就像你按下了房子的電源開關，所有的設備都開始運轉起來。

構建客戶端

服務器搭好了，接下來就是客戶端啦。客戶端就像是房子的大門，負責把消息送出去，也負責接收服務器的回信。

同樣在項目里創建一個客戶端配置類，叫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();
    }
}

這里創建了一個簡單的AiClient實例，SimpleAiClient是 Spring AI 提供的基礎客戶端實現。

然后，創建一個客戶端消息發送類，比如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方法就是用來發送消息的。它先創建一個AiMessage對象，把要發送的消息放進去，然后通過AiClient把消息發送出去，再接收服務器返回的消息，最后把服務器返回的消息內容返回給調用者。這就好比你寫好一封信，裝進信封，通過郵局寄出去，然后等著收信人的回信，收到回信后把信的內容讀出來告訴別人。

現在，咱們可以在一個測試類里測試一下客戶端和服務器的通信啦。創建一個測試類，比如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);
    }
}

運行這個測試方法，你會看到控制臺輸出你發送的消息和服務器返回的消息。如果一切順利，你會看到服務器返回的消息是你發送的消息的大寫形式，這說明客戶端和服務器之間的通信成功啦！就像你成功地和遠方的朋友通過信件交流了一樣。

深入優化與擴展

到這里，咱們已經搭建好了一個基本的 MCP Client - Server 架構，并且能實現簡單的消息通信。但是，這就像你蓋好了一座毛坯房，還得進行裝修和擴建，才能讓它變得更舒適、更強大。

性能優化

在實際應用中，服務器可能會收到大量的消息，這時候性能就變得非常重要。咱們可以從幾個方面來優化性能。

首先，緩存是個好東西。就像你在家里把常用的東西放在一個容易拿到的地方，服務器也可以把一些常用的處理結果緩存起來。比如，如果有一些消息處理的結果是固定不變的，或者在一段時間內不會變，就可以把這些結果緩存起來，下次再收到相同的消息時，直接從緩存里取結果，不用再重新處理。

在 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。這樣，服務器就可以同時處理多個消息，提高處理效率。比如說，當有大量用戶同時發送消息時，線程池里的多個線程可以同時處理這些消息，避免出現排隊等待時間過長的情況。

安全加固

在網絡世界里，安全就像房子的門鎖，非常重要。咱們得確保客戶端和服務器之間傳輸的消息不被竊取、篡改。

一種常見的方法是使用加密技術。就像你把重要的信件放在一個帶鎖的信封里一樣，咱們可以對消息進行加密后再傳輸。在 Spring AI 里，可以使用一些加密算法，比如 AES（高級加密標準）。可以創建一個加密工具類，對消息進行加密和解密：

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;
        }
    }
}

在客戶端發送消息前，先對消息進行加密：

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 架構。從基礎環境搭建，到服務器端與客戶端的構建，再到性能優化、安全加固，每一步都為我們打造強大而靈活的應用系統奠定了堅實基礎。

通過 Spring AI 的助力，原本復雜的人工智能集成變得簡單高效，就像給我們的開發工作安裝了一個強力引擎。在未來的項目開發中，無論是構建智能物聯網系統，讓設備間的消息交互更智能；還是打造智能金融風控平臺，借助不同人工智能模型對風險消息進行精準分析，這個架構都能發揮巨大作用。

希望大家在實際開發中，能夠充分運用今天所學的知識，將 Spring AI 與 MCP Client - Server 架構巧妙融合，創造出更多創新且實用的應用。說不定哪天，你用這個架構搭建的智能應用，就會像一陣旋風，在行業里掀起新的技術潮流呢！加油，各位 Java 開發者們，去盡情釋放 Spring AI 與 MCP Client - Server 架構的無限潛力吧！

責任編輯：武曉燕來源：石杉的架構筆記

Spring 架構 AI

成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看