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')