利用 Java 操作 Jenkins API 实现对 Jenkins 的控制详解
文章目录
!版权声明：本博客内容均为原创,每篇博文作为知识积累,写博不易,转载请注明出处。
由于最近工作需要利用 Jenkins 远程 API 操作 Jenkins 来完成一些列操作，就抽空研究了下如何利用 JAVA 操作 Jenkins API，实现对 Jenkins Job、View等等的增、删、改、查操作。
系统环境：
- Java 版本：1.8
- Jenkins 版本：2.172
参靠及项目地址：
- 本示例项目 Github 地址：https://github.com/my-dlq/blog-example/tree/master/jenkins/jenkins-api-demo
- Jenkins API wiki 地址：https://wiki.jenkins.io/display/JENKINS/Remote+access+API
- Jenkins-Java-Client Github 地址：https://github.com/jenkinsci/java-client-api
如果示例对你就帮助就 github 帮忙点个星哈~
一、 Jenkins API
1、Jenkins API 简介
Jenkins 远程 API 能够通过 Http 协议远程调用相关命令操作 Jenkins 进行 Jenkins 视图、任务、插件、构建信息、任务日志信息、统计信息等，非常容易与其配合更好的完成 CI/CD 工作。
2、Jenkins API 格式
Jenkins API 总共有三种格式，分别为：
- JSON API
- XML API
- Python API
3、Jenkins 查看 API 信息
可以用浏览器打开你的 Jenkins UI 界面，然后 URL 地址栏后面追加 “/api/json” 或者 “/api/xml” ，效果如下：
- “JenkinsURL/api/json” 显示：
1<hudson _class='hudson.model.Hudson'>
2 <assignedLabel>
3 <name>master</name>
4 </assignedLabel>
5 <mode>NORMAL</mode>
6 <nodeDescription>Jenkins的master节点</nodeDescription>
7 <nodeName></nodeName>
8 <numExecutors>1</numExecutors>
9 <job _class='org.jenkinsci.plugins.workflow.job.WorkflowJob'>
10 <name>deploy-test2</name>
11 <url>http://127.0.0.1:8080/jenkins/job/deploy-test2/</url>
12 <color>red</color>
13 </job>
14 <job _class='org.jenkinsci.plugins.workflow.job.WorkflowJob'>
15 <name>test-job</name>
16 <url>http://127.0.0.1:8080/jenkins/job/test-job/</url>
17 <color>blue</color>
18 </job>
19 <quietingDown>false</quietingDown>
20 <slaveAgentPort>50000</slaveAgentPort>
21 <unlabeledLoad _class='jenkins.model.UnlabeledLoadStatistics'></unlabeledLoad>
22 <useCrumbs>false</useCrumbs>
23 <useSecurity>true</useSecurity>
24 <view _class='hudson.model.AllView'>
25 <name>all</name>
26 <url>http://127.0.0.1:8080/jenkins/</url>
27 </view>
28</hudson>
- “JenkinsURL/api/xml” 显示：
1{
2 "_class": "hudson.model.Hudson",
3 "assignedLabels": [
4 {
5 "name": "master"
6 }
7 ],
8 "mode": "NORMAL",
9 "nodeDescription": "Jenkins的master节点",
10 "nodeName": "",
11 "numExecutors": 1,
12 "description": null,
13 "jobs": [
14 {
15 "_class": "org.jenkinsci.plugins.workflow.job.WorkflowJob",
16 "name": "deploy-test2",
17 "url": "http://127.0.0.1:8080/jenkins/job/deploy-test2/",
18 "color": "red"
19 },
20 {
21 "_class": "org.jenkinsci.plugins.workflow.job.WorkflowJob",
22 "name": "test-job",
23 "url": "http://127.0.0.1:8080/jenkins/job/test-job/",
24 "color": "blue"
25 }
26 ],
27 "overallLoad": {},
28 "primaryView": {
29 "_class": "hudson.model.AllView",
30 "name": "all",
31 "url": "http://127.0.0.1:8080/jenkins/"
32 },
33 "quietingDown": false,
34 "slaveAgentPort": 50000,
35 "unlabeledLoad": {
36 "_class": "jenkins.model.UnlabeledLoadStatistics"
37 },
38 "useCrumbs": false,
39 "useSecurity": true,
40 "views": [
41 {
42 "_class": "hudson.model.AllView",
43 "name": "all",
44 "url": "http://192.168.2.11:8080/jenkins/"
45 }
46 ]
47}
还可以访问 View、Job等 API 信息，例如：
- View API： /view/<view-name>/api/json
- Job API： /job/<job-name>/api/xml
- build API： /job/<job-name>/<build-number>/
二、调用接口前对 Jenkins 参数调整
1、关闭 CSRF
由于在调用 Jenkins 中，操作执行 Job 一些命令时会用到 Post 方式命令，所以需要关闭 Jenkins 的 CSRF 选项。
关闭 系统管理->全局安全配置->跨站请求伪造保护 选项
2、系统设置中和 jenkins 地址一致
设置 系统管理->系统设置->Jenkins Location 的 URL 和 Jenkins 访问地址保持一致
三、使用 Java 调用 Jenkins API 示例
下面将演示如何通过 Java 调用 Jenkins API 来对 Jenkins 进行操作，在注释中有详细描述，就不在外面一步步说明了。
本示例项目 Github 地址：https://github.com/my-dlq/blog-example/tree/master/jenkins-api-demo
1、Maven 引入工具
在 Jenkins Github 中查找到已经有人做了封装调用 Jenkins API 的工具 Jar，这里只需要我们 Maven 中引入这个工具 java-client-api，就可以方便的调用 Jenkins API 了。
1<?xml version="1.0" encoding="UTF-8"?>
2<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4 <modelVersion>4.0.0</modelVersion>
5
6 <groupId>club.mydlq</groupId>
7 <artifactId>jenkins-api-demo</artifactId>
8 <version>0.0.1</version>
9 <name>jenkins-api-demo</name>
10 <description>jenkins api demo</description>
11
12 <properties>
13 <java.version>1.8</java.version>
14 </properties>
15
16 <dependencies>
17 <!--jenkins-java-client-->
18 <dependency>
19 <groupId>com.offbytwo.jenkins</groupId>
20 <artifactId>jenkins-client</artifactId>
21 <version>0.3.8</version>
22 </dependency>
23 </dependencies>
24
25</project>
2、连接 Jenkins 工具类
此类主要用于连接 Jenkins
JenkinsConnect.java
1import com.offbytwo.jenkins.JenkinsServer;
2import com.offbytwo.jenkins.client.JenkinsHttpClient;
3import java.net.URI;
4import java.net.URISyntaxException;
5
6/**
7 * 连接 Jenkins
8 */
9public class JenkinsConnect {
10
11 private JenkinsConnect(){}
12
13 // 连接 Jenkins 需要设置的信息
14 static final String JENKINS_URL = "http://192.168.2.11:8080/jenkins/";
15 static final String JENKINS_USERNAME = "admin";
16 static final String JENKINS_PASSWORD = "123456";
17
18 /**
19 * Http 客户端工具
20 *
21 * 如果有些 API 该Jar工具包未提供，可以用此Http客户端操作远程接口，执行命令
22 * @return
23 */
24 public static JenkinsHttpClient getClient(){
25 JenkinsHttpClient jenkinsHttpClient = null;
26 try {
27 jenkinsHttpClient = new JenkinsHttpClient(new URI(JENKINS_URL), JENKINS_USERNAME, JENKINS_PASSWORD);
28 } catch (URISyntaxException e) {
29 e.printStackTrace();
30 }
31 return jenkinsHttpClient;
32 }
33
34 /**
35 * 连接 Jenkins
36 */
37 public static JenkinsServer connection() {
38 JenkinsServer jenkinsServer = null;
39 try {
40 jenkinsServer = new JenkinsServer(new URI(JENKINS_URL), JENKINS_USERNAME, JENKINS_PASSWORD);
41 } catch (URISyntaxException e) {
42 e.printStackTrace();
43 }
44 return jenkinsServer;
45 }
46}
3、操作视图
此类主要用于操作 Jenkins 中的 View
ViewApi.java
1import com.offbytwo.jenkins.JenkinsServer;
2import com.offbytwo.jenkins.client.JenkinsHttpClient;
3import com.offbytwo.jenkins.model.View;
4import java.io.IOException;
5
6/**
7 * View(视图) 相关操作
8 *
9 * 例如对视图的增、删、改、查等操作
10 */
11public class ViewApi {
12
13 // Jenkins 对象
14 private JenkinsServer jenkinsServer;
15 // http 客户端对象
16 private JenkinsHttpClient jenkinsHttpClient;
17
18 /**
19 * 构造方法中调用连接 Jenkins 方法
20 */
21 ViewApi() {
22 JenkinsApi jenkinsApi = new JenkinsApi();
23 // 连接 Jenkins
24 jenkinsServer = JenkinsConnect.connection();
25 // 设置客户端连接 Jenkins
26 jenkinsHttpClient = JenkinsConnect.getClient();
27 }
28
29 /**
30 * 创建视图
31 */
32 public void createView() {
33 try {
34 // 创建一个 xml 字符串，里面设置一个 view 描述信息
35 String xml = "<listView _class=\"hudson.model.ListView\">\n" +
36 "<description>用于测试的视图</description>\n" +
37 "</listView>";
38 // 创建 view
39 jenkinsServer.createView("test-view", xml);
40 } catch (IOException e) {
41 e.printStackTrace();
42 }
43 }
44
45 /**
46 * 获取视图基本信息
47 */
48 public void getView() {
49 try {
50 // 视图名
51 String viewName = "test-view";
52 // 获取视图基本信息
53 View view = jenkinsServer.getView(viewName);
54 System.out.println(view.getName());
55 System.out.println(view.getUrl());
56 System.out.println(view.getDescription());
57 // 获取视图xml信息
58 String viewXml = jenkinsHttpClient.get("/view/" + viewName + "/api/xml");
59 System.out.println(viewXml);
60 } catch (IOException e) {
61 e.printStackTrace();
62 }
63 }
64
65 /**
66 * 获取视图配置 XML 信息
67 */
68 public void getViewConfig() {
69 try {
70 // 视图名
71 String viewName = "test-view";
72 // 获取视图配置xml信息
73 String viewConfigXml = jenkinsHttpClient.get("/view/" + viewName + "/config.xml");
74 System.out.println(viewConfigXml);
75 } catch (IOException e) {
76 e.printStackTrace();
77 }
78 }
79
80 /**
81 * 更新视图信息
82 */
83 public void updateView() {
84 try {
85 // 创建一个 xml 字符串，里面设置一个要修改的某些字段,具体xml可以到jenkins查看
86 // 例如，下面xml文件是从地址：https://Jenkins-IP/jenkins/view/test-view/config.xml 获取的
87 String xml = "<hudson.model.ListView>\n" +
88 "<name>test-view</name>\n" +
89 "<description>用于测试的视图1111</description>\n" +
90 "<filterExecutors>false</filterExecutors>\n" +
91 "<filterQueue>false</filterQueue>\n" +
92 "<properties class=\"hudson.model.View$PropertyList\"/>\n" +
93 "<jobNames>\n" +
94 "<comparator class=\"hudson.util.CaseInsensitiveComparator\"/>\n" +
95 "</jobNames>\n" +
96 "<jobFilters/>\n" +
97 "<columns>\n" +
98 "<hudson.views.StatusColumn/>\n" +
99 "<hudson.views.WeatherColumn/>\n" +
100 "<hudson.views.JobColumn/>\n" +
101 "<hudson.views.LastSuccessColumn/>\n" +
102 "<hudson.views.LastFailureColumn/>\n" +
103 "<hudson.views.LastDurationColumn/>\n" +
104 "<hudson.views.BuildButtonColumn/>\n" +
105 "<hudson.plugins.favorite.column.FavoriteColumn plugin=\"favorite@2.3.2\"/>\n" +
106 "</columns>\n" +
107 "<recurse>false</recurse>\n" +
108 "</hudson.model.ListView>";
109 jenkinsServer.updateView("test-view", xml);
110 } catch (IOException e) {
111 e.printStackTrace();
112 }
113 }
114
115 /**
116 * 删除视图
117 */
118 public void deleteView() {
119 try {
120 String viewName = "test-view";
121 jenkinsHttpClient.post("/view/" + viewName + "/doDelete");
122 } catch (IOException e) {
123 e.printStackTrace();
124 }
125 }
126
127
128 public static void main(String[] args) {
129 ViewApi viewApi = new ViewApi();
130 // 创建视图
131 //viewApi.createView();
132 // 获取视图信息
133 //viewApi.getView();
134 // 获取视图配置xml信息
135 //viewApi.getViewConfig();
136 // 更新视图信息
137 //viewApi.updateView();
138 // 删除视图
139 //viewApi.deleteView();
140 }
141}
4、操作任务
此类主要用于操作 Jenkins 中的 Job
JobApi.java
1import com.offbytwo.jenkins.JenkinsServer;
2import com.offbytwo.jenkins.client.JenkinsHttpClient;
3import com.offbytwo.jenkins.model.Build;
4import com.offbytwo.jenkins.model.Job;
5import com.offbytwo.jenkins.model.JobWithDetails;
6import com.offbytwo.jenkins.model.MavenJobWithDetails;
7import java.io.IOException;
8import java.util.HashMap;
9import java.util.Map;
10
11/**
12 * Job(任务) 相关操作
13 *
14 * 例如对任务的增、删、改、查等操作
15 */
16public class JobApi {
17
18 // Jenkins 对象
19 private JenkinsServer jenkinsServer;
20 // http 客户端对象
21 private JenkinsHttpClient jenkinsHttpClient;
22
23 /**
24 * 构造方法中调用连接 Jenkins 方法
25 */
26 JobApi() {
27 JenkinsApi jenkinsApi = new JenkinsApi();
28 // 连接 Jenkins
29 jenkinsServer = JenkinsConnect.connection();
30 // 设置客户端连接 Jenkins
31 jenkinsHttpClient = JenkinsConnect.getClient();
32 }
33
34 /**
35 * 创建 Job
36 */
37 public void ceateJob(){
38 try {
39 /**创建一个流水线任务，且设置一个简单的脚本**/
40 // 创建 Pipeline 脚本
41 String script = "node(){ \n" +
42 "echo 'hello world!' \n" +
43 "}";
44 // xml配置文件，且将脚本加入到配置中
45 String xml = "<flow-definition plugin=\"workflow-job@2.32\">\n" +
46 "<description>测试项目</description>\n" +
47 "<definition class=\"org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition\" plugin=\"workflow-cps@2.66\">\n" +
48 "<script>" + script + "</script>\n" +
49 "<sandbox>true</sandbox>\n" +
50 "</definition>\n" +
51 "</flow-definition>";
52 // 创建 Job
53 jenkinsServer.createJob("test-job",xml);
54 } catch (IOException e) {
55 e.printStackTrace();
56 }
57 }
58
59 /**
60 * 更新 Job
61 *
62 * 更改之前创建的无参数Job，更改其为参数Job
63 */
64 public void updateJob(){
65 try {
66 /**
67 * 更改一个流水线任务，让一个无参数的任务变成带参数任务
68 */
69 // 创建 Pipeline 脚本，用一个key变量
70 String script = "node(){ \n" +
71 "echo \"${key}\" \n" +
72 "}";
73 // xml配置文件，且将脚本加入到配置中
74 String xml = "<flow-definition plugin=\"workflow-job@2.32\">\n" +
75 "<actions/>\n" +
76 "<description>测试项目</description>\n" +
77 "<keepDependencies>false</keepDependencies>\n" +
78 "<properties>\n" +
79 "<hudson.model.ParametersDefinitionProperty>\n" +
80 "<parameterDefinitions>\n" +
81 "<hudson.model.StringParameterDefinition>\n" +
82 "<name>key</name>\n" +
83 "<description>用于测试的字符变量</description>\n" +
84 "<defaultValue>hello</defaultValue>\n" +
85 "<trim>false</trim>\n" +
86 "</hudson.model.StringParameterDefinition>\n" +
87 "</parameterDefinitions>\n" +
88 "</hudson.model.ParametersDefinitionProperty>\n" +
89 "</properties>\n" +
90 "<definition class=\"org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition\" plugin=\"workflow-cps@2.66\">\n" +
91 "<script>" + script + "</script>\n" +
92 "<sandbox>true</sandbox>\n" +
93 "</definition>\n" +
94 "<disabled>false</disabled>\n" +
95 "</flow-definition>";
96 // 创建 Job
97 jenkinsServer.updateJob("test-job",xml);
98 } catch (IOException e) {
99 e.printStackTrace();
100 }
101 }
102
103 /**
104 * 获取 Job 基本信息
105 */
106 public void getJob(){
107 try {
108 // 获取 Job 信息
109 JobWithDetails job = jenkinsServer.getJob("test-job");
110 // 获取 Job 名称
111 System.out.println(job.getName());
112 // 获取 Job URL
113 System.out.println(job.getUrl());
114 // 获取 Job 下一个 build 编号
115 System.out.println(job.getNextBuildNumber());
116 // 获取 Job 显示的名称
117 System.out.println(job.getDisplayName());
118 // 输出 Job 描述信息
119 System.out.println(job.getDescription());
120 // 获取 Job 下游任务列表
121 System.out.println(job.getDownstreamProjects());
122 // 获取 Job 上游任务列表
123 System.out.println(job.getUpstreamProjects());
124 } catch (IOException e) {
125 e.printStackTrace();
126 }
127 }
128
129 /**
130 * 获取 Maven Job 信息
131 */
132 public void getMavenJob(){
133 try {
134 // 获取 Job 信息
135 MavenJobWithDetails job = jenkinsServer.getMavenJob("test-job");
136 } catch (IOException e) {
137 e.printStackTrace();
138 }
139 }
140
141 /**
142 * 获取 Job 列表
143 */
144 public void getJobList(){
145 try {
146 // 获取 Job 列表
147 Map<String,Job> jobs = jenkinsServer.getJobs();
148 for (Job job:jobs.values()){
149 System.out.println(job.getName());
150 }
151 } catch (IOException e) {
152 e.printStackTrace();
153 }
154 }
155
156 /**
157 * 获取 View 名称获取 Job 列表
158 */
159 public void getJobListByView(){
160 try {
161 // 获取 Job 列表
162 Map<String,Job> jobs = jenkinsServer.getJobs("all");
163 for (Job job:jobs.values()){
164 System.out.println(job.getName());
165 }
166 } catch (IOException e) {
167 e.printStackTrace();
168 }
169 }
170
171 /**
172 * 查看 Job XML 信息
173 */
174 public void getJobConfig(){
175 try {
176 String xml = jenkinsServer.getJobXml("test-job");
177 System.out.println(xml);
178 } catch (IOException e) {
179 e.printStackTrace();
180 }
181 }
182
183 /**
184 * 执行无参数 Job build
185 */
186 public void buildJob(){
187 try {
188 jenkinsServer.getJob("test-job").build();
189 } catch (IOException e) {
190 e.printStackTrace();
191 }
192 }
193
194 /**
195 * 执行带参数 Job build
196 */
197 public void buildParamJob(){
198 try {
199 /**
200 * 例如，现有一个job，拥有一个字符参数"key"
201 * 现在对这个值进行设置，然后执行一个输出这个值的脚本
202 */
203 // 设置参数值
204 Map<String,String> param = new HashMap<>();
205 param.put("key","hello world!");
206 // 执行 build 任务
207 jenkinsServer.getJob("test-job").build(param);
208 } catch (IOException e) {
209 e.printStackTrace();
210 }
211 }
212
213 /**
214 * 停止最后构建的 Job Build
215 */
216 public void stopLastJobBuild(){
217 try {
218 // 获取最后的 build 信息
219 Build build = jenkinsServer.getJob("test-job").getLastBuild();
220 // 停止最后的 build
221 build.Stop();
222 } catch (IOException e) {
223 e.printStackTrace();
224 }
225 }
226
227 /**
228 * 删除 Job
229 */
230 public void deleteJob(){
231 try {
232 jenkinsServer.deleteJob("test-job");
233 } catch (IOException e) {
234 e.printStackTrace();
235 }
236 }
237
238 /**
239 * 禁用 Job
240 */
241 public void disableJob(){
242 try {
243 jenkinsServer.disableJob("test-job");
244 } catch (IOException e) {
245 e.printStackTrace();
246 }
247 }
248
249 /**
250 * 启用 Job
251 */
252 public void enableJob(){
253 try {
254 jenkinsServer.enableJob("test-job");
255 } catch (IOException e) {
256 e.printStackTrace();
257 }
258 }
259
260 public static void main(String[] args) {
261 JobApi jobApi = new JobApi();
262 // 创建 Job
263 jobApi.ceateJob();
264 // 构建无参数的 Job
265 jobApi.buildJob();
266 // 构建带参数的 Job
267 jobApi.buildParamJob();
268 // 停止最后构建的 Job Build
269 jobApi.stopLastJobBuild();
270 // 更新 Job
271 jobApi.updateJob();
272 // 获取 Job 信息
273 jobApi.getJob();
274 // 获取 Maven 项目 Job
275 jobApi.getMavenJob();
276 // 获取 Job 配置xml
277 jobApi.getJobConfig();
278 // 获取全部 Job 列表
279 jobApi.getJobList();
280 // 根据 view 名称获取 Job 列表
281 jobApi.getJobListByView();
282 // 禁用 Job
283 jobApi.disableJob();
284 // 启用 Job
285 jobApi.enableJob();
286 // 删除 Job
287 jobApi.deleteJob();
288 }
289
290}
5、操作编译
此类主要用于操作 Jenkins 中的 Build
JobBuildApi.java
1import com.offbytwo.jenkins.JenkinsServer;
2import com.offbytwo.jenkins.client.JenkinsHttpClient;
3import com.offbytwo.jenkins.helper.Range;
4import com.offbytwo.jenkins.model.*;
5import java.io.IOException;
6import java.util.List;
7
8/**
9 * Job Build(任务构建) 相关操作
10 *
11 * 例如对任务 Build 相关的信息进行获取操作、例如获取构建日志
12 */
13public class JobBuildApi {
14
15 // Jenkins 对象
16 private JenkinsServer jenkinsServer;
17 // http 客户端对象
18 private JenkinsHttpClient jenkinsHttpClient;
19
20 /**
21 * 构造方法中调用连接 Jenkins 方法
22 */
23 JobBuildApi() {
24 JenkinsApi jenkinsApi = new JenkinsApi();
25 // 连接 Jenkins
26 jenkinsServer = JenkinsConnect.connection();
27 // 设置客户端连接 Jenkins
28 jenkinsHttpClient = JenkinsConnect.getClient();
29 }
30
31 /**
32 * 获取 Job 最后的 Build
33 */
34 public void getJobLastBuild(){
35 try {
36 // 获取 Job 信息
37 JobWithDetails job = jenkinsServer.getJob("test-job");
38 // 获得最后编译信息
39 Build lastBuild = job.getLastBuild();
40 // 获取最后成功的编译信息
41 Build lastSuccessfulBuild = job.getLastSuccessfulBuild();
42 // 获取最后事变的编译信息
43 Build lastFailedBuild = job.getLastFailedBuild();
44 // 获取最后完成的编译信息
45 Build lastCompletedBuild = job.getLastCompletedBuild();
46 // 获取最后稳定的编译信息
47 Build lastStableBuild = job.getLastStableBuild();
48 // 获取最后不稳定的编译信息
49 Build lastUnstableBuild = job.getLastUnstableBuild();
50 // 获取最后未成功的编译信息
51 Build lastUnsuccessfulBuild = job.getLastUnsuccessfulBuild();
52 } catch (IOException e) {
53 e.printStackTrace();
54 }
55 }
56
57 /**
58 * 获取 Job 首次 Build
59 */
60 public void getJobFirstBuild(){
61 try {
62 // 获取 Job 信息
63 JobWithDetails job = jenkinsServer.getJob("test-job");
64 // 获得首次编译信息
65 Build firstBuild = job.getFirstBuild();
66 } catch (IOException e) {
67 e.printStackTrace();
68 }
69 }
70
71 /**
72 * 根据 Job Build 编号获取编译信息
73 */
74 public void getJobByNumber(){
75 try {
76 // 获取 Job 信息
77 JobWithDetails job = jenkinsServer.getJob("test-job");
78 // 根据
79 Build numberBuild = job.getBuildByNumber(1);
80 } catch (IOException e) {
81 e.printStackTrace();
82 }
83 }
84
85 /**
86 * 获取全部 Job Build列表
87 */
88 public void getJobBuildListAll(){
89 try {
90 // 获取 Job 信息
91 JobWithDetails job = jenkinsServer.getJob("test-job");
92 // 获取全部 Build 信息
93 List<Build> builds = job.getAllBuilds();
94 for (Build build:builds){
95 System.out.println(build.getNumber());
96 }
97 } catch (IOException e) {
98 e.printStackTrace();
99 }
100 }
101
102 /**
103 * 获取 Job 一定范围的 Build 列表
104 */
105 public void getJobBuildListRange(){
106 try {
107 // 获取 Job 信息
108 JobWithDetails job = jenkinsServer.getJob("test-job");
109 // 设定范围
110 Range range = Range.build().from(1).to(2);
111 System.err.println(range.getRangeString());
112 // 获取一定范围的 Build 信息
113 List<Build> builds = job.getAllBuilds(range);
114 for (Build build:builds){
115 System.out.println(build.getNumber());
116 }
117 } catch (IOException e) {
118 e.printStackTrace();
119 }
120 }
121
122 /**
123 * 获取 Build 基本信息
124 */
125 public void getJobBuildInfo(){
126 try {
127 // 获取 Job 信息
128 JobWithDetails job = jenkinsServer.getJob("test-job");
129 // 这里用最后一次编译来示例
130 Build build = job.getLastBuild();
131 // 获取构建的 URL 地址
132 System.out.println(build.getUrl());
133 // 获取构建编号
134 System.out.println(build.getNumber());
135 // 获取测试报告
136 //build.getTestReport();
137 // 获取测试结果
138 //build.getTestResult();
139 } catch (IOException e) {
140 e.printStackTrace();
141 }
142 }
143
144 /**
145 * 获取 Build 详细信息
146 */
147 public void getJobBuildDetailInfo(){
148 try {
149 // 获取 Job 信息
150 JobWithDetails job = jenkinsServer.getJob("test-job");
151 // 这里用最后一次编译来示例
152 BuildWithDetails build = job.getLastBuild().details();
153 // 获取构建的显示名称
154 System.out.println(build.getDisplayName());
155 // 获取构建的参数信息
156 System.out.println(build.getParameters());
157 // 获取构建编号
158 System.out.println(build.getNumber());
159 // 获取构建结果，如果构建未完成则会显示为null
160 System.out.println(build.getResult());
161 // 获取执行构建的活动信息
162 System.out.println(build.getActions());
163 // 获取构建持续多少时间(ms)
164 System.out.println(build.getDuration());
165 // 获取构建开始时间戳
166 System.out.println(build.getTimestamp());
167 // 获取构建头信息，里面包含构建的用户，上游信息，时间戳等
168 List<BuildCause> buildCauses = build.getCauses();
169 for (BuildCause bc:buildCauses){
170 System.out.println(bc.getUserId());
171 System.out.println(bc.getShortDescription());
172 System.out.println(bc.getUpstreamBuild());
173 System.out.println(bc.getUpstreamProject());
174 System.out.println(bc.getUpstreamUrl());
175 System.out.println(bc.getUserName());
176 }
177 } catch (IOException e) {
178 e.printStackTrace();
179 }
180 }
181
182 /**
183 * 获取 Build Log 日志信息
184 */
185 public void getJobBuildLog(){
186 try {
187 // 获取 Job 信息
188 JobWithDetails job = jenkinsServer.getJob("test-job");
189 // 这里用最后一次编译来示例
190 BuildWithDetails build = job.getLastBuild().details();
191 // 获取构建的日志，如果正在执行构建，则会只获取已经执行的过程日志
192
193 // Text格式日志
194 System.out.println(build.getConsoleOutputText());
195 // Html格式日志
196 System.out.println(build.getConsoleOutputHtml());
197
198 // 获取部分日志,一般用于正在执行构建的任务
199 ConsoleLog consoleLog = build.getConsoleOutputText(0);
200 // 获取当前日志大小
201 System.out.println(consoleLog.getCurrentBufferSize());
202 // 是否已经构建完成，还有更多日志信息
203 System.out.println(consoleLog.getHasMoreData());
204 // 获取当前截取的日志信息
205 System.out.println(consoleLog.getConsoleLog());
206 }catch (IOException e) {
207 e.printStackTrace();
208 }
209 }
210
211 /**
212 * 获取正在执行构建任务的日志信息
213 */
214 public void getBuildActiveLog(){
215 try {
216 // 这里用最后一次编译来示例
217 BuildWithDetails build = jenkinsServer.getJob("test-job").getLastBuild().details();
218 // 当前日志
219 ConsoleLog currentLog = build.getConsoleOutputText(0);
220 // 输出当前获取日志信息
221 System.out.println(currentLog.getConsoleLog());
222 // 检测是否还有更多日志,如果是则继续循环获取
223 while (currentLog.getHasMoreData()){
224 // 获取最新日志信息
225 ConsoleLog newLog = build.getConsoleOutputText(currentLog.getCurrentBufferSize());
226 // 输出最新日志
227 System.out.println(newLog.getConsoleLog());
228 currentLog = newLog;
229 // 睡眠1s
230 Thread.sleep(1000);
231 }
232 }catch (IOException | InterruptedException e) {
233 e.printStackTrace();
234 }
235 }
236
237 public static void main(String[] args) {
238 JobBuildApi jobBuildApi = new JobBuildApi();
239 // 获取 Job 最后的 Build
240 jobBuildApi.getJobLastBuild();
241 // 获取 Job 首次 Build
242 jobBuildApi.getJobFirstBuild();
243 // 根据 Job Build 编号获取编译信息
244 jobBuildApi.getJobByNumber();
245 // 获取 Build 全部列表
246 jobBuildApi.getJobBuildListAll();
247 // 获取一定范围的 Build 列表
248 jobBuildApi.getJobBuildListRange();
249 // 获取 Build 基本信息
250 jobBuildApi.getJobBuildInfo();
251 // 获取 Build 详细信息
252 jobBuildApi.getJobBuildDetailInfo();
253 // 获取 Build Log 日志信息
254 jobBuildApi.getJobBuildLog();
255 // 获得正在执行的编译 Log 日志信息
256 jobBuildApi.getBuildActiveLog();
257 }
258}
6、其它 Jenkins 相关操作
此类主要用于操作 Jenkins 中的基本信息，例如关闭 Jenkins、获取 Jenkins 插件信息等。
JenkinsApi.java
1import java.io.IOException;
2import com.offbytwo.jenkins.JenkinsServer;
3import com.offbytwo.jenkins.model.*;
4import java.util.List;
5import java.util.Map;
6
7/**
8 * 获取 Jenkins 相关信息
9 *
10 * 例如获取插件信息、获取Label信息、关闭Jenkins等
11 */
12public class JenkinsApi {
13
14 // Jenkins 对象
15 private JenkinsServer jenkinsServer;
16
17 /**
18 * 构造方法中调用连接 Jenkins 方法
19 */
20 JenkinsApi(){
21 jenkinsServer = JenkinsConnect.connection();
22 }
23
24 /**
25 * 获取主机信息
26 */
27 public void getComputerInfo() {
28 try {
29 Map<String, Computer> map = jenkinsServer.getComputers();
30 for (Computer computer : map.values()) {
31 // 获取当前节点-节点名称
32 System.out.println(computer.details().getDisplayName());
33 // 获取当前节点-执行者数量
34 System.out.println(computer.details().getNumExecutors());
35 // 获取当前节点-执行者详细信息
36 List<Executor> executorList = computer.details().getExecutors();
37 // 查看当前节点-是否脱机
38 System.out.println(computer.details().getOffline());
39 // 获得节点的全部统计信息
40 LoadStatistics loadStatistics = computer.details().getLoadStatistics();
41 // 获取节点的-监控数据
42 Map<String, Map> monitorData = computer.details().getMonitorData();
43 //......
44 }
45 } catch (IOException e) {
46 e.printStackTrace();
47 }
48 }
49
50 /**
51 * 重启 Jenkins
52 */
53 public void restart() {
54 try {
55 jenkinsServer.restart(true);
56 } catch (IOException e) {
57 e.printStackTrace();
58 }
59 }
60
61 /**
62 * 安全重启 Jenkins
63 */
64 public void safeRestart() {
65 try {
66 jenkinsServer.safeRestart(true);
67 } catch (IOException e) {
68 e.printStackTrace();
69 }
70 }
71
72 /**
73 * 安全结束 Jenkins
74 */
75 public void safeExit() {
76 try {
77 jenkinsServer.safeExit(true);
78 } catch (IOException e) {
79 e.printStackTrace();
80 }
81 }
82
83 /**
84 * 关闭 Jenkins 连接
85 */
86 public void close() {
87 jenkinsServer.close();
88 }
89
90 /**
91 * 根据 Label 查找代理节点信息
92 */
93 public void getLabelNodeInfo() {
94 try {
95 LabelWithDetails labelWithDetails = jenkinsServer.getLabel("jnlp-agent");
96 // 获取标签名称
97 System.out.println(labelWithDetails.getName());
98 // 获取 Cloud 信息
99 System.out.println(labelWithDetails.getClouds());
100 // 获取节点信息
101 System.out.println(labelWithDetails.getNodeName());
102 // 获取关联的 Job
103 System.out.println(labelWithDetails.getTiedJobs());
104 // 获取参数列表
105 System.out.println(labelWithDetails.getPropertiesList());
106 // 是否脱机
107 System.out.println(labelWithDetails.getOffline());
108 // 获取描述信息
109 System.out.println(labelWithDetails.getDescription());
110 } catch (IOException e) {
111 e.printStackTrace();
112 }
113 }
114
115 /**
116 * 判断 Jenkins 是否运行
117 */
118 public void isRunning() {
119 boolean isRunning = jenkinsServer.isRunning();
120 System.out.println(isRunning);
121 }
122
123 /**
124 * 获取 Jenkins 插件信息
125 */
126 public void getPluginInfo(){
127 try {
128 PluginManager pluginManager =jenkinsServer.getPluginManager();
129 // 获取插件列表
130 List<Plugin> plugins = pluginManager.getPlugins();
131 for (Plugin plugin:plugins){
132 // 插件 wiki URL 地址
133 System.out.println(plugin.getUrl());
134 // 版本号
135 System.out.println(plugin.getVersion());
136 // 简称
137 System.out.println(plugin.getShortName());
138 // 完整名称
139 System.out.println(plugin.getLongName());
140 // 是否支持动态加载
141 System.out.println(plugin.getSupportsDynamicLoad());
142 // 插件依赖的组件
143 System.out.println(plugin.getDependencies());
144 }
145 } catch (IOException e) {
146 e.printStackTrace();
147 }
148 }
149
150 public static void main(String[] args) {
151 // 创建 JenkinsApi 对象，并在构造方法中连接 Jenkins
152 JenkinsApi jenkinsApi = new JenkinsApi();
153 // 重启 Jenkins
154 //jenkinsApi.restart();
155 // 安全重启 Jenkins
156 //jenkinsApi.safeRestart();
157 // 获取节点信息
158 //jenkinsApi.getComputerInfo();
159 // 安全结束 Jenkins
160 //jenkinsApi.safeExit();
161 // 关闭 Jenkins 连接
162 //jenkinsApi.close();
163 // 获取 Label 节点信息
164 //jenkinsApi.getLabelNodeInfo();
165 // 查看 Jenkins 是否允许
166 //jenkinsApi.isRunning();
167 // 获取 Jenkins 插件信息
168 //jenkinsApi.getPluginInfo();
169 }
170
171}
四、对 Java Client 组件的补充
关于该 Jenkins Java Client 部分功能封装并不完整，这里有部分网友咨询相关问题，补充一下：
1import com.offbytwo.jenkins.JenkinsServer;
2import com.offbytwo.jenkins.client.JenkinsHttpClient;
3import com.offbytwo.jenkins.client.util.EncodingUtils;
4import java.io.IOException;
5
6public class CustomService {
7
8 // Jenkins 对象
9 private JenkinsServer jenkinsServer;
10 // http 客户端对象
11 private JenkinsHttpClient jenkinsHttpClient;
12
13 /**
14 * 构造方法中调用连接 Jenkins 方法
15 */
16 CustomService() {
17 // 连接 Jenkins
18 jenkinsServer = JenkinsConnect.connection();
19 // 设置客户端连接 Jenkins
20 jenkinsHttpClient = JenkinsConnect.getClient();
21 }
22
23 /**
24 * 创建 Jenkins Job 并指定 Job 类型
25 * 关于 Jenkins Job 部分类型，如下：
26 * - 自由风格项目：hudson.model.FreeStyleProject
27 * - Maven 项目：hudson.maven.MavenModuleSet
28 * - 流水线项目：org.jenkinsci.plugins.workflow.job.WorkflowJob
29 * - 多配置项目：hudson.matrix.MatrixProject
30 */
31 public void createJob() {
32 try {
33 // job 名称
34 String jobName = "test-project";
35 // 创建 Job 的 xml，可以在 jenkins 中查看，例如 http://jenkins.mydlq.club/job/{job名称}/config.xml 来查看该 job 的 xml 配置
36 String jobXml = "<project>\n" +
37 "<keepDependencies>false</keepDependencies>\n" +
38 "<properties/>\n" +
39 "<scm class=\"hudson.scm.NullSCM\"/>\n" +
40 "<canRoam>false</canRoam>\n" +
41 "<disabled>false</disabled>\n" +
42 "<blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>\n" +
43 "<blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>\n" +
44 "<triggers/>\n" +
45 "<concurrentBuild>false</concurrentBuild>\n" +
46 "<builders/>\n" +
47 "<publishers/>\n" +
48 "<buildWrappers/>\n" +
49 "<link type=\"text/css\" id=\"dark-mode\" rel=\"stylesheet\" href=\"\"/>\n" +
50 "</project>";
51 // 创建 Jenkins Job 并指定 Job 类型
52 jenkinsHttpClient.post_xml("createItem?name=" + EncodingUtils.encodeParam(jobName) +
53 "&mode=hudson.model.FreeStyleProject", jobXml, true);
54 } catch (IOException e) {
55 e.printStackTrace();
56 }
57 }
58
59 public static void main(String[] args) {
60 // 自定义服务
61 CustomService customService = new CustomService();
62 // 创建指定类型的 Job
63 customService.createJob();
64 }
65
66}
---END---
!版权声明：本博客内容均为原创,每篇博文作为知识积累,写博不易,转载请注明出处。