{"id":76629,"date":"2018-05-08T07:00:39","date_gmt":"2018-05-08T04:00:39","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=76629"},"modified":"2018-05-07T15:48:02","modified_gmt":"2018-05-07T12:48:02","slug":"gradle-tutorial","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2018\/05\/gradle-tutorial.html","title":{"rendered":"Gradle Tutorial"},"content":{"rendered":"

1. Introduction<\/h2>\n

In this lesson, we will study about Gradle<\/a>, which is a build tool and a dependency management system very similar to Maven<\/a> and Ant<\/a> and designed specifically for building Java-based projects.<\/p>\n

Unlike Maven and Ant build systems, Gradle doesn’t use XML. It is actually built in DSL based on Groovy<\/a>. The biggest advantage Groovy-based Gradle scripts provided was to make much smaller and concise build scripts as compared to other build systems which were based on XML. Just like a Maven build file is called pom.xml<\/code>, Gradle’s configuration file is called build.gradle<\/code> by convention. In this lesson, we will study about core Gradle concepts and also set up a simple project based on Spring Boot. Even if you’re not a Spring Developer, you can still follow along as the lesson is defined in such a way that a framework doesn’t introduce any hindrance in your learning the Gradle concepts. Let’s start the action!<\/p>\n

\n

Table Of Contents<\/h3>\n
\n
1. Introduction<\/a><\/dt>\n
2. Gradle Core Concepts<\/a><\/dt>\n
3. Installing Gradle<\/a><\/dt>\n
4. Setting up a Sample Projec<\/a><\/dt>\n
5. Running Gradle<\/a><\/dt>\n
\n
\n
5.1 Running a Task<\/a><\/dt>\n
5.2 Running Multiple Tasks<\/a><\/dt>\n
5.3 Task Name Abbreviation<\/a><\/dt>\n
5.4 Excluding Tasks<\/a><\/dt>\n
5.5 Quiet Mode<\/a><\/dt>\n
5.6 Listing Tasks in Build Script<\/a><\/dt>\n
5.7 Explicitly Specifying Build Script<\/a><\/dt>\n
5.8 Specifying Project<\/a><\/dt>\n
5.9 Listing Subprojects<\/a><\/dt>\n
5.10 Gradle Help<\/a><\/dt>\n<\/dl>\n<\/dd>\n
6. Defining and Using Gradle Tasks<\/a><\/dt>\n
\n
\n
6.1 Defining Gradle Tasks<\/a><\/dt>\n
6.2 Task Execution Phases<\/a><\/dt>\n
6.3 Shorter Syntax for Task definition<\/a><\/dt>\n<\/dl>\n<\/dd>\n
7. Always running Gradle in Quiet Mode<\/a><\/dt>\n
8. Extending Java Spring Boot Project<\/a><\/dt>\n
\n
\n
8.1 Defining a Controller<\/a><\/dt>\n
8.2 Running the Project with Gradle<\/a><\/dt>\n
8.3 Trying the APIs<\/a><\/dt>\n<\/dl>\n<\/dd>\n
9. Gradle Wrapper<\/a><\/dt>\n
10. Ant vs Maven vs Gradle<\/a><\/dt>\n
11. Conclusion<\/a><\/dt>\n
12. Download the Source Code<\/a><\/dt>\n<\/dl>\n<\/div>\n

2. Gradle Core Concepts<\/h2>\n

The core concepts behind Gradle build system can be listed down to three main features. They are:<\/p>\n

    \n
  1. Projects: A software which you want to build<\/li>\n
  2. Tasks: These are actions which actually build the project<\/li>\n
  3. Build-scripts: This is the script which contains Tasks which build the project<\/li>\n<\/ol>\n

    To understand the relationship between each of them, let’s study them together. So, a project is something you want to build. The tasks are the actions which build the project. To be specific, there can be tasks to compile the source code, making an executable file like a WAR or a JAR file. A Gradle-based project can contain any number of tasks to execute in order to build the project.<\/p>\n

    The tasks are defined inside a build script file<\/strong> which can be executed by Gradle to run each task in a specified order. It is even possible to pick a particular task with the gradle<\/code> command to run only the specified task. These tasks are defined in the build.script<\/code> file which is present in the root directory of the project. Usually, we only have a single build file<\/strong> for a project.<\/p>\n

    3. Installing Gradle<\/h2>\n

    Before we can start playing with Gradle commands and start defining Gradle tasks, we must install Gradle on our system. Please note that the Gradle needs JDK 6 or above to be run. Gradle will use the Java JDK which it finds on your system’s PATH environment as JAVA_HOME<\/code>. If you want a Java version apart from what you actually use, just make the JAVA_HOME<\/code> environment variable points to that version of Java and Gradle will start using it. You can make sure that Java is installed on your system with this simple command:<\/p>\n

    Check Java version<\/em><\/span><\/p>\n

    java -version\r\n<\/pre>\n
    You should see something like this:<\/p>\n
    \"Check<\/a>
    Check java version<\/figcaption><\/figure><\/p>\n
    Once the Java version is confirmed, download<\/a> the version of Gradle you want to install, and unzip it into the directory you want Gradle installed in. When Gradle is extracted into the install directory, add the DIRECTCRY_PATH\/bin<\/code> to the PATH environment variable. The DIRECTCRY_PATH<\/code> part of the added path must be the full path to the Gradle install directory (and not “DIRECTCRY_PATH” as text). Once this is done, we can check the Gradle version the same way we did for Java, with the following command:<\/p>\n
    Check Gradle version<\/em><\/span><\/p>\n
    gradle -version\r\n<\/pre>\n
    You should see something like this:<\/p>\n
    \"Gradle<\/a>
    Gradle version<\/figcaption><\/figure><\/p>\n
    Even though we have already installed Gradle, you can follow along with the lesson even if you do not install Gradle and make a sample project as we describe in our next section. The gradle build script will be self-contained in that project and won’t need an explicit installation of Gradle on the system itself. Isn’t that excellent?!<\/p>\n
    4. Setting up a Sample Project<\/h2>\n
    We will be using one of the most popular web tool to make a sample project in this lesson and won\u2019t do it from the command line, we will make use of Spring Initializr<\/a>. Just open the link in your browser and explore around. To setup our project, we used the following configuration:<\/p>\n
    \"Spring<\/a>
    Spring Initializr config<\/figcaption><\/figure><\/p>\n
    We added a single dependency as shown and it doesn’t really matter. Unzip the project and open build.gradle<\/code> file present in the root directory of the project in any text editor you like. For this project, the file will look like:<\/p>\n
    build.gradle<\/em><\/span><\/p>\n
    buildscript {\r\n\text {\r\n\t\tspringBootVersion = '2.0.1.RELEASE'\r\n\t}\r\n\trepositories {\r\n\t\tmavenCentral()\r\n\t}\r\n\tdependencies {\r\n\t\tclasspath(\"org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}\")\r\n\t}\r\n}\r\n\r\napply plugin: 'java'\r\napply plugin: 'eclipse'\r\napply plugin: 'org.springframework.boot'\r\napply plugin: 'io.spring.dependency-management'\r\n\r\ngroup = 'com.javacodegeeks.example'\r\nversion = '0.0.1-SNAPSHOT'\r\nsourceCompatibility = 1.8\r\n\r\nrepositories {\r\n\tmavenCentral()\r\n}\r\n\r\ndependencies {\r\n\tcompile('org.springframework.boot:spring-boot-starter-web')\r\n\ttestCompile('org.springframework.boot:spring-boot-starter-test')\r\n}\r\n<\/pre>\n
    In the script file above, we see that some plugins were specified in the file.\u00a0The first plugin we made use of is the Java plugin. This plugin provides some predefined configurations and tasks that enable us to build a java project very easily. It makes use of Maven-like source sets to find the source code in the specified project.<\/p>\n
    A\u00a0Source-Set<\/strong>\u00a0is defined as a configuration that informs the plugin of\u00a0where to look for the source code for compiling and testing tasks. By default, the Java source code is found under\u00a0src\/main\/java\u00a0<\/strong>and the test packages can be found under\u00a0src\/test\/java<\/strong>. The same directories will be searched for the source code unless stated otherwise.
     
    <\/div> <\/div><\/p>\n
    Apart from the plugin, we also added some dependencies<\/em> to our project as well. Gradle knows where to look for these dependencies from the\u00a0repositories<\/em> section we defined. We specified that for any dependency resolution, Gradle should refer to the Maven central<\/a> repository to download any needed JARs it needs to run the project.<\/p>\n
    5. Running Gradle<\/h2>\n
    Open a command-line terminal and change to the root directory of the project. As this project is Gradle based and we have install Gradle on our system as well, we can run Gradle now. Let\u2019s look at how this can be done:<\/p>\n
    Running Gradle<\/em><\/span><\/p>\n
    gradle\r\n<\/pre>\n
    This will run Gradle on the build.gradle<\/code> file present in the root directory of the project.<\/p>\n
    5.1 Running a Task<\/h3>\n
    The Gradle build script contains one or more tasks which we can execute. We can execute a task on the project by simply putting the task name after the gradle command:<\/p>\n
    Running single tasks<\/em><\/span><\/p>\n
    gradle compileCode\r\n<\/pre>\n
    The above command will trigger the mentioned task to compile the code for the project. As we mentioned earlier, Gradle will be able to find the source code of the project due to the presence of the apporpriate java plugin in the build file.<\/p>\n
    5.2 Running Multiple Tasks<\/h3>\n
    Just like we executed a single task in the previous section by putting the task name after the gradle command, we can even execute multiple tasks at a single go to execute them in the specified order. Let\u2019s look at how this can be done:<\/p>\n
    Running Multiple tasks<\/em><\/span><\/p>\n
    gradle clean build\r\n<\/pre>\n
    This command will first execute the clean<\/code> task. Once that task is completed, the install<\/code> task will be automatically triggered. Once we run this command, we will see something like:<\/p>\n
    \"Executing<\/a>
    Executing multiple tasks<\/figcaption><\/figure><\/p>\n
    Just to make a point, even if you mention the same task multiple times, the task will be executed only one time. Like in following command:<\/p>\n
    Running Multiple tasks<\/em><\/span><\/p>\n
    gradle clean clean\r\n<\/pre>\n
    Even if the clean<\/code> task is mentioned more than once, it will only be executed once and not twice.<\/p>\n
    5.3 Task Name Abbreviation<\/h3>\n
    It is not necessary that you type the complete task name to execute it. Like, for the clean<\/code> task, we can write:<\/p>\n
    Task Abbreviation<\/em><\/span><\/p>\n
    gradle c\r\n<\/pre>\n
    If there are no conflicts in name with other tasks, gradle will find the clean task and execute it. When we ran this, it failed as more than one tasks started with the character c<\/code>:<\/p>\n
    \"Task<\/a>
    Task Abbreviation<\/figcaption><\/figure><\/p>\n
    The error clearly states that the possible candidates are: ‘check’, ‘classes’, ‘clean’, ‘components’. So, we need to be more specific in this case. The following command will work fine though:<\/p>\n
    Task Abbreviation<\/em><\/span><\/p>\n
    gradle cle\r\n<\/pre>\n
    This will execute the clean<\/code> task. This way, Gradle provides a way to be friendly to developers even by providing esy conventions and command-line utilities and we don’t have to do anything manually shorten our commands.<\/p>\n
    5.4 Excluding Tasks<\/h3>\n
    There are Gradle tasks which depend on other tasks as well. So, when you execute a primary task, it will trigger execution of all the tasks it depends on. Although this creates no issue but this slows down the build process. Consider a case when you want to execute the build task. It will trigger test<\/code> and testClasses<\/code> tasks as well but you know that test<\/code> task will succeed as you just tested all the test cases, so you might want to ignore it to speed up the process. This can be done with the -x<\/code> switch as shown:<\/p>\n
    Ignoring Tasks<\/em><\/span><\/p>\n
    gradle build -x test\r\n<\/pre>\n
    5.5 Quiet Mode<\/h3>\n
    Gradle, when executing a task, prints a lot of messages to the console. If you want a little and quiet task execution, we can use the -q<\/code> switch as shown to quietly execute the task with no console messages:<\/p>\n
    Quiet Mode<\/em><\/span><\/p>\n
    gradle -q compileCode\r\n<\/pre>\n
    Quiet mode is useful when you write scripts to deploy your project using automated build and deployment files or code pipelines. This way, the log files are not populated with unnecessary log messages produced during gradle task execution.<\/p>\n
    5.6 Listing Tasks in Build Script<\/h3>\n
    When we want to list all tasks which are presented in a build script, we can simply run the following command:<\/p>\n
    List all tasks<\/em><\/span><\/p>\n
    gradle tasks\r\n<\/pre>\n
    For our project, we will see that we have a lot of tasks defined already:<\/p>\n
    \"List<\/a>
    List all available Gradle Tasks<\/figcaption><\/figure><\/p>\n
    We see information related to each task. This provides a handy way where we get information to each task that was pre-defined into the plugins we defined in the script.<\/p>\n
    5.7 Explicitly Specifying Build Script<\/h3>\n
    Even though Gradle automatically picks the default build.gradle file in the root directory of the project, if you want to name the file otherwise, it is possible to provide a name to the gradle name for the file you want it to pick as configuration file with the help of -b<\/code> switch:<\/p>\n
    pom.xml<\/em><\/span><\/p>\n
    gradle -b build.gradle build\r\n<\/pre>\n
    5.8 Specifying Project<\/h3>\n
    If the project you’re building contains a subproject you want to build in a standalone mode, you can even specify the project to be executed with the -p<\/code> option:<\/p>\n
    Execute Subprojects<\/em><\/span><\/p>\n
    gradle -p subproject-directory build\r\n<\/pre>\n
    5.9 Listing Subprojects<\/h3>\n
    We can list all subprojects contained in our main project (as specified inside the Gradle build script for the project) with a simple command:<\/p>\n
    Listing Subprojects<\/em><\/span><\/p>\n
    gradle projects\r\n<\/pre>\n
    This command comes handy when you’re looking at public projects and want to identify what all subprojects are included in the project.<\/p>\n
    5.10 Gradle Help<\/h3>\n
    If you need help related to any gradle command and tasks, we can run a simple command to obtain information about various tasks and commands we can execute:<\/p>\n
    pom.xml<\/em><\/span><\/p>\n
    gradle -h\r\n<\/pre>\n
    We will present the detailed list of options we have for Gradle command:<\/p>\n
    \"Gradle<\/a>
    Gradle Help<\/figcaption><\/figure><\/p>\n
    6. Defining and Using Gradle Tasks<\/h2>\n
    Gradle tasks define the actions needed to build a project. Without tasks, our build script will not build anything when Gradle executes it. Now, we will see how we can make our own tasks in the project we already defined above.<\/p>\n
    6.1 Defining Gradle Tasks<\/h3>\n
    Let’s define a new Gradle Task in the build.gradle<\/code> file as shown:<\/p>\n
    build.gradle<\/em><\/span><\/p>\n
    task hello { \r\n    println \"Hello, JavaCodeGeeks.\" \r\n}\r\n<\/pre>\n
    We can execute the task we defined as:<\/p>\n
    Running our task<\/em><\/span><\/p>\n
    gradle hello\r\n<\/pre>\n
    We will see the output as:<\/p>\n
    \"Running<\/a>
    Running our own Task in Gradle<\/figcaption><\/figure><\/p>\n
    6.2 Task Execution Phases<\/h3>\n
    When a Gradle task is executed, it passes through two execution phases before the result is evaluated. These phases are:<\/p>\n