Build Tools: Gradle Basics

Gradle is a build automation tool that, like Maven, manages dependencies and orchestrates compiling, testing, and packaging — but it takes a different approach. Instead of a declarative XML file, Gradle build scripts are written in a real programming language: either Groovy (build.gradle) or Kotlin (build.gradle.kts). This makes Gradle scripts more flexible and often faster, at the cost of a steeper learning curve than Maven's fixed structure.

Gradle is the default build tool for Android development and is widely used in large, performance-sensitive Java and Kotlin projects, largely because of its incremental build and caching capabilities.

Why it matters

Gradle is the build tool of Android and of a growing share of server-side Java, including Spring's own projects. Its build files are code, not XML, which makes them shorter and more flexible, and its incremental builds are fast. You are as likely to open a project built with Gradle as with Maven.

Anatomy of a build.gradle File

A Gradle build script typically applies plugins, declares dependency repositories, and lists dependencies — conceptually similar to a Maven pom.xml, but expressed as executable code rather than a fixed XML schema.

• plugins { } — applies build capabilities, such as the java or application plugin.
• repositories { } — declares where to fetch dependencies from, commonly mavenCentral().
• dependencies { } — lists libraries using configurations like implementation, testImplementation, and runtimeOnly.
• tasks — Gradle work is organized into tasks (compileJava, test, jar, build), and you can define custom tasks directly in the script.

Dependency Configurations

Gradle's dependency configurations are more expressive than Maven's scopes. implementation is the standard choice for a dependency your code needs at compile and runtime, but that consumers of your library don't need to see on their own compile classpath (this speeds up compilation for large multi-module projects). api exposes a dependency to consumers as well. testImplementation is scoped only to test source sets, mirroring Maven's test scope.

Gradle vs. Maven: Flexibility and Performance

Maven's XML is declarative and rigid by design — every project of a given type looks structurally similar, which makes it easy to read but harder to customize. Gradle's script-based approach lets you write conditional logic, custom tasks, and multi-project build logic directly, which is powerful for complex builds but means two Gradle projects can look quite different from each other. Performance-wise, Gradle's incremental builds, build cache, and daemon process (a long-running background JVM that avoids repeated JVM startup cost) generally make repeated builds noticeably faster than Maven, especially on large codebases with many modules.

Example

plugins {
    id 'java'
    id 'application'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.google.guava:guava:33.0.0-jre'
    testImplementation platform('org.junit:junit-bom:5.10.0')
    testImplementation 'org.junit.jupiter:junit-jupiter'
}

application {
    mainClass = 'com.webnest.orders.Main'
}

test {
    useJUnitPlatform()
}

tasks.register('printVersion') {
    doLast {
        println "Building version " + project.version
    }
}

// Terminal: gradle build

> Task :compileJava
> Task :test
> Task :jar
> Task :build

BUILD SUCCESSFUL in 2s
5 actionable tasks: 5 executed

Exercise

This exercise needs Gradle installed, so it does not run in the playground. Write a build.gradle in the Groovy DSL for a Java project: apply the Java plugin, use Maven Central, add JUnit Jupiter 5.10.0 for the tests, make the test task use the JUnit Platform, and register a custom task named hello that prints a message. Then give the commands that run the custom task and the full build.

Expected result: gradle hello prints the message, and gradle build compiles, tests and creates the JAR in build/libs.

// TODO: plugins

// TODO: repositories

// TODO: dependencies

// TODO: test configuration

// TODO: the custom task hello

# TODO: the two commands

plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.0'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

test {
    useJUnitPlatform()
}

tasks.register('hello') {
    doLast {
        println 'Hello from Gradle'
    }
}

gradle hello
gradle build

Quick quiz

Interview questions