How to get started with Gradle
Tags: beginners, java, gradle, webdev
Published: 2020-03-24 13:30:40

---
title: "How to get started with Gradle"
description: "How to get started with Gradle"
published : true
tags : beginner, java, gradle, webdev 
cover_image: https://dev-to-uploads.s3.amazonaws.com/i/uv1lehadongq2uc2v9d9.jpg
canonical_url: https://adityasridhar.com/posts/how-to-get-started-with-gradle
---

**This post was originally published in [adityasridhar.com](https://adityasridhar.com/posts/how-to-get-started-with-gradle)**


Gradle is used very often in the industry and I felt it will be good to cover the basics of Gradle in this article so that it can be used efficiently😄

# What is Gradle

Gradle is a Build Automation tool and is also Open source. This Article will cover the following topics in Gradle.

* Creating a Java Application by using Gradle as the build tool
* Running Unit tests for the Java Application 
* Gradle Build Script and Tasks

# Installing Gradle

You can Install Gradle from [https://docs.gradle.org/current/userguide/installation.html](https://docs.gradle.org/current/userguide/installation.html)

Also ensure Gradle is set in the PATH so that `gradle` commands work.

you can verify if gradle is installed and can be accessed using the command

```bash
gradle -v
```

Also ensure [JAVA_HOME](https://docs.oracle.com/cd/E19182-01/820-7851/inst_cli_jdk_javahome_t/) is set.

# Creating a Java Application by Using Gradle as Build Tool

Create a folder called as 'simple-gradle-java-app' and enter into the folder in command prompt. This will be our project folder. 

```bash
mkdir simple-gradle-java-app
cd simple-gradle-java-app
```

Use the following Command to Initialize Gradle for this project

```bash
gradle init
```

This will ask you to select the type of project to generate. Choose **'application'**. This is because we are creating an application

Next you will be asked to select Implementation Language. Choose **'Java'**. This is because we are creating a Java Application.

Next you will be asked to Choose Build Script DSL. Choose **'Groovy'**. In this Demo we will be using Groovy as the build script language.

Next you will be asked to Select  a Test Framework. Choose **'Junit Jupiter'**. 

For now you can leave the project name and source package as default.

![GradleInit](https://dev-to-uploads.s3.amazonaws.com/i/5udl567trjxxa6h4bzqr.JPG)

## Folder Structure

Once the project is created. It would have the following Folder Structure

![FolderStructure](https://dev-to-uploads.s3.amazonaws.com/i/rwu0nlazo98e45hv59np.jpg)

Some of the notable items created in this folder structure are 

* **src/main/java**: This is the folder which has all the Java Code in the Application
* **src/test/java**: This is folder which has all the test cases for the Above Java code
* **gradlew and gradlew.bat**: This is the gradle wrapper which is used the run various gradle tasks and Commands. **gradlew** works in Linux and MacOS and **gradlew.bat** is used for Windows.
* **settings.gradle**: This file indicates which projects to include in the build. In our case we have only one project which is 'simple-gradle-java-app'. This is set in settings.gradle as `rootProject.name = 'simple-gradle-java-app'`
* **build.gradle**: This is the file in which the Build Script is written. We will be discussing more on this later in this Blog.
* **gradle**: This is the folder which has all the Gradle Wrapper files

## Modifying the Java Class and Its Test Class

In **src/main/java** The Init Script has automatically Created a Java Class called as **App.java**.

This is the Java class which is Automatically generated for us. 

```java
package simple.gradle.java.app;

public class App {
    public String getGreeting() {
        return "Hello world.";
    }

    public static void main(String[] args) {
        System.out.println(new App().getGreeting());
    }
}
```
Replace the Above Java class with the following Class

```java
package simple.gradle.java.app;

public class App {
    public static int getSum(int num1, int num2) {
        return (num1 + num2);

    }

    public static void main(String[] args) {
            System.out.println("Sum is " + getSum(4,5));
    }
}
```

We have a function here called as **getSum** which returns sum of 2 numbers. The **main** function calls this function.

In **src/test/java** the Init Script has automatically created a Java Test class for us Called as **AppTest.java**

The class this is generated is given below

```java
package simple.gradle.java.app;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class AppTest {
    @Test void appHasAGreeting() {
        App classUnderTest = new App();
        assertNotNull(classUnderTest.getGreeting(), "app should have a greeting");
    }
}
```

Replace the Above java class with the following 

```java
package simple.gradle.java.app;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class AppTest {
    @Test void getSum() {
       int result = App.getSum(10, 12);
       int expected = 22;
       assertEquals(expected,result);
    }

    @Test void main(){
        App.main(new String[]{});
    }
}
```

Here we have written a unit test to check if **getSum** function is working as expected.

## Running The Java Application

First let us build the project using Gradle. This can be done using the following command

**Windows**
```bash
gradlew.bat build
```
**Linux and MacOS**
```bash
./gradlew build
```

Once the build is done, a folder called as **build** is created which will have the built project and also it would contain information like the test reports.

Then we can run the Application using the following Command

**Windows**
```bash
gradlew.bat run
```
**Linux and MacOS**
```bash
./gradlew run
```

This will Run the application and Print the output as Shown Below

```bash
> Task: run
Sum is 9
```

If needed we can clean the build using the below Command 

**Windows**
```bash
gradlew.bat clean
```
**Linux and MacOS**
```bash
./gradlew clean
```

This will delete the **build** folder.


## Running The Unit Tests

When we Built the project using the **build** command, it would automatically run the Test classes as well and Generate the Test reports

The Test reports can be found in **build/reports/tests/test/index.html**. Open the index.html file using a browser to see the test results. 

Now if you want to run only the tests, then you can use the following command.


**Windows**
```bash
gradlew.bat test
```
**Linux and MacOS**
```bash
./gradlew test
```

This will also generate the **index.html** file. The Test report will look as shown below

![Test Report](https://dev-to-uploads.s3.amazonaws.com/i/05igv2emc74zprc7nq4o.JPG)

**Now Let us make an Error on Purpose In the code**

Replace **App.java** with the following

```java
package simple.gradle.java.app;

public class App {
    public static int getSum(int num1, int num2) {
        return num1;

    }

    public static void main(String[] args) {
            System.out.println("Sum is " + getSum(4,5));
    }
}
```

As you can see here, we are  always returning num1 instead of num1 + num2 in **getSum** function which is wrong.

Let's Run the tests now 

**Windows**
```bash
gradlew.bat test
```
**Linux and MacOS**
```bash
./gradlew test
```

You would notice that now it says that the **Task: Test failed**. Let's check the report in **index.html** now to see what it is showing 

![FailedTestReport](https://dev-to-uploads.s3.amazonaws.com/i/wjdt55t7h85mcgmx9sx7.JPG)

The Error Clearly shows that it Expected the sum to be 22, But then our App logic is returning 10. Hence the Test has Failed. 

**Now modify getSum Function in App.java to return ( num1 + num2 ) and re-run the test and it will pass**

# Gradle Build Script and Tasks

**build.gradle** has the build script. In this demo we are using Groovy for the build script.

The build.gradle which was generated has the following snippets. All of these are already Automatically generated for us. So here I will be explaining all the snippets generated

## Plugins

```groovy
plugins {
    // Apply the java plugin to add support for Java
    id 'java'

    // Apply the application plugin to add support for building a CLI application.
    id 'application'
}
```

**Plugins** help to add additional functionality to Groovy. Here we have a java plugin to Support Java Classes. We also have an Application Plugin so that We can build Applications using Groovy

## Dependencies

```groovy
dependencies {
    // This dependency is used by the application.
    implementation 'com.google.guava:guava:28.1-jre'

    // Use JUnit Jupiter API for testing.
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.2'

    // Use JUnit Jupiter Engine for testing.
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.5.2'
}
```

**Dependencies** is where we add additional libraries need in the project. For Example here we are mentioning that we need **junit jupiter** dependency for Unit Testing. If you wanted to make a Database connection, then you will need to use a Library like JDBC for it. In that case JDBC will be added as a dependency.

## Repositories

```groovy
repositories {
    // Use jcenter for resolving dependencies.
    // You can declare any Maven/Ivy/file repository here.
    jcenter()
}
```

**Repositories** is the location from where Groovy will fetch and download the dependencies. Here we have mentioned that the repository we are using is Jcenter. You can read more about Jcenter [here](https://bintray.com/bintray/jcenter). Another Commonly used Repository is Maven Central. You can read more about Maven Central [here](https://mvnrepository.com/repos/central)

## Application

```groovy
application {
    // Define the main class for the application.
    mainClassName = 'simple.gradle.java.app.App'
}
```

Since we have created a Java application, we need to mention the Java class containing the main class in the build script. In this case it is App.Java.

## Tasks

A Task is a piece of work that the build needs to do. In **build.gradle** currently we do not see any tasks defined. But a lot of default tasks already exist. You can see them by typing the following command 

**Windows**
```bash
gradlew.bat tasks
```
**Linux and MacOS**
```bash
./gradlew tasks
```

This will give the following output

```bash
Application tasks
-----------------
run - Runs this project as a JVM application

Build tasks
-----------
assemble - Assembles the outputs of this project.
build - Assembles and tests this project.
clean - Deletes the build directory.
jar - Assembles a jar archive containing the main classes.
testClasses - Assembles test classes.

Documentation tasks
-------------------
javadoc - Generates Javadoc API documentation for the main source code.

Help tasks
----------
tasks - Displays the tasks runnable from root project 'simple-gradle-java-app'.

Verification tasks
------------------
test - Runs the unit tests.
```

We have already used some of these tasks like **build**, **clean**, **run** and **test**.

The Flexibility of groovy is that we can add Custom Tasks as well. Let's add a Custom Task and then Run the Task. Add the following code snippet in **build.gradle**

```groovy
task projectupper {
    group = 'Custom Tasks'
    description = 'Task to get Project Name and Convert it to upper case'
    doLast {
        String projectName = project.name
        println "Project Name: $projectName"
        println "Upper case: ${projectName.toUpperCase()}"
    }
}
```

We have written a simple task here which takes the project name , Coverts the name to upper case and then prints the Name in Upper case.

**projectupper** is name of the Task

**group** and **description** are very important since it will list this task in the tasks report whenever we run `gradlew.bat tasks`

**doLast** is where we define the task action. We first get the project Name using **project.name**, then we convert it to upper case and print it. 

In order to run the task use the following command

**Windows**
```bash
gradlew.bat projectupper
```
**Linux and MacOS**
```bash
./gradlew projectupper
```

This will generate the following output 

```bash
> Task :projectupper
Project Name: simple-gradle-java-app
Upper case: SIMPLE-GRADLE-JAVA-APP
```

This task is a very simple task. We can create much more complex tasks in groovy as well and I will cover those in future articles.

# Code

The entire code discussed here is available in this repo [https://github.com/aditya-sridhar/simple-gradle-java-app](https://github.com/aditya-sridhar/simple-gradle-java-app)


# References

Gradle Offical Guide: [https://gradle.org/](https://gradle.org/)

Gradle Tasks : [https://docs.gradle.org/current/userguide/tutorial_using_tasks.html](https://docs.gradle.org/current/userguide/tutorial_using_tasks.html)

Building Java Projects with Gradle: [https://docs.gradle.org/current/userguide/building_java_projects.html](https://docs.gradle.org/current/userguide/building_java_projects.html)


# Congrats 😄

You know how to use Gradle now. This Article covered some of the basic Concepts of Gradle. Please go over the documentation of Gradle to know more about Gradle.

Happy Coding 😄

### Feel free to connect with me in [LinkedIn] (https://www.linkedin.com/in/aditya1811/) or follow me in [twitter](https://twitter.com/adityasridhar18).

### If you liked this post, you can checkout my website [https://adityasridhar.com](https://adityasridhar.com) for other similar posts