Springboot使用 jenkins-client 调用Jenkins REST API教程和构建 build时 报错 403

前言：最近在工作中，遇到一个需求，使用 java 调用 Jenkins 进行全自动测试的需求

于是在网上查找大量资料，可以使用 jenkins-client 这个工具可以调用 Jenkins REST API

在执行 GET请求获取 Jenkins 信息的时候 没有任何问题，但是 执行 POST 请求时，比如 build构建 job ，create 创建 job 操作时，一直报错 403 ，查阅资料，发现新版的 Jenkins 有一项设置，跨站请求伪造（Cross-Site Request Forgery，简称 CSRF）默认开启，并且没有关闭选项，网上好多都说 修改 jenkins 的 配置文件，我找到一个最简单的方法。

在查看 jenkinsServer 的底层时发现参数里面有个 crumbFlag，调用build方法时传入 true就可以解决！

在springboot项目的 pom.xml 文件中添加 jenkins-client 依赖

<dependency>
    <groupId>com.offbytwo.jenkins</groupId>
    <artifactId>jenkins-client</artifactId>
    <version>0.3.8</version>
</dependency>

 整体代码案例 放在最后！

创建连接 jenkins 的工具类

package com.ruoyi.web.jenkinsUtil;

import com.offbytwo.jenkins.JenkinsServer;
import com.offbytwo.jenkins.client.JenkinsHttpClient;
import java.net.URI;
import java.net.URISyntaxException;
 
/**
 * 连接 Jenkins
 */
public class JenkinsConnect {
 
    private JenkinsConnect(){}
 
    // 连接 Jenkins 需要设置的信息
    static final String JENKINS_URL = "";      // 自己的jenkins url
    static final String JENKINS_USERNAME = ""; // jenkins 等登录账号
    static final String JENKINS_PASSWORD = ""; // jenkins 的登录密码
 
    /**
     * Http 客户端工具
     *
     * 如果有些 API 该Jar工具包未提供，可以用此Http客户端操作远程接口，执行命令
     * @return
     */
    public static JenkinsHttpClient getClient(){
        JenkinsHttpClient jenkinsHttpClient = null;
        try {
            jenkinsHttpClient = new JenkinsHttpClient(new URI(JENKINS_URL), JENKINS_USERNAME, JENKINS_PASSWORD);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
        return jenkinsHttpClient;
    }
 
    /**
     * 连接 Jenkins
     */
    public static JenkinsServer connection() {
        JenkinsServer jenkinsServer = null;
        try {
            jenkinsServer = new JenkinsServer(new URI(JENKINS_URL), JENKINS_USERNAME, JENKINS_PASSWORD);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
        return jenkinsServer;
    }
}

准备调用 JenkinsAPI 时使用到的信息

    // Jenkins 对象
    private JenkinsServer jenkinsServer;
    // http 客户端对象
    private JenkinsHttpClient jenkinsHttpClient;
    public String jobName = "test";
    public String token = "123456";
    private String sessionId;
    private String crumb;

构造方法中调用连接 Jenkins 方法

   JobApi() {
        JenkinsApi jenkinsApi = new JenkinsApi();
        // 连接 Jenkins
        jenkinsServer = JenkinsConnect.connection();
        // 设置客户端连接 Jenkins
        jenkinsHttpClient = JenkinsConnect.getClient();
    }

 创建 Jenkins 任务的方法

    // 创建 Job

    public void ceateJob(){
        try {
            /**创建一个流水线任务，且设置一个简单的脚本**/
            // 创建 Pipeline 脚本
            String script = "node(){ \n" +
                                "echo 'hello world!' \n" +
                            "}";
            // xml配置文件，且将脚本加入到配置中
            String xml = "<flow-definition plugin=\"[email protected]\">\n" +
                             "<description>测试项目</description>\n" +
                             "<definition class=\"org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition\" plugin=\"[email protected]\">\n" +
                                 "<script>" + script + "</script>\n" +
                                 "<sandbox>true</sandbox>\n" +
                             "</definition>\n" +
                          "</flow-definition>";
            // 创建 Job 调用 createJob API 传入三个参数 job名，xml配置文件，是否关闭Crumb 跨站请求伪造保护 如果不填的话，默认为false
            jenkinsServer.createJob("test5",xml,true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 复制一个 Jenkins 任务的方法

// 复制 Job
    public void copyJob(String newJobName,String oldJobName){
        try {
            // 获取旧任务的详情
            JobWithDetails oldJob = jenkinsServer.getJob(oldJobName);
            if (oldJob == null) {
                System.out.println("旧任务不存在: " + oldJobName);
                return;
            }

            // 获取旧任务的XML配置
            String jobConfigXml = jenkinsServer.getJobXml(oldJobName);

            // 创建新任务
            jenkinsServer.createJob(newJobName, jobConfigXml,true);

            System.out.println("任务复制成功: " + newJobName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

获取 Jenkins 任务基本信息的方法

 /**
     * 获取 Job 基本信息
     */
    public void getJob(){
        try {
            // 获取 Job 信息                -- 这里参数是自己创建的job名称
            JobWithDetails job = jenkinsServer.getJob("test");
            // 获取 Job 名称
            System.out.println("job-name:"+job.getName());
            // 获取 Job URL
            System.out.println("job-url:"+job.getUrl());
            // 获取 Job 下一个 build 编号
            System.out.println("job-build编号:"+job.getNextBuildNumber());
            // 获取 Job 显示的名称
            System.out.println("job-showName:"+job.getDisplayName());
            // 输出 Job 描述信息
            System.out.println("job-text:"+job.getDescription());
            // 获取 Job 下游任务列表
            System.out.println(job.getDownstreamProjects());
            // 获取 Job 上游任务列表
            System.out.println(job.getUpstreamProjects());
            // 获取最后一次构建
            System.out.println(job.getLastBuild());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 获取 Jenkin 任务 Job XML 的方法

    /**
     * 查看 Job XML 信息
     */
    public void getJobConfig(){
        try {
            String xml = jenkinsServer.getJobXml(jobName);
            System.out.println("job-xml:"+xml);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

更改 Jenkins 任务的方法

    /**
     * 更新 Job
     */
    public void updateJob(){
        try {
            /**
             * 更改一个流水线任务，让一个无参数的任务变成带参数任务
             */
            // 创建 Pipeline 脚本，用一个key变量
            String script = "node(){ \n" +
                    "echo \"${key}\" \n" +
                    "}";
            // xml配置文件，且将脚本加入到配置中，这里流水线方式为SCM方式的xml
            String xml = "<flow-definition plugin=\"[email protected]\">\n" +
                    "    <description>从 Git SCM 获取 Jenkinsfile</description>\n" +
                    "    <definition class=\"org.jenkinsci.plugins.workflow.cps.CpsScmFlowDefinition\" plugin=\"[email protected]\">\n" +
                    "        <scm class=\"hudson.plugins.git.GitSCM\" plugin=\"[email protected]\">\n" +
                    "            <configVersion>2</configVersion>\n" +
                    "            <userRemoteConfigs>\n" +
                    "                <hudson.plugins.git.UserRemoteConfig>\n" +
                    "                    <url>your - JenkinsUrl</url>\n" +
                    "                    <credentialsId>1</credentialsId> <!-- 这里引用凭证ID -->\n" +
                    "                </hudson.plugins.git.UserRemoteConfig>\n" +
                    "            </userRemoteConfigs>\n" +
                    "            <branches>\n" +
                    "                <hudson.plugins.git.BranchSpec>\n" +
                    "                    <name>*/main</name>\n" +
                    "                </hudson.plugins.git.BranchSpec>\n" +
                    "            </branches>\n" +
                    "            <doGenerateSubmoduleConfigurations>false</doGenerateSubmoduleConfigurations>\n" +
                    "            <submoduleCfg class=\"list\"/>\n" +
                    "            <extensions/>\n" +
                    "        </scm>\n" +
                    "        <lightweight>false</lightweight>\n" +
                    "    </definition>\n" +
                    "</flow-definition>";
            // 更新Job
            jenkinsServer.updateJob(jobName,xml,true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 执行构建 Jenkins 任务的方法

    /**
     * 执行 Job build
     */
    public void buildJob(){
        try {
            // 这里的参数，没有可以不传
            Map<String,String> param = new HashMap<>();
            param.put("project_url","");
            param.put("project_id","111");
            param.put("task_id","222");
            JobWithDetails job = jenkinsServer.getJob("test5");
            QueueReference queueReference = job.build(param,true);
            QueueItem queueItem = jenkinsServer.getQueueItem(queueReference);
            // 获取构建的buildNumber
            Executable executable = queueItem.getExecutable();
            // 这边需要进行一下轮训
            while (executable == null) {
                executable = jenkinsServer.getQueueItem(queueReference).getExecutable();

            }
            Long number = executable.getNumber();
            System.out.println("第"+ number+"次构建");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 删除 Jenkins 任务的方法

    /**
     * 删除 Job
     */
    public void deleteJob(){
        try {
            jenkinsServer.deleteJob(jobName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

禁用 Jenkins 任务的方法

   /**
     * 禁用 Job
     */
    public void disableJob(){
        try {
            jenkinsServer.disableJob(jobName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 

启用 Jenkins 任务的方法

   /**
     * 启用 Job
     */
    public void enableJob(){
        try {

            // 获取Job对象
            Job job = jenkinsServer.getJob(jobName);
            System.out.println(job);
            // 构建参数
            Map<String, String> parameters = new HashMap<>();
            parameters.put("project_id", "111");
            parameters.put("take_id", "222");
            parameters.put("project_url", "your-jenkins Url"); // 确保URL是正确

            // 启用 job
            jenkinsServer.enableJob(jobName);
            // 执行带参数的构建
            job.build(parameters);


            // 打印构建信息
            System.out.println("构建结束");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

编写main方法，执行测试，方法是否生效

public static void main(String[] args) {
        JobApi jobApi = new JobApi();
        // 创建 Job
         jobApi.ceateJob();

        // 复制任务 传入两个参数，新的job名字，要复制的job名字
         jobApi.copyJob("NewJobName","OldJobName");

        // 构建 Job
         jobApi.buildJob();

        // 停止最后构建的 Job Build
         jobApi.stopLastJobBuild();

        // 更新 Job
         jobApi.updateJob();

        // 获取 Job 信息
         jobApi.getJob();

        // 获取 Job 配置xml
         jobApi.getJobConfig();

        // 禁用 Job
         jobApi.disableJob();

        // 启用 Job
         jobApi.enableJob();

        // 删除 Job
         jobApi.deleteJob();

    }