Friday, 16 September 2016

How to Build Java Projects Using Gradle


Gradle is an automated project building tool that uses the concepts of both Apache Ant and Apache Maven but is based on a domain specific language rather than the traditional XML approach. Gradle is designed to support multi-project builds that are quite large and are difficult to manage via Ant or Maven.

This article will discuss the concepts of Gradle as a project building tool and also show how to configure and build a sample Java project.


Gradle is an build tool that can be used to automate the process of building, testing, publishing, deploying, generating API documentations, etc.

Features: Gradle comes with following list of features:
  • Declarative build - Gradle provides declarative language elements that we can be assembled as per our choice. This declarative language is extensible which enables us to add our own new language or enhance the existing one. These elements also provide build by convention support for Java, Groovy and other modern Java based technologies.
  • Language for dependency based programming- The declarative language is very flexible and enables Gradle to support the specific requirements.
  • Structure the build- Gradle allows us to apply common design principles to our build, which enables us to create a structured build for our applications.
  • Scalability- Gradle has the ability to easily scale from a simple single project build to a huge enterprise multi-project build. It enables the incremental build and also has the ability to tackle the performance issues that plague large enterprise build scripts.
  • Multi-project support- Gradle supports multi-project builds. It enables us to maintain the relationships between different projects in the case of a multi-project build environment. It also supports partial builds. We can build a single subproject out of an enterprise application. While building the single subproject, Gradle takes care of the other subprojects if the said subproject has dependency on other subprojects.
  • Dependency Management- Gradle provides different ways to manage internal as well as external dependencies. It provides supports for all kinds of dependency management, starting from transitive dependency management with remote access to Maven or any other repository-- even the local file system.
  • Integration tool- Gradle can easily import any Ant project and its targets and converts them into native Gradle tasks at runtime. Gradle also provides conversion mechanism to convert the maven pom.xml file into Gradle script.
  • Migration- Gradle easily adapts to any structure. We can easily develop the Gradle build in the same production branch.
  • Groovy Support - Gradle scripts are written in Groovy and not XML based.

Gradle Architecture

The following diagram shows the architecture components of Gradle build tool.

How to Build Java Projects Using Gradle

Installation and Use

Gradle comes in a zip bundle and can be downloaded from On the website, you can find three downloadable files:
  • gradle-<VERSION> - This bundle contains all components including binaries, source and documentation.
  • gradle-<VERSION> - This bundle contains only the binaries.
  • gradle-<VERSION> - This bundle contains only the source files.
As a beginner, my advice is to download the gradle-<VERSION> file. Unzip this bundle on your UNIX system and append the bin folder to the path.

Steps to Complete the Installation

: As a prerequisite install JDK 1.5 or higher. Groovy library comes with the Gradle bundle so no need to install Groovy separately.
  1. Download Gradle distribution from
  2. The Gradle distribution comes as a ZIP file. Unpack the distribution.
  3. Add GRADLE_HOME/bin to your PATH environment variable.
  4. Run Gradle via the gradle command. Check Gradle installation by using gradle -v command. It will display Gradle version and other details.
To test the installation, simply type 'gradle' on your terminal, you should see the following output:

Listing 1: Sample showing testing the installation

: help

Welcome to Gradle <version>.

To run a build, run gradle <task>...

To see a list of available tasks, run gradle tasks

To see a list of command-line options, run gradle --help


Total time: 3.135 secs

Once we are done with the installation, to check this, let us create a sample java project that has a simple java class:

Listing 2: Sample showing simple Java application

package com.home.gradletest;

public class MyGradleSample {
public static void main( String[] args ) {
System.out.println( " Hello Every one . " ); 
System.out.println( " If you can see this output , it means that your gradle installation is successful ! " );


In order to run Gradle you should have a 'build.gradle'. If you don't have this file, still you can check what tasks are available for the project. Simply type the following –

Listing 3: Sample showing available tasks

gradle tasks

You should see the following output:


== All tasks runnable from root project

== Build Setup tasks
setupBuild - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

== Help tasks
dependencies - Displays all dependencies declared in root project 'gradletest'.
dependencyInsight - Displays the insight into a specific dependency in root project 'gradletest'.
help - Displays a help message
projects - Displays the sub-projects of root project 'gradletest'.
properties - Displays the properties of root project 'gradletest'.
tasks - Displays the tasks runnable from root project 'gradletest'.

To see all tasks and more detail, run with --all.


Total time: 2.667 secs

To begin, let's create a simple build.gradle file.

Listing 4: Sample showing build.gradle file

apply plugin: 'java'
apply plugin: 'eclipse'

// tag::repositories[]
repositories {
// end::repositories[]

// tag::jar[]
jar {
    baseName = 'gradletest'
    version =  '0.9'
// end::jar[]

// tag::dependencies[]
dependencies {
    compile "joda-time:joda-time:2.2"
// end::dependencies[]

// tag::wrapper[]
task wrapper(type: Wrapper) {
    gradleVersion = '<INSTALLED VERSION OF GRADLE>'
// end::wrapper[]

The gradle file above is a very basic one. Now if we run the 'gradle task' command again, we can see a list of tasks available to build the project, create javadocs etc. Here we will use the 'gradle build' task more frequently. This task is responsible for:
  • Compiling the source code
  • Running the test classes
  • Assembling the code in a jar or a war file.
Once the build task is executed, and we see 'BUILD SUCCESSFUL' message we can see several folders being added inside the build folder. The most common ones are:
  • Classes - This contains the class files of the project.
  • Reports - This contains the reports generated by the build e.g. junit reports (if any)
  • libs - This contains the assembled project libraries (usually jar or war files).
Now let's go inside the above script
  • The first couple of lines mentions the plugins that we need during the build process.
  • Next part is the repositories. This is the location where we include the third party libraries. Once declared, we are ready for the third party libraries. Here we are using the joda time library version 2.2 of the joda time group. This is explained in the dependencies block. Other important dependencies are:
    • providedCompile - This includes the dependencies used for compiling the project.
    • testCompile - This includes the dependencies used for compiling and running the test cases of a project.
  • In the last block we specify the name of our jar file along with its version.