Gradle复制子任务仅直接调用生效：copyall执行异常问题排查

Let's break down exactly what's happening here—this is a common pitfall with Gradle's two core phases: configuration and execution.

The Root Cause #

When you define copyA inside the closure of copyall, here's the step-by-step breakdown:

1. When you run gradle copyall, Gradle first enters the configuration phase. It executes the closure of every task in your build script, including copyall.
   • During this phase, your mkdir 'web' line runs immediately (it's plain Groovy code, not part of a task's execution logic), so the directory gets created.
   • The copyA task gets defined, but copyall doesn't have any dependency on it, and copyall itself has no execution logic of its own.
2. Once configuration is done, Gradle moves to the execution phase—but it only runs the copyall task (since that's what you specified). Since copyall doesn't trigger copyA, the copy action never happens.

When you run gradle copyA directly, Gradle configures all tasks (still creating the web directory in the process), then executes the copyA task's copy logic—so everything works as expected.

Fixes That Work #

There are two clean ways to fix this, depending on your needs:

1. Use Task Dependencies (Recommended)

Define copyA as a top-level task, then make copyall depend on it. This follows Gradle's intended design and preserves features like incremental builds:

// Define the copy task at the project level
task copyA(type: Copy) {
    from 'src'
    into 'web'
    // No need for manual mkdir—Copy tasks auto-create target directories!
}

// Make copyall depend on copyA, so copyA runs when copyall is called
task copyall {
    dependsOn copyA
    doFirst {
        println 'starting...'
    }
}

Now when you run gradle copyall, Gradle will first execute copyA (handling directory creation and file copy), then run copyall's doFirst action to print your message.

2. Explicitly Execute the Subtask (Not Recommended)

If you really need to define copyA inside copyall (this is not ideal for readability or Gradle's built-in features), you can create and execute it during copyall's execution phase:

task copyall {
    doFirst {
        println 'starting...'
        // Create and configure the copy task during execution
        def copyA = tasks.create('copyA', Copy) {
            from 'src'
            into 'web'
        }
        // Explicitly run the task
        copyA.execute()
    }
}

Note: This bypasses Gradle's dependency management and incremental build checks, so it's better to use the first approach unless you have a specific reason not to.

Key Takeaways #

• Always remember Gradle's configuration vs execution split—code in a task's top-level closure runs during configuration, while code in doFirst/doLast runs during execution.
• Use dependsOn to link tasks instead of nesting task definitions—it's the standard, maintainable way to build task workflows.
• Copy tasks handle target directory creation automatically, so you don't need to call mkdir manually.

内容的提问来源于stack exchange，提问作者Rustam A.