vtucircle » BCSL657D 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.

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")
}

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.

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.
Example of running the build task:

gradle build

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

BCSL657D Program 3

VTU Links

Quick Links

About vtucircle

Follow Us