Gradle is an open-source build tool that was initially released in 2007 and stably released in 2019. It uses Directed Acyclic Graphs (DAG) to define the order of the process that needs to be executed and introduces a Java and Groovy-based Domain Specific Language (DML). This Gradle tutorial is designed for both beginners and professionals. Here, we would be covering basic and advanced concepts of the Gradle tool such as -
|In this Gradle Tutorial, you will learn the below topics.|
In software development and testing, build tools are used. Build tools are the programs that are used to automate the process of compiling, testing, and deploying source code efficiently. These tools help developers focus on actual software development activities rather than doing drudge work.
Some of the most commonly used build tools are -
In this tutorial, we would be learning about Gradle step by step and also compare it with other build tools available in the market. Moreover, we will find the advantages of Gradle and why we should use it.
|Enthusiastic about exploring the skill set of Gradle? Then, have a look at the Gradle Training Course together with additional knowledge.|
Gradle can build automation on many platforms and languages such as Java, Android, C, C++, Groovy, and Scala and provides integration with many development tools and servers including Eclipse, Jenkins, IntelliJ, and Android Studio.
Gradle is an open-source Java-based build tool that combines the best features of Maven and Ant. Before getting to the installation process, let us first know the prerequisites for the Gradle.
Gradle is a Java-based tool, so it is mandatory to install Java 8 or higher versions on your computer. Before installing the Gradle, ensure that the Java SDK 8 or higher version is already installed.
To verify whether Java is installed on your system or not, you can use the command prompt.
After verifying, follow the below-given steps to install Gradle.
Step 1 - Visit the official website of Gradle and click on the option "Install Gradle". After that, you will find many options to install Gradle.
Step 2 - Go to Installing manually option and click on "binary-only" to download the binary file.
Step 3 - The selected option will start downloading a Zip file. Go to download and right-click on the downloaded file and unzip it. Also, browse the location where you want to locate it.
Step 4 - Now we need to set the environment variables. For that, Right-click on "This PC or My computer" > Properties > Advanced system settings > Environment variables. You will see the box as shown below.
Step 5 - You can now click on “New” to create a new variable. Give a name to the variable and in the variable value section, you have to give the location where the Gradle folder is stored.
Now, this variable name given by you will appear in the user variable list as shown below.
After that, click on “Path” and then “New”. Add the location of the Gradle bin folder and press OK.
Step 6 - Now, you have to verify whether Gradle is installed in your system or not using the command prompt.
This screen shows that the Gradle tool is installed in your system.
There are two ways of installing Gradle on Mac OS - Manually and using homebrew. But before that, you need to ensure you have installed the Java 8 or above version on your system. The process of installing Gradle on Mac OS manually is very similar to that of installing Gradle on Windows manually. The only thing that differs is the way of setting the environment variables.
Step 1 - Use the command prompt to check whether Java 8 or above version is installed as shown in Windows. If yes, skip this step.
Step 2 - Download the Gradle from the Official page and create a directory to unzip the downloaded file.
Unzip the downloaded file
Step 3 - Next is to set up the environment variable by running the following command.
Step 4 - In the next step, we will source the bash config file.
Step 5 - In the last step, we have to verify the Gradle installation by running the below command.
Open eclipse > Help > Eclipse Marketplace
A box will pop up of Eclipse Marketplace. There, a 'Find' search box will be present, from there you have to search Gradle and then select build ship Gradle integration.
Click on the install button and then Gradle will get installed in Eclipse. After that Eclipse will automatically restart.
|Related Article: Java Build Tools|
Projects may have dependencies ie; they may require JAR files from other projects or external JARs in the classpath. We can say that most of the projects are not self-contained. Dependency configuration is a collection of dependencies and artifacts. There are three main tasks in the configuration -
Dependency is an essential part of projects and can be used on different phases of the project such as - Compile, Runtime, Test Compile, and Test Runtime. We must declare dependencies that we want to download from the web.
This is a dependency on the files that are built outside the current build and are stored in the repository. Below, a code snippet is given that is used to define the external dependency.
Dependencies come in the form of modules and the location where these modules are stored are called repositories. Gradle specifies these repositories to retrieve the module for the project. Repositories are of different forms - local directory and remote repository.
A repository is a collection of files that are organized by group, name, and version. By default, Gradle does not define repositories but we need to define at least one. At runtime, Gradle finds out the declared dependencies that are required to process the tasks. Once the dependency is resolved, important files of dependency are stored in the local cache memory also referred to as a remote repository. Future builds can reuse these saved files to avoid unnecessary network calls. Gradle supports different repository formats -
Different repository formats can be added to projects by adding that specific code snippet to the 'build.gradle file.
To add the repository to the project, we need to declare its URL address or its location in the 'build.gradle' file
Dependency management is a process of declaring, resolving, and using the dependencies required by the project. Gradle has built-in support for dependency management and for that following things are needed -
Most of the projects need files that are built by other projects for their compilation. These files are said to be the dependency of the project. Gradle specifies the dependencies, finds them and makes them available in a project. These dependencies can be downloaded from remote Ivy or Maven repository or we can also build our dependencies and include them in the project. This process is called dependency resolution.
Suppose file A is dependent on file B and also file is dependent on file C. This process is called transitive dependency.
A build scan is a centralized record that provides insights into the details of the Gradle project. It is shareable and can be accessed from the Gradle remote server.
To create a build scan, the first step would be to create a Gradle project. Let us see how to create build scans step by step.
Step 1 - Create a Gradle project
We can clone a project from GitHub or use the existing project. But to create a new project, use the below command.
Step 2 - Apply the Build Scan plugin
From Gradle 4.3 onwards, there is no need to add any additional configuration to enable build scans. The required build scan plugin gets applied automatically when we use the -scan option.
To publish a build scan, you need to accept the Gradle terms by selecting the option 'Yes'. Execute the below-given command to publish a build scan.
After running the command, you are going to get this output screen. The green link is used to access the build scan.
|Related Article: Frequently Asked Gradle Interview Questions|
To access the build scan online, go to the generated link and activate the build scan. Enter your email id and choose the 'Go' option.
After that, you will receive a link in the given email id to activate the build scan. Check your inbox and follow the link.
Click on ‘Discover your build’ and explore the created build.
The above image shows the information about the create build scans such as console log, timeline, failure points, performance, tests, dependencies, plugins, projects, switches, execution time, infrastructure, and more.
A multi-project consists of a root project and multiple subprojects. Gradle promotes multi-project build to accelerate project development and takes care of the dependencies that occurred from other parts of the project.
Each of the subprojects in Gradle is capable of configuring itself in complete isolation, therefore, the subprojects share common characteristics. Here, configuration means the execution of 'build.gradle' of a project. By default, configurations are done before the execution of any task. After configuration, a project becomes more flexible in case of updating or accessing any module of a project.
Let us create a project where the root project name is Multi_project and its subproject name is sub_project. Now, create a new directory using the command: mkdir Multi_project. Then create a Gradle build by running the init command. The init command includes a wrapper command which creates the build.gradle and setting.gradle file in the root project.
After executing the init command, the user needs to enter the type of project from the four given options -
Then, it will ask to select the build script DSL from two available options -
After that, enter the project name and press enter to continue.
Multi_project/ build.gradle setting.gradle Sub_project/ build.gradle setting.gradle
Add the below-given code snippet in the root project build script to create the multi-project build.
To include the subproject into the root project, add the below statements in the setting.gradle.
To execute, use the command: gradle -q hello. You will get an output screen as shown below -
To execute, use the command: gradle -q hello. You will get an output screen as shown below -
Gradle project API allows users to access the subprojects only. For that, define a common behavior of the project and subproject. Let us see how to write the code for it.
Now, execute the command: gradle -q hello and get the output screen given below
Installing software and ensuring that it is the right version can be pretty difficult for the user. But with Gradle wrapper, a user can overcome all these challenges.
The wrapper is a batch of scripts that invokes a declared version of Gradle automatically. The Gradle wrapper helps developers to run a build without following the manual installation process. It saves the company time and money.
Gradlew.bat file for Windows systems and gradlew file for Unix-based systems acts as Gradle commands used in case Gradle is not installed on the machine.
There are the following benefits of using Gradle Wrapper -
In the coming sections, we would be discussing three different workflows -
Gradle has a built-in task called Wrapper. On execution of wrapper task, necessary wrapper files are generated in the project directory. To run the wrapper task, use the below command
The generated wrapper properties file contains the following information about Gradle distribution -
All the above aspects can be configured by executing the following command line -
It is always preferred to execute a build using a wrapper for reliable and standardized execution of the build. Depending on the OS, a user can either use gradlew or gardlew.bat instead of using the Gradle command. In case the Gradle distribution is not present on the system, Wrapper will download and store it in the local file system.
It is important to update the software to get the benefits of new features and improvements. We can manually upgrade the Gradle to the newer version by changing the URL properties in the wrapper property file. But it would be better to upgrade the wrapper through the wrapper task.
To upgrade a Gradle wrapper to a particular version, run the below command
To check the specified version of the Gradle, we can run the following command: gradle -version
Although, default runtime behavior of Gradle is good sometimes we need to customize the wrapper as per organization requirements. The built-in wrapper task gives numerous options to customize the runtime behavior as per your needs.
Gradle is one of the best build tools available for Java. Maven was developed before Gradle and is generally used alternatively. It is tough to decide which build tool is best suited for our project with different frameworks. Here, we would be comparing Gradle Vs Maven that is helpful in deciding which matches our project needs better.
|It is a build automation tool that used domain-specific language||It is a software management system that is basically used for Java projects.|
|Gradle avoids the compilation of Java||The compilation is mandatory in Maven|
|It does not use XML file to declare the project configuration||It uses an XML file to declare the project, dependencies, build order, and required plugin|
|Highly customizable and offers a wide range of IDE support custom builds||It has a limited number of parameters so customization is pretty difficult|
|It gives faster performance by running only those tasks that have different inputs||Build time is slower than Gradle|
|The main goal is to add functionality to the project||The main goal is related to the project phase|
|Based on the graph of task dependencies that do the work||Based on the phases of linear and fixed model|
|The open-source build tool is written in Kotlin, Java, and Groovy||The open-source build tool is written in Java|
|It supports multi-project builds||It does not support multi-project builds|
|Allows easy migration to other tools||Jenkins does not provide the migration from other tools|
|It is not an integration server||It is a continuous integration server|
|It facilitates with only two types of plugins to support the build process||It facilitates around 300 plugins to support the build process|
|It integrates with several development tools and servers such as Eclipse, IntelliJ, Android Studio, and Jenkins||It integrates all types of SDLC processes such as build, stage, package, deploys, static analysis, document, and more|
|Gradle is a Groovy-based build automation tool||Ant is a Java-based build automation tool.|
|Gradle supports multi-project build||It does not support multi-project build|
|More standardized||Less flexible|
|Gradle provides comfortable support to IDE integration||IDE integration is slightly complex|
|Gradle provides a structured build||Ant does not impose project structured|
|Gradle is developed to overcome all the drawbacks of Ant and Maven||Ant is developed to overcome the drawback of the make build tool of Unix|
|Uses DSL (Domain Specific Language) instead of XML||It uses XML files to define build scripts|
This was all about Gradle, hope you found the information useful. In case you come across any doubt, please drop the query in the comment box.
Pooja Mishra is an enthusiastic content writer working at Mindmajix.com. She writes articles on the trending IT-related topics, including Big Data, Business Intelligence, Cloud computing, AI & Machine learning, and so on. Her way of writing is easy to understand and informative at the same time. You can reach her on LinkedIn & Twitter.