Gradle基础知识

// 插件配置
plugins {
    id 'java'
    id 'application'
    id 'org.springframework.boot' version '2.7.0'
}

// 项目基本信息
group = 'com.example'
version = '1.0.0'
sourceCompatibility = '11'

// 仓库配置
repositories {
    mavenCentral()
    gradlePluginPortal()
}

// 依赖配置
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.junit.jupiter:junit-jupiter'
}

// 任务配置
tasks.named('test') {
    useJUnitPlatform()
}

// 应用配置
application {
    mainClass = 'com.example.Application'
}

// 根项目名称
rootProject.name = 'my-gradle-project'

// 包含子项目
include 'subproject1', 'subproject2'

// 插件管理
pluginManagement {
    repositories {
        gradlePluginPortal()
        mavenCentral()
    }
}

// 依赖解析管理
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        mavenCentral()
    }
}

plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
}

tasks.named('test') {
    useJUnitPlatform()
}

// 1. 方法调用可以省略括号
println 'Hello Gradle'
println('Hello Gradle')  // 等价

// 2. 字符串插值
def version = '1.0.0'
println "Current version: ${version}"
println "Current version: $version"  // 简化形式

// 3. 闭包（Closure）
def myClosure = { param ->
    println "Parameter: $param"
}
myClosure('test')

// 4. 集合操作
def list = ['java', 'kotlin', 'scala']
list.each { language ->
    println "Language: $language"
}

// 5. Map操作
def config = [
    version: '1.0.0',
    encoding: 'UTF-8'
]
println config.version

// 1. 配置块（Configuration Block）
android {
    compileSdkVersion 33
    defaultConfig {
        applicationId "com.example.app"
        minSdkVersion 21
    }
}

// 2. 任务配置
task myTask {
    doLast {
        println 'Executing myTask'
    }
}

// 3. 依赖配置
dependencies {
    implementation 'org.springframework:spring-core:5.3.21'
    testImplementation 'junit:junit:4.13.2'
}

// 4. 属性访问
project.version = '1.0.0'
version = '1.0.0'  // 简化形式

// ==================== 1. 插件配置 ====================
plugins {
    // 核心插件
    id 'java'
    id 'application'

    // 社区插件
    id 'org.springframework.boot' version '2.7.0'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'

    // 条件应用插件
    if (project.hasProperty('android')) {
        id 'com.android.application'
    }
}

// ==================== 2. 项目属性 ====================
group = 'com.example'
version = '1.0.0-SNAPSHOT'
description = 'My Gradle Project'

// Java配置
java {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11
    withJavadocJar()
    withSourcesJar()
}

// ==================== 3. 仓库配置详解 ====================
repositories {
    // 仓库优先级：从上到下依次查找

    // 1. 本地Maven仓库（最快）
    mavenLocal()
    // 位置：~/.m2/repository
    // 优势：本地缓存，访问最快
    // 注意：可能包含SNAPSHOT版本，生产环境需谨慎

    // 2. Maven中央仓库（最权威）
    mavenCentral()
    // 地址：https://repo1.maven.org/maven2/
    // 优势：官方仓库，最可靠
    // 包含：大部分开源项目的正式版本

    // 3. Gradle插件门户
    gradlePluginPortal()
    // 地址：https://plugins.gradle.org/
    // 用途：Gradle插件专用仓库

    // 4. 国内镜像仓库（加速访问）
    maven {
        name = 'Aliyun'
        url = 'https://maven.aliyun.com/repository/public'
        // 优势：国内访问速度快
        // 适用：开发环境加速下载
    }

    // 5. 特定用途仓库
    maven {
        name = 'Spring Milestones'
        url = 'https://repo.spring.io/milestone'
        // 内容过滤：只包含Spring相关依赖
        mavenContent {
            includeGroupByRegex 'org\\.springframework.*'
            includeGroup 'org.springframework.boot'
            includeGroup 'org.springframework.cloud'
        }
    }

    // 6. 企业私有仓库（需要认证）
    maven {
        name = 'CompanyNexus'
        url = 'https://nexus.company.com/repository/maven-public/'
        credentials {
            // 从gradle.properties读取认证信息
            username = project.findProperty('nexusUsername') ?: 'guest'
            password = project.findProperty('nexusPassword') ?: 'guest'
        }
        // 认证方式
        authentication {
            basic(BasicAuthentication)
        }
    }

    // 7. SNAPSHOT仓库
    maven {
        name = 'CompanySnapshots'
        url = 'https://nexus.company.com/repository/maven-snapshots/'
        credentials {
            username = project.findProperty('nexusUsername')
            password = project.findProperty('nexusPassword')
        }
        // 只包含SNAPSHOT版本
        mavenContent {
            snapshotsOnly()
        }
    }

    // 8. 条件仓库（根据环境决定）
    if (project.hasProperty('useInternalRepo')) {
        maven {
            name = 'InternalRepo'
            url = 'https://internal.company.com/repository/'
        }
    }
}

// 仓库配置最佳实践案例
repositories {
    // 开发环境：优先使用本地和镜像
    if (project.hasProperty('dev')) {
        mavenLocal()
        maven { url 'https://maven.aliyun.com/repository/public' }
        mavenCentral()
    }
    // 生产环境：只使用可靠仓库
    else {
        mavenCentral()
        maven {
            url 'https://nexus.company.com/repository/maven-public/'
            credentials {
                username nexusUsername
                password nexusPassword
            }
        }
    }
}

// ==================== 4. 依赖配置 ====================
// 版本管理
ext {
    springBootVersion = '2.7.0'
    junitVersion = '5.9.2'
    mockitoVersion = '4.11.0'
}

dependencies {
    // ==================== 编译时依赖 ====================
    // implementation: 编译和运行时需要，但不传递给消费者
    implementation "org.springframework.boot:spring-boot-starter-web:${springBootVersion}"
    // 说明：Spring Boot Web启动器，包含Spring MVC、Tomcat等
    // 使用场景：Web应用开发的核心依赖

    implementation 'org.apache.commons:commons-lang3:3.12.0'
    // 说明：Apache Commons工具库，提供字符串、数组等工具方法
    // 使用场景：日常开发中的工具类需求

    implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.3'
    // 说明：JSON序列化/反序列化库
    // 使用场景：API数据交换、配置文件解析

    // ==================== 编译时专用依赖 ====================
    // compileOnly: 编译时需要，运行时由容器或环境提供
    compileOnly 'javax.servlet:javax.servlet-api:4.0.1'
    // 说明：Servlet API，运行时由Tomcat等容器提供
    // 使用场景：Web应用开发，避免与容器版本冲突

    compileOnly 'org.projectlombok:lombok:1.18.24'
    // 说明：Lombok注解处理器，编译时生成代码
    // 使用场景：减少样板代码，如getter/setter

    // ==================== 运行时依赖 ====================
    // runtimeOnly: 运行时需要，编译时不需要
    runtimeOnly 'mysql:mysql-connector-java:8.0.33'
    // 说明：MySQL数据库驱动
    // 使用场景：数据库连接，编译时不直接使用

    runtimeOnly 'com.h2database:h2:2.1.214'
    // 说明：H2内存数据库
    // 使用场景：开发和测试环境的轻量级数据库

    // ==================== 注解处理器 ====================
    // annotationProcessor: 编译时注解处理
    annotationProcessor 'org.springframework.boot:spring-boot-configuration-processor'
    // 说明：Spring Boot配置元数据生成器
    // 作用：为@ConfigurationProperties生成元数据，支持IDE自动补全

    annotationProcessor 'org.projectlombok:lombok:1.18.24'
    // 说明：Lombok注解处理器
    // 作用：编译时生成getter、setter、toString等方法

    // ==================== 测试依赖 ====================
    // testImplementation: 测试编译和运行时需要
    testImplementation "org.junit.jupiter:junit-jupiter:${junitVersion}"
    // 说明：JUnit 5测试框架
    // 使用场景：单元测试、集成测试

    testImplementation "org.mockito:mockito-core:${mockitoVersion}"
    // 说明：Mock框架，用于创建测试替身
    // 使用场景：单元测试中模拟依赖对象

    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    // 说明：Spring Boot测试启动器，包含多个测试库
    // 包含：JUnit、Mockito、AssertJ、Hamcrest等

    testImplementation 'org.testcontainers:junit-jupiter:1.17.3'
    // 说明：Testcontainers集成测试框架
    // 使用场景：使用Docker容器进行集成测试

    testImplementation 'org.testcontainers:mysql:1.17.3'
    // 说明：MySQL Testcontainer
    // 使用场景：数据库集成测试

    // ==================== 测试运行时依赖 ====================
    // testRuntimeOnly: 测试运行时需要，测试编译时不需要
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
    // 说明：JUnit平台启动器
    // 作用：IDE和构建工具运行测试时需要
}

// ==================== 依赖配置实战案例 ====================

// 案例1：Spring Boot Web应用完整依赖配置
dependencies {
    // Web层
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-validation'

    // 数据层
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'mysql:mysql-connector-java'

    // 安全
    implementation 'org.springframework.boot:spring-boot-starter-security'

    // 监控
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    implementation 'io.micrometer:micrometer-registry-prometheus'

    // 工具类
    implementation 'org.apache.commons:commons-lang3'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'

    // 测试
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.springframework.security:spring-security-test'
    testImplementation 'org.testcontainers:mysql'
    testRuntimeOnly 'com.h2database:h2'
}

// 案例2：微服务项目依赖配置
dependencies {
    // Spring Cloud
    implementation 'org.springframework.cloud:spring-cloud-starter-netflix-eureka-client'
    implementation 'org.springframework.cloud:spring-cloud-starter-config'
    implementation 'org.springframework.cloud:spring-cloud-starter-sleuth'

    // 服务间通信
    implementation 'org.springframework.cloud:spring-cloud-starter-openfeign'
    implementation 'org.springframework.cloud:spring-cloud-starter-loadbalancer'

    // 消息队列
    implementation 'org.springframework.boot:spring-boot-starter-amqp'

    // 缓存
    implementation 'org.springframework.boot:spring-boot-starter-data-redis'

    // 基础依赖
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
}

// ==================== 5. 任务配置 ====================
// 测试配置
tasks.named('test') {
    useJUnitPlatform()

    // 测试JVM参数
    jvmArgs = ['-Xmx1024m']

    // 系统属性
    systemProperty 'spring.profiles.active', 'test'

    // 测试报告
    reports {
        html.required = true
        junitXml.required = true
    }

    // 测试事件监听
    testLogging {
        events 'passed', 'skipped', 'failed'
        exceptionFormat = 'full'
    }
}

// 编译配置
tasks.withType(JavaCompile) {
    options.encoding = 'UTF-8'
    options.compilerArgs += ['-parameters', '-Xlint:unchecked']
}

// JAR配置
jar {
    manifest {
        attributes(
            'Implementation-Title': project.name,
            'Implementation-Version': project.version,
            'Main-Class': 'com.example.Application'
        )
    }

    // 排除文件
    exclude 'META-INF/*.RSA', 'META-INF/*.SF', 'META-INF/*.DSA'
}

// ==================== 6. 自定义任务 ====================
task printProjectInfo {
    group = 'help'
    description = '打印项目信息'

    doLast {
        println "Project: ${project.name}"
        println "Version: ${project.version}"
        println "Java Version: ${java.sourceCompatibility}"
        println "Dependencies: ${configurations.runtimeClasspath.files.size()}"
    }
}

// ==================== 7. 应用配置 ====================
application {
    mainClass = 'com.example.Application'
    applicationDefaultJvmArgs = ['-Xmx512m']
}

// ==================== 8. 发布配置 ====================
publishing {
    publications {
        maven(MavenPublication) {
            from components.java

            pom {
                name = project.name
                description = project.description
                url = 'https://github.com/example/my-project'

                licenses {
                    license {
                        name = 'Apache License 2.0'
                        url = 'https://www.apache.org/licenses/LICENSE-2.0'
                    }
                }

                developers {
                    developer {
                        id = 'johndoe'
                        name = 'John Doe'
                        email = 'john@example.com'
                    }
                }
            }
        }
    }

    repositories {
        maven {
            name = 'CompanyNexus'
            url = version.endsWith('SNAPSHOT') ?
                'https://nexus.company.com/repository/maven-snapshots/' :
                'https://nexus.company.com/repository/maven-releases/'
            credentials {
                username = project.findProperty('nexusUsername')
                password = project.findProperty('nexusPassword')
            }
        }
    }
}

dependencies {
    // implementation: 内部实现，不暴露给消费者
    implementation 'org.springframework:spring-core:5.3.21'
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.3'

    // api: 公共API，会传递给消费者（仅在java-library插件中可用）
    api 'org.apache.commons:commons-lang3:3.12.0'

    // compileOnly: 编译时需要，运行时由容器提供
    compileOnly 'javax.servlet:javax.servlet-api:4.0.1'
    compileOnly 'org.projectlombok:lombok:1.18.24'

    // runtimeOnly: 运行时依赖，如数据库驱动
    runtimeOnly 'mysql:mysql-connector-java:8.0.33'
    runtimeOnly 'com.h2database:h2:2.1.214'

    // annotationProcessor: 注解处理器
    annotationProcessor 'org.projectlombok:lombok:1.18.24'
    annotationProcessor 'org.springframework.boot:spring-boot-configuration-processor'

    // 测试依赖
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
    testImplementation 'org.mockito:mockito-core:4.11.0'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'

    // 测试运行时
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

dependencies {
    // 1. 直接指定版本
    implementation 'org.springframework:spring-core:5.3.21'

    // 2. 使用变量管理版本
    implementation "org.springframework:spring-core:${springVersion}"

    // 3. 使用ext属性
    implementation "org.springframework:spring-core:${ext.springVersion}"

    // 4. 版本范围（不推荐生产环境）
    implementation 'org.springframework:spring-core:5.+'
    implementation 'org.springframework:spring-core:[5.0,6.0)'

    // 5. 最新版本（不推荐）
    implementation 'org.springframework:spring-core:latest.release'
}

// 版本管理最佳实践
ext {
    springVersion = '5.3.21'
    junitVersion = '5.9.2'
    mockitoVersion = '4.11.0'
}

// 或使用gradle.properties
// springVersion=5.3.21
// junitVersion=5.9.2

// 使用Spring Boot BOM
dependencies {
    // 导入BOM
    implementation platform('org.springframework.boot:spring-boot-dependencies:2.7.0')

    // 无需指定版本，由BOM管理
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

    // 覆盖BOM版本
    implementation 'com.fasterxml.jackson.core:jackson-core:2.14.0'
}

// 自定义依赖约束
dependencyManagement {
    dependencies {
        dependency 'org.apache.commons:commons-lang3:3.12.0'
        dependency 'com.google.guava:guava:31.1-jre'
    }
}

dependencies {
    implementation 'org.springframework:spring-core:5.3.21'

    // 1. 排除传递依赖
    implementation('org.springframework:spring-context:5.3.21') {
        exclude group: 'commons-logging', module: 'commons-logging'
    }

    // 2. 排除所有传递依赖
    implementation('some.group:some-module:1.0') {
        transitive = false
    }

    // 3. 强制使用特定版本
    implementation 'commons-logging:commons-logging:1.2'
}

// 全局依赖解析策略
configurations.all {
    resolutionStrategy {
        // 强制使用特定版本
        force 'commons-logging:commons-logging:1.2'

        // 版本冲突时失败
        failOnVersionConflict()

        // 缓存动态版本
        cacheDynamicVersionsFor 10, 'minutes'
        cacheChangingModulesFor 4, 'hours'

        // 替换模块
        dependencySubstitution {
            substitute module('commons-logging:commons-logging') with module('org.slf4j:jcl-over-slf4j:1.7.36')
        }
    }
}

// 任务定义阶段
task myTask {
    // 配置阶段执行
    println 'Configuring myTask'

    // 执行阶段
    doFirst {
        println 'Before myTask execution'
    }

    doLast {
        println 'After myTask execution'
    }
}

// 任务配置
myTask {
    description = 'My custom task'
    group = 'custom'
}

// 1. Ad-hoc任务（简单任务）
task hello {
    doLast {
        println 'Hello, Gradle!'
    }
}

// 2. 类型化任务
task copyFiles(type: Copy) {
    from 'src/main/resources'
    into 'build/resources'
}

task createZip(type: Zip) {
    from 'src/main/java'
    archiveFileName = 'sources.zip'
    destinationDirectory = file('build/distributions')
}

// 3. 自定义任务类
class GreetingTask extends DefaultTask {
    @Input
    String greeting = 'hello'

    @Input
    String recipient = 'world'

    @TaskAction
    void greet() {
        println "${greeting}, ${recipient}!"
    }
}

task greeting(type: GreetingTask) {
    greeting = 'Hi'
    recipient = 'Gradle'
}

task taskA {
    doLast {
        println 'Task A'
    }
}

task taskB {
    doLast {
        println 'Task B'
    }
}

task taskC {
    // 依赖taskA和taskB
    dependsOn taskA, taskB
    doLast {
        println 'Task C'
    }
}

// 动态依赖
task taskD {
    dependsOn tasks.matching { task -> task.name.startsWith('test') }
    doLast {
        println 'Task D'
    }
}

// 条件依赖
taskC.dependsOn {
    tasks.findAll { task -> task.name.startsWith('compile') && task.enabled }
}

task taskX {
    doLast { println 'Task X' }
}

task taskY {
    doLast { println 'Task Y' }
}

// mustRunAfter: 如果两个任务都要执行，确保顺序
taskY.mustRunAfter taskX

// shouldRunAfter: 软排序，尽量保证顺序
taskY.shouldRunAfter taskX

// finalizedBy: 无论成功失败都会执行
task cleanup {
    doLast { println 'Cleanup' }
}

taskX.finalizedBy cleanup

// ==================== 基础输入输出配置 ====================
task processFiles {
    // 输入文件配置
    inputs.files fileTree('src/main/resources') {
        include '**/*.properties'
        include '**/*.yml'
        exclude '**/*.tmp'
    }

    // 输入属性配置
    inputs.property 'version', project.version
    inputs.property 'environment', project.findProperty('env') ?: 'dev'

    // 输出目录配置
    outputs.dir 'build/processed'

    // 缓存配置
    outputs.cacheIf { true }

    // 增量构建配置
    outputs.upToDateWhen {
        // 自定义最新检查逻辑
        file('build/processed').exists() &&
        file('build/processed').lastModified() > inputs.files.asFileTree.maxBy { it.lastModified() }.lastModified()
    }

    doLast {
        // 确保输出目录存在
        outputs.files.singleFile.mkdirs()

        // 处理文件
        copy {
            from inputs.files
            into outputs.files.singleFile
            filter { line ->
                line.replace('${version}', project.version)
                    .replace('${env}', project.findProperty('env') ?: 'dev')
            }
        }

        println "Processed ${inputs.files.files.size()} files to ${outputs.files.singleFile}"
    }
}

// ==================== 使用注解的任务类 ====================
class ProcessFilesTask extends DefaultTask {

    // 输入文件：支持增量构建
    @InputFiles
    @PathSensitive(PathSensitivity.RELATIVE)
    FileCollection inputFiles

    // 输入属性：影响任务执行结果
    @Input
    String version

    @Input
    @Optional
    String environment = 'dev'

    // 输出目录：任务的产出
    @OutputDirectory
    File outputDir

    // 内部属性：不影响任务最新状态
    @Internal
    String logLevel = 'INFO'

    @TaskAction
    void processFiles() {
        // 确保输出目录存在
        outputDir.mkdirs()

        // 处理每个输入文件
        inputFiles.each { file ->
            def outputFile = new File(outputDir, file.name)

            outputFile.text = file.text
                .replace('${version}', version)
                .replace('${environment}', environment)

            if (logLevel == 'DEBUG') {
                println "Processed: ${file.name} -> ${outputFile.name}"
            }
        }

        println "Processed ${inputFiles.files.size()} files for environment: ${environment}"
    }
}

// 注册自定义任务
tasks.register('processConfigFiles', ProcessFilesTask) {
    inputFiles = fileTree('src/main/resources/config')
    version = project.version
    environment = project.findProperty('env') ?: 'dev'
    outputDir = file('build/processed-config')
}

// ==================== 复杂任务输入输出示例 ====================
task generateDocumentation {
    // 多种输入类型
    inputs.files fileTree('src/main/java') {
        include '**/*.java'
    }
    inputs.files fileTree('docs/templates')
    inputs.property 'version', project.version
    inputs.property 'buildTime', new Date().format('yyyy-MM-dd HH:mm:ss')

    // 多个输出
    outputs.dir 'build/docs/api'
    outputs.dir 'build/docs/user-guide'
    outputs.file 'build/docs/README.html'

    // 缓存配置
    outputs.cacheIf {
        // 只有在生产环境才缓存文档生成
        project.hasProperty('prod')
    }

    doLast {
        // 生成API文档
        exec {
            commandLine 'javadoc', '-d', 'build/docs/api',
                       '-sourcepath', 'src/main/java',
                       '-subpackages', 'com.example'
        }

        // 生成用户指南
        copy {
            from 'docs/templates'
            into 'build/docs/user-guide'
            expand(
                version: project.version,
                buildTime: new Date().format('yyyy-MM-dd HH:mm:ss')
            )
        }

        // 生成README
        def readmeContent = """
        # ${project.name} v${project.version}

        Generated on: ${new Date().format('yyyy-MM-dd HH:mm:ss')}

        ## API Documentation
        See [API Docs](api/index.html)

        ## User Guide
        See [User Guide](user-guide/index.html)
        """.stripIndent()

        file('build/docs/README.html').text = readmeContent
    }
}

// ==================== 任务输入输出最佳实践 ====================

// 1. 文件复制任务
task copyResources(type: Copy) {
    from 'src/main/resources'
    into 'build/resources'

    // 输入输出自动配置
    // inputs.files 自动设置为 from 的文件
    // outputs.dir 自动设置为 into 的目录

    // 文件过滤
    filter { line ->
        line.replace('${project.version}', project.version)
    }

    // 包含/排除文件
    include '**/*.properties'
    exclude '**/*.tmp'
}

// 2. ZIP打包任务
task createDistribution(type: Zip) {
    archiveFileName = "${project.name}-${project.version}.zip"
    destinationDirectory = file('build/distributions')

    from 'build/libs'
    from 'src/main/scripts'
    from 'README.md'

    // 自动配置输入输出
    // inputs 包含所有 from 的文件
    // outputs.file 为生成的ZIP文件
}

// 3. 测试任务配置
tasks.named('test') {
    // 输入配置
    inputs.files sourceSets.test.runtimeClasspath
    inputs.files sourceSets.main.runtimeClasspath
    inputs.property 'javaVersion', System.getProperty('java.version')

    // 输出配置
    outputs.dir 'build/test-results'
    outputs.dir 'build/reports/tests'

    // 缓存配置
    outputs.cacheIf {
        // 只有在没有系统属性变化时才缓存
        !project.hasProperty('rerunTests')
    }
}

// 1. 核心插件（推荐）
plugins {
    id 'java'
    id 'application'
}

// 2. 社区插件
plugins {
    id 'org.springframework.boot' version '2.7.0'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
}

// 3. 传统方式（不推荐）
apply plugin: 'java'
apply plugin: 'application'

// 4. 条件应用
plugins {
    id 'java'
    if (project.hasProperty('android')) {
        id 'com.android.application'
    }
}

// 5. 脚本插件
apply from: 'gradle/dependencies.gradle'
apply from: 'https://raw.githubusercontent.com/example/scripts/main/common.gradle'

plugins {
    id 'java'
}

// Java插件配置
java {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11

    // 生成源码jar
    withSourcesJar()

    // 生成javadoc jar
    withJavadocJar()
}

// 编译配置
compileJava {
    options.encoding = 'UTF-8'
    options.compilerArgs += ['-parameters', '-Xlint:unchecked']
}

// 测试配置
test {
    useJUnitPlatform()

    testLogging {
        events 'passed', 'skipped', 'failed'
    }

    reports {
        html.required = true
        junitXml.required = true
    }
}

plugins {
    id 'application'
}

application {
    mainClass = 'com.example.Application'
    applicationDefaultJvmArgs = ['-Xmx512m', '-Dfile.encoding=UTF-8']
}

// 生成的任务
// run: 运行应用
// distZip: 创建ZIP分发包
// distTar: 创建TAR分发包
// installDist: 安装应用到build/install

plugins {
    id 'org.springframework.boot' version '2.7.0'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
}

springBoot {
    buildInfo()

    mainClass = 'com.example.Application'
}

// 生成的任务
// bootRun: 运行Spring Boot应用
// bootJar: 创建可执行JAR
// bootBuildImage: 构建Docker镜像

// ==================== 项目基本信息 ====================
// 根项目名称：影响生成的JAR文件名
rootProject.name = 'my-multi-project'

// ==================== 子项目包含配置 ====================
// 标准子项目包含
include 'common'
include 'api'
include 'service'
include 'web'
include 'integration-tests'

// 嵌套项目包含
include 'common:common-core'
include 'common:common-web'
include 'common:common-data'

// 服务模块
include 'services:user-service'
include 'services:order-service'
include 'services:payment-service'

// 基础设施模块
include 'infrastructure:config-server'
include 'infrastructure:eureka-server'

// ==================== 项目目录映射 ====================
// 自定义项目目录结构
project(':common').projectDir = file('modules/common')
project(':api').projectDir = file('modules/api')

// 批量设置服务模块目录
['user-service', 'order-service', 'payment-service'].each { serviceName ->
    project(":services:${serviceName}").projectDir = file("services/${serviceName}")
}

// ==================== 插件管理详解 ====================
pluginManagement {
    // 插件仓库配置
    repositories {
        gradlePluginPortal()    // Gradle官方插件门户
        mavenCentral()          // Maven中央仓库
        // 企业私有插件仓库
        maven {
            url = 'https://nexus.company.com/repository/gradle-plugins/'
            credentials {
                username = providers.gradleProperty('nexusUsername').orNull
                password = providers.gradleProperty('nexusPassword').orNull
            }
        }
    }

    // 插件版本管理：统一管理所有插件版本
    plugins {
        // Spring Boot相关
        id 'org.springframework.boot' version '2.7.0'
        id 'io.spring.dependency-management' version '1.0.11.RELEASE'

        // 代码质量
        id 'jacoco' version '0.8.8'
        id 'com.github.spotbugs' version '5.0.9'
        id 'checkstyle' version '10.3.1'

        // 容器化
        id 'com.palantir.docker' version '0.34.0'
        id 'com.google.cloud.tools.jib' version '3.2.1'

        // 文档生成
        id 'org.asciidoctor.jvm.convert' version '3.3.2'

        // 性能分析
        id 'com.gradle.build-scan' version '3.11'
    }

    // 插件解析策略
    resolutionStrategy {
        eachPlugin {
            // 自定义插件解析逻辑
            if (requested.id.namespace == 'com.company') {
                useModule('com.company:gradle-plugins:1.0.0')
            }
        }
    }
}

// ==================== 依赖解析管理详解 ====================
dependencyResolutionManagement {
    // 仓库模式：FAIL_ON_PROJECT_REPOS 确保所有仓库在这里统一配置
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)

    // 统一仓库配置
    repositories {
        // 本地仓库（开发环境）
        if (providers.gradleProperty('useLocalRepo').isPresent()) {
            mavenLocal()
        }

        // 企业私有仓库
        maven {
            name = 'CompanyNexus'
            url = 'https://nexus.company.com/repository/maven-public/'
            credentials {
                username = providers.gradleProperty('nexusUsername').orNull
                password = providers.gradleProperty('nexusPassword').orNull
            }
        }

        // 国内镜像（加速下载）
        maven {
            name = 'Aliyun'
            url = 'https://maven.aliyun.com/repository/public'
        }

        // Maven中央仓库
        mavenCentral()

        // Spring仓库
        maven {
            name = 'SpringRepo'
            url = 'https://repo.spring.io/milestone'
            mavenContent {
                includeGroupByRegex 'org\\.springframework.*'
            }
        }
    }

    // 版本目录配置（Gradle 7.0+）
    versionCatalogs {
        libs {
            // 定义版本
            version('spring-boot', '2.7.0')
            version('spring-cloud', '2021.0.3')
            version('junit', '5.9.2')

            // 定义库
            library('spring-boot-starter-web', 'org.springframework.boot', 'spring-boot-starter-web').versionRef('spring-boot')
            library('spring-boot-starter-test', 'org.springframework.boot', 'spring-boot-starter-test').versionRef('spring-boot')
            library('junit-jupiter', 'org.junit.jupiter', 'junit-jupiter').versionRef('junit')

            // 定义插件
            plugin('spring-boot', 'org.springframework.boot').versionRef('spring-boot')
            plugin('spring-dependency-management', 'io.spring.dependency-management').version('1.0.11.RELEASE')

            // 定义bundle（依赖组合）
            bundle('spring-boot-web', ['spring-boot-starter-web', 'spring-boot-starter-actuator'])
            bundle('testing', ['junit-jupiter', 'spring-boot-starter-test'])
        }
    }
}

// ==================== 构建缓存配置 ====================
buildCache {
    local {
        enabled = true
        directory = file('build-cache')
        removeUnusedEntriesAfterDays = 30
    }

    remote(HttpBuildCache) {
        url = 'https://cache.company.com/'
        push = providers.gradleProperty('pushToCache').isPresent()
        credentials {
            username = providers.gradleProperty('cacheUsername').orNull
            password = providers.gradleProperty('cachePassword').orNull
        }
    }
}

// ==================== 特性预览配置 ====================
enableFeaturePreview('TYPESAFE_PROJECT_ACCESSORS')
enableFeaturePreview('VERSION_CATALOGS')

// 企业级多模块项目settings.gradle
rootProject.name = 'enterprise-platform'

// 核心模块
include 'platform-core'
include 'platform-common'
include 'platform-security'

// 业务模块
['user', 'order', 'payment', 'inventory'].each { module ->
    include "business-${module}"
    project(":business-${module}").projectDir = file("business/${module}")
}

// 基础设施模块
['gateway', 'config', 'registry', 'monitor'].each { infra ->
    include "infra-${infra}"
    project(":infra-${infra}").projectDir = file("infrastructure/${infra}")
}

pluginManagement {
    repositories {
        // 企业私有插件仓库优先
        maven {
            url = 'https://nexus.corp.com/repository/gradle-plugins/'
            credentials {
                username = System.getenv('CORP_NEXUS_USER')
                password = System.getenv('CORP_NEXUS_PASS')
            }
        }
        gradlePluginPortal()
    }
}

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        // 企业仓库优先
        maven {
            url = 'https://nexus.corp.com/repository/maven-public/'
            credentials {
                username = System.getenv('CORP_NEXUS_USER')
                password = System.getenv('CORP_NEXUS_PASS')
            }
        }
        mavenCentral()
    }
}

// 开源项目settings.gradle
rootProject.name = 'awesome-library'

include 'core'
include 'extensions'
include 'examples'
include 'benchmarks'

pluginManagement {
    repositories {
        gradlePluginPortal()
        mavenCentral()
    }

    plugins {
        id 'java-library'
        id 'maven-publish'
        id 'signing'
        id 'org.gradle.test-retry' version '1.4.1'
        id 'com.gradle.plugin-publish' version '1.0.0'
    }
}

dependencyResolutionManagement {
    repositories {
        mavenCentral()
        // 快照版本仓库
        maven {
            url = 'https://oss.sonatype.org/content/repositories/snapshots/'
            mavenContent {
                snapshotsOnly()
            }
        }
    }
}

// 应用于所有项目的配置
allprojects {
    group = 'com.example'
    version = '1.0.0-SNAPSHOT'
    
    repositories {
        mavenCentral()
    }
}

// 应用于所有子项目的配置
subprojects {
    apply plugin: 'java'
    apply plugin: 'java-library'
    
    java {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
    }
    
    // 公共依赖
    dependencies {
        implementation 'org.slf4j:slf4j-api:1.7.36'
        testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
        testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
    }
    
    // 公共任务配置
    tasks.withType(JavaCompile) {
        options.encoding = 'UTF-8'
        options.compilerArgs += ['-parameters']
    }
    
    test {
        useJUnitPlatform()
        testLogging {
            events 'passed', 'skipped', 'failed'
        }
    }
}

// 特定项目配置
project(':web') {
    apply plugin: 'org.springframework.boot'
    apply plugin: 'io.spring.dependency-management'
    
    dependencies {
        implementation project(':service')
        implementation 'org.springframework.boot:spring-boot-starter-web'
    }
}

project(':service') {
    dependencies {
        implementation project(':api')
        implementation project(':common')
        implementation 'org.springframework.boot:spring-boot-starter'
    }
}

project(':api') {
    dependencies {
        api project(':common')
        api 'javax.validation:validation-api:2.0.1.Final'
    }
}

// 聚合任务
task buildAll {
    dependsOn subprojects.collect { it.tasks.named('build') }
    description = '构建所有子项目'
    group = 'build'
}

task testAll {
    dependsOn subprojects.collect { it.tasks.named('test') }
    description = '测试所有子项目'
    group = 'verification'
}

// 公共工具模块
dependencies {
    api 'org.apache.commons:commons-lang3:3.12.0'
    api 'com.fasterxml.jackson.core:jackson-databind:2.13.3'
    api 'com.google.guava:guava:31.1-jre'
    
    implementation 'org.slf4j:slf4j-api:1.7.36'
    
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
    testImplementation 'org.assertj:assertj-core:3.23.1'
}

// 生成源码jar
java {
    withSourcesJar()
    withJavadocJar()
}

plugins {
    id 'org.springframework.boot'
    id 'io.spring.dependency-management'
}

dependencies {
    // 项目依赖
    implementation project(':api')
    implementation project(':common')
    
    // Spring Boot依赖
    implementation 'org.springframework.boot:spring-boot-starter'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-validation'
    
    // 数据库
    runtimeOnly 'mysql:mysql-connector-java'
    testImplementation 'com.h2database:h2'
    
    // 测试
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

// 禁用bootJar任务（这是一个库，不是应用）
jar {
    enabled = true
    archiveClassifier = ''
}

bootJar {
    enabled = false
}

plugins {
    id 'org.springframework.boot'
    id 'io.spring.dependency-management'
}

dependencies {
    // 项目依赖
    implementation project(':service')
    
    // Spring Boot Web
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    implementation 'org.springframework.boot:spring-boot-starter-validation'
    
    // 前端资源处理
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
    
    // 测试
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.springframework.boot:spring-boot-testcontainers'
    testImplementation 'org.testcontainers:mysql'
}

// Spring Boot配置
springBoot {
    buildInfo()
    mainClass = 'com.example.web.WebApplication'
}

// 构建Docker镜像
task buildImage {
    dependsOn bootBuildImage
    description = '构建Docker镜像'
    group = 'build'
}

// gradle/common.gradle
// 可复用的构建逻辑

ext {
    springBootVersion = '2.7.0'
    junitVersion = '5.9.2'
}

configurations {
    integrationTestImplementation.extendsFrom testImplementation
    integrationTestRuntimeOnly.extendsFrom testRuntimeOnly
}

sourceSets {
    integrationTest {
        java.srcDir 'src/integration-test/java'
        resources.srcDir 'src/integration-test/resources'
    }
}

task integrationTest(type: Test) {
    testClassesDirs = sourceSets.integrationTest.output.classesDirs
    classpath = sourceSets.integrationTest.runtimeClasspath
    
    useJUnitPlatform()
    
    testLogging {
        events 'passed', 'skipped', 'failed'
    }
}

// 在项目中使用
// apply from: rootProject.file('gradle/common.gradle')

// buildSrc/build.gradle
plugins {
    id 'groovy-gradle-plugin'
}

repositories {
    gradlePluginPortal()
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-gradle-plugin:2.7.0'
}
// buildSrc/src/main/groovy/com.example.java-conventions.gradle
// 约定插件

plugins {
    id 'java'
    id 'jacoco'
}

java {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11
    withSourcesJar()
    withJavadocJar()
}

repositories {
    mavenCentral()
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

tasks.withType(JavaCompile) {
    options.encoding = 'UTF-8'
    options.compilerArgs += ['-parameters', '-Xlint:unchecked']
}

test {
    useJUnitPlatform()
    finalizedBy jacocoTestReport
}

jacocoTestReport {
    dependsOn test
    reports {
        xml.required = true
        html.required = true
    }
}

// my-gradle-plugin/build.gradle
plugins {
    id 'java-gradle-plugin'
    id 'groovy'
    id 'maven-publish'
}

group = 'com.example'
version = '1.0.0'

repositories {
    gradlePluginPortal()
    mavenCentral()
}

dependencies {
    implementation gradleApi()
    implementation localGroovy()
    
    testImplementation 'org.spockframework:spock-core:2.3-groovy-3.0'
}

gradlePlugin {
    plugins {
        myPlugin {
            id = 'com.example.my-plugin'
            implementationClass = 'com.example.MyPlugin'
            displayName = 'My Custom Plugin'
            description = 'A custom Gradle plugin'
        }
    }
}

// 发布配置
publishing {
    repositories {
        maven {
            url = 'https://nexus.company.com/repository/gradle-plugins/'
            credentials {
                username = project.findProperty('nexusUsername')
                password = project.findProperty('nexusPassword')
            }
        }
    }
}

// src/main/groovy/com/example/tasks/GreetingTask.groovy
package com.example.tasks

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.*

class GreetingTask extends DefaultTask {

    @Input
    String greeting = 'Hello'

    @Input
    String recipient = 'World'

    @OutputFile
    File outputFile

    @TaskAction
    void greet() {
        def message = "${greeting}, ${recipient}!"
        println message

        if (outputFile) {
            outputFile.parentFile.mkdirs()
            outputFile.text = message
        }
    }
}

// src/main/groovy/com/example/MyPlugin.groovy
package com.example

import com.example.tasks.GreetingTask
import org.gradle.api.Plugin
import org.gradle.api.Project

class MyPlugin implements Plugin<Project> {

    @Override
    void apply(Project project) {
        // 创建扩展
        def extension = project.extensions.create('myPlugin', MyPluginExtension)

        // 注册任务
        project.tasks.register('greeting', GreetingTask) { task ->
            task.greeting = extension.greeting
            task.recipient = extension.recipient
            task.outputFile = project.file("${project.buildDir}/greeting.txt")
        }

        // 配置现有任务
        project.tasks.named('build') {
            dependsOn 'greeting'
        }

        // 添加配置
        project.afterEvaluate {
            println "MyPlugin applied to ${project.name}"
        }
    }
}

// 扩展类
class MyPluginExtension {
    String greeting = 'Hello'
    String recipient = 'Gradle'
}

// build.gradle
plugins {
    id 'com.example.my-plugin' version '1.0.0'
}

myPlugin {
    greeting = 'Hi'
    recipient = 'Developer'
}

// settings.gradle - 企业级缓存配置
buildCache {
    local {
        enabled = true
        directory = file('/opt/gradle-cache')  // 使用SSD路径
        removeUnusedEntriesAfterDays = 7       // 企业环境快速清理
    }

    remote(HttpBuildCache) {
        url = 'https://gradle-cache.company.com/'

        // 只有CI环境和发布分支推送缓存
        push = (System.getenv('CI') != null) &&
               (System.getenv('BRANCH_NAME') in ['main', 'develop'])

        credentials {
            username = System.getenv('GRADLE_CACHE_USER')
            password = System.getenv('GRADLE_CACHE_PASS')
        }

        // 企业网络配置
        allowUntrustedServer = false
        connectionTimeoutMs = 10000
        socketTimeoutMs = 30000
    }
}

// build.gradle - 开源项目缓存配置
buildCache {
    local {
        enabled = true
        removeUnusedEntriesAfterDays = 14
    }

    // 使用Gradle Build Cache Node
    remote(HttpBuildCache) {
        url = 'https://ge.gradle.org/cache/'
        push = false  // 开源项目通常只读取缓存
    }
}

// 针对开源项目的缓存优化
tasks.withType(Javadoc).configureEach {
    // JavaDoc生成通常很慢，启用缓存
    outputs.cacheIf { true }
}

tasks.withType(Test).configureEach {
    // 测试缓存配置
    outputs.cacheIf {
        // 只有在测试代码和依赖没有变化时才缓存
        !project.hasProperty('forceTests')
    }
}

// build.gradle - 多环境缓存策略
buildCache {
    local {
        enabled = true
        directory = file("${System.getProperty('user.home')}/.gradle/build-cache")

        // 根据环境调整清理策略
        removeUnusedEntriesAfterDays = project.hasProperty('dev') ? 7 : 30
    }

    remote(HttpBuildCache) {
        def cacheUrl = project.findProperty('cacheUrl') ?:
                      System.getenv('GRADLE_CACHE_URL')

        if (cacheUrl) {
            url = cacheUrl

            // 环境特定的推送策略
            push = project.hasProperty('pushCache') ||
                   System.getenv('GRADLE_CACHE_PUSH') == 'true'

            credentials {
                username = project.findProperty('cacheUser') ?:
                          System.getenv('GRADLE_CACHE_USER')
                password = project.findProperty('cachePass') ?:
                          System.getenv('GRADLE_CACHE_PASS')
            }
        }
    }
}

// ==================== 环境配置处理 ====================
// 环境检测
def environment = project.findProperty('env') ?: 'dev'
def isProduction = environment == 'prod'
def isDevelopment = environment == 'dev'
def isTesting = environment == 'test'

// 根据环境设置属性
ext {
    env = environment

    // 数据库配置
    dbUrl = project.findProperty('database.url') ?: 'jdbc:h2:mem:testdb'
    dbUsername = project.findProperty('database.username') ?: 'sa'
    dbPassword = project.findProperty('database.password') ?: ''

    // Redis配置
    redisHost = project.findProperty('redis.host') ?: 'localhost'
    redisPort = project.findProperty('redis.port') ?: '6379'

    // 日志配置
    logLevel = project.findProperty('log.level') ?: 'INFO'

    // Spring配置
    springProfiles = project.findProperty('spring.profiles.active') ?: 'dev'
}

// ==================== 环境特定依赖 ====================
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

    // 开发环境依赖
    if (isDevelopment) {
        developmentOnly 'org.springframework.boot:spring-boot-devtools'
        runtimeOnly 'com.h2database:h2'
    }

    // 生产环境依赖
    if (isProduction) {
        runtimeOnly 'mysql:mysql-connector-java'
        implementation 'io.micrometer:micrometer-registry-prometheus'
    }

    // 测试环境依赖
    if (isTesting) {
        testImplementation 'org.testcontainers:mysql'
        testImplementation 'org.testcontainers:redis'
    }
}

// ==================== 环境特定任务配置 ====================
tasks.named('bootRun') {
    systemProperty 'spring.profiles.active', springProfiles
    systemProperty 'database.url', dbUrl
    systemProperty 'database.username', dbUsername
    systemProperty 'database.password', dbPassword
    systemProperty 'redis.host', redisHost
    systemProperty 'redis.port', redisPort

    // 开发环境特定配置
    if (isDevelopment) {
        systemProperty 'spring.devtools.restart.enabled', 'true'
        systemProperty 'logging.level.com.example', 'DEBUG'
    }
}

tasks.named('test') {
    systemProperty 'spring.profiles.active', 'test'
    systemProperty 'database.url', 'jdbc:h2:mem:testdb'

    // 测试环境JVM参数
    jvmArgs = ['-Xmx1024m', '-XX:MaxMetaspaceSize=256m']
}

// ==================== 资源文件处理 ====================
tasks.named('processResources') {
    // 资源文件属性替换
    filesMatching(['**/*.properties', '**/*.yml']) {
        expand(
            version: project.version,
            environment: environment,
            databaseUrl: dbUrl,
            databaseUsername: dbUsername,
            redisHost: redisHost,
            redisPort: redisPort,
            logLevel: logLevel
        )
    }
}

// build.gradle - 多环境构建配置
// 环境配置映射
def environmentConfigs = [
    dev: [
        profile: 'dev',
        dbUrl: 'jdbc:mysql://localhost:3306/myapp_dev',
        dbUser: 'dev_user',
        dbPass: 'dev_password',
        redisHost: 'localhost',
        logLevel: 'DEBUG',
        skipTests: false
    ],
    test: [
        profile: 'test',
        dbUrl: 'jdbc:mysql://test-server:3306/myapp_test',
        dbUser: 'test_user',
        dbPass: System.getenv('TEST_DB_PASSWORD'),
        redisHost: 'test-redis.company.com',
        logLevel: 'INFO',
        skipTests: false
    ],
    prod: [
        profile: 'prod',
        dbUrl: 'jdbc:mysql://prod-cluster:3306/myapp_prod',
        dbUser: 'prod_user',
        dbPass: System.getenv('PROD_DB_PASSWORD'),
        redisHost: 'prod-redis-cluster.company.com',
        logLevel: 'WARN',
        skipTests: true
    ]
]

// 获取当前环境配置
def currentEnv = project.findProperty('env') ?: 'dev'
def config = environmentConfigs[currentEnv]

if (!config) {
    throw new GradleException("Unknown environment: ${currentEnv}")
}

// 应用环境配置
ext {
    environmentConfig = config
}

// 环境特定任务
task deployToEnvironment {
    group = 'deployment'
    description = "Deploy to ${currentEnv} environment"

    doLast {
        println "Deploying to ${currentEnv} environment..."
        println "Database: ${config.dbUrl}"
        println "Redis: ${config.redisHost}"
        println "Log Level: ${config.logLevel}"

        // 执行部署逻辑
        if (config.skipTests) {
            println "Skipping tests for ${currentEnv} environment"
        } else {
            println "Running tests for ${currentEnv} environment"
        }
    }
}

// 环境验证任务
task validateEnvironment {
    group = 'verification'
    description = "Validate ${currentEnv} environment configuration"

    doLast {
        println "Validating ${currentEnv} environment..."

        // 验证必需的环境变量
        def requiredEnvVars = []
        if (currentEnv == 'test') {
            requiredEnvVars = ['TEST_DB_PASSWORD']
        } else if (currentEnv == 'prod') {
            requiredEnvVars = ['PROD_DB_PASSWORD', 'PROD_REDIS_PASSWORD']
        }

        requiredEnvVars.each { envVar ->
            if (!System.getenv(envVar)) {
                throw new GradleException("Required environment variable not set: ${envVar}")
            }
        }

        println "Environment validation passed for ${currentEnv}"
    }
}

// 构建前验证环境
tasks.named('build') {
    dependsOn validateEnvironment
}

// build.gradle - Docker多环境构建
apply plugin: 'com.palantir.docker'

docker {
    name = "${project.name}:${project.version}-${currentEnv}"

    // 基础镜像
    dockerfile file('docker/Dockerfile')

    // 构建参数
    buildArgs([
        'JAR_FILE': "build/libs/${project.name}-${project.version}.jar",
        'ENVIRONMENT': currentEnv,
        'JAVA_OPTS': getJavaOpts(currentEnv)
    ])

    // 文件复制
    files tasks.bootJar.outputs.files
    files 'docker/entrypoint.sh'
    files "src/main/resources/application-${currentEnv}.yml"
}

// 根据环境获取JVM参数
def getJavaOpts(env) {
    def javaOpts = [
        dev: '-Xmx1g -Xms512m -XX:+UseG1GC',
        test: '-Xmx2g -Xms1g -XX:+UseG1GC',
        prod: '-Xmx4g -Xms2g -XX:+UseG1GC -XX:+UseStringDeduplication'
    ]
    return javaOpts[env] ?: javaOpts['dev']
}

// 环境特定Docker任务
task buildDockerDev {
    group = 'docker'
    description = 'Build Docker image for development'
    dependsOn 'bootJar'
    finalizedBy 'docker'

    doFirst {
        project.ext.currentEnv = 'dev'
    }
}

task buildDockerProd {
    group = 'docker'
    description = 'Build Docker image for production'
    dependsOn 'bootJar'
    finalizedBy 'docker'

    doFirst {
        project.ext.currentEnv = 'prod'
    }
}