java_demo/Jenkinsfile

pipeline {
    agent any
    
    options {
        buildDiscarder(logRotator(numToKeepStr: '10'))
        timeout(time: 60, unit: 'MINUTES')  // 增加到60分钟
        timestamps()
    }
    
    environment {
        // 使用系统默认或Jenkins节点上已安装的JDK
        // 不再强制指定JAVA_HOME，让Jenkins自动检测
        
        // 目标服务器配置
        DEPLOY_SERVER = '116.62.163.84'
        
        // Docker相关环境变量
        IMAGE_NAME = 'jenkins-demo'
        IMAGE_TAG = "${BUILD_NUMBER}"
        
        // SonarQube配置
        SONAR_HOST_URL = 'http://116.62.163.84:15010'
        SONAR_PROJECT_KEY = 'jenkins-demo'
        SONAR_TOKEN = 'squ_7e4217cabd0faae6f3b8ee359b3b8e2ac52eb69a'
    }
    
    // 使用Jenkins中配置的工具（自动安装）
    tools {
        maven 'Maven-3.9.6'  // 使用您在Jenkins中配置的Maven名称
        // JDK使用容器中已有的，不需要额外配置
    }
    
    stages {
        stage('Checkout') {
            steps {
                echo '🔄 开始检出代码...'
                checkout scm
                
                script {
                    env.GIT_COMMIT_SHORT = sh(
                        script: "git rev-parse --short HEAD",
                        returnStdout: true
                    ).trim()
                }                
                echo "📋 Git提交ID: ${env.GIT_COMMIT_SHORT}"
            }
        }
        
        stage('环境检查') {
            steps {
                echo '🔍 检查构建环境...'
                script {
                    sh '''
                        echo "=== Java版本 ==="
                        java -version
                        
                        echo "=== Maven版本 ==="
                        mvn -version
                        
                        echo "=== Git版本 ==="
                        git --version
                          echo "=== 工作目录 ==="
                        pwd && ls -la
                    '''
                    
                    // 设置Maven命令
                    env.MVN_CMD = 'mvn'
                    echo "✅ 构建环境检查完成，Maven命令: ${env.MVN_CMD}"
                }
            }        }
        
        stage('编译') {
            steps {
                echo '🔨 开始编译项目...'
                sh "mvn clean compile -DskipTests=true"
            }
        }
        
        stage('单元测试') {
            steps {
                echo '🧪 运行单元测试...'
                sh "mvn test"
            }
            post {
                always {
                    script {
                        // 发布测试结果
                        if (fileExists('target/surefire-reports/*.xml')) {
                            publishTestResults testResultsPattern: 'target/surefire-reports/*.xml'
                        }
                          // 发布代码覆盖率报告 - 使用传统语法
                        if (fileExists('target/site/jacoco/jacoco.xml')) {
                            publishHTML([
                                allowMissing: false,
                                alwaysLinkToLastBuild: true,
                                keepAll: true,
                                reportDir: 'target/site/jacoco',
                                reportFiles: 'index.html',
                                reportName: 'JaCoCo Coverage Report'
                            ])
                            echo '✅ JaCoCo覆盖率报告已发布'
                        } else if (fileExists('target/jacoco.exec')) {
                            echo '✅ JaCoCo执行文件已生成: target/jacoco.exec'
                        } else {
                            echo '⚠️ 未找到JaCoCo覆盖率报告文件'
                        }
                    }
                }
            }
        }
        
        stage('代码质量扫描') {
            steps {
                echo '🔍 运行SonarQube代码扫描...'
                script {
                    try {
                        sh """
                            mvn sonar:sonar \
                                -Dsonar.projectKey=${SONAR_PROJECT_KEY} \
                                -Dsonar.host.url=${SONAR_HOST_URL} \
                                -Dsonar.login=${SONAR_TOKEN} \
                                -Dsonar.coverage.jacoco.xmlReportPaths=target/site/jacoco/jacoco.xml
                        """
                        
                        echo "✅ SonarQube代码扫描完成"
                    } catch (Exception e) {                        echo "⚠️ SonarQube扫描失败，继续构建流程: ${e.getMessage()}"
                    }
                }
            }
        }
        
        stage('打包') {
            steps {
                echo '📦 开始打包应用程序...'
                sh "mvn package -DskipTests=true"
            }
            post {
                success {
                    script {
                        // 归档构建产物
                        if (fileExists('target/*.jar')) {
                            archiveArtifacts artifacts: 'target/*.jar', fingerprint: true
                        }
                    }
                }
            }
        }
        
        stage('构建Docker镜像') {
            steps {
                echo '🐳 构建Docker镜像...'
                script {
                    retry(3) {
                        try {
                            // 清理旧镜像以节省空间
                            sh 'docker image prune -f || true'
                            
                            echo "开始构建Docker镜像: ${IMAGE_NAME}:${IMAGE_TAG}"
                            
                            // 启用Docker Buildx并创建构建器
                            sh '''
                                # 检查并安装buildx（如果需要）
                                if ! docker buildx version; then
                                    echo "Installing Docker Buildx..."
                                    DOCKER_BUILDX_VERSION=v0.12.1
                                    curl -L https://github.com/docker/buildx/releases/download/${DOCKER_BUILDX_VERSION}/buildx-${DOCKER_BUILDX_VERSION}.linux-amd64 -o docker-buildx
                                    chmod +x docker-buildx
                                    mkdir -p ~/.docker/cli-plugins
                                    mv docker-buildx ~/.docker/cli-plugins/
                                fi
                                
                                # 创建并使用新的构建器实例
                                docker buildx create --name jenkins-builder --use --bootstrap || docker buildx use jenkins-builder
                                
                                # 验证构建器状态
                                docker buildx inspect --bootstrap
                            '''
                            
                            // 使用Buildx构建镜像，增加超时时间到30分钟
                            timeout(time: 30, unit: 'MINUTES') {
                                sh '''
                                    # 使用Buildx构建镜像，启用缓存和并行构建
                                    docker buildx build \\
                                        --builder jenkins-builder \\
                                        --platform linux/amd64 \\
                                        --cache-from type=local,src=/tmp/.buildx-cache \\
                                        --cache-to type=local,dest=/tmp/.buildx-cache-new,mode=max \\
                                        --build-arg BUILDKIT_INLINE_CACHE=1 \\
                                        --build-arg HTTP_PROXY= \\
                                        --build-arg HTTPS_PROXY= \\
                                        --network=host \\
                                        --load \\
                                        -t ${IMAGE_NAME}:${IMAGE_TAG} \\
                                        -t ${IMAGE_NAME}:latest \\
                                        .
                                    
                                    # 移动缓存（避免缓存无限增长）
                                    rm -rf /tmp/.buildx-cache || true
                                    mv /tmp/.buildx-cache-new /tmp/.buildx-cache || true
                                '''
                            }
                            
                            echo "✅ Docker镜像构建完成: ${IMAGE_NAME}:${IMAGE_TAG}"
                            
                            // 验证镜像是否创建成功
                            sh "docker images ${IMAGE_NAME}:${IMAGE_TAG}"
                            
                        } catch (Exception e) {
                            echo "⚠️ Docker构建失败: ${e.getMessage()}"
                            // 清理可能的中间状态和缓存
                            sh '''
                                docker system prune -f || true
                                rm -rf /tmp/.buildx-cache* || true
                            '''
                            throw e
                        }
                    }
                }
            }
        }
        
        stage('传输Docker镜像到服务器') {
            when {
                anyOf {
                    branch 'main'
                    branch 'master'
                    branch 'develop'
                }
            }
            steps {
                echo '📤 传输Docker镜像到目标服务器...'
                script {
                    // 将Docker镜像保存为tar文件并传输到目标服务器
                    sshagent(['deploy-server-ssh-key']) {
                        sh '''
                            # 保存Docker镜像为tar文件
                            docker save ${IMAGE_NAME}:${IMAGE_TAG} -o ${IMAGE_NAME}-${IMAGE_TAG}.tar
                            
                            # 传输镜像文件到目标服务器
                            scp -o StrictHostKeyChecking=no ${IMAGE_NAME}-${IMAGE_TAG}.tar root@${DEPLOY_SERVER}:/tmp/
                            
                            # 在目标服务器上加载镜像
                            ssh -o StrictHostKeyChecking=no root@${DEPLOY_SERVER} << EOF
                                # 加载Docker镜像
                                docker load -i /tmp/${IMAGE_NAME}-${IMAGE_TAG}.tar
                                
                                # 创建latest标签
                                docker tag ${IMAGE_NAME}:${IMAGE_TAG} ${IMAGE_NAME}:latest
                                
                                # 清理临时文件
                                rm -f /tmp/${IMAGE_NAME}-${IMAGE_TAG}.tar
                                
                                echo "✅ Docker镜像加载完成"
EOF
                            
                            # 清理本地临时文件
                            rm -f ${IMAGE_NAME}-${IMAGE_TAG}.tar
                        '''
                    }
                    echo "✅ Docker镜像传输完成"
                }
            }
        }
        
        stage('部署到测试环境') {
            when {
                anyOf {
                    branch 'develop'
                    branch 'feature/*'
                }
            }
            steps {
                echo '🚀 部署到测试环境...'
                script {
                    // 部署到测试服务器
                    sshagent(['deploy-server-ssh-key']) {
                        sh '''
                            ssh -o StrictHostKeyChecking=no root@${DEPLOY_SERVER} << EOF
                                # 停止现有容器
                                docker stop jenkins-demo-test || true
                                docker rm jenkins-demo-test || true
                                
                                # 运行新容器
                                docker run -d --name jenkins-demo-test \\
                                    -p 8080:8080 \\
                                    --restart unless-stopped \\
                                    -e SPRING_PROFILES_ACTIVE=test \\
                                    ${IMAGE_NAME}:${IMAGE_TAG}
                                    
                                echo "✅ 测试环境部署完成"
EOF
                        '''
                    }
                }
            }
        }
        
        stage('部署到生产环境') {
            when {
                anyOf {
                    branch 'main'
                    branch 'master'
                }
            }
            steps {
                echo '🎯 部署到生产环境...'
                script {
                    // 需要手动确认
                    input message: '确认部署到生产环境?', ok: '部署',
                          parameters: [choice(name: 'DEPLOY_ENV', choices: ['prod'], description: '选择部署环境')]
                    
                    // 部署到生产服务器
                    sshagent(['deploy-server-ssh-key']) {
                        sh '''
                            ssh -o StrictHostKeyChecking=no root@${DEPLOY_SERVER} << EOF
                                # 备份当前版本
                                docker tag ${IMAGE_NAME}:latest ${IMAGE_NAME}:backup-$(date +%Y%m%d-%H%M%S) || true
                                
                                # 停止现有容器
                                docker stop jenkins-demo-prod || true
                                docker rm jenkins-demo-prod || true
                                
                                # 运行新容器
                                docker run -d --name jenkins-demo-prod \\
                                    -p 80:8080 \\
                                    --restart unless-stopped \\
                                    -e SPRING_PROFILES_ACTIVE=prod \\
                                    -e JAVA_OPTS="-Xms512m -Xmx1024m" \\
                                    ${IMAGE_NAME}:${IMAGE_TAG}
                                    
                                # 更新latest标签
                                docker tag ${IMAGE_NAME}:${IMAGE_TAG} ${IMAGE_NAME}:latest
                                    
                                echo "✅ 生产环境部署完成"
EOF
                        '''
                    }
                }
            }
        }
        
        stage('健康检查') {
            steps {
                echo '🏥 执行应用健康检查...'
                script {
                    // 等待应用启动
                    sleep(time: 30, unit: 'SECONDS')
                    
                    try {
                        // 检查应用健康状态
                        def healthCheckUrl = "http://${DEPLOY_SERVER}/api/health"
                        def response = sh(
                            script: "curl -s -o /dev/null -w '%{http_code}' ${healthCheckUrl} || echo '000'",
                            returnStdout: true
                        ).trim()
                        
                        if (response == "200") {
                            echo "✅ 应用健康检查通过"
                        } else {
                            echo "⚠️ 应用健康检查失败，HTTP状态码: ${response}"
                            echo "🔄 应用可能还在启动中，这是正常现象"
                        }
                    } catch (Exception e) {
                        echo "⚠️ 健康检查异常: ${e.getMessage()}"
                        echo "🔄 这可能是网络问题或应用还在启动中"
                    }
                }
            }
        }
    }
    
    post {
        always {
            script {
                echo '🧹 清理工作空间...'
                try {
                    // 清理Docker镜像
                    sh '''
                        docker image prune -f || true
                        docker system prune -f || true
                    '''
                } catch (Exception e) {
                    echo "⚠️ Docker清理失败: ${e.getMessage()}"
                }
            }
        }
        
        success {
            script {
                echo '✅ 流水线执行成功！'
                // 发送成功通知
                def message = """
🎉 Jenkins构建成功！

📋 项目: ${env.JOB_NAME}
🔢 构建号: ${env.BUILD_NUMBER}
🌿 分支: ${env.BRANCH_NAME ?: 'unknown'}
📝 提交: ${env.GIT_COMMIT_SHORT ?: 'unknown'}
⏱️ 持续时间: ${currentBuild.durationString}
🔗 构建链接: ${env.BUILD_URL}
                """
                
                echo message
            }
        }
        
        failure {
            script {
                echo '❌ 流水线执行失败！'
                // 发送失败通知
                def message = """
💥 Jenkins构建失败！

📋 项目: ${env.JOB_NAME}
🔢 构建号: ${env.BUILD_NUMBER}
🌿 分支: ${env.BRANCH_NAME ?: 'unknown'}
📝 提交: ${env.GIT_COMMIT_SHORT ?: 'unknown'}
⏱️ 持续时间: ${currentBuild.durationString}
🔗 构建链接: ${env.BUILD_URL}
📄 查看日志: ${env.BUILD_URL}console
                """
                
                echo message
            }
        }
        
        unstable {
            echo '⚠️ 构建不稳定，可能存在测试失败'
        }
          cleanup {
            script {
                try {
                    // 清理Docker构建缓存（防止磁盘空间不足）
                    sh '''
                        # 清理buildx缓存
                        rm -rf /tmp/.buildx-cache* || true
                        
                        # 清理未使用的Docker资源
                        docker system prune -f || true
                        
                        # 移除构建器（如果存在）
                        docker buildx rm jenkins-builder || true
                    '''
                    
                    // 清理工作空间
                    cleanWs()
                    
                    echo "✅ 清理完成"
                } catch (Exception e) {
                    echo "⚠️ 清理失败: ${e.getMessage()}"
                }
            }
        }
    }
}