对话即服务:Spring Boot整合MCP让你的CRUD系统秒变AI助手

简介: 本文介绍了如何通过Model Context Protocol (MCP) 协议将传统Spring Boot服务改造为支持AI交互的智能系统。MCP作为“万能适配器”,让AI以统一方式与多种服务和数据源交互,降低开发复杂度。文章以图书管理服务为例,详细说明了引入依赖、配置MCP服务器、改造服务方法(注解方式或函数Bean方式)及接口测试的全流程。最终实现用户通过自然语言查询数据库的功能,展示了MCP在简化AI集成、提升系统易用性方面的价值。未来,“对话即服务”有望成为主流开发范式。

引言

随着人工智能的飞速发展,大语言模型(LLM)正在革命性地重塑用户与软件的交互范式。想象一下这样的场景:用户无需钻研复杂的API文档或者在繁琐的表单间来回切换,只需通过自然语言直接与系统对话——"帮我查找所有2023年出版的图书"、"创建一个新用户叫张三,邮箱是zhangsan@example.com"。这种直观、流畅的交互方式不仅能显著降低新用户的学习曲线,更能大幅削减B端系统的培训成本和实施周期,让企业应用变得更为简单和高效。

这正是Model Context Protocol (MCP) 协议在应用层面所带来的价值体现。

认识MCP

我这里不粘贴官方的定义,用大白话给大家解释下:MCP就像是AI世界的"万能适配器"。想象你有很多不同类型的服务和数据库,每个都有自己独特的"说话方式"。AI需要和这些服务交流时就很麻烦,因为要学习每个服务的"语言"。

MCP解决了这个问题 - 它就像一个统一的翻译官,让AI只需学一种"语言"就能和所有服务交流。这样开发者不用为每个服务单独开发连接方式,AI也能更容易获取它需要的信息。

如果你是一个后端同学,那么应该接触或听说过gRPCgRPC通过标准化的通信方式可以实现不同语言开发的服务之间进行通信,那么MCP专门为AI模型设计的"翻译官和接口管理器",让AI能以统一方式与各种应用或数据源交互。

我们假设开发了一个天气服务,用户想要查询深圳的天气,这里分别以传统API方式和MCP方式进行对比:

1.png

对现有Spring Boot服务改造

这里为了演示,先准备好一个图书管理服务,图书实体字段如下:

import jakarta.persistence.*;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.PastOrPresent;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;


import java.time.LocalDate;

@Entity
@Table(name = "books")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Book {
   

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @NotBlank(message = "书名不能为空")
  @Column(nullable = false)
  private String title;

  @NotBlank(message = "分类不能为空")
  @Column(nullable = false)
  private String category;

  @NotBlank(message = "作者不能为空")
  @Column(nullable = false)
  private String author;

  @NotNull(message = "出版日期不能为空")
  @PastOrPresent(message = "出版日期不能是未来日期")
  @Column(nullable = false)
  private LocalDate publicationDate;

  @NotBlank(message = "ISBN编码不能为空")
  @Column(nullable = false, unique = true)
  private String isbn;

  }

为这个服务编写了2个测试方法:

import com.example.entity.Book;

import java.util.List;

public interface BookService {
   

  // 根据作者查询
  List<Book> findBooksByAuthor(String author);

  // 根据分类查询
  List<Book> findBooksByCategory(String category);
}

现在我们要将这个SpringBoot服务改造成MCP服务,需要以下步骤:

1.导入依赖

pom.xml中引入相关依赖,这里提示一下anthropic的访问需要代理,否则会提示403。

<!-- Spring AI 核心依赖 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-core</artifactId>
</dependency>

<!-- Anthropic 模型支持 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-anthropic-spring-boot-starter</artifactId>
</dependency>

<!-- MCP 服务器支持 - WebMVC版本 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-mcp-server-webmvc-spring-boot-starter</artifactId>
</dependency>

由于目前这些依赖还是预览版本,所以在Maven中央仓库中是找不到的,需要我们额外引入仓库地址。

<repositories>
    <repository>
        <id>spring-milestones</id>
        <name>Spring Milestones</name>
        <url>https://repo.spring.io/milestone</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
    <repository>
        <id>spring-snapshots</id>
        <name>Spring Snapshots</name>
        <url>https://repo.spring.io/snapshot</url>
        <releases>
            <enabled>false</enabled>
        </releases>
    </repository>
    <repository>
        <name>Central Portal Snapshots</name>
        <id>central-portal-snapshots</id>
        <url>https://central.sonatype.com/repository/maven-snapshots/</url>
        <releases>
            <enabled>false</enabled>
        </releases>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>

关于项目中代理的配置可以参考我这段配置:

import jakarta.annotation.PostConstruct;
import org.springframework.context.annotation.Configuration;


@Configuration
public class ProxyConfig {
   

  // 代理设置
  private final String PROXY_HOST = "127.0.0.1";
  private final int PROXY_PORT = 10080;

  @PostConstruct
  public void setSystemProxy() {
   
    // 设置系统代理属性,这会影响Spring Boot自动配置的HTTP客户端
    System.setProperty("http.proxyHost", PROXY_HOST);
    System.setProperty("http.proxyPort", String.valueOf(PROXY_PORT));
    System.setProperty("https.proxyHost", PROXY_HOST);
    System.setProperty("https.proxyPort", String.valueOf(PROXY_PORT));

    System.out.println("System proxy configured: http://" + PROXY_HOST + ":" + PROXY_PORT);
  }
}

2.引入配置

我们的目的是将一个Spring服务改造成MCP服务,所以这里不需要进行客户端的配置,同理,在引入依赖的时候也不用引入客户端的依赖。

# Spring AI api-key
spring.ai.anthropic.api-key=这里换成你的api-key

# MCP服务端开启
spring.ai.mcp.server.enabled=true

# MCP服务端配置
spring.ai.mcp.server.name=book-management-server
spring.ai.mcp.server.version=1.0.0
spring.ai.mcp.server.type=SYNC
spring.ai.mcp.server.sse-message-endpoint=/mcp/message

3.改造原服务方法

服务的改造有两种思路-分别是工具配置方式和函数Bean方式,这里对两种方式都做下简略说明:
工具配置方式在需要改造的实现类对需要改造的方法加上@Tool和@ToolParam注解分别标记方法和参数。

import com.example.entity.Book;
import com.example.repository.BookRepository;
import com.example.service.BookService;
import jakarta.annotation.Resource;
import lombok.RequiredArgsConstructor;
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.ai.tool.annotation.ToolParam;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
@RequiredArgsConstructor
public class BookServiceImpl  implements BookService {
   

  @Resource
  private BookRepository bookRepository;


  @Override
  @Tool(name = "findBooksByTitle", description = "根据书名模糊查询图书,支持部分标题匹配")
  public List<Book> findBooksByTitle(@ToolParam(description = "书名关键词") String title) {
   
    return bookRepository.findByTitleContaining(title);
  }

  @Override
  @Tool(name = "findBooksByAuthor", description = "根据作者精确查询图书")
  public List<Book> findBooksByAuthor(@ToolParam(description = "作者姓名") String author) {
   
    return bookRepository.findByAuthor(author);
  }

  @Override
  @Tool(name = "findBooksByCategory", description = "根据图书分类精确查询图书")
  public List<Book> findBooksByCategory(@ToolParam(description = "图书分类")String category) {
   
    return bookRepository.findByCategory(category);
  }
}

接着将这个实现类注册到MCP服务器配置上即可。

import com.example.service.BookService;
import org.springframework.ai.tool.ToolCallbackProvider;
import org.springframework.ai.tool.method.MethodToolCallbackProvider;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * MCP服务器配置类,负责注册MCP工具
 */
@Configuration
public class McpServerConfig {
   

  /**
   * 注册工具回调提供者,将BookQueryService中的@Tool方法暴露为MCP工具
   *
   * @param bookService 图书服务
   * @return 工具回调提供者
   */
  @Bean
  public ToolCallbackProvider bookToolCallbackProvider(BookService bookService) {
   
    return MethodToolCallbackProvider.builder()
            .toolObjects(bookService)
            .build();
  }

}

此时在聊天客户端配置引入注册工具即可。

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.tool.ToolCallbackProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/**
 * 聊天客户端配置类
 */
@Configuration
public class ChatClientConfig {
   


  @Autowired
  private ToolCallbackProvider toolCallbackProvider;

  /**
   * 配置ChatClient,注册系统指令和工具函数
   */
  @Bean
  public ChatClient chatClient(ChatClient.Builder builder) {
   
    return builder
            .defaultSystem("你是一个图书管理助手,可以帮助用户查询图书信息。" +
                    "你可以根据书名模糊查询、根据作者查询和根据分类查询图书。" +
                    "回复时,请使用简洁友好的语言,并将图书信息整理为易读的格式。")
            // 注册工具方法
            .defaultTools(toolCallbackProvider)
            .build();
  }
}

除了上述的方式,还可以单独声明一个类将查询方法作为函数Bean导出。

import com.example.entity.Book;
import com.example.service.BookService;
import jakarta.annotation.Resource;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.function.Function;

/**
 * 图书查询服务,将查询方法作为函数Bean导出
 */
@Service
public class BookQueryService {
   

  @Resource
  private BookService bookService;

  /**
   * 根据书名查询图书的函数Bean
   */
  @Bean
  public Function<String, List<Book>> findBooksByTitle() {
   
    return title -> bookService.findBooksByTitle(title);
  }

  /**
   * 根据作者查询图书的函数Bean
   */
  @Bean
  public Function<String, List<Book>> findBooksByAuthor() {
   
    return author -> bookService.findBooksByAuthor(author);
  }

  /**
   * 根据分类查询图书的函数Bean
   */
  @Bean
  public Function<String, List<Book>> findBooksByCategory() {
   
    return category -> bookService.findBooksByCategory(category);
  }

}

采用这种方式在定义AI聊天客户端的时候需要显式地声明。

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 聊天客户端配置类
 */
@Configuration
public class ChatClientConfig {
   


  /**
   * 配置ChatClient,注册系统指令和工具函数
   */
  @Bean
  public ChatClient chatClient(ChatClient.Builder builder) {
   
    return builder
            .defaultSystem("你是一个图书管理助手,可以帮助用户查询图书信息。" +
                    "你可以根据书名模糊查询、根据作者查询和根据分类查询图书。" +
                    "回复时,请使用简洁友好的语言,并将图书信息整理为易读的格式。")
            // 注册工具方法,这里使用方法名称来引用Spring上下文中的函数Bean
            .defaultTools(
                    "findBooksByTitle",
                    "findBooksByAuthor",
                    "findBooksByCategory"
            )
            .build();
  }
}

4.接口测试

完成了服务开发后,我们就可以声明一个控制器对外暴露进行调用。

import com.example.model.ChatRequest;
import com.example.model.ChatResponse;
import jakarta.annotation.Resource;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

/**
 * 聊天控制器,处理AI聊天请求
 */
@RestController
@RequestMapping("/api/chat")
public class ChatController {
   


  @Resource
  private ChatClient chatClient;


  /**
   * 处理聊天请求,使用AI和MCP工具进行响应
   *
   * @param request 聊天请求
   * @return 包含AI回复的响应
   */
  @PostMapping
  public ResponseEntity<ChatResponse> chat(@RequestBody ChatRequest request) {
   
    try {
   
      // 创建用户消息
      String userMessage = request.getMessage();

      // 使用流式API调用聊天
      String content = chatClient.prompt()
              .user(userMessage)
              .call()
              .content();

      return ResponseEntity.ok(new ChatResponse(content));
    } catch (Exception e) {
   
      e.printStackTrace();
      return ResponseEntity.ok(new ChatResponse("处理请求时出错: " + e.getMessage()));
    }
  }

}

为了方便测试,我们开发一个数据初始化器,通过实现CommandLineRunner接口,它会在我们的应用程序启动时自动向数据库中加载这些测试数据。

import com.example.entity.Book;
import com.example.repository.BookRepository;
import jakarta.annotation.Resource;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.time.LocalDate;
import java.util.Arrays;
import java.util.List;

@Component
@RequiredArgsConstructor
public class DataInitializer  implements CommandLineRunner {
   

  @Resource
  private BookRepository bookRepository;

  @Override
  public void run(String... args) throws Exception {
   
    // 准备示例数据
    List<Book> sampleBooks = Arrays.asList(
            new Book(null, "Spring实战(第6版)", "编程", "Craig Walls",
                    LocalDate.of(2022, 1, 15), "9787115582247"),
            new Book(null, "深入理解Java虚拟机", "编程", "周志明",
                    LocalDate.of(2019, 12, 1), "9787111641247"),
            new Book(null, "Java编程思想(第4版)", "编程", "Bruce Eckel",
                    LocalDate.of(2007, 6, 1), "9787111213826"),
            new Book(null, "算法(第4版)", "计算机科学", "Robert Sedgewick",
                    LocalDate.of(2012, 10, 1), "9787115293800"),
            new Book(null, "云原生架构", "架构设计", "张三",
                    LocalDate.of(2023, 3, 15), "9781234567890"),
            new Book(null, "微服务设计模式", "架构设计", "张三",
                    LocalDate.of(2021, 8, 20), "9789876543210"),
            new Book(null, "领域驱动设计", "架构设计", "Eric Evans",
                    LocalDate.of(2010, 4, 10), "9787111214748"),
            new Book(null, "高性能MySQL", "数据库", "Baron Schwartz",
                    LocalDate.of(2013, 5, 25), "9787111464747"),
            new Book(null, "Redis实战", "数据库", "Josiah L. Carlson",
                    LocalDate.of(2015, 9, 30), "9787115419378"),
            new Book(null, "深入浅出Docker", "容器技术", "李四",
                    LocalDate.of(2022, 11, 20), "9787123456789")
    );

    // 保存示例数据
    bookRepository.saveAll(sampleBooks);

    System.out.println("数据初始化完成,共加载 " + sampleBooks.size() + " 本图书");
  }

}

接下来我们通过请求接口进行如下测试:

2.png

3.png

可以看到此时返回结果是数据库中的测试数据内容。这里是根据用户输入的问题,大模型会判断我们开放的工具方法中是否有匹配的,如果有则进行调用并返回。

小结

通过Spring Boot与MCP的整合,我们轻松实现了传统CRUD系统到智能AI助手的转变。MCP作为AI与服务之间的桥梁,极大简化了集成工作。未来随着MCP生态发展,"对话即服务"将可能成为应用的开发范式,让复杂系统变得更加易用。

目录
相关文章
|
3天前
|
XML 人工智能 JSON
别再误会MCP了!一篇写给AI工程师的硬核“辟谣”指南
本文深入剖析Model Context Protocol(MCP)的本质,澄清其常被误认为“高级Function Calling”的认知偏差。通过架构分析、源码验证与实战解剖,论证MCP实为模型无关的工程协议,由Host、Client、Server三组件构成,核心在于实现AI智能与能力执行的解耦。文章揭示MCP的真实价值是提供标准化、可互操作的AI应用基础设施,而非直接提升AI能力,并指出其在Token成本与意图识别稳定性上的挑战,最终回归工程本质,强调对Host智能优化的关键作用。
别再误会MCP了!一篇写给AI工程师的硬核“辟谣”指南
|
4天前
|
人工智能 监控 搜索推荐
给RAG打分:小白也能懂的AI系统评测全攻略
RAG系统评估听起来高深,其实跟我们生活中的'尝鲜评测'没啥两样!本文用轻松幽默的方式,带你从检索质量、生成质量到用户体验,全方位掌握如何科学评测RAG系统,避免踩坑,让你的AI应用又快又准。#RAG技术 #AI评估 #信息检索 #大模型 #数据科学
|
23天前
|
JSON 人工智能 Java
基于Spring AI构建智能Text-to-SQL转换器:一个完整的MCP
Spring AI 更新结构化输出转换器,弃用旧版 Parser 类,引入与 Spring 框架对齐的 Converter 体系,提升命名规范与功能兼容性。新版本支持 JSON、XML 及 Java 对象转换,确保 LLM 输出结构化,便于下游应用处理。
|
29天前
|
人工智能 算法 前端开发
超越Prompt Engineering:揭秘高并发AI系统的上下文工程实践
本文系统解析AI工程范式从Prompt Engineering到Context Engineering的演进路径,深入探讨RAG、向量数据库、上下文压缩等关键技术,并结合LangGraph与智能体系统架构,助力开发者构建高可靠AI应用。
193 1
|
15天前
|
人工智能 JavaScript 算法
Playwright携手MCP:AI智能体实现自主化UI回归测试
MCP 协议使得 AI 能够通过 Playwright 操作浏览器,其中快照生成技术将页面状态转化为 LLM 可理解的文本,成为驱动自动化测试的关键。该方式适用于探索性测试和快速验证,但目前仍面临快照信息缺失、元素定位不稳定、成本高、复杂场景适应性差以及结果确定性不足等挑战。人机协同被认为是未来更可行的方向,AI 负责执行固定流程,人类则专注策略与验证。
|
4天前
|
机器学习/深度学习 人工智能 机器人
AI Compass前沿速览:Nano Bananary、MCP Registry、通义DeepResearch 、VoxCPM、InternVLA·M1具身机器人
AI Compass前沿速览:Nano Bananary、MCP Registry、通义DeepResearch 、VoxCPM、InternVLA·M1具身机器人
|
5天前
|
人工智能 Java 机器人
基于Spring AI Alibaba + Spring Boot + Ollama搭建本地AI对话机器人API
Spring AI Alibaba集成Ollama,基于Java构建本地大模型应用,支持流式对话、knife4j接口可视化,实现高隐私、免API密钥的离线AI服务。
74 1
基于Spring AI Alibaba + Spring Boot + Ollama搭建本地AI对话机器人API
|
19天前
|
人工智能 安全 数据可视化
深度解析三大AI协议:MCP、ACP与A2A,看懂智能代理的通信法则
在AI代理技术快速发展的背景下,MCP、ACP和A2A三大协议成为推动AI生态协作的关键标准。MCP(模型上下文协议)为大模型提供标准化信息接口,提升AI处理外部数据的效率;ACP(代理通信协议)专注于边缘设备间的低延迟通信,实现本地系统的高效协同;A2A(代理对代理协议)则构建跨平台通信标准,打通不同AI系统的协作壁垒。三者各司其职,共同推动AI从独立工具向智能协作团队演进,提升整体智能化水平与应用灵活性。
186 2
深度解析三大AI协议:MCP、ACP与A2A,看懂智能代理的通信法则
|
5天前
|
人工智能 Java 数据库
Spring AI
Spring AI 为 Java 生态注入智能,提供统一抽象接口,简化大模型集成,助力开发者高效构建 AI 应用,推动企业智能化转型。

热门文章

最新文章