Gradle 中的 Task 是什么？如何创建和配置 Task？

Gradle 中的 Task 是构建过程中的基本执行单元，理解 Task 的概念和配置对于高效使用 Gradle 至关重要。

Task 的基本概念

Task 是一个原子操作单元，代表构建过程中的一个具体步骤，如编译代码、运行测试、打包 JAR 文件等。每个 Task 都有：

• 名称：唯一标识任务
• 类型：继承自 org.gradle.api.Task 接口
• 动作（Action）：任务执行时实际运行的代码
• 依赖关系：与其他任务的依赖关系
• 输入/输出：用于增量构建的输入文件和输出文件

创建 Task 的方式

1. 使用 tasks.register()（推荐）

groovy
// 延迟初始化，只在需要时创建
tasks.register('myTask') {
    doLast {
        println 'Executing myTask'
    }
}

// 指定任务类型
tasks.register('copyFiles', Copy) {
    from 'src/main/resources'
    into 'build/resources'
}

2. 使用 tasks.create()（立即创建）

groovy
// 立即创建任务实例
tasks.create('myTask') {
    doLast {
        println 'Executing myTask'
    }
}

3. 在 build.gradle 中直接定义

groovy
task myTask {
    doLast {
        println 'Executing myTask'
    }
}

task myTask2(type: Copy) {
    from 'src/main/resources'
    into 'build/resources'
}

Task 的配置

基本配置

groovy
tasks.register('myTask') {
    // 任务描述
    description = 'This is my custom task'
    
    // 任务分组
    group = 'Custom Tasks'
    
    // 设置任务依赖
    dependsOn 'clean', 'compileJava'
    
    // 设置任务必须运行
    mustRunAfter 'test'
    
    // 设置任务应该运行
    shouldRunAfter 'build'
    
    // 设置任务输入
    inputs.file('config.properties')
    inputs.dir('src/main/java')
    
    // 设置任务输出
    outputs.dir('build/output')
    
    // 任务动作
    doFirst {
        println 'Before task execution'
    }
    
    doLast {
        println 'After task execution'
    }
}

动态配置

groovy
// 使用 configure 块
tasks.register('myTask') {
    doLast {
        println "Project name: ${project.name}"
    }
}

tasks.named('myTask').configure {
    enabled = project.hasProperty('enableMyTask')
}

// 批量配置
tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
    options.compilerArgs << '-Xlint:unchecked'
}

Task 的依赖关系

dependsOn

groovy
tasks.register('taskA') {
    doLast { println 'Task A' }
}

tasks.register('taskB') {
    dependsOn 'taskA'
    doLast { println 'Task B' }
}

// 多个依赖
tasks.register('taskC') {
    dependsOn tasks.taskA, tasks.taskB
    doLast { println 'Task C' }
}

mustRunAfter 和 shouldRunAfter

groovy
tasks.register('taskA') {
    doLast { println 'Task A' }
}

tasks.register('taskB') {
    doLast { println 'Task B' }
}

// taskB 必须在 taskA 之后运行
taskB.mustRunAfter taskA

// taskC 应该在 taskA 之后运行（软约束）
tasks.register('taskC') {
    shouldRunAfter taskA
    doLast { println 'Task C' }
}

finalizedBy

groovy
tasks.register('taskA') {
    finalizedBy 'cleanupTask'
    doLast { println 'Task A' }
}

tasks.register('cleanupTask') {
    doLast { println 'Cleanup' }
}

Task 的执行控制

条件执行

groovy
tasks.register('conditionalTask') {
    onlyIf {
        project.hasProperty('runConditional')
    }
    
    doLast {
        println 'This task runs only if property exists'
    }
}

// 使用 enabled 属性
tasks.register('anotherTask') {
    enabled = false  // 禁用任务
    doLast {
        println 'This will not run'
    }
}

跳过执行

groovy
tasks.register('skipTask') {
    doLast {
        println 'This task will be skipped'
    }
    
    // 方式1：使用 onlyIf
    onlyIf { false }
    
    // 方式2：抛出 StopExecutionException
    doFirst {
        if (!project.hasProperty('force')) {
            throw new StopExecutionException()
        }
    }
}

常用内置 Task 类型

• Copy：复制文件和目录
• Delete：删除文件和目录
• Exec：执行外部命令
• JavaExec：执行 Java 应用程序
• Test：运行测试
• Jar：创建 JAR 文件
• Zip/Tar/GZip：创建压缩文件

最佳实践

1. 使用 tasks.register() 而不是 tasks.create()：延迟初始化可以提高性能
2. 明确任务的输入和输出：启用增量构建，提高构建速度
3. 合理使用任务依赖：避免循环依赖
4. 为任务添加描述和分组：提高可读性
5. 使用 doFirst 和 doLast：而不是直接在任务体中写代码，这样可以避免在配置阶段执行