最新资讯

前言

首先介绍下MCP是什么？

MCP是由开发了 Claude 模型的 Anthropic 公司2024年11月提出并开源的一项开放标准，全称：Model Context Protocol，它是一个开放协议，它使 LLM 应用与外部数据源和工具之间的无缝集成成为可能。无论你是构建 AI 驱动的 IDE、改善chat 交互，还是构建自定义的 AI 工作流，MCP 提供了一种标准化的方式，将 LLM 与它们所需的上下文连接起来。

大白话

如果不使用 MCP 是什么样的？

就像自己（LLM大模型）学做菜，首先需要学会如何使用刀、锅、锅铲、炉灶，甚至需要自己生火，每一个步骤都需要从头摸索工具，无法专注烹饪本身。​

使用 MCP

MCP 协议相当于给大模型配了一个服务员（MCP Client），当食客（LLM大模型）需要吃什么菜时，可以直接根据菜单上的菜品告诉服务员（MCP Client），知道菜品后，服务员（MCP Client）根据菜品是哪个菜系找不同菜系的厨师（MCP Server），厨师（MCP Server）接到炒菜的任务就使用冰箱、食材、锅、锅铲等（工具）完成菜品制作任务，并将菜品（结果）精准端给服务员（MCP Client），让大模型无需直接操作工具就能完成复杂任务。

初衷

最近接触到 MCP 协议，我觉得它在未来AI实际应用中潜力巨大，很可能成为行业趋势。不过，我留意到mcp.so网站上，大部分 MCP Server 是用 Python 编写的，用 Java 开发的极为少见。就连 Spring AI，也是在 2025 年 2 月才开始支持并封装 MCP 协议的大部分逻辑。所以，我希望有更多从事 Java 开发的人员能够关注这项技术，将其广泛运用到实际项目里 。

正文

流程图

环境准备

• Jenkins（需启用「远程访问API」权限）
• JDK 17
• SpringBoot 3.3.6
• IDEA
• Maven 3

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starterartifactId>
dependency>
<dependency>
    <groupId>org.springframework.aigroupId>
    <artifactId>spring-ai-mcp-server-spring-boot-starterartifactId>
    <version>1.0.0-M6version>
dependency>
<dependency>
	<groupId>com.google.code.gsongroupId>
    <artifactId>gsonartifactId>
    <version>2.8.0version>
dependency>
<dependency>
    <groupId>com.google.injectgroupId>
    <artifactId>guiceartifactId>
    <version>5.1.0version>
dependency>
<dependency>
    <groupId>io.github.cdancygroupId>
    <artifactId>jenkins-restartifactId>
    <version>1.0.2version>
    <exclusions>
        <exclusion>
            <artifactId>guiceartifactId>
            <groupId>com.google.injectgroupId>
        exclusion>
    exclusions>
dependency>
<dependency>
     <groupId>org.projectlombokgroupId>
     <artifactId>lombokartifactId>
     <version>1.18.36version>
     <scope>providedscope>
 dependency>

核心代码

• JenkinsMcpServerConfig.java

MCP Server必须的配置类

package com.agua.ai.mcp.server.config;

import com.agua.ai.mcp.server.service.JenkinsApiService;
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;

@Configuration
public class JenkinsMcpServerConfig {

    @Bean
    public ToolCallbackProvider jenkinsTools(JenkinsApiService jenkinsApiService) {
        return MethodToolCallbackProvider.builder().toolObjects(jenkinsApiService).build();
    }
}

• JenkinsProperties.java

定义Jenkins的配置

package com.agua.ai.mcp.server.properties;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Data
@Component
@ConfigurationProperties("jenkins")
public class JenkinsProperties {
    /**
     * 服务URI
     */
    private String serverUri;
    /**
     * 用户名
     */
    private String username;
    /**
     * 密码/token
     */
    private String password;
}

• JenkinsTemplate.java

对com.cdancy.jenkins（封装了Jenkins Rest API的工具类）已经集成的方法进行再次封装，方便调用

package com.agua.ai.mcp.server.util;

import com.cdancy.jenkins.rest.JenkinsClient;
import com.cdancy.jenkins.rest.domain.common.IntegerResponse;
import com.cdancy.jenkins.rest.domain.common.RequestStatus;
import com.cdancy.jenkins.rest.domain.job.BuildInfo;
import com.cdancy.jenkins.rest.domain.job.JobInfo;
import com.cdancy.jenkins.rest.domain.job.JobList;
import com.cdancy.jenkins.rest.domain.job.ProgressiveText;
import com.cdancy.jenkins.rest.features.JobsApi;
import com.agua.ai.mcp.server.properties.JenkinsProperties;
import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;

/**
 * Jenkins 模板类，用于封装 Jenkins API 的调用
 */
@Component
public class JenkinsTemplate {

    private final JenkinsClient jenkinsClient;

    private JobsApi jobsApi;

    @Autowired
    public JenkinsTemplate(JenkinsProperties jenkinsProperties) {
        this.jenkinsClient = JenkinsClient.builder()
                .endPoint(jenkinsProperties.getServerUri())
                .credentials(jenkinsProperties.getUsername() + ":" + jenkinsProperties.getPassword())
                .build();
    }

    @PostConstruct
    public void init() {
        this.jobsApi = jenkinsClient.api().jobsApi();
    }

    /**
     * 获取任务列表
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @return 任务列表
     */
    public JobList getJobList(String optionalFolderPath) {
        return jobsApi.jobList(optionalFolderPath);
    }

    /**
     * 获取任务信息
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @return 任务信息
     */
    public JobInfo getJobInfo(String optionalFolderPath, String jobName) {
        return jobsApi.jobInfo(optionalFolderPath, jobName);
    }

    /**
     * 使用 XML 文件创建任务
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @param configXML 任务的配置 XML
     * @return 请求状态
     */
    public RequestStatus createJob(String optionalFolderPath, String jobName, String configXML) {
        return jobsApi.create(optionalFolderPath, jobName, configXML);
    }

    /**
     * 删除任务
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @return 请求状态
     */
    public RequestStatus deleteJob(String optionalFolderPath, String jobName) {
        return jobsApi.delete(optionalFolderPath, jobName);
    }

    /**
     * 启用任务
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @return 是否成功
     */
    public boolean enableJob(String optionalFolderPath, String jobName) {
        return jobsApi.enable(optionalFolderPath, jobName);
    }

    /**
     * 禁用任务
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @return 是否成功
     */
    public boolean disableJob(String optionalFolderPath, String jobName) {
        return jobsApi.disable(optionalFolderPath, jobName);
    }

    /**
     * 获取任务配置文件内容
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @return 配置文件内容
     */
    public String getJobConfig(String optionalFolderPath, String jobName) {
        return jobsApi.config(optionalFolderPath, jobName);
    }

    /**
     * 更新任务配置文件内容
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @param configXML 新的配置 XML
     * @return 是否成功
     */
    public boolean updateJobConfig(String optionalFolderPath, String jobName, String configXML) {
        return jobsApi.config(optionalFolderPath, jobName, configXML);
    }

    /**
     * 构建任务
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @return 构建响应
     */
    public IntegerResponse buildJob(String optionalFolderPath, String jobName) {
        return jobsApi.build(optionalFolderPath, jobName);
    }

    /**
     * 构建带参数的任务
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @param properties 参数列表
     * @return 构建响应
     */
    public IntegerResponse buildJobWithParams(String optionalFolderPath, String jobName, Map<String, List<String>> properties) {
        return jobsApi.buildWithParameters(optionalFolderPath, jobName, properties);
    }

    /**
     * 获取任务上次构建序号
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @return 构建序号
     */
    public Integer getLastBuildNumber(String optionalFolderPath, String jobName) {
        return jobsApi.lastBuildNumber(optionalFolderPath, jobName);
    }

    /**
     * 获取任务上次构建时间戳
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @return 时间戳
     */
    public String getLastBuildTimestamp(String optionalFolderPath, String jobName) {
        return jobsApi.lastBuildTimestamp(optionalFolderPath, jobName);
    }

    /**
     * 获取构建信息
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @param buildNumber 构建编号
     * @return 构建信息
     */
    public BuildInfo getBuildInfo(String optionalFolderPath, String jobName, int buildNumber) {
        return jobsApi.buildInfo(optionalFolderPath, jobName, buildNumber);
    }

    /**
     * 获取构建控制台输出内容
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @param buildNumber 构建编号
     * @param start 开始位置
     * @return 控制台输出内容
     */
    public ProgressiveText getBuildLog(String optionalFolderPath, String jobName, int buildNumber, int start) {
        return jobsApi.progressiveText(optionalFolderPath, jobName, buildNumber, start);
    }

    /**
     * 重命名任务
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param currentJobName 当前任务名称
     * @param newJobName 新任务名称
     * @return 是否成功
     */
    public boolean renameJob(String optionalFolderPath, String currentJobName, String newJobName) {
        return jobsApi.rename(optionalFolderPath, currentJobName, newJobName);
    }

    /**
     * 停止任务
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @param buildNumber 构建编号
     * @return 是否成功
     */
    public RequestStatus killJob(String optionalFolderPath, String jobName, int buildNumber) {
        return jobsApi.kill(optionalFolderPath, jobName, buildNumber);
    }

    /**
     * 查看执行日志
     *
     * @param optionalFolderPath 可选的文件夹路径
     * @param jobName 任务名称
     * @param start 开始位置
     * @return 是否成功
     */
    public ProgressiveText progressiveTextJob(String optionalFolderPath, String jobName, int start) {
        return jobsApi.progressiveText(optionalFolderPath, jobName, start);
    }
}

• JenkinsApiService.java

直接暴露给LLM大模型的可调用的工具的Service

package com.agua.ai.mcp.server.service;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.TypeReference;
import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.agua.ai.mcp.server.util.JenkinsTemplate;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.ai.tool.annotation.ToolParam;
import org.springframework.stereotype.Service;

@Service
@AllArgsConstructor
public class JenkinsApiService {

    private final JenkinsTemplate jenkinsTemplate;

    @Tool(description = "获取任务列表")
    public String getJobList(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.getJobList(optionalFolderPath));
    }

    @Tool(description = "获取任务信息")
    public String getJobInfo(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                             @ToolParam(description = "任务名称") String jobName) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.getJobInfo(optionalFolderPath, jobName));
    }

    @Tool(description = "使用 XML 文件创建任务")
    public String createJob(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                            @ToolParam(description = "任务名称") String jobName,
                            @ToolParam(description = "任务的配置 XML") String configXML) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.createJob(optionalFolderPath, jobName, configXML));
    }

    @Tool(description = "删除任务")
    public String deleteJob(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                            @ToolParam(description = "任务名称") String jobName) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.deleteJob(optionalFolderPath, jobName));
    }

    @Tool(description = "启用任务")
    public String enableJob(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                            @ToolParam(description = "任务名称") String jobName) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.enableJob(optionalFolderPath, jobName));
    }

    @Tool(description = "禁用任务")
    public String disableJob(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                             @ToolParam(description = "任务名称") String jobName) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.disableJob(optionalFolderPath, jobName));
    }

    @Tool(description = "获取任务配置文件内容")
    public String getJobConfig(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                               @ToolParam(description = "任务名称") String jobName) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.getJobConfig(optionalFolderPath, jobName));
    }

    @Tool(description = "更新任务配置文件内容")
    public String updateJobConfig(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                                  @ToolParam(description = "任务名称") String jobName,
                                  @ToolParam(description = "新的配置 XML") String configXML) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.updateJobConfig(optionalFolderPath, jobName, configXML));
    }

    @Tool(description = "构建任务")
    public String buildJob(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                           @ToolParam(description = "任务名称") String jobName) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.buildJob(optionalFolderPath, jobName));
    }

    @Tool(description = "构建带参数的任务")
    public String buildJobWithParams(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                                     @ToolParam(description = "任务名称") String jobName,
                                     @Schema(description = "参数列表（格式：Map>）") String properties) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.buildJobWithParams(optionalFolderPath, jobName, JSON.parseObject(properties, new TypeReference<>() {})));
    }

    @Tool(description = "获取任务上次构建序号")
    public String getLastBuildNumber(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                                     @ToolParam(description = "任务名称") String jobName) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.getLastBuildNumber(optionalFolderPath, jobName));
    }

    @Tool(description = "获取任务上次构建时间戳")
    public String getLastBuildTimestamp(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                                        @ToolParam(description = "任务名称") String jobName) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.getLastBuildTimestamp(optionalFolderPath, jobName));
    }

    @Tool(description = "获取构建信息")
    public String getBuildInfo(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                               @ToolParam(description = "任务名称") String jobName,
                               @ToolParam(description = "构建编号（必须是整数）") String buildNumber,
                               @ToolParam(description = "是否返回变更历史（boolean类型）") String changeSetFlag) {
        Gson gson = new GsonBuilder().setExclusionStrategies(new ExclusionStrategy() {
            @Override
            public boolean shouldSkipField(FieldAttributes f) {
                return Boolean.parseBoolean(changeSetFlag) && "changeSet".equals(f.getName());
            }
            @Override
            public boolean shouldSkipClass(Class<?> clazz) {
                return false;
            }
        }).create();
        return gson.toJson(jenkinsTemplate.getBuildInfo(optionalFolderPath, jobName, Integer.parseInt(buildNumber)));
    }

    @Tool(description = "获取构建控制台输出内容")
    public String getBuildLog(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                              @ToolParam(description = "任务名称") String jobName,
                              @ToolParam(description = "构建编号（必须是整数）") String buildNumber,
                              @ToolParam(description = "开始位置（必须是整数）") String start) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.getBuildLog(optionalFolderPath, jobName, Integer.parseInt(buildNumber), Integer.parseInt(start)));
    }

    @Tool(description = "重命名任务")
    public String renameJob(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                            @ToolParam(description = "当前任务名称") String currentJobName,
                            @ToolParam(description = "新任务名称") String newJobName) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.renameJob(optionalFolderPath, currentJobName, newJobName));
    }

    @Tool(description = "停止任务（必须二次确认）")
    public String killJob(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                          @ToolParam(description = "任务名称") String jobName,
                          @ToolParam(description = "构建编号（必须是整数）") String buildNumber) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.killJob(optionalFolderPath, jobName, Integer.parseInt(buildNumber)));
    }

    @Tool(description = "查看执行日志")
    public String progressiveTextJob(@ToolParam(description = "可选的文件夹路径") String optionalFolderPath,
                          @ToolParam(description = "任务名称") String jobName,
                          @ToolParam(description = "开始位置（必须是整数）") String start) {
        Gson gson = new GsonBuilder().create();
        return gson.toJson(jenkinsTemplate.progressiveTextJob(optionalFolderPath, jobName, Integer.parseInt(start)));
    }
}

• application.yml

spring:
  ai:
    mcp:
      server:
        stdio: true
        name: jenkins-api
        version: 0.0.1
        type: SYNC
  main:
    web-application-type: none
    banner-mode: off
jenkins:
  # jenkins的访问url
  server-uri: ${JENKINS_API_SERVER_URI}
  username: ${JENKINS_API_USERNAME}
  password: ${JENKINS_API_TOKEN}
logging:
  level:
    root: INFO

使用配置

如果是用 Cursor 作为客户端，那么可以通过一下方式启动 MCP Server ，本地 MCP Server 服务请将{你的路径}替换成实际的 jar 包存放路径

• command方式

java -Dspring.ai.mcp.server.transport=STDIO -Dspring.main.web-application-type=none -jar {你的路径}mcp-jenkins-server-0.0.1-SNAPSHOT.jar

• mcp.json配置

{
  "mcpServers": {
    "jenkins-mcp": {
      "command": "java",
      "args": [
        "-jar",
        "{你的路径}mcp-jenkins-server-0.0.1-SNAPSHOT.jar"
      ],
      "env": {
        "JENKINS_API_SERVER_URI": "jenkins-uri",
        "JENKINS_API_USERNAME": "username",
        "JENKINS_API_TOKEN": "password/token" 
      }
    }
  }
}

最终演示效果

用户提问

请部署v1.2.3版本到测试环境

MCP Client解析后调用：

{
  "tool": "buildJobWithParams",
  "params": {
  	"optionalFolderPath": "",
    "jobName": "qa-system",
    "properties": {"version": ["v1.2.3"], "env": ["test"]}
  }
}

Jenkins MCP Server执行结果

{
  "value": "12345",
  "errors": []
}

总结

目前大模型的优势就是它能够一定程度地理解用户所说的内容，并转换成调用工具所需的请求参数，减少人工解析的工作量并且降低人工适配的成本。现在 MCP 还处于初期发展阶段，因此需要广大开发者的支持，才能支撑起庞大 AI 应用生态构建。

项目github地址
jenkins-mcp-server
相关链接
MCP 介绍
Spring AI MCP
Jenkins 官网
jenkins-rest（Github 地址）