In this part, we will set up a java project using Gradle. We will also be configuring IntelliJ, so we can run or debug a java project based on Gradle in IntelliJ.
This part is the continuation of Part 2, Installing Gradle on Local Machine. Have quick look before you start this part.
Set up Java Project using Gradle
Now, we already have Gradle installed on local machine. If not, have a quick look here Part 2: Installing Gradle on local Machine and do a quick installation. I am using IntelliJ idea IDE. Now let’s get started.
Let’s create a directory with name test-gradle
mkdir test-gradle
cd test-gradle/
Gradle needs to be initialised in this folder.This will setup the gradle structure inside the folder. It can be done using:
gradle init --type java-application
The following output is displayed:
Starting a Gradle Daemon, 2 incompatible and 1 stopped Daemons could not be reused, use --status for details
Select build script DSL:
1: groovy
2: kotlin
Enter selection (default: groovy) [1..2]
Let’s choose groovy (option 1) and move forward. After that it will ask you about the testing-framework
Select test framework:
1: junit
2: testng
3: spock
Enter selection (default: junit) [1..3]
Let’s choose junit (option 1) for now.
Then it will ask you for Project and package name
Project name (default: test-gradle):
Source package (default: test.gradle):
You can change as you like or else default will be test-gradle. Press enter and you can see the following:
BUILD SUCCESSFUL in 3m 21s
2 actionable tasks: 2 executed
So now lets open this folder in intellij or any IDE. On opening in IntelliJ, you will have a pop up as shown below. Enable auto-imports; you can also set custom gradle location as done in under screen shot

After pressing enter, the IntelliJ will open the project as in the screenshot below. Notice build.gradle file; we will be making changes in this file shortly.

Now open your terminal, change directory(cd) to current folder and then run
gradle run
> Task :run
Hello world.
The output Hello world is written in class App.java. You can change that and run it. Now lets make some more changes so that we can run it by IntelliJ itself.
Configuring IntelliJ idea for Java project
Its pretty simple. Open your build.gradle file and add id 'idea'
in the plugins block. So your plugin block will now appear like
plugins {
// Apply the java plugin to add support for Java
id 'java'
// Apply the application plugin to add support for building an application
id 'application'
id 'idea'
}
Now open Edit configuration and add configuration as

Notice the run in tasks section. Run is a task, we will talk about tasks more in next section, this task is already provided by application plugin . You can check these things as

You can play more around these settings. Now press run button and you can see the output in result

So that’s it! Your IntelliJ is ready for Gradle projects. Now lets add some dependencies to the project
Adding dependencies using Gradle to your project
Let’s add google guice as a dependency to our project. Lets open build.gradle. As you can see in the repositories by default jcenter is the default repository; we can change it to maven, ivy, file as needed. Let’s change it to maven. For that, we need to add mavenCentral()
to our repositories
block. So our repository block will be like
repositories {
// Use jcenter for resolving your dependencies.
// You can declare any Maven/Ivy/file repository here.
mavenCentral()
}
Now let’s add dependency. We can simply do that by adding compile group: 'com.google.inject', name: 'guice', version: '4.0'
to the dependencies
block. So our dependencies block will look like
dependencies { compile group: 'com.google.inject', name: 'guice', version: '4.0' testImplementation 'junit:junit:4.12' }
Now lets modify our main class to use guice dependencies like
We are calculating the time taken in execution. Now we can run it either by command line using the command gradle run
or by ide that we just configured above.
So that’s it for this part; now we know how to add dependencies and set up java project using gradle and also how to set up IDE for Gradle project. In next section, Part 4, Creating executable fat jar using Gradle we will cover how to create executable fat jar using Gradle that can be deployed on production.
Pingback: Gradle:Part 1, Introduction to Gradle - Code Saying
Pingback: Gradle: Part 2, Installing Gradle on Linux System - Code Saying
Pingback: Gradle: Part 4, Creating executable fat jar using Gradle - Code Saying