跳过剩余流水线阶段的最简单方法是设置一个变量，该变量将控制是否应跳过后续阶段。类似于：

def skipRemainingStages = false

pipeline {
    agent any

    stages {
        stage("Stage 1") {
            steps {
                script {
                    skipRemainingStages = true

                    println "skipRemainingStages = ${skipRemainingStages}"
                }
            }
        }

        stage("Stage 2") {
            when {
                expression {
                    !skipRemainingStages
                }
            }

            steps {
                script {
                    println "This text wont show up...."
                }
            }
        }

        stage("Stage 3") {
            when {
                expression {
                    !skipRemainingStages
                }
            }

            steps {
                script {
                    println "This text wont show up...."
                }
            }
        }
    }
}

这是一个非常简单的示例，在Stage 1处将skipRemainingStages设置为true，并且跳过Stage 2和Stage 3，因为when块中的表达式的计算结果不为true。

或者，您可以呼叫error(String message)步骤来停止管缐，并将其状态设为FAILED。例如，如果阶段1呼叫error(msg)步骤，如下所示：

stage("Stage 1") {
    steps {
        script {
            error "This pipeline stops here!"
        }
    }
}

在这种情况下，只要找到error(msg)步骤，流水线就会停止，并且忽略所有剩余阶段（甚至不检查when块）。

当然，您可以根据某些条件调用error(msg)，使其仅在满足特定条件时才变为FAILED。

您可以在阶段中使用post来结束，如下所示：

pipeline {
    stages {
        stage('stage 1') {
            steps {
                 //step 1
            }
        }
        stage('stage 2') {
            steps {
                script{ 
                    //step 2
                }
            }
            post{
                success {
                }
                failure {
                    script{
                        sh "exit 1"
                        //or
                        error "Failed, exiting now..."
                    }
                }
                aborted {
                }
                unstable {
                    script{
                           sh "exit 1"
                          //or
                          error "Unstable, exiting now..."                    
                     }
                }
            }
        }
    }
}

这将中止生成，作业将不会进一步运行。

你也可以简单地抛出一个异常。这将中止构建。事实上，简单地在catch子句中设置构建状态工作得很好。你也可以在finally块中添加自定义逻辑，用于发送构建状态更改的通知（电子邮件、Slack消息等）。
因此，可能会出现以下情况。注意：我已经从一个现有的Jenkinsfile中复制了一些。所以不能100%确定这和你使用的语法是一样的：

pipeline {
   try {
      stages {
         stage("stage1") {
             if (something) {
               throw new RuntimeException("Something went wrong")
             }
         }

         stage("stage2") {

         }

      } 
  } catch (e) {
     currentBuild.result = "FAILED"
     throw e
  } 
}

您可以尝试：

stage('Set skipRemainingStages variable which decides, whether to run next stages or not') {
    steps {
        script {
            skipRemainingStages = true
            try {
                println("In if block")
                skipRemainingStages = true
            }
            catch (Exception exc) {
                println("Exception block: ${exc}")
                skipRemainingStages = false
            }

            if (skipRemainingStages) {
                currentBuild.result = 'FAILURE'
                error("Stopping early!")
            }
        }
    }
}
stage('This will not execute if skipRemainingStages=true')
{.
.
.
}

您可以使用将构建标记为失败，然后使用sh "exit 1"中断其在Jenkins管道中的执行，如下所示：

pipeline {
    stages {
        stage('stage 1') {
            steps {

            }
        }
        stage('stage 2') {
            steps {
                script{ 
                      if (something) {
                            currentBuild.result = "FAILURE"
                            sh "exit 1"
                      }
                }
            }
        }
    }
}