## Jenkins Pipeline 功能总结
### 概述
这是一个 **Jenkins 批量自动化构建脚本**，用于定时或手动触发指定目录下的所有 Job，支持并发分批构建和串行构建两种模式。
---
### 触发方式
| 方式 | 说明 |
|------|------|
| 定时触发 | 每周六 UTC 17:00（北京时间周日凌晨 1:00）自动执行 |
| 手动触发 | 支持自定义参数手动触发 |
---
### 参数说明
| 参数 | 默认值 | 说明 |
|------|--------|------|
| `FOLDER_NAME` | `UAT` | 扫描的 Jenkins 目录 |
| `BRANCH` | `release` | 构建分支 |
| `BATCH_SIZE` | `5` | 并发批次大小 |
| `SPECIFIC_JOBS` | 空 | 手动指定 Job 列表（含参数覆盖） |
---
### 核心流程
```
开始
├─ 1. 扫描 MAVEN_API_MODE 标记
│ 检测上次构建参数，自动识别需要 JAR-Only 模式的 Job
│
├─ 2. 生成任务列表
│ ├─ 手动模式：解析 SPECIFIC_JOBS（支持 :: 分隔传参）
│ └─ 自动模式：扫描目录，按 MODULE × Deploy_Env 笛卡尔积展开任务
│
├─ 3. 任务分类
│ ├─ 普通任务 → 并发分批执行
│ └─ rapidtrade-* → 串行逐个执行（CPU 密集型保护）
│
├─ 4. 第一阶段：普通任务并发构建
│ 按 BATCH_SIZE 分批，批内并发，批间顺序
│ 自动注入 BRANCH、MODULE、Deploy_Env、MAVEN_API_MODE 等参数
│
└─ 5. 第二阶段：rapidtrade-* 串行构建
全部走默认参数，一次只跑 1 个，等待完成后再触发下一个
```
---
### 关键设计点
**自动参数展开**：Job 若同时有 `MODULE` 和 `Deploy_Env` 两个选项参数，会自动进行笛卡尔积展开，为每个组合各触发一次构建。
**MAVEN_API_MODE 自动识别**：不需要手动标记，脚本读取该 Job 上次构建的实际参数，自动继承 `MAVEN_API_MODE=true`。
**CPU 密集型保护**：`rapidtrade-` 开头的 Job 被识别为 CPU 密集型，强制串行执行，避免并发抢占资源。
**构建异常不中断**：每个 Job 用 `try/catch` + `propagate: false` 包裹，单个 Job 失败不影响后续任务继续执行。pipeline {
agent any
triggers {
cron('0 17 * * 6')
}
parameters {
string(name: 'FOLDER_NAME', defaultValue: 'UAT', description: '目录名称')
string(name: 'BRANCH', defaultValue: 'release', description: '构建分支（不需要加 origin/ 前缀）')
string(name: 'BATCH_SIZE', defaultValue: '5', description: '每批并发数量')
text(
name: 'SPECIFIC_JOBS',
defaultValue: '',
description: '''手动指定任务（每行一个），不填则自动扫描目录下所有 Job：
UAT/job-name
UAT/job-name::MODULE=pigeon-gw
UAT/job-name::Deploy_Env=uat-shard-30
UAT/job-name::MODULE=pigeon-gw::Deploy_Env=uat-shard-30'''
)
}
stages {
stage('扫描并生成任务列表') {
steps {
script {
def allTasks = []
// ============================================================
// 自动检测哪些 Job 需要 MAVEN_API_MODE = true (Build JAR Only)
// 通过读取最近一次成功构建的实际参数值来判断
// ============================================================
def jarOnlyJobs = [] as Set
def scanFolder = Jenkins.instance.getItemByFullName(params.FOLDER_NAME)
if (scanFolder) {
scanFolder.getItems().each { job ->
def paramsDef = job.getProperty(hudson.model.ParametersDefinitionProperty.class)
if (!paramsDef) return
def mavenParam = paramsDef.getParameterDefinitions().find { it.name == 'MAVEN_API_MODE' }
if (!mavenParam) return
// 查最近一次构建的实际值
def lastBuild = job.getLastBuild()
if (lastBuild) {
def action = lastBuild.getAction(hudson.model.ParametersAction.class)
if (action) {
def p = action.getParameter('MAVEN_API_MODE')
if (p && p.getValue() == true) {
jarOnlyJobs << job.fullName
}
}
}
}
}
if (jarOnlyJobs) {
echo "===== 以下 Job 将自动勾选 MAVEN_API_MODE=true (Build JAR Only) ====="
jarOnlyJobs.sort().each { echo " ☑️ ${it}" }
}
if (params.SPECIFIC_JOBS?.trim()) {
params.SPECIFIC_JOBS.trim().split('\n').each { line ->
line = line.trim()
if (!line) return
def parts = line.split('::')
def jobName = parts[0].trim()
def extraParams = [:]
for (int i = 1; i < parts.size(); i++) {
def kv = parts[i].trim().split('=')
if (kv.size() == 2) extraParams[kv[0].trim()] = kv[1].trim()
}
allTasks << [job: jobName, extra: extraParams]
}
echo "手动模式，共 ${allTasks.size()} 个任务"
} else {
echo "自动扫描 [${params.FOLDER_NAME}] 目录..."
def folder = Jenkins.instance.getItemByFullName(params.FOLDER_NAME)
if (!folder) error("目录 [${params.FOLDER_NAME}] 不存在")
folder.getItems().each { job ->
def paramsDef = job.getProperty(hudson.model.ParametersDefinitionProperty.class)
if (!paramsDef) {
allTasks << [job: job.fullName, extra: [:]]
return
}
def moduleChoices = []
def deployEnvChoices = []
paramsDef.getParameterDefinitions().each { p ->
if (p.name == 'MODULE' && p instanceof hudson.model.ChoiceParameterDefinition) {
moduleChoices = p.choices.collect { it.trim() }.findAll { it }
}
if (p.name == 'Deploy_Env' && p instanceof hudson.model.ChoiceParameterDefinition) {
deployEnvChoices = p.choices.collect { it.trim() }.findAll { it }
}
}
def buildTask = { extra -> [job: job.fullName, extra: extra] }
if (moduleChoices && deployEnvChoices) {
moduleChoices.each { m ->
deployEnvChoices.each { d ->
allTasks << buildTask([MODULE: m, Deploy_Env: d])
}
}
} else if (moduleChoices) {
moduleChoices.each { m ->
allTasks << buildTask([MODULE: m])
}
} else if (deployEnvChoices) {
deployEnvChoices.each { d ->
allTasks << buildTask([Deploy_Env: d])
}
} else {
allTasks << buildTask([:])
}
}
echo "自动扫描完成，共 ${allTasks.size()} 个任务"
}
if (allTasks.isEmpty()) error("没有找到任何任务")
// ============================================================
// 分离 rapidtrade- 开头的 CPU 密集型任务（串行执行）
// 和普通任务（按批次并发执行）
// ============================================================
def rapidtradeTasks = []
def normalTasks = []
allTasks.each { task ->
// 取 Job 名称最后一段（去掉目录前缀）做匹配
def shortName = task.job.contains('/') ? task.job.split('/').last() : task.job
if (shortName.startsWith('rapidtrade-')) {
rapidtradeTasks << task
} else {
normalTasks << task
}
}
if (rapidtradeTasks) {
echo "===== rapidtrade-* 任务 (串行执行, CPU密集型) ====="
rapidtradeTasks.each {
def extraStr = it.extra.collect { k, v -> "$k=$v" }.join(', ')
echo " - ${it.job}" + (extraStr ? " [$extraStr]" : "") + " [默认参数]"
}
}
echo "===== 普通任务列表 ====="
normalTasks.each {
def extraStr = it.extra.collect { k, v -> "$k=$v" }.join(', ')
def jarTag = jarOnlyJobs.contains(it.job) ? ' [JAR_ONLY ☑️]' : ''
echo " - ${it.job}" + (extraStr ? " [$extraStr]" : "") + " [BRANCH=${params.BRANCH}]" + jarTag
}
// ============================================================
// 第一阶段：普通任务按批次并发执行
// ============================================================
if (normalTasks) {
def batchSize = params.BATCH_SIZE.toInteger()
def batches = []
for (int i = 0; i < normalTasks.size(); i += batchSize) {
batches << new ArrayList(normalTasks.subList(i, Math.min(i + batchSize, normalTasks.size())))
}
echo "===== 普通任务共 ${normalTasks.size()} 个，分 ${batches.size()} 批，每批最多 ${batchSize} 个 ====="
for (int b = 0; b < batches.size(); b++) {
def batch = batches[b]
echo "===== 第 ${b + 1} 批，共 ${batch.size()} 个任务 ====="
def parallelJobs = [:]
for (int j = 0; j < batch.size(); j++) {
def task = batch[j]
def taskKey = task.extra ? "${task.job}[${task.extra.collect { k,v -> "$k=$v" }.join('_')}]" : task.job
parallelJobs[taskKey] = {
def extraInfo = task.extra.collect { k, v -> "$k=$v" }.join(', ')
def isJarOnly = jarOnlyJobs.contains(task.job)
echo "触发构建: ${task.job}" + (extraInfo ? " [$extraInfo]" : "") + " (BRANCH=${params.BRANCH})" + (isJarOnly ? " [MAVEN_API_MODE=true]" : "")
try {
def buildParams = []
buildParams << string(name: 'BRANCH', value: params.BRANCH)
task.extra.each { k, v -> buildParams << string(name: k, value: v) }
// 自动为需要的 Job 勾选 MAVEN_API_MODE
if (isJarOnly) {
buildParams << booleanParam(name: 'MAVEN_API_MODE', value: true)
}
build job: task.job,
parameters: buildParams,
wait: true,
propagate: false
echo "✅ ${taskKey} 构建完成" + (isJarOnly ? " (JAR Only)" : "")
} catch (e) {
echo "❌ ${taskKey} 构建异常: ${e.message}"
}
}
}
parallel parallelJobs
echo "第 ${b + 1} 批完成，继续下一批..."
}
}
// ============================================================
// 第二阶段：rapidtrade-* 任务逐个串行执行（CPU密集型，一次只跑1个）
// 所有参数走默认，直接触发构建
// ============================================================
if (rapidtradeTasks) {
echo "===== 开始 rapidtrade-* 串行构建（共 ${rapidtradeTasks.size()} 个）====="
for (int r = 0; r < rapidtradeTasks.size(); r++) {
def task = rapidtradeTasks[r]
def taskKey = task.extra ? "${task.job}[${task.extra.collect { k,v -> "$k=$v" }.join('_')}]" : task.job
echo "串行构建 [${r + 1}/${rapidtradeTasks.size()}]: ${task.job} (默认参数)"
try {
// rapidtrade-* 走默认参数，不传 BRANCH 等自定义参数
build job: task.job,
wait: true,
propagate: false
echo "✅ ${taskKey} 构建完成 (串行)"
} catch (e) {
echo "❌ ${taskKey} 构建异常: ${e.message}"
}
}
}
echo "===== 全部构建完成 ====="
}
}
}
}
}定时或者手动执行效果：
