Program 3
3. Working with Gradle: Setting Up a Gradle Project, Understanding Build Scripts (Groovy and Kotlin
DSL), Dependency Management and Task Automation.
Gradle Project Overview
1: Setting Up a Gradle Project
Install Gradle (If you haven’t already):
Follow Gradle installation Program 1 click here
Create a new Gradle project: You can set up a new Gradle project using the Gradle Wrapper or
manually. Using the Gradle Wrapper is the preferred approach as it ensures your project will use the
correct version of Gradle.
To create a new Gradle project using the command line:
gradle init --type java-application
This command creates a new Java application project with a sample build.gradle file.
2: Understanding Build Scripts
Gradle uses a DSL (Domain-Specific Language) to define the build scripts. Gradle supports two DSLs:
Groovy DSL (default)
Kotlin DSL (alternative)
Groovy DSL: This is the default language used for Gradle build scripts (build.gradle). Example of a
simple build.gradle file (Groovy DSL):
plugins {
id 'java'
}
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web:2.5.4'
}
task customTask {
doLast {
println 'This is a custom task'
}
}
Kotlin DSL: Gradle also supports Kotlin for its build scripts (build.gradle.kts). Example of a
simple build.gradle.kts file (Kotlin DSL):
plugins {
kotlin("jvm") version "1.5.21"
}
repositories {
mavenCentral()
}
dependencies {
implementation("org.springframework.boot:spring-boot-starter-web:2.5.4")
}
tasks.register("customTask") {
doLast {
println("This is a custom task")
}
}
Difference between Groovy and Kotlin DSL:
Syntax: Groovy uses a more concise, dynamic syntax, while Kotlin offers a more structured, statically-
typed approach.
Error handling: Kotlin provides better error detection at compile time due to its static nature.
Task Block: Tasks define operations in Gradle, and they can be executed from the command line
using gradle <task-name>.
In Groovy DSL:
task hello {
doLast {
println 'Hello, Gradle!'
}
}
In Kotlin DSL:
tasks.register("hello") {
doLast {
println("Hello, Gradle!")
}
}
3: Dependency Management
Gradle provides a powerful dependency management system. You define your project’s dependencies in
the dependencies block.
1. Adding dependencies:
Gradle supports various dependency scopes such
as implementation, compileOnly, testImplementation, and others.
Example of adding a dependency in build.gradle (Groovy DSL):
dependencies {
implementation 'com.google.guava:guava:30.1-jre'
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.1'
}
Example in build.gradle.kts (Kotlin DSL):
dependencies {
implementation("com.google.guava:guava:30.1-jre")
testImplementation("org.junit.jupiter:junit-jupiter-api:5.7.1")
}
2. Declaring repositories: To resolve dependencies, you need to specify repositories where Gradle
should look for them. Typically, you’ll use Maven Central or JCenter, but you can also configure
private repositories.
Example (Groovy):
repositories {
mavenCentral()
}
Example (Kotlin):
repositories {
mavenCentral()
}
4: Task Automation
Gradle tasks automate various tasks in your project lifecycle, like compiling code, running tests, and
creating builds.
1. Using predefined tasks: Gradle provides many predefined tasks for common activities, such as:
build – compiles the project, runs tests, and creates the build output.
test – runs tests.
clean – deletes the build output.
2. Example of running the build task:
gradle build
3. Creating custom tasks: You can define your own tasks to automate specific actions. For example,
creating a custom task to print a message.
Example Groovy DSL:
task printMessage {
doLast {
println 'This is a custom task automation'
}
}
Example Kotlin DSL:
tasks.register("printMessage") {
doLast {
println("This is a custom task automation")
}
}
5: Running Gradle Tasks
To run a task, use the following command in the terminal:
gradle <task-name>
For example:
To run the build task: gradle build
To run a custom task: gradle printMessage
6: Advanced Automation
You can define task dependencies and configure tasks to run in a specific order. Example of task
dependency:
task firstTask {
doLast {
println 'Running the first task'
}
}
task secondTask {
dependsOn firstTask
doLast {
println 'Running the second task'
}
}
In this case, secondTask will depend on the completion of firstTask before it runs.
Working with Gradle Project (Groovy DSL):
Step 1: Create a new Project
gradle init --type java-application
while creating project it will ask necessary requirement:
Enter target Java version (min: 7, default: 21): 17
Project name (default: program3-groovy): groovyProject
Select application structure:
1: Single application project
2: Application and library project
Enter selection (default: Single application project) [1..2] 1
Select build script DSL:
1: Kotlin
2: Groovy
Enter selection (default: Kotlin) [1..2] 2
Select test framework:
1: JUnit 4
2: TestNG
3: Spock
4: JUnit Jupiter
Enter selection (default: JUnit Jupiter) [1..4] 1
Generate build using new APIs and behavior (some features may change in the next minor
release)? (default: no) [yes, no]
no
Step 2: build.gradle (Groovy DSL)
plugins {
id 'application'
}
application {
mainClass = 'com.example.AdditionOperation'
}
repositories {
mavenCentral()
}
dependencies {
testImplementation 'junit:junit:4.13.2'
}
test {
outputs.upToDateWhen { false }
testLogging {
events "passed", "failed", "skipped"
exceptionFormat "full"
showStandardStreams = true
}
}
Step 3: AdditionOperation.java(Change file name and update below code)
After creating project change the file name.
Manually navigate the folder path like src/main/java/org/example/
Change the file name App.java to AdditionOperation.java
After then open that file and copy the below code and past it, save it.
package com.example;
public class AdditionOperation {
public static void main(String[] args) {
double num1 = 5;
double num2 = 10;
double sum = num1 + num2;
System.out.printf("The sum of %.2f and %.2f is %.2f%n", num1, num2, sum);
}
}
Step 4: AdditionOperationTest.java (JUnit Test) (Change file name and update below code)
After creating project change the file name.
Manually navigate the folder path like src/test/java/org/example/
Change the file name AppTest.java to AdditionOperationTest.java
After then open that file and copy the below code and past it, save it.
package com.example;
import org.junit.Test;
import static org.junit.Assert.*;
public class AdditionOperationTest {
@Test
public void testAddition() {
double num1 = 5;
double num2 = 10;
double expectedSum = num1 + num2;
double actualSum = num1 + num2;
assertEquals(expectedSum, actualSum, 0.01);
}
}
Step 5: Run Gradle Commands
To build the project:
gradle build
To run the project:
gradle run
To test the project:
gradle test
Working with Gradle Project (Kotlin DSL):
Step 1: Create a new Project
gradle init --type java-application
while creating project it will ask necessary requirement:
Enter target Java version (min: 7, default: 21): 17
Project name (default: program3-kotlin): kotlinProject
Select application structure:
1: Single application project
2: Application and library project
Enter selection (default: Single application project) [1..2] 1
Select build script DSL:
1: Kotlin
2: Groovy
Enter selection (default: Kotlin) [1..2] 1
Select test framework:
1: JUnit 4
2: TestNG
3: Spock
4: JUnit Jupiter
Enter selection (default: JUnit Jupiter) [1..4] 1
Generate build using new APIs and behavior (some features may change in the next minor
release)? (default: no) [yes, no]
no
Step 2: build.gradle.kts (Kotlin DSL)
plugins {
kotlin("jvm") version "1.8.21"
application
}
repositories {
mavenCentral()
}
dependencies {
implementation(kotlin("stdlib"))
testImplementation("junit:junit:4.13.2")
}
application {
mainClass.set("com.example.MainKt")
}
tasks.test {
useJUnit()
testLogging {
events("passed", "failed", "skipped")
exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
showStandardStreams = true
}
outputs.upToDateWhen { false }
}
java {
toolchain {
languageVersion.set(JavaLanguageVersion.of(17))
}
}
Step 3: Main.kt (Change file name and update below code)
After creating project change the file name.
Manually navigate the folder path like src/main/java/org/example/
Change the file name App.java to Main.kt
After then open that file and copy the below code and past it, save it.
package com.example
fun addNumbers(num1: Double, num2: Double): Double {
return num1 + num2
}
fun main() {
val num1 = 10.0
val num2 = 5.0
val result = addNumbers(num1, num2)
println("The sum of $num1 and $num2 is: $result")
}
Step 4: MainTest.kt (JUnit Test) (Change file name and update below code)
After creating project change the file name.
Manually navigate the folder path like src/test/java/org/com/example/
Change the file name MainTest.java to MainTest.kt
After then open that file and copy the below code and past it, save it.
package com.example
import org.junit.Assert.*
import org.junit.Test
class MainTest {
@Test
fun testAddNumbers() {
val num1 = 10.0
val num2 = 5.0
val result = addNumbers(num1, num2)
assertEquals("The sum of $num1 and $num2 should be 15.0", 15.0, result, 0.001)
}
}
Step 5: Run Gradle Commands
To build the project:
gradle build
To run the project:
gradle run
To test the project:
gradle test
