Java使用Jenkins API操作任务，视图，部署等

文章目录

• 1、什么是Jenkins API
• 2、Jenkins API分类
• • ①、JSON API
  • ②、XML API
  • ③、Python API
  • ④、其他
• 3、使用Java调用Jenkins API
• • ①、View
  • • Ⅰ、创建View
    • Ⅱ、获取View
    • Ⅲ、获取View配置 XML 信息
    • Ⅳ、更新View
    • Ⅴ、删除View
  • ②、Job
  • • Ⅰ、创建Job
    • Ⅱ、更新Job
    • Ⅲ、获取Job基本信息
    • Ⅳ、获取Maven Job信息
    • Ⅴ、获取Job列表
    • Ⅵ、根据View名称获取Job列表
    • Ⅶ、查看Job XML信息
    • Ⅷ、无参数 Job build
    • Ⅸ、有参构建
    • Ⅹ、停止最后构建的 Job Build
    • ⅩⅠ、禁用 Job
    • ⅩⅡ、启用Job
    • ⅩⅢ、删除 Job
  • ③、编译
  • • Ⅰ、获取Build基本信息
    • Ⅱ、获取 Job 最后的 Build
    • Ⅲ、获取 Job 首次 Build
    • Ⅳ、根据 Job Build 编号获取编译信息
    • Ⅴ、获取全部 Job Build列表
    • Ⅵ、获取 Job 一定范围的 Build 列表
    • Ⅶ、获取Build详细信息
    • Ⅷ、获取 Build Log 日志信息
    • Ⅸ、获取正在执行构建任务的日志信息
  • ④、其他
  • • Ⅰ、获取主机信息
    • Ⅱ、重启Jenkins
    • Ⅲ、安全重启Jenkins
    • Ⅳ、安全结束Jenkins
    • Ⅴ、关闭连接
    • Ⅵ、根据 Label 查找代理节点信息
    • Ⅶ、判断Jenkins是否运行
    • Ⅷ、获取 Jenkins 插件信息
• 4、问题处理
• • ①、HttpResponseException: Forbidden
  • • Ⅰ、关闭跨域保护（高版本）
    • Ⅱ、携带Token建立连接

1、什么是Jenkins API

Jenkins 远程 API 能够通过 Http 协议远程调用相关命令操作 Jenkins 进行 Jenkins 视图、任务、插件、构建信息、任务日志信息、统计信息等，非常容易与其配合更好的完成 CI/CD 工作

2、Jenkins API分类 ①、JSON API

浏览器打开http://JenkinsURL/api/json

格式化如下

{
    "_class":"hudson.model.Hudson",
    "assignedLabels":[
        {
            "name":"master"
        }
    ],
    "mode":"NORMAL",
    "nodeDescription":"the master Jenkins node",
    "nodeName":"",
    "numExecutors":2,
    "description":null,
    "jobs":[
        {
            "_class":"hudson.maven.MavenModuleSet",
            "name":"CenterServer",
            "url":"http://192.168.225.130/job/CenterServer/",
            "color":"blue"
        },
        {
            "_class":"hudson.maven.MavenModuleSet",
            "name":"HelloWorld",
            "url":"http://192.168.225.130/job/HelloWorld/",
            "color":"blue"
        },
        {
            "_class":"hudson.maven.MavenModuleSet",
            "name":"PMServer",
            "url":"http://192.168.225.130/job/PMServer/",
            "color":"blue"
        }
    ],
    "overallLoad":{

    },
    "primaryView":{
        "_class":"hudson.model.AllView",
        "name":"all",
        "url":"http://192.168.225.130/"
    },
    "quietDownReason":null,
    "quietingDown":false,
    "slaveAgentPort":-1,
    "unlabeledLoad":{
        "_class":"jenkins.model.UnlabeledLoadStatistics"
    },
    "url":"http://192.168.225.130/",
    "useCrumbs":true,
    "useSecurity":true,
    "views":[
        {
            "_class":"hudson.model.AllView",
            "name":"all",
            "url":"http://192.168.225.130/"
        }
    ]
}

②、XML API

浏览器打开http://JenkinsURL/api/xml

    
        master
    
    NORMAL
    the master Jenkins node
    
    2
    
        CenterServer
        http://192.168.225.130/job/CenterServer/
        blue
    
    
        HelloWorld
        http://192.168.225.130/job/HelloWorld/
        blue
    
    
        PMServer
        http://192.168.225.130/job/PMServer/
        blue
    
    
    
        all
        http://192.168.225.130/
    
    false
    -1
    
    http://192.168.225.130/
    true
    true
    
        all
        http://192.168.225.130/
    

③、Python API

浏览器打开http://JenkinsURL/api/python

格式化如下

{
    "_class":"hudson.model.Hudson",
    "assignedLabels":[
        {
            "name":"master"
        }
    ],
    "mode":"NORMAL",
    "nodeDescription":"the master Jenkins node",
    "nodeName":"",
    "numExecutors":2,
    "description":None,
    "jobs":[
        {
            "_class":"hudson.maven.MavenModuleSet",
            "name":"CenterServer",
            "url":"http://192.168.225.130/job/CenterServer/",
            "color":"blue"
        },
        {
            "_class":"hudson.maven.MavenModuleSet",
            "name":"HelloWorld",
            "url":"http://192.168.225.130/job/HelloWorld/",
            "color":"blue"
        },
        {
            "_class":"hudson.maven.MavenModuleSet",
            "name":"PMServer",
            "url":"http://192.168.225.130/job/PMServer/",
            "color":"blue"
        }
    ],
    "overallLoad":{

    },
    "primaryView":{
        "_class":"hudson.model.AllView",
        "name":"all",
        "url":"http://192.168.225.130/"
    },
    "quietDownReason":None,
    "quietingDown":False,
    "slaveAgentPort":-1,
    "unlabeledLoad":{
        "_class":"jenkins.model.UnlabeledLoadStatistics"
    },
    "url":"http://192.168.225.130/",
    "useCrumbs":True,
    "useSecurity":True,"views":[
        {
            "_class":"hudson.model.AllView",
            "name":"all",
            "url":"http://192.168.225.130/"
        }
    ]
}

④、其他

根据以上三种API查询出来的信息中出现了几个任务的url如http://192.168.225.130/job/HelloWorld/，可以在在后面追加/api/xml访问查看对应Job的构建记录

根据提供了若干构建记录还可以查看构建的详细信息，直接访问提供的url即可http://192.168.225.130/job/helloworld/11/

3、使用Java调用Jenkins API

创建一个Jenkins API Demo工程

导入依赖

    
    
        com.offbytwo.jenkins
        jenkins-client
        0.3.8
    

创建Jenkins链接工具类JenkinsConnectFactory

package com.phz.jenkins_api_demo.factory;

import com.offbytwo.jenkins.JenkinsServer;
import com.offbytwo.jenkins.client.JenkinsHttpClient;

import java.net.URI;
import java.net.URISyntaxException;


public class JenkinsConnectFactory {
    static final String JENKINS_URL = "http://192.168.225.130";
    static final String JENKINS_USERNAME = "PengHuanZhi";
    static final String JENKINS_PASSWORD = "123456789";
    private static JenkinsHttpClient jenkinsHttpClient = null;
    private static JenkinsServer jenkinsServer = null;

    public static JenkinsHttpClient getClientInstance() {
        if (jenkinsHttpClient == null) {
            try {
                jenkinsHttpClient = new JenkinsHttpClient(new URI(JENKINS_URL, JENKINS_USERNAME, JENKINS_PASSWORD), "PengHuanZhi", "11622ce96b51846c8658a6390253d87f7e");
            } catch (URISyntaxException e) {
                e.printStackTrace();
            }
        }
        return jenkinsHttpClient;
    }

    public static JenkinsServer getConnection() {
        if (jenkinsServer == null) {
            try {
                jenkinsServer = new JenkinsServer(new URI(JENKINS_URL, JENKINS_USERNAME, JENKINS_PASSWORD), "PengHuanZhi", "11622ce96b51846c8658a6390253d87f7e");
            } catch (URISyntaxException e) {
                e.printStackTrace();
            }
        }
        return jenkinsServer;
    }
}

①、View Ⅰ、创建View

public void createView() {
    try {
        // 创建一个 xml 字符串，里面设置一个 view 描述信息
        String xml = "n" +
                "用于测试的视图n" +
                "";
        JenkinsConnectFactory.getConnection().createView("test-view", xml);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅱ、获取View

public void getView() {
    try {
        // 视图名
        String viewName = "test-view";
        // 获取视图基本信息
        View view = JenkinsConnectFactory.getConnection().getView(viewName);
        System.out.println(view.getName());
        System.out.println(view.getUrl());
        System.out.println(view.getDescription());
        // 获取视图xml信息
        String viewXml = JenkinsConnectFactory.getClientInstance().get("/view/" + viewName + "/api/xml");
        System.out.println(viewXml);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅲ、获取View配置 XML 信息

public void getViewConfig() {
    try {
        // 视图名
        String viewName = "test-view";
        // 获取视图配置xml信息
        String viewConfigXml = JenkinsConnectFactory.getClientInstance().get("/view/" + viewName + "/config.xml");
        System.out.println(viewConfigXml);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅳ、更新View

public void updateView() {
    try {
        // 创建一个 xml 字符串，里面设置一个要修改的某些字段,具体xml可以到jenkins查看
        // 例如，下面xml文件是从地址：https://Jenkins-IP/jenkins/view/test-view/config.xml 获取的
        String xml = "n" +
            "test-viewn" +
            "用于测试的视图1111n" +
            "falsen" +
            "falsen" +
            "n" +
            "n" +
            "n" +
            "n" +
            "n" +
            "n" +
            "n" +
            "n" +
            "n" +
            "n" +
            "n" +
            "n" +
            "n" +
            "n" +
            "n" +
            "falsen" +
            "";
        JenkinsConnectFactory.getConnection().updateView("test-view", xml);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅴ、删除View

public void deleteView() {
    try {
        String viewName = "test-view";
        JenkinsConnectFactory.getClientInstance().post("/view/" + viewName + "/doDelete");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

②、Job Ⅰ、创建Job

public void createJob() {
    try {
        
        // 创建 Pipeline 脚本
        String script = "node(){ n" +
                "echo 'hello world!' n" +
                "}";
        // xml配置文件，且将脚本加入到配置中
        String xml = "n" +
                "测试项目n" +
                "n" +
                "n" +
                "truen" +
                "n" +
                "";
        // 创建 Job
        JenkinsConnectFactory.getConnection().createJob("test-job", xml);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1bLLJziA-1633686593481)(C:UsersAdministratorAppDataRoamingTyporatypora-user-imagesimage-20211008161119542.png)]

Ⅱ、更新Job

public void updateJob() {
    try {
        
        // 创建 Pipeline 脚本，用一个key变量
        String script = "node(){ n" +
                "echo "${key}" n" +
                "}";
        // xml配置文件，且将脚本加入到配置中
        String xml = "n" +
                "n" +
                "测试项目n" +
                "falsen" +
                "n" +
                "n" +
                "n" +
                "n" +
                "keyn" +
                "用于测试的字符变量n" +
                "hellon" +
                "falsen" +
                "n" +
                "n" +
                "n" +
                "n" +
                "n" +
                "n" +
                "truen" +
                "n" +
                "falsen" +
                "";
        // 创建 Job
        JenkinsConnectFactory.getConnection().updateJob("test-job", xml);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅲ、获取Job基本信息

public void getJob() {
    try {
        // 获取 Job 信息
        JobWithDetails job = JenkinsConnectFactory.getConnection().getJob("test-job");
        // 获取 Job 名称
        System.out.println(job.getName());
        // 获取 Job URL
        System.out.println(job.getUrl());
        // 获取 Job 下一个 build 编号
        System.out.println(job.getNextBuildNumber());
        // 获取 Job 显示的名称
        System.out.println(job.getDisplayName());
        // 输出 Job 描述信息
        System.out.println(job.getDescription());
        // 获取 Job 下游任务列表
        System.out.println(job.getDownstreamProjects());
        // 获取 Job 上游任务列表
        System.out.println(job.getUpstreamProjects());
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅳ、获取Maven Job信息

public void getMavenJob() {
    try {
        // 获取 Job 信息
        MavenJobWithDetails job = JenkinsConnectFactory.getConnection().getMavenJob("HelloWorld");
        // 获取 Job 名称
        System.out.println(job.getName());
        // 获取 Job URL
        System.out.println(job.getUrl());
        // 获取 Job 下一个 build 编号
        System.out.println(job.getNextBuildNumber());
        // 获取 Job 显示的名称
        System.out.println(job.getDisplayName());
        // 获取 Job 下游任务列表
        System.out.println(job.getDownstreamProjects());
        // 获取 Job 上游任务列表
        System.out.println(job.getUpstreamProjects());
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅴ、获取Job列表

public void getJobList() {
    try {
        // 获取 Job 列表
        Map jobs = JenkinsConnectFactory.getConnection().getJobs();
        for (Job job : jobs.values()) {
            System.out.println(job.getName());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅵ、根据View名称获取Job列表

public void getJobListByView() {
    try {
        // 获取 Job 列表
        Map jobs = JenkinsConnectFactory.getConnection().getJobs("all");
        for (Job job : jobs.values()) {
            System.out.println(job.getName());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅶ、查看Job XML信息

public void getJobConfig() {
    try {
        String xml = JenkinsConnectFactory.getConnection().getJobXml("test-job");
        System.out.println(xml);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅷ、无参数 Job build

因为修改过本Job为有参Job，这里测试还需更改为无参job

public void buildJob() {
    try {
        JenkinsConnectFactory.getConnection().getJob("test-job").build();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅸ、有参构建

public void buildParamJob() {
    try {
        
        // 设置参数值
        Map param = new HashMap<>();
        param.put("key", "hello world!");
        // 执行 build 任务
        JenkinsConnectFactory.getConnection().getJob("test-job").build(param);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅹ、停止最后构建的 Job Build

public void stopLastJobBuild() {
    try {
        // 获取最后的 build 信息
        Build build = JenkinsConnectFactory.getConnection().getJob("HelloWorld").getLastBuild();
        // 停止最后的 build
        build.Stop();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

ⅩⅠ、禁用 Job

public void disableJob() {
    try {
        JenkinsConnectFactory.getConnection().disableJob("test-job");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

ⅩⅡ、启用Job

public void enableJob() {
    try {
        JenkinsConnectFactory.getConnection().enableJob("test-job");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

ⅩⅢ、删除 Job

public void deleteJob() {
    try {
        JenkinsConnectFactory.getConnection().deleteJob("test-job");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

③、编译 Ⅰ、获取Build基本信息

private void printBuild(Build build) throws IOException {
    System.out.println(build.getNumber());
    System.out.println(build.getUrl());
    System.out.println(build.getQueueId());
}

Ⅱ、获取 Job 最后的 Build

public void getJobLastBuild() {
    try {
        // 获取 Job 信息
        JobWithDetails job = JenkinsConnectFactory.getConnection().getJob("test-job");
        // 获得最后编译信息
        Build lastBuild = job.getLastBuild();
        printBuild(lastBuild);
        // 获取最后成功的编译信息
        Build lastSuccessfulBuild = job.getLastSuccessfulBuild();
        printBuild(lastSuccessfulBuild);
        // 获取最后事变的编译信息
        Build lastFailedBuild = job.getLastFailedBuild();
        printBuild(lastFailedBuild);
        // 获取最后完成的编译信息
        Build lastCompletedBuild = job.getLastCompletedBuild();
        printBuild(lastCompletedBuild);
        // 获取最后稳定的编译信息
        Build lastStableBuild = job.getLastStableBuild();
        printBuild(lastStableBuild);
        // 获取最后不稳定的编译信息
        Build lastUnstableBuild = job.getLastUnstableBuild();
        printBuild(lastUnstableBuild);
        // 获取最后未成功的编译信息
        Build lastUnsuccessfulBuild = job.getLastUnsuccessfulBuild();
        printBuild(lastUnsuccessfulBuild);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅲ、获取 Job 首次 Build

public void getJobFirstBuild() {
    try {
        // 获取 Job 信息
        JobWithDetails job = JenkinsConnectFactory.getConnection().getJob("test-job");
        // 获得首次编译信息
        Build firstBuild = job.getFirstBuild();
        printBuild(firstBuild);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅳ、根据 Job Build 编号获取编译信息

public void getJobByNumber() {
    try {
        // 获取 Job 信息
        JobWithDetails job = JenkinsConnectFactory.getConnection().getJob("test-job");
        // 根据
        Build numberBuild = job.getBuildByNumber(1);
        printBuild(numberBuild);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅴ、获取全部 Job Build列表

public void getJobBuildListAll() {
    try {
        // 获取 Job 信息
        JobWithDetails job = JenkinsConnectFactory.getConnection().getJob("test-job");
        // 获取全部 Build 信息
        List builds = job.getAllBuilds();
        for (Build build : builds) {
            System.out.println(build.getNumber());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅵ、获取 Job 一定范围的 Build 列表

public void getJobBuildListRange() {
    try {
        // 获取 Job 信息
        JobWithDetails job = JenkinsConnectFactory.getConnection().getJob("test-job");
        // 设定范围
        Range range = Range.build().from(0).to(2);
        System.err.println(range.getRangeString());
        // 获取一定范围的 Build 信息
        List builds = job.getAllBuilds(range);
        for (Build build : builds) {
            System.out.println(build.getNumber());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅶ、获取Build详细信息

public void getJobBuildDetailInfo() {
    try {
        // 获取 Job 信息
        JobWithDetails job = JenkinsConnectFactory.getConnection().getJob("test-job");
        // 这里用最后一次编译来示例
        BuildWithDetails build = job.getLastBuild().details();
        // 获取构建的显示名称
        System.out.println(build.getDisplayName());
        // 获取构建的参数信息
        System.out.println(build.getParameters());
        // 获取构建编号
        System.out.println(build.getNumber());
        // 获取构建结果，如果构建未完成则会显示为null
        System.out.println(build.getResult());
        // 获取执行构建的活动信息
        System.out.println(build.getActions());
        // 获取构建持续多少时间(ms)
        System.out.println(build.getDuration());
        // 获取构建开始时间戳
        System.out.println(build.getTimestamp());
        // 获取构建头信息，里面包含构建的用户，上游信息，时间戳等
        List buildCauses = build.getCauses();
        for (BuildCause bc : buildCauses) {
            System.out.println(bc.getUserId());
            System.out.println(bc.getShortDescription());
            System.out.println(bc.getUpstreamBuild());
            System.out.println(bc.getUpstreamProject());
            System.out.println(bc.getUpstreamUrl());
            System.out.println(bc.getUserName());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅷ、获取 Build Log 日志信息

public void getJobBuildLog() {
    try {
        // 获取 Job 信息
        JobWithDetails job = JenkinsConnectFactory.getConnection().getJob("test-job");
        // 这里用最后一次编译来示例
        BuildWithDetails build = job.getLastBuild().details();
        // 获取构建的日志，如果正在执行构建，则会只获取已经执行的过程日志

        // Text格式日志
        System.out.println(build.getConsoleOutputText());
        // Html格式日志
        System.out.println(build.getConsoleOutputHtml());

        // 获取部分日志,一般用于正在执行构建的任务
        ConsoleLog consoleLog = build.getConsoleOutputText(0);
        // 获取当前日志大小
        System.out.println(consoleLog.getCurrentBufferSize());
        // 是否已经构建完成，还有更多日志信息
        System.out.println(consoleLog.getHasMoreData());
        // 获取当前截取的日志信息
        System.out.println(consoleLog.getConsoleLog());
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅸ、获取正在执行构建任务的日志信息

public void getBuildActiveLog() {
    try {
        // 这里用最后一次编译来示例
        BuildWithDetails build = JenkinsConnectFactory.getConnection().getJob("test-job").getLastBuild().details();
        // 当前日志
        ConsoleLog currentLog = build.getConsoleOutputText(0);
        // 输出当前获取日志信息
        System.out.println(currentLog.getConsoleLog());
        // 检测是否还有更多日志,如果是则继续循环获取
        while (currentLog.getHasMoreData()) {
            // 获取最新日志信息
            ConsoleLog newLog = build.getConsoleOutputText(currentLog.getCurrentBufferSize());
            // 输出最新日志
            System.out.println(newLog.getConsoleLog());
            currentLog = newLog;
            // 睡眠1s
            Thread.sleep(1000);
        }
    } catch (IOException | InterruptedException e) {
        e.printStackTrace();
    }
}

④、其他 Ⅰ、获取主机信息

public void getComputerInfo() {
    try {
        Map map = JenkinsConnectFactory.getConnection().getComputers();
        for (Computer computer : map.values()) {
            // 获取当前节点-节点名称
            System.out.println(computer.details().getDisplayName());
            // 获取当前节点-执行者数量
            System.out.println(computer.details().getNumExecutors());
            // 获取当前节点-执行者详细信息
            List executorList = computer.details().getExecutors();
            // 查看当前节点-是否脱机
            System.out.println(computer.details().getOffline());
            // 获得节点的全部统计信息
            LoadStatistics loadStatistics = computer.details().getLoadStatistics();
            // 获取节点的-监控数据
            Map monitorData = computer.details().getMonitorData();
            //......
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅱ、重启Jenkins

public void restart() {
    try {
        JenkinsConnectFactory.getConnection().restart(true);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅲ、安全重启Jenkins

public void safeRestart() {
    try {
        JenkinsConnectFactory.getConnection().safeRestart(true);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅳ、安全结束Jenkins

public void safeExit() {
    try {
        JenkinsConnectFactory.getConnection().safeExit(true);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅴ、关闭连接

public void close() {
    JenkinsConnectFactory.getConnection().close();
}

Ⅵ、根据 Label 查找代理节点信息

public void getLabelNodeInfo() {
    try {
        LabelWithDetails labelWithDetails = JenkinsConnectFactory.getConnection().getLabel("jnlp-agent");
        // 获取标签名称
        System.out.println(labelWithDetails.getName());
        // 获取 Cloud 信息
        System.out.println(labelWithDetails.getClouds());
        // 获取节点信息
        System.out.println(labelWithDetails.getNodeName());
        // 获取关联的 Job
        System.out.println(labelWithDetails.getTiedJobs());
        // 获取参数列表
        System.out.println(labelWithDetails.getPropertiesList());
        // 是否脱机
        System.out.println(labelWithDetails.getOffline());
        // 获取描述信息
        System.out.println(labelWithDetails.getDescription());
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Ⅶ、判断Jenkins是否运行

public void isRunning() {
    boolean isRunning = JenkinsConnectFactory.getConnection().isRunning();
    System.out.println(isRunning);
}

Ⅷ、获取 Jenkins 插件信息

public void getPluginInfo() {
    try {
        PluginManager pluginManager = JenkinsConnectFactory.getConnection().getPluginManager();
        // 获取插件列表
        List plugins = pluginManager.getPlugins();
        for (Plugin plugin : plugins) {
            // 插件 wiki URL 地址
            System.out.println(plugin.getUrl());
            // 版本号
            System.out.println(plugin.getVersion());
            // 简称
            System.out.println(plugin.getShortName());
            // 完整名称
            System.out.println(plugin.getLongName());
            // 是否支持动态加载
            System.out.println(plugin.getSupportsDynamicLoad());
            // 插件依赖的组件
            System.out.println(plugin.getDependencies());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

4、问题处理 ①、HttpResponseException: Forbidden

这种跨域问题有两种处理办法，第一种就是关闭Jenkins的跨域保护

Ⅰ、关闭跨域保护（高版本）

笔者Jenkins服务放在了一台CentOS8虚拟机中

vim /etc/sysconfig/jenkins

找到JENKINS_JAVA_OPTIONS配置

在后面追加如下内容

-Dhudson.security.csrf.GlobalCrumbIssuerConfiguration.DISABLE_CSRF_PROTECTION=true

保存退出重启Jenkins服务

systemctl restart jenkins.service 

查看配置生效

Ⅱ、携带Token建立连接

进入用户管理页面，新增一个Token

在创建JenkinsHttpClient和JenkinsServer的时候添加该Token，如下

                jenkinsHttpClient = new JenkinsHttpClient(new URI(JENKINS_URL, JENKINS_USERNAME, JENKINS_PASSWORD), "PengHuanZhi", "11622ce96b51846c8658a6390253d87f7e");
                jenkinsServer = new JenkinsServer(new URI(JENKINS_URL, JENKINS_USERNAME, JENKINS_PASSWORD), "PengHuanZhi", "11622ce96b51846c8658a6390253d87f7e");

参考1

参考2