Jenkins共享库优化：差异化构建阶段的优雅实现咨询

你的现有代码能正常运行，但存在闭包嵌套冗余、扩展性弱的问题——新增构建工具时要重复写相似的包装方法。下面两种方案可以让代码更简洁、易维护：

方案一：策略模式（闭包映射）—— 轻量简洁，适合简单构建逻辑 #

把构建逻辑抽成独立闭包，用Map做工具到逻辑的映射，核心流水线只负责通用步骤，构建逻辑按需分发：

// vars/pipelineCommon.groovy
// 核心通用流水线入口
def run(Map args) {
    // 前置参数校验，避免无效执行
    if (!args.buildTool) {
        error "必须指定buildTool参数，可选值：maven、npm"
    }

    node {
        stage('初始化') {
            println "执行通用初始化：拉取代码、环境准备..."
        }

        stage('静态检查') {
            println "执行通用静态检查..."
        }

        stage('构建') {
            runBuild(args)
        }

        stage('产物归档') {
            println "执行通用产物归档..."
        }
    }
}

// 构建逻辑分发器：根据工具类型匹配对应逻辑
private def runBuild(Map args) {
    def buildHandlers = [
        maven: { Map params ->
            println "Maven构建参数：${params}"
            sh "mvn clean package -DskipTests ${params.mavenOpts ?: ''}"
        },
        npm: { Map params ->
            println "Npm构建参数：${params}"
            sh "npm install ${params.npmInstallOpts ?: ''}"
            sh "npm run build ${params.npmBuildOpts ?: ''}"
        }
        // 新增工具只需在这里加新的键值对，比如gradle: { ... }
    ]

    def handler = buildHandlers[args.buildTool]
    if (!handler) {
        error "不支持的构建工具：${args.buildTool}"
    }
    handler(args)
}

// 保留快捷方法，方便用户直接调用（可选）
def maven(Map args) {
    args.buildTool = 'maven'
    run(args)
}

def npm(Map args) {
    args.buildTool = 'npm'
    run(args)
}

优点： #

• 核心流水线与构建逻辑完全解耦，代码结构清晰
• 新增构建工具只需在buildHandlers里加一行闭包，无需修改通用流程
• 参数传递直接，消除了原代码的冗余闭包嵌套
• 增加参数校验，提前拦截错误

方案二：面向对象拆分—— 适合复杂构建逻辑 #

如果后续每个构建工具的逻辑会变得复杂（比如要处理依赖缓存、多环境构建等），可以把每个工具的构建逻辑抽成单独的类，放在共享库的src目录下：

1. 编写构建工具类

// src/com/example/builders/MavenBuilder.groovy
package com.example.builders

class MavenBuilder {
    def steps  // Jenkins步骤对象，用于调用sh、println等方法
    def args

    MavenBuilder(steps, args) {
        this.steps = steps
        this.args = args
    }

    void build() {
        steps.println "开始Maven构建，参数：${args}"
        // 可以添加更复杂的逻辑，比如依赖缓存、测试报告生成等
        steps.sh "mvn clean package -DskipTests ${args.mavenOpts ?: ''}"
        steps.junit 'target/surefire-reports/*.xml'
    }
}

// src/com/example/builders/NpmBuilder.groovy
package com.example.builders

class NpmBuilder {
    def steps
    def args

    NpmBuilder(steps, args) {
        this.steps = steps
        this.args = args
    }

    void build() {
        steps.println "开始Npm构建，参数：${args}"
        // 复杂逻辑示例：缓存node_modules
        steps.cache(path: 'node_modules', key: "npm-\${checksum 'package-lock.json'}") {
            steps.sh "npm install ${args.npmInstallOpts ?: ''}"
        }
        steps.sh "npm run build ${args.npmBuildOpts ?: ''}"
        steps.archiveArtifacts artifacts: 'dist/**', fingerprint: true
    }
}

2. 修改核心流水线的构建分发逻辑

// vars/pipelineCommon.groovy
def run(Map args) {
    if (!args.buildTool) {
        error "必须指定buildTool参数，可选值：maven、npm"
    }

    node {
        stage('初始化') {
            println "执行通用初始化..."
        }

        stage('静态检查') {
            println "执行通用静态检查..."
        }

        stage('构建') {
            runBuild(args)
        }

        stage('产物归档') {
            println "执行通用产物归档..."
        }
    }
}

private def runBuild(Map args) {
    // 动态加载对应构建工具的类
    def builderClassName = "com.example.builders.${args.buildTool.capitalize()}Builder"
    try {
        def builder = this.class.classLoader.loadClass(builderClassName).newInstance(this, args)
        builder.build()
    } catch (ClassNotFoundException e) {
        error "不支持的构建工具：${args.buildTool}"
    }
}

// 快捷调用方法（可选）
def maven(Map args) {
    args.buildTool = 'maven'
    run(args)
}

def npm(Map args) {
    args.buildTool = 'npm'
    run(args)
}

优点： #

• 每个构建工具的逻辑独立维护，代码更易读、易调试
• 适合复杂场景，能封装更多个性化逻辑
• 扩展性极强，新增工具只需新增对应类，无需修改核心流水线

总结 #

• 如果构建逻辑简单，优先选方案一，代码轻量简洁
• 如果构建逻辑复杂且需要个性化扩展，选方案二，符合面向对象设计

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