Maven vs Gradle in Java: Which Build Tool Should You Use?

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
             http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <!-- POM model version — always 4.0.0 for Maven 2+ -->
    <modelVersion>4.0.0</modelVersion>

    <!-- Your project's unique identity in the Maven ecosystem -->
    <groupId>io.thecodeforge</groupId>
    <artifactId>order-service</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <!-- Pin the Java version used to compile source files -->
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <!-- Consistent file encoding prevents platform-specific build breaks -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- Runtime dependency: Jackson for JSON serialisation -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.16.1</version>
        </dependency>

        <!-- Test-scoped dependency: only on the classpath during mvn test -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.10.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- Maven Surefire: the plugin that actually runs your unit tests -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.2.2</version>
            </plugin>
        </plugins>
    </build>

</project>

// Kotlin DSL build script — type-safe and IDE-friendly
plugins {
    // Apply the Java plugin to get compile, test, and jar tasks automatically
    java
    // Apply the application plugin so we can run the app with ./gradlew run
    application
}

group = "io.thecodeforge"
version = "1.0.0"

// Tell Gradle which Java version to compile against
java {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
}

// Define the entry point for the application plugin
application {
    mainClass.set("io.thecodeforge.OrderServiceApplication")
}

// All dependencies are declared here — Gradle resolves them from the repositories block
dependencies {
    // 'implementation' = compile + runtime, but NOT exposed to consumers of this library
    implementation("com.fasterxml.jackson.core:jackson-databind:2.16.1")

    // 'testImplementation' = only available during test compilation and test execution
    testImplementation("org.junit.jupiter:junit-jupiter:5.10.1")

    // 'testRuntimeOnly' = only needed at test runtime, not for compilation
    testRuntimeOnly("org.junit.platform:junit-platform-launcher:1.10.1")
}

repositories {
    // Pull dependencies from Maven Central — same repository Maven uses
    mavenCentral()
}

tasks.test {
    // Tell Gradle's test task to use the JUnit Platform (required for JUnit 5)
    useJUnitPlatform()

    // Stream test output to the console so failures are visible immediately
    testLogging {
        events("passed", "failed", "skipped")
    }
}

// Custom task example — something you'd need a plugin for in Maven
tasks.register("printProjectInfo") {
    // 'doLast' means: run this code when the task executes, not during configuration
    doLast {
        println("Project: $project.name | Version: $project.version")
        println("Java source dirs: ${sourceSets.main.get().java.srcDirs}")
    }
}

// settings.gradle.kts — the entry point for a multi-module Gradle build
// Gradle reads this file FIRST before any build.gradle.kts files

// The root project name — this becomes the top-level artifact group name
rootProject.name = "ecommerce-platform"

// Register each submodule — Gradle will look for build.gradle.kts in each folder
include(
    "common",           // Shared utilities and domain models
    "order-service",    // Business logic for placing orders
    "payment-service",  // Handles payment processing
    "integration-tests" // End-to-end tests that depend on all services
)

// --- root build.gradle.kts (separate file, shown here for context) ---
// subprojects { ... } applies this config to ALL submodules at once
// This is the equivalent of Maven's parent POM dependency management

/*
subprojects {
    apply(plugin = "java")

    repositories {
        mavenCentral()
    }

    // Shared dependency versions — no need to repeat in each submodule
    dependencies {
        testImplementation("org.junit.jupiter:junit-jupiter:5.10.1")
    }

    tasks.test {
        useJUnitPlatform()
    }
}
*/

// --- order-service/build.gradle.kts ---
// A submodule's build file only declares what's UNIQUE to that module

/*
plugins { java }

dependencies {
    // Reference the 'common' subproject directly — no version needed
    // Gradle resolves this as an intra-project dependency
    implementation(project(":common"))

    implementation("com.fasterxml.jackson.core:jackson-databind:2.16.1")
}
*/

package io.thecodeforge.orderservice;

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
import java.util.UUID;

/**
 * A simple order service — the same Java code compiles identically
 * whether you use Maven or Gradle. The build tool is invisible at runtime.
 * This class exists to show that the TOOL choice is purely about developer
 * experience and build pipeline efficiency, not about the code itself.
 */
public class OrderService {

    private final ObjectMapper jsonMapper = new ObjectMapper();

    /**
     * Calculates the total price for a list of order items.
     * Throws if the order is empty — no point building an empty order.
     */
    public double calculateOrderTotal(List<OrderItem> items) {
        if (items == null || items.isEmpty()) {
            throw new IllegalArgumentException(
                "Cannot calculate total for an empty order"
            );
        }

        // Stream the items, extract the price, and sum them up
        return items.stream()
                    .mapToDouble(OrderItem::price)
                    .sum();
    }

    /**
     * Serialises an order to JSON — demonstrates the jackson-databind
     * dependency we declared in both pom.xml and build.gradle.kts above.
     */
    public String serialiseOrder(String orderId, List<OrderItem> items) throws Exception {
        var orderSummary = new OrderSummary(
            orderId,
            items,
            calculateOrderTotal(items)
        );
        // ObjectMapper.writeValueAsString converts the POJO to a JSON string
        return jsonMapper.writeValueAsString(orderSummary);
    }

    public static void main(String[] args) throws Exception {
        var service = new OrderService();

        var items = List.of(
            new OrderItem(UUID.randomUUID().toString(), "Mechanical Keyboard", 129.99),
            new OrderItem(UUID.randomUUID().toString(), "USB-C Hub",           49.99),
            new OrderItem(UUID.randomUUID().toString(), "Monitor Stand",       35.00)
        );

        String orderId = UUID.randomUUID().toString();
        String json    = service.serialiseOrder(orderId, items);

        System.out.println("Order JSON:");
        System.out.println(json);
        System.out.printf("Total: $%.2f%n", service.calculateOrderTotal(items));
    }
}

// Record types — concise, immutable data carriers (Java 16+)
record OrderItem(String itemId, String productName, double price) {}
record OrderSummary(String orderId, List<OrderItem> items, double total) {}