如何在Jenkins共享库中不使用DSL手动组装生成Pipeline

你设想的完全绕过Pipeline DSL、直接实例化流水线内置对象手动组装执行的思路无法落地。
原因是Jenkins Pipeline基于CPS（连续传递风格）引擎执行，你在DSL里写的node、stage、echo都不是可直接公开实例化的普通类，你自己new出来的Node、Stage对象不会被CPS引擎识别为合法的流水线结构，直接返回这类对象无法触发流水线正常执行。

不需要硬绕DSL，你完全可以通过「自定义组装类+统一翻译为DSL执行」的分层设计，实现和你示例几乎一致的编码体验，同时天然支持编排逻辑和运行时逻辑的混合编写。
核心思路是：

• 自己定义普通Groovy类作为流水线、阶段的元数据载体，只存配置和步骤闭包，这一层完全不耦合DSL，你可以按照面向对象的方式自由组装阶段、增删步骤
• 组装完成后，只在一个统一的入口方法里把元数据翻译成原生Pipeline DSL调用执行，这是唯一和DSL耦合的层

示例实现如下：

// 共享库中存放的纯组装类，无DSL依赖
class PipelineBuilder {
    String runOnLabel = 'default'
    List<StageMeta> stages = []

    // 组装阶段的方法，和你预期的addStage逻辑完全一致
    PipelineBuilder stage(String stageName, @DelegatesTo(StageMeta) Closure stageConfig) {
        StageMeta stage = new StageMeta(name: stageName)
        stageConfig.delegate = stage
        stageConfig.resolveStrategy = Closure.DELEGATE_ONLY
        stageConfig.call()
        stages.add(stage)
        return this
    }

    // 最终执行方法，统一对接DSL
    void execute(Script dslContext) {
        dslContext.node(runOnLabel) {
            stages.each { stageMeta ->
                dslContext.stage(stageMeta.name) {
                    stageMeta.stepList.each { stepClosure ->
                        stepClosure.delegate = dslContext
                        stepClosure.call()
                    }
                }
            }
        }
    }
}

class StageMeta {
    String name
    List<Closure> stepList = []
    // 组装步骤的方法，和你预期的addStep逻辑一致
    StageMeta step(Closure stepLogic) {
        stepList.add(stepLogic)
        return this
    }
}

在共享库的入口方法里，你可以用和预期几乎一致的写法组装流水线：

def call() {
    PipelineBuilder pipeline = new PipelineBuilder(runOnLabel: 'build-node')
    
    // ========== 这里是编排时逻辑：决定要创建哪些阶段、加哪些步骤 ==========
    pipeline.stage("Hello world") {
        step {
            echo "Hello world"
        }
    }

    // 可自由插入动态决策逻辑：比如检测到代码库存在Dockerfile就加镜像构建阶段
    if (fileExists('Dockerfile')) {
        pipeline.stage("Build Image") {
            step {
                sh 'docker build -t app:${BUILD_NUMBER} .'
            }
        }
    }

    // 根据分支判断是否加发布阶段
    if (env.BRANCH_NAME == 'main') {
        pipeline.stage("Deploy to Prod") {
            step {
                sh './deploy.sh prod'
            }
        }
    }

    // ========== 这里是运行时逻辑：执行到对应阶段才会触发的判断和操作 ==========
    pipeline.stage("Run Test") {
        step {
            // 测试失败标记构建不稳定，不直接中断
            catchError(buildResult: 'UNSTABLE', stageResult: 'FAILURE') {
                sh 'mvn test'
            }
            // 检测到报告文件存在才采集测试结果
            if (fileExists('target/surefire-reports/*.xml')) {
                junit 'target/surefire-reports/*.xml'
            }
        }
    }

    // 传入当前DSL上下文，启动流水线执行
    pipeline.execute(this)
}

• 所有需要在流水线运行过程中动态判断的逻辑（比如文件存在才执行步骤、测试失败做兜底处理），直接封装成闭包传入step方法即可，这部分闭包会在流水线执行到对应阶段时才运行，完全支持所有原生Pipeline步骤和语法
• 不要尝试直接实例化Pipeline内部的实现类，这些类属于引擎内部API，不同版本兼容性极差，而且脱离CPS上下文后完全无法正常工作
• 如果需要封装更复杂的逻辑（比如并行阶段、post块、when条件），只需要在自定义的元数据类里加对应字段，在execute方法里翻译成对应的DSL调用即可，扩展成本极低

内容的提问来源于stack exchange，提问作者Nazrax