在 Jenkins Pipeline 中，Groovy 语法用于定义流水线的逻辑和步骤。以下是 Jenkins Pipeline 中常用的 Groovy 语法和结构： --- ### **1. 基本结构** Jenkins Pipeline 通常由 `pipeline` 块定义，包含 `agent`、`stages` 和 `steps` 等关键部分。 ```groovy pipeline { agent any // 指定执行环境 stages { stage('Build') { steps { sh 'echo "Building..."' // 执行 Shell 命令 } } stage('Test') { steps { sh 'echo "Testing..."' } } } } ``` --- ### **2. 变量定义** Groovy 变量可以是全局（`env`）或局部（`def`）。 ```groovy pipeline { agent any environment { // 全局环境变量 NAME = "Jenkins" } stages { stage('Example') { steps { script { // 在 script 块中可以使用 Groovy 逻辑 def localVar = "Hello, ${env.NAME}!" // 局部变量 echo localVar } } } } } ``` --- ### **3. 条件语句** 支持 `if-else` 和 `switch-case`。 ```groovy stage('Condition') { steps { script { if (env.BRANCH_NAME == 'main') { echo 'Running on main branch' } else { echo 'Running on other branch' } } } } ``` --- ### **4. 循环** 支持 `for`、`while` 等循环结构。 ```groovy stage('Loop') { steps { script { def items = ['a', 'b', 'c'] for (item in items) { echo "Processing ${item}" } } } } ``` --- ### **5. 异常处理** 使用 `try-catch-finally` 处理错误。 ```groovy stage('Error Handling') { steps { script { try { sh 'exit 1' // 模拟失败 } catch (Exception e) { echo "Caught error: ${e}" currentBuild.result = 'FAILURE' // 标记构建失败 } } } } ``` --- ### **6. 参数化构建** 通过 `parameters` 定义用户输入参数。 ```groovy pipeline { agent any parameters { string(name: 'USER', defaultValue: 'Jenkins', description: 'Enter your name') } stages { stage('Param Example') { steps { echo "Hello, ${params.USER}!" } } } } ``` --- ### **7. 调用外部脚本** 使用 `sh`（Linux/macOS）或 `bat`（Windows）执行脚本。 ```groovy stage('Run Script') { steps { sh './script.sh' // 执行 Shell 脚本 // 或 bat 'script.bat' （Windows） } } ``` --- ### **8. 函数定义** 在 `script` 块中定义函数。 ```groovy stage('Function') { steps { script { def greet(name) { echo "Hello, ${name}!" } greet("Jenkins") } } } ``` --- ### **9. 并行执行** 使用 `parallel` 实现并行任务。 ```groovy stage('Parallel') { parallel { stage('Task 1') { steps { echo 'Running Task 1' } } stage('Task 2') { steps { echo 'Running Task 2' } } } } ``` --- ### **10. 动态阶段** 根据条件动态生成阶段。 ```groovy stage('Dynamic') { steps { script { def stages = [:] for (i in 1..3) { stages["Task ${i}"] = { echo "Running dynamic task ${i}" } } parallel stages // 并行执行动态阶段 } } } ``` --- ### **11. 访问 Jenkins 环境变量** 通过 `env` 或 `params` 访问变量。 ```groovy stage('Env Vars') { steps { echo "Build number: ${env.BUILD_NUMBER}" echo "Workspace: ${env.WORKSPACE}" } } ``` --- ### **12. 工具集成** 使用 `tool` 自动安装工具（如 Maven、JDK）。 ```groovy pipeline { agent any tools { maven 'M3' // 需在 Jenkins 全局工具配置中定义 } stages { stage('Build with Maven') { steps { sh 'mvn --version' } } } } ``` --- ### **13. 输入等待** 通过 `input` 暂停流水线并等待用户确认。 ```groovy stage('Approval') { steps { input 'Approve deployment?' // 用户需手动确认 echo 'Deployment approved!' } } ``` --- ### **14. 共享库（Shared Library）** 复用 Groovy 代码（需在 Jenkins 中配置共享库）。 ```groovy @Library('my-shared-library') _ // 引入共享库 pipeline { agent any stages { stage('Shared Lib') { steps { helloWorld() // 调用共享库中的函数 } } } } ``` --- ### **15. 构建后操作** 通过 `post` 定义构建完成后的逻辑。 ```groovy pipeline { agent any stages { stage('Example') { steps { sh 'echo "Running..."' } } } post { always { echo 'This always runs' } success { echo 'Build succeeded!' } failure { echo 'Build failed!' } } } ``` --- ### **关键注意事项** 1. **脚本式 vs 声明式**： - 声明式 Pipeline（`pipeline { ... }`）结构更严格，适合大多数场景。 - 脚本式 Pipeline（`node { ... }`）更灵活，适合复杂逻辑。 2. **沙箱限制**： - 在 Jenkins 中，未授权的 Groovy 代码可能无法运行（需管理员审批）。 3. **错误处理**： - 使用 `try-catch` 或 `catchError` 捕获异常，避免流水线意外终止。 4. **性能优化**： - 避免在 `steps` 中直接写复杂逻辑，尽量用 `script` 块封装。 --- ### **示例：完整 Pipeline** ```groovy pipeline { agent any parameters { choice(name: 'ENV', choices: ['dev', 'prod'], description: 'Select environment') } stages { stage('Checkout') { steps { git url: 'https://github.com/example/repo.git', branch: 'main' } } stage('Build') { steps { sh 'mvn clean package' } } stage('Deploy') { when { expression { params.ENV == 'prod' } } // 条件部署 steps { sh './deploy.sh' } } } post { success { mail to: 'team@example.com', subject: "Success: ${env.JOB_NAME}", body: 'Build completed!' } } } ``` 通过掌握这些 Groovy 语法，可以高效编写 Jenkins Pipeline 脚本，实现自动化构建、测试和部署。