jenkinsServer.createJob("auto_test_job", replacedText, true);
String xml = jenkinsServer.getJobXml("auto_test_job");

jenkinsServer.updateJob("auto_test_job", replacedText, true);

POST http://127.0.0.1:8080/{optionalFolderPath}job/{project_name}/doDelete

DELETE https://<Jenkins_url>/job/<job_name>/

POST http://127.0.0.1:8080/{optionalFolderPath}job/{job_name}/buildWithParameters

$ curl -v  -XPOST http://localhost:8080/job/test/build/api/json
*   Trying ::1...
* TCP_NODELAY set
* Connected to localhost (::1) port 8080 (#0)
> POST /job/test/build/api/json HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.54.0
> Accept: */*
>
< HTTP/1.1 201 Created
< Date: Sat, 05 Jan 2019 08:33:45 GMT
< X-Content-Type-Options: nosniff
< Location: http://localhost:8080/queue/item/17/
< Content-Length: 0
< Server: Jetty(9.4.z-SNAPSHOT)
<
* Connection #0 to host localhost left intact

GET http://localhost:8080/queue/item/17/api/json 

$ curl  http://localhost:8080/queue/item/17/api/json\?pretty\=true
{
  "_class" : "hudson.model.Queue$LeftItem",
  "actions" : [
    {
      "_class" : "hudson.model.CauseAction",
      "causes" : [
        {
          "_class" : "hudson.model.Cause$UserIdCause",
          "shortDescription" : "由用户 anonymous 启动",
          "userId" : null,
          "userName" : "anonymous"
        }
      ]
    }
  ],
  "blocked" : false,
  "buildable" : false,
  "id" : 17,
  "inQueueSince" : 1546677225670,
  "params" : "",
  "stuck" : false,
  "task" : {
    "_class" : "hudson.maven.MavenModuleSet",
    "name" : "test",
    "url" : "http://localhost:8080/job/test/",
    "color" : "blue"
  },
  "url" : "queue/item/17/",
  "why" : null,
  "cancelled" : false,
  "executable" : {
    "_class" : "hudson.maven.MavenModuleSetBuild",
    "number" : 6,
    "url" : "http://localhost:8080/job/test/6/"
  }
}

curl http://localhost:8080/job/test/6/api/json\?pretty\=true
{
  ...
  "building" : false,
  "description" : null,
  "displayName" : "#6",
  "duration" : 13631,
  "estimatedDuration" : 17999,
  "executor" : null,
  "fullDisplayName" : "test #6",
  "id" : "6",
  "keepLog" : false,
  "number" : 6,
  "queueId" : 17,
  "result" : "SUCCESS",
  "timestamp" : 1546677234794,
  "url" : "http://localhost:8080/job/test/6/",
  "builtOn" : "",
 ...
}

// text
GET http://localhost:8080/job/test/{build_number}/logText/progressiveText/api/json

// html
GET http://localhost:8080/job/test/{build_number}/logText/progressiveHtml/api/json

JobWithDetails job = jenkinsServer.getJob(jenkinsJob);
...
 QueueReference reference = job.build( true);
...
QueueItem queueItem = jenkinsServer.getQueueItem(new QueueReference(queuePart));
...
Build build = jenkinsServer.getBuild(queueItem);
...
BuildWithDetails details = build.details();
BuildResult result = details.getResult();
...
String logs =  details.getConsoleOutputText();

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

import com.offbytwo.jenkins.JenkinsServer;
import com.offbytwo.jenkins.client.JenkinsHttpClient;
 
import java.net.URI;
import java.net.URISyntaxException;
 
public class JenkinsConnect {
 
    private JenkinsConnect(){}
 
    // 连接 Jenkins 需要设置的信息
    static final String JENKINS_URL = "http://jenkins:8080/";
    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;
    }
}

import com.offbytwo.jenkins.JenkinsServer;
import com.offbytwo.jenkins.client.JenkinsHttpClient;
import com.offbytwo.jenkins.model.Build;
import com.offbytwo.jenkins.model.Job;
import com.offbytwo.jenkins.model.JobWithDetails;
import com.offbytwo.jenkins.model.MavenJobWithDetails;
 
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
 
public class JobApi {
 
    // Jenkins 对象
    private JenkinsServer jenkinsServer;
    // http 客户端对象
    private JenkinsHttpClient jenkinsHttpClient;
 
    /**
     * 构造方法中调用连接 Jenkins 方法
     */
    JobApi() {
        // 连接 Jenkins
        jenkinsServer = JenkinsConnect.connection();
        // 设置客户端连接 Jenkins
        jenkinsHttpClient = JenkinsConnect.getClient();
    }
 
    /**
     * 创建 Job
     */
    public void ceateJob(){
        try {
            /**创建一个流水线任务，且设置一个简单的脚本**/
            // 创建 Pipeline 脚本
            String script = "node(){ \n" +
                    "echo 'hello world!' \n" +
                    "}";
            // xml配置文件，且将脚本加入到配置中
            String xml = "<flow-definition plugin=\"workflow-job@2.32\">\n" +
                    "<description>测试项目</description>\n" +
                    "<definition class=\"org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition\" plugin=\"workflow-cps@2.66\">\n" +
                    "<script>" + script + "</script>\n" +
                    "<sandbox>true</sandbox>\n" +
                    "</definition>\n" +
                    "</flow-definition>";
            // 创建 Job
            jenkinsServer.createJob("test-job",xml, true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 更新 Job
     *
     * 更改之前创建的无参数Job，更改其为参数Job
     */
    public void updateJob(){
        try {
            /**
             * 更改一个流水线任务，让一个无参数的任务变成带参数任务
             */
            // 创建 Pipeline 脚本，用一个key变量
            String script = "node(){ \n" +
                    "echo \"${key}\" \n" +
                    "}";
            // xml配置文件，且将脚本加入到配置中
            String xml = "<flow-definition plugin=\"workflow-job@2.32\">\n" +
                    "<actions/>\n" +
                    "<description>测试项目</description>\n" +
                    "<keepDependencies>false</keepDependencies>\n" +
                    "<properties>\n" +
                    "<hudson.model.ParametersDefinitionProperty>\n" +
                    "<parameterDefinitions>\n" +
                    "<hudson.model.StringParameterDefinition>\n" +
                    "<name>key</name>\n" +
                    "<description>用于测试的字符变量</description>\n" +
                    "<defaultValue>hello</defaultValue>\n" +
                    "<trim>false</trim>\n" +
                    "</hudson.model.StringParameterDefinition>\n" +
                    "</parameterDefinitions>\n" +
                    "</hudson.model.ParametersDefinitionProperty>\n" +
                    "</properties>\n" +
                    "<definition class=\"org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition\" plugin=\"workflow-cps@2.66\">\n" +
                    "<script>" + script + "</script>\n" +
                    "<sandbox>true</sandbox>\n" +
                    "</definition>\n" +
                    "<disabled>false</disabled>\n" +
                    "</flow-definition>";
            // 创建 Job
            jenkinsServer.updateJob("test-job",xml, true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 获取 Job 基本信息
     */
    public void getJob(){
        try {
            // 获取 Job 信息
            JobWithDetails job = jenkinsServer.getJob("das-app-android-pkg");
            // 获取 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 = jenkinsServer.getMavenJob("test-job");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 获取 Job 列表
     */
    public void getJobList(){
        try {
            // 获取 Job 列表
            Map<String, Job> jobs = jenkinsServer.getJobs();
            for (Job job:jobs.values()){
                System.out.println(job.getName());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 获取 View 名称获取 Job 列表
     */
    public void getJobListByView(){
        try {
            // 获取 Job 列表
            Map<String,Job> jobs = jenkinsServer.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 = jenkinsServer.getJobXml("test-job");
            System.out.println(xml);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 执行无参数 Job build
     */
    public void buildJob(){
        try {
            jenkinsServer.getJob("test-job").build(true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 执行带参数 Job build
     */
    public void buildParamJob(){
        try {
            /**
             * 例如，现有一个job，拥有一个字符参数"key"
             * 现在对这个值进行设置，然后执行一个输出这个值的脚本
             */
            // 设置参数值
            Map<String,String> param = new HashMap<>();
            param.put("way","gm-R-b");
            // 执行 build 任务
            jenkinsServer.getJob("das-app-android-pkg").build(param, true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 停止最后构建的 Job Build
     */
    public void stopLastJobBuild(){
        try {
            // 获取最后的 build 信息
            Build build = jenkinsServer.getJob("test-job").getLastBuild();
            // 停止最后的 build
            build.Stop();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 删除 Job
     */
    public void deleteJob(){
        try {
            jenkinsServer.deleteJob("test-job", true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 禁用 Job
     */
    public void disableJob(){
        try {
            jenkinsServer.disableJob("test-job", true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * 启用 Job
     */
    public void enableJob(){
        try {
            jenkinsServer.enableJob("test-job", true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public static void main(String[] args) {
        JobApi jobApi = new JobApi();
//        jobApi.getJob();
//        jobApi.getJobList();
        jobApi.buildParamJob();
//        // 创建 Job
//        jobApi.ceateJob();
//        // 构建无参数的 Job
//        jobApi.buildJob();
//        // 构建带参数的 Job
//        jobApi.buildParamJob();
//        // 停止最后构建的 Job Build
//        jobApi.stopLastJobBuild();
//        // 更新 Job
//        jobApi.updateJob();
//        // 获取 Job 信息
//        jobApi.getJob();
//        // 获取 Maven 项目 Job
//        jobApi.getMavenJob();
//        // 获取 Job 配置xml
//        jobApi.getJobConfig();
        // 获取全部 Job 列表
//        jobApi.getJobList();
        // 根据 view 名称获取 Job 列表
//        jobApi.getJobListByView();
//        // 禁用 Job
//        jobApi.disableJob();
//        // 启用 Job
//        jobApi.enableJob();
//        // 删除 Job
//        jobApi.deleteJob();
    }
 
}