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):
  • 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")
}
  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.

  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
  1. 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
Create a new Project Groovy

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
Successful build project
  • To run the project:
gradle run
Run project output
  • To test the project:
gradle test
Successful Test cmd

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
kotlinProject

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
build project output
  • To run the project:
gradle run
run project output
  • To test the project:
gradle test
test the project Output
guest
1 Comment
Inline Feedbacks
View all comments
Shreya Shetty
Shreya Shetty
20-02-2025 3:34 PM

Please upload the remaining lab programs soon.

0
0
Reply
1
0
Would love your thoughts, please comment.x
()
x