Gradle is a powerful build automation tool used in JVM-based projects like Java, Kotlin, and Groovy. Understanding its task lifecycle is essential for writing efficient and well-structured build scripts. This article explains the Gradle task lifecycle, execution phases, plugin tasks, and the role of doLast {} in defining main actions.

Gradle Task Lifecycle

A Gradle build goes through three main phases:

1. Initialization Phase

• Identifies the projects involved in the build.
• Creates Project objects but does not execute tasks.

2. Configuration Phase

• Evaluates build.gradle or build.gradle.kts scripts.
• Defines tasks and their dependencies, but does not execute them.

3. Execution Phase

• Determines which tasks need to run based on dependencies.
• Executes each task in the correct order.
• Each task runs in three steps:
  1. doFirst {} (Pre-action, runs before the main task logic)
  2. Main task action (Defined within doLast {} if no type is set)
  3. doLast {} (Post-action, executes after the main task logic)

Execution Phase Example

Let's define some simple tasks and observe their execution order:

// Define taskA
task taskA {
    doFirst { println "Before taskA" }
    doLast { println "Main action of taskA" }
    doLast { println "After taskA" }
}

// Define taskB
task taskB {
    doFirst { println "Before taskB" }
    doLast { println "Main action of taskB" }
    doLast { println "After taskB" }
}

// Define taskC, which depends on taskA and taskB
task taskC {
    dependsOn taskA, taskB
    doLast { println "Main action of taskC" }
}

Expected Output when Running "gradle taskC"

> Task :taskA
Before taskA
Main action of taskA
After taskA

> Task :taskB
Before taskB
Main action of taskB
After taskB

> Task :taskC
Main action of taskC

Since taskC depends on taskA and taskB, Gradle ensures that taskA and taskB execute before taskC.

Common Main Task Actions

Gradle tasks can perform various actions, such as:

✅ Compiling code (compileJava)

task compileCode {
    doLast { println "Compiling source code..." }
}

✅ Copying files (Copy task)

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

✅ Running tests (test task)

task runTests {
    doLast { println "Running unit tests..." }
}

✅ Creating a JAR file (Jar task)

task createJar(type: Jar) {
    archiveBaseName.set("myApp")
    destinationDirectory.set(file("$buildDir/libs"))
}

✅ Running an application (JavaExec task)

task runApp(type: JavaExec) {
    mainClass = "com.example.Main"
    classpath = sourceSets.main.runtimeClasspath
}

✅ Cleaning build directories (clean task)

task cleanBuild {
    doLast {
        delete file("build")
        println "Build directory cleaned!"
    }
}

Are Plugin Tasks Part of the Main Task?

• No, plugin tasks do not run automatically unless explicitly executed or added as dependencies.
• Applying a plugin (e.g., java) provides tasks like compileJava, test, and jar, but they must be invoked or referenced.

Example:

apply plugin: 'java' // Adds Java-related tasks

task myBuildTask {
    dependsOn 'build' // Now includes plugin tasks
    doLast { println "Custom build complete!" }
}

Running gradle myBuildTask executes Java plugin tasks (compileJava, test, jar, etc.) before myBuildTask.

Do You Need doLast for the Main Task?

• If a task has no type, the main action must be inside doLast {}.

  task myTask {
    doLast { println "Executing my task!" }
  }

• If a task has a type, it already has built-in behavior, so doLast {} is only needed for additional actions.

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

Avoid Running Actions Outside doLast

task badTask {
    println "This runs during the configuration phase!"
}

❌ Problem: The message prints immediately during configuration, not when the task executes.

✅ Solution: Use doLast {}.

Final Takeaways

✅ Gradle tasks go through Initialization → Configuration → Execution phases.

✅ Tasks without a type need doLast {} for their main logic.

✅ Plugin tasks are independent but can be linked via dependencies.

✅ Use built-in tasks (e.g., Copy, Jar, JavaExec) when possible.

✅ Always place executable logic inside doLast{} for tasks without predefined behavior.

By understanding these concepts, you can write efficient Gradle scripts that optimize build processes. 🚀

Gradle, a powerful build automation tool, follows a structured process to build and configure projects. This process involves distinct phases, each playing a crucial role in the overall build lifecycle. In this article, we will explore the Initialization, Configuration, and Execution phases of a Gradle build and provide examples to illustrate each phase.

Initialization Phase

The Initialization Phase is the starting point of the Gradle build process. During this phase, Gradle constructs the Project instance, and sets up the build environment. The settings.gradle file is a key component executed during this phase.

Example:

// settings.gradle
rootProject.name = 'gradleBuildPhases'
println "Initialization Phase: This is executed during initialization"

In this example, the Initialization Phase prints a message when the settings.gradle file is executed.

Configuration Phase

The Configuration Phase follows the Initialization Phase and involves configuring the project and the tasks. During this phase, Gradle evaluates build scripts to set up the tasks and their dependencies.

Example:

// build.gradle
println 'Configuration Phase: Outside any task configuration.'

task myTask {
    println "Configuration Phase: Inside task configuration"
}

In this example, a task named myTask is defined in the build script. All the println statements will be performed during the Configuration Phase. Notice that there is a println statement outside the task, it will be executed as part of this phase. Moreover, this is also the phase where the task graph is created for all the requested tasks.

Execution Phase

The Execution Phase is where the actual tasks are executed based on their dependencies. Gradle ensures that tasks are executed in the correct order to fulfill their dependencies.

Example:

task myTask {

    doFirst {
        println 'Execution Phase: This is executed first.'
    }

    doLast {
        println 'Execution Phase: This is execute last.'
    }

    println "Configuration Phase: Inside task configuration"
}

Updating myTask task from the previous section. When executing it, Gradle automatically executes the action specified in the doFirst closure first, and the actions specified in the doLast closures will be performed last. Gradle will follow the task graph generated by the configuration phase.

Conclusion

Understanding the flow through Initialization, Configuration, and Execution phases is essential for effective project configuration and task execution in Gradle. By leveraging these phases, developers can structure their builds, manage dependencies, and define tasks to create a robust and efficient build process.

In conclusion, Gradle's build phases provide a systematic approach to building and configuring projects. Utilizing the Initialization Phase to set up the build environment, the Configuration Phase to define tasks, and the Execution Phase to carry out actions ensures a well-organized and reliable build process.

Add the following entry to gradle.properties:

org.gradle.jvmargs='-Dfile.encoding=UTF-8'

1. Download the gradle binary from the following address:

   https://services.gradle.org/distributions/

   For example gradle-7.4-all.zip.

2. Place the downloaded gradle binary to the gradle/wrapper directory of the gradle project.

3. Update the wrapper configuration (i.e. gradle/wrapper/gradle-wrapper.properties) like the following:

   If you've downloaded gradle-7.4-all.zip binary from step 1.

   distributionBase=PROJECT
   distributionPath=wrapper/dists
   distributionUrl=gradle-7.4-all.zip
   zipStoreBase=PROJECT
   zipStorePath=wrapper/dists

1. Create settings.gradle file with the following content:

   rootProject.name = 'download-dependecies'

2. Create build.gradle file with the following content:

   plugins {
       id 'application'
   }
   
   group 'xyz.ronella.gradle'
   version '1.0.0'
   
   repositories {
       mavenCentral()
   }
   
   dependencies {
       //Add all the target dependencies here
       implementation 'org.apache.poi:poi:3.5-FINAL'
   }
   
   task download(group: 'resolver') {
       doFirst {
           ant.delete(dir: 'libs')
           ant.mkdir(dir: 'libs')
       }
       doLast {
           copy {
               from sourceSets.main.runtimeClasspath
               into 'libs/'
           }
           def outputFile = "${project.buildDir}\\${project.name}-${version}.zip"
           ant.zip(basedir: "${file('libs')}", destfile: "${outputFile}", excludes: '*.class')
           println "Output: ${outputFile}"
           ant.delete(dir: 'libs')
       }
   }

3. Run the following gradle command:

   gradle download

   If you are using the gradle wrapper, use the following command:

   gradlew download

1. Create gradle.properties files in the following directory if not yet existing:

    <USER_HOME>/.gradle

2. Add the following entries for http proxy configuration in the gradle.properties file:

   systemProp.http.proxyHost=<PROXY_HOST>
   systemProp.http.proxyPort=<PROXY_PORT>
   systemProp.http.proxyUser=<PROXY_USERNAME>
   systemProp.http.proxyPassword=<PROXY_PASSWORD>
   systemProp.http.nonProxyHosts=<NON_PROXY_HOSTS>

   Note: <NON_PROXY_HOSTS> is delimited by pipe symbol (e.g. localhost|*.test.net)

   Note: If https proxy configuration is needed use the same entries except that all http will must be replaced with https (e.g. systemProp.https.proxyHost).