Gradle Basics

What is Gradle?

Gradle is a build automation tool configured with a real programming language (Kotlin or Groovy) instead of declarative XML. Where Maven follows a fixed lifecycle of named phases, Gradle builds a task graph: a directed graph of tasks with dependencies between them, computed fresh for each build based on what actually needs to run.

The problem this solves: Maven's fixed lifecycle is predictable but rigid — every build re-runs the same phases regardless of what changed. Gradle tracks inputs and outputs of every task and skips work that's already up to date. For a large codebase, this is the difference between a 3-minute build and a 15-second build when you've only touched one file.

// The headline difference: Gradle SKIPS work Maven would always redo
./gradlew build
// :compileJava UP-TO-DATE   ← nothing changed since last run, skipped entirely
// :test UP-TO-DATE          ← test inputs unchanged, skipped
// :jar                      ← only this actually ran

// This page uses Kotlin DSL (build.gradle.kts) — the modern default,
// statically typed with IDE autocomplete. Groovy DSL (build.gradle) still
// exists in many legacy projects but Kotlin DSL is what new projects use.

Project Structure

my-project/
├── build.gradle.kts      # build configuration — what THIS project builds
├── settings.gradle.kts   # project name + included subprojects
├── gradle/wrapper/        # pins the exact Gradle version — always commit this
├── gradlew, gradlew.bat   # wrapper scripts — never invoke 'gradle' directly
└── src/main/java, src/test/java   # same convention as Maven

A real Spring Boot build.gradle.kts

plugins {
    java
    id("org.springframework.boot") version "3.2.0"
    id("io.spring.dependency-management") version "1.1.4"  // gives BOM-style version management
}

group = "com.company"
version = "0.0.1-SNAPSHOT"

java {
    toolchain { languageVersion.set(JavaLanguageVersion.of(21)) }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    runtimeOnly("org.postgresql:postgresql")
    testImplementation("org.springframework.boot:spring-boot-starter-test")
}

tasks.test { useJUnitPlatform() }

// Tasks provided by the Spring Boot plugin:
//   ./gradlew bootRun          — run the application
//   ./gradlew bootJar          — build an executable fat jar
//   ./gradlew bootBuildImage   — build an OCI/Docker image, no Dockerfile needed

Dependency Configurations

Gradle's equivalent of Maven scopes — but with one extra distinction Maven doesn't have: api vs implementation, which matters specifically when your project is itself a library consumed by others.

dependencies {
    implementation("com.google.guava:guava:32.1.3-jre")  // standard — compile + runtime

    compileOnly("org.projectlombok:lombok:1.18.30")       // needed to compile, NOT bundled/runtime
    annotationProcessor("org.projectlombok:lombok:1.18.30") // runs Lombok's code generation

    runtimeOnly("org.postgresql:postgresql:42.6.0")        // needed at runtime, NOT to compile your code

    testImplementation("org.junit.jupiter:junit-jupiter:5.10.0")
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")

    // api vs implementation — ONLY matters if you're building a library
    // consumed by other projects/modules
    api("com.company:public-contracts:1.0")       // leaks into CONSUMERS' compile classpath
    implementation("com.company:internal-utils:1.0") // hidden from consumers entirely
}

Common Tasks

# Always invoke via the wrapper — guarantees everyone uses the same Gradle version
./gradlew build              # compile, test, package — Gradle's equivalent of mvn package
./gradlew clean build        # wipe build/ first

./gradlew test                          # run all tests
./gradlew test --tests "UserTest"       # single class
./gradlew test --tests "*ServiceTest"   # pattern match

./gradlew run                # run via the 'application' plugin
./gradlew bootRun            # run via the Spring Boot plugin

# Diagnostics — the Gradle equivalents of Maven's dependency:tree commands
./gradlew dependencies                              # full dependency tree
./gradlew dependencyInsight --dependency jackson-core  # WHY is this version resolved? shows the conflict path

./gradlew tasks              # list all available tasks for this project
./gradlew tasks --all        # include tasks from applied plugins too

Incremental Builds — Gradle's Real Advantage

Every Gradle task declares its inputs (source files, configuration) and outputs. Before running a task, Gradle hashes the inputs and compares against the last successful run. If nothing changed, the task is marked UP-TO-DATE and genuinely skipped — not just fast, but not executed at all.

// gradle.properties — performance tuning that actually matters in CI
org.gradle.parallel=true              // build independent subprojects concurrently
org.gradle.caching=true               // reuse task outputs across builds/machines (build cache)
org.gradle.configuration-cache=true   // cache the build configuration phase itself, not just tasks
org.gradle.jvmargs=-Xmx2g

# Command-line equivalents for a one-off run
./gradlew build --parallel
./gradlew build --build-cache
./gradlew build --no-daemon   # disable the daemon — only for CI isolation, not local dev

Multi-Project Builds

// settings.gradle.kts — declares which subprojects exist
rootProject.name = "my-project"
include("api", "service", "web")

// Root build.gradle.kts — shared config applied to every subproject
subprojects {
    apply(plugin = "java")
    repositories { mavenCentral() }
    java { toolchain { languageVersion.set(JavaLanguageVersion.of(21)) } }
}

// Project-specific dependency, including a project-to-project dependency
project(":service") {
    dependencies {
        implementation(project(":api"))  // depends on the sibling 'api' module's output directly
    }
}

Gradle computes the build order from these project-to-project dependencies automatically — same principle as Maven's reactor, different syntax.

Custom Tasks

// Simple ad-hoc task
tasks.register("printVersion") {
    doLast { println("Building version ${project.version}") }
}

// Task with explicit dependency ordering
tasks.register("releaseCheck") {
    dependsOn("test", "check")
    doLast { println("All checks passed — ready to release") }
}

// Typed task — gets you Gradle's built-in input/output tracking for free,
// which is what makes THIS task incrementally skippable too
tasks.register<Copy>("copyDocs") {
    from("docs")
    into("build/docs")
    include("**/*.md")
}

// Configuring an existing task (from a plugin) rather than creating a new one
tasks.named<Jar>("jar") {
    manifest {
        attributes("Main-Class" to "com.company.Main")
    }
}

The Gradle Wrapper

# Generate/update the wrapper to pin a specific Gradle version
gradle wrapper --gradle-version 8.5

# Everyone — devs and CI — uses the wrapper, never a locally-installed gradle
./gradlew build      # Unix/Mac
gradlew.bat build    # Windows

Interview Questions