A task can contain many subtasks. Subtasks can be defined and ordered using the doFirst and doLast keywords. The following code snippet describes the Java method style task definition and subtask ordering:

task aTask(){
  doLast{
   println 'Executing last.'
  }
  
  doFirst {
        println 'Running 1st'
  }
}

Here, we defined a task named aTask using the Java method style. The task aTask contains two closure keywords: doLast and doFirst.

The doFirst closure is executed once the task is invoked, and the doLast closure is executed at the end.

When we run gradle aTask, it prints the following messages:

:aTask
Running 1st
Executing last.

BUILD SUCCESSFUL

In Ant, we can define a default target; similarly, Gradle provides options for default tasks using the keyword defaultTasks 'taskName1', …'taskNameN'.

The defaultTasks 'aTask' keyword defines aTask as a default task. So now if we only execute gradle with no task name, then it will invoke the default task.

In Ant, a target depends on another target, for example, a Java code compile task may depend on cleaning of the output folder; similarly, in Gradle, a task may depend on another task. The dependency is defined using the dependsOn keyword. The following syntax is used to define a task dependency:

secondTask.dependsOn 'firstTask'

Here, secondTask depends on firstTask.

Another way of defining task dependency is passing the dependency in a method-like style. The following code snippet shows the method argument style:

task secondTask (dependsOn: 'firstTask') {

  doLast {
        println 'Running last'
    }
  
   doFirst {
        println 'Running first'
    }

}

Execute gradle secondTask; it will first execute the dependent task firstTask and then execute the task secondTask as follows:

:firstTask
Hello world.
:secondTask
Running first
Running last

Another way of defining intertask dependency is using secondTask.dependsOn = ['firstTask'] or secondTask.dependsOn 'firstTask'.

Each time the gradle command is invoked, a new process is started, the Gradle classes and libraries are loaded, and the build is executed. Loading classes and libraries take time. Execution time can be reduced if a JVM, Gradle classes, and libraries, are not loaded each time. The --daemon command-line option starts a new Java process and preloads the Gradle classes and libraries; so, the first execution takes time. The next execution with the --daemon option takes almost no time because only the build gets executed—the JVM, with the required Gradle classes and libraries is already loaded. The configuration for daemon is often put into a GRADLE_OPTS environment variable; so, the flag is not needed on all calls. The following screenshot shows the execution of daemon:

Note that the first build took 31 seconds, whereas the second build tool took only 2 seconds.

To stop a daemon process, use gradle –stop the command-line option.

The Eclipse plugin generates the project files necessary to import a project in Eclipse.

Any Eclipse project has two important files: a .project file and a .classpath file. The .project file contains the project information such as the project name and project nature. The .classpath file contains the classpath entries for the project.

Let's create a simple Gradle build with the Eclipse plugin using the following steps:

Now, we can launch Eclipse and import the project. We can edit the .project file and change the project name.

Normally, a Java project depends on third-party JARs, such as the JUnit JAR and Apache utility JARs. In the next section, we will learn how a classpath can be generated with JAR dependencies.

The Java plugin provides some default tasks for your project that will compile and unit test your Java source code and bundle it into a JAR file.

The Java plugin defines the default values for many aspects of the project, such as the source files' location and Maven repository. We can follow the conventions or customize them if necessary; generally, if we follow the conventional defaults, then we don't need to do much in our build script.

Let's create a simple Gradle build script with the Java plugin and observe what the plugin offers. Perform the following steps:

Since no source code was available, the build script didn't build anything. However, we can see the list of available tasks—build tasks are dependent on compile, JAR creation, test execution, and so on.

Java plugins come with a convention that the build source files will be under src/main/java, relative to the project directory. Non-Java resource files such as the XML and properties files will be under src/main/resources. Tests will be under src/test/java, and the test resources under the src/test/resources.

To change the default Gradle project source file directory settings, use the sourceSets keyword. The sourceSets keyword allows us to change the default source file's location.

A Gradle script must know the location of the lib directory to compile files. The Gradle convention for library locations is repositories. Gradle supports the local lib folder, external dependencies, and remote repositories.

Gradle also supports the following repositories:

In this section, we will create a Java project, write a test, execute the test, compile source or test files, and finally build a JAR file. Perform the following steps:

Gradle is an intelligent build tool, and it supports incremental build. Rerun the gradle build command. It will just skip the tasks and say UP-TO-DATE. The following is a screenshot of the incremental build:

If we make a change to the test class, only test tasks will be executed. The following are the test tasks: compileTestJava, testClasses, test, check, and build.

In next chapters, we will explore more on Gradle. Do you want to dive deep now? If so, you can visit http://www.gradle.org/docs/current/userguide/userguide.html.

Perform the following steps to compile the project:

To execute the tests in Demo, open the command prompt and type in mvn test; it will download JUnit JARs and surefire JARs for test compilation and test report generation respectively and then execute the test. The following screenshot shows the output: