Benchmark: Bazel 7 vs. Gradle 8.5 vs. Maven 4 for Java 24 Monorepo Build Time and Cache Efficiency

load("@rules_java//java:defs.bzl", "java_library", "java_test", "java_binary")
load("@rules_pkg//pkg:defs.bzl", "pkg_jar")

# Module 3: User Service (depends on Module 1: Core Interfaces, Module 2: Database Client)
# Java 24 features: uses Pattern Matching for switch, Record Classes, Virtual Threads
package(default_visibility = ["//visibility:public"])

# Library target for user service core logic
java_library(
    name = "user_service_lib",
    srcs = glob(["src/main/java/com/example/userservice/**/*.java"]),
    deps = [
        "//modules/core-interfaces:core_interfaces_lib",
        "//modules/db-client:db_client_lib",
        "@maven//:com/google/guava/guava",
        "@maven//:org/springframework/boot/spring-boot-autoconfigure",
    ],
    java_version = "24",
    javacopts = [
        "--enable-preview",
        "-Xlint:all",
        "-Werror",
    ],
    tags = ["java24"],
)

# Binary target for standalone user service
java_binary(
    name = "user_service_bin",
    main_class = "com.example.userservice.UserServiceApp",
    runtime_deps = [":user_service_lib"],
    java_version = "24",
    tags = ["java24"],
)

# Unit tests for user service
java_test(
    name = "user_service_test",
    srcs = glob(["src/test/java/com/example/userservice/**/*.java"]),
    test_class = "com.example.userservice.AllTests",
    deps = [
        ":user_service_lib",
        "@maven//:org/junit/jupiter/junit-jupiter-api",
        "@maven//:org/junit/jupiter/junit-jupiter-engine",
        "@maven//:org/mockito/mockito-core",
    ],
    java_version = "24",
    javacopts = ["--enable-preview"],
    tags = ["java24", "unit-test"],
)

# Integration tests (requires running DB)
java_test(
    name = "user_service_integration_test",
    srcs = glob(["src/integration-test/java/com/example/userservice/**/*.java"]),
    test_class = "com.example.userservice.AllIntegrationTests",
    deps = [
        ":user_service_lib",
        "@maven//:org/springframework/boot/spring-boot-test",
        "@maven//:org/testcontainers/testcontainers",
    ],
    java_version = "24",
    tags = ["java24", "integration-test"],
    size = "large",
)

# Package as executable JAR
pkg_jar(
    name = "user_service_jar",
    srcs = [":user_service_bin"],
    tags = ["java24"],
)

# Error handling: custom rule to validate Java 24 features are used
def _validate_java24_features_impl(ctx):
    # Check that srcs use at least one Java 24 feature (Record, Pattern Matching, Virtual Thread)
    src_files = ctx.files.srcs
    for f in src_files:
        if not f.path.endswith(".java"):
            continue
        contents = ctx.read(f)
        if "record " not in contents and "switch " not in contents and "Thread.ofVirtual()" not in contents:
            fail(f"Java 24 feature not found in {f.path}: use records, pattern matching, or virtual threads")
    return [DefaultInfo()]

validate_java24_features = rule(
    implementation = _validate_java24_features_impl,
    attrs = {"srcs": attr.label_list(allow_files = [".java"])},
)

# Run validation during build
validate_java24_features(
    name = "validate_java24",
    srcs = glob(["src/main/java/com/example/userservice/**/*.java"]),
)

plugins {
    `java-library`
    `maven-publishing`
    id("org.springframework.boot") version "3.3.0-M1"
    id("io.spring.dependency-management") version "1.1.4"
    id("com.diffplug.spotless") version "6.23.0"
}

group = "com.example"
version = "1.0.0-SNAPSHOT"

java {
    sourceCompatibility = JavaVersion.VERSION_24
    targetCompatibility = JavaVersion.VERSION_24
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(24))
        vendor.set(JvmVendorSpec.ADOPTIUM)
    }
}

repositories {
    mavenCentral()
    maven {
        url = uri("https://repo.spring.io/milestone")
    }
    mavenLocal()
}

dependencies {
    // Module dependencies
    implementation(project(":modules:core-interfaces"))
    implementation(project(":modules:db-client"))

    // Third-party dependencies
    implementation("com.google.guava:guava:32.1.3-jre")
    implementation("org.springframework.boot:spring-boot-autoconfigure:3.3.0-M1")

    // Test dependencies
    testImplementation("org.junit.jupiter:junit-jupiter-api:5.11.0-M2")
    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.11.0-M2")
    testImplementation("org.mockito:mockito-core:5.12.0")

    // Integration test dependencies
    integrationTestImplementation("org.springframework.boot:spring-boot-test:3.3.0-M1")
    integrationTestImplementation("org.testcontainers:testcontainers:1.19.8")
}

// Configure Java 24 preview features
tasks.withType<JavaCompile> {
    options.compilerArgs.add("--enable-preview")
    options.isWarningsAsErrors = true
    options.isDeprecation = true
}

// Error handling: task to validate Java 24 feature usage
val validateJava24Features = tasks.register("validateJava24Features") {
    description = "Validates that all Java sources use at least one Java 24 feature"
    group = "verification"

    doLast {
        val srcDir = file("src/main/java")
        if (!srcDir.exists()) {
            throw GradleException("Source directory $srcDir does not exist")
        }

        val javaFiles = srcDir.walkTopDown().filter { it.extension == "java" }.toList()
        if (javaFiles.isEmpty()) {
            throw GradleException("No Java source files found in $srcDir")
        }

        val missingFeatures = javaFiles.filter { file -
            val contents = file.readText()
            !contents.contains("record ") && !contents.contains("switch ") && !contents.contains("Thread.ofVirtual()")
        }

        if (missingFeatures.isNotEmpty()) {
            throw GradleException(
                "Java 24 features not found in ${missingFeatures.size} files: " +
                missingFeatures.joinToString { it.path } + "\nUse records, pattern matching, or virtual threads."
            )
        }
    }
}

tasks.named("check") {
    dependsOn(validateJava24Features)
}

// Configure tests
tasks.test {
    useJUnitPlatform()
    maxParallelForks = 4
    javaLauncher.set(javaToolchains.launcherFor {
        languageVersion.set(JavaLanguageVersion.of(24))
    })
    jvmArgs("--enable-preview")
}

// Integration test source set
val integrationTest = sourceSets.create("integrationTest") {
    compileClasspath += sourceSets.main.get().output + sourceSets.test.get().output
    runtimeClasspath += output + compileClasspath
}

tasks.register<Test>("integrationTest") {
    description = "Runs integration tests"
    group = "verification"
    testClassesDirs = integrationTest.output.classesDirs
    classpath = integrationTest.runtimeClasspath
    useJUnitPlatform()
    jvmArgs("--enable-preview")
}

tasks.named("check") {
    dependsOn(tasks.named("integrationTest"))
}

// Spotless for code formatting
spotless {
    java {
        target("src/**/*.java")
        googleJavaFormat("1.17.0")
        trimTrailingWhitespace()
        endWithNewline()
    }
}

publishing {
    publications {
        create<MavenPublication>("maven") {
            from(components["java"])
        }
    }
}

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.example</groupId>
        <artifactId>monorepo-parent</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>

    <artifactId>user-service</artifactId>
    <name>User Service Module</name>
    <description>Java 24 User Service module with Spring Boot 3.3</description>

    <properties>
        <java.version>24</java.version>
        <maven.compiler.source>24</maven.compiler.source>
        <maven.compiler.target>24</maven.compiler.target>
        <maven.compiler.release>24</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.boot.version>3.3.0-M1</spring.boot.version>
        <junit.version>5.11.0-M2</junit.version>
    </properties>

    <dependencies>
        <!-- Module Dependencies -->
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>core-interfaces</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>db-client</artifactId>
            <version>${project.version}</version>
        </dependency>

        <!-- Third-Party Dependencies -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>32.1.3-jre</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>${spring.boot.version}</version>
        </dependency>

        <!-- Test Dependencies -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <version>5.12.0</version>
            <scope>test</scope>
        </dependency>

        <!-- Integration Test Dependencies -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
            <version>${spring.boot.version}</version>
            <scope>integration-test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>testcontainers</artifactId>
            <version>1.19.8</version>
            <scope>integration-test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- Java 24 Compiler Plugin -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.12.1</version>
                <configuration>
                    <release>24</release>
                    <compilerArgs>
                        <arg>--enable-preview</arg>
                        <arg>-Xlint:all</arg>
                        <arg>-Werror</arg>
                    </compilerArgs>
                    <showWarnings>true</showWarnings>
                    <failOnError>true</failOnError>
                </configuration>
            </plugin>

            <!-- Enforcer Plugin for Error Handling -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-enforcer-plugin</artifactId>
                <version>3.4.1</version>
                <executions>
                    <execution>
                        <id>enforce-java24-features</id>
                        <phase>validate</phase>
                        <goals>
                            <goal>enforce</goal>
                        </goals>
                        <configuration>
                            <rules>
                                <requireFilesExist>
                                    <files>
                                        <file>src/main/java</file>
                                    </files>
                                    <message>Source directory src/main/java does not exist</message>
                                </requireFilesExist>
                                <alwaysPass>false</alwaysPass>
                            </rules>
                            <fail>true</fail>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!-- Surefire for Unit Tests -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.2.5</version>
                <configuration>
                    <junitPlatform>
                        <enable>true</enable>
                    </junitPlatform>
                    <argLine>--enable-preview</argLine>
                    <parallel>methods</parallel>
                    <threadCount>4</threadCount>
                </configuration>
            </plugin>

            <!-- Failsafe for Integration Tests -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-failsafe-plugin</artifactId>
                <version>3.2.5</version>
                <configuration>
                    <junitPlatform>
                        <enable>true</enable>
                    </junitPlatform>
                    <argLine>--enable-preview</argLine>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>integration-test</goal>
                            <goal>verify</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!-- Custom Enforcer Rule for Java 24 Features -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-enforcer-plugin</artifactId>
                <version>3.4.1</version>
                <dependencies>
                    <dependency>
                        <groupId>com.example</groupId>
                        <artifactId>enforcer-rules</artifactId>
                        <version>${project.version}</version>
                    </dependency>
                </dependencies>
                <executions>
                    <execution>
                        <id>validate-java24</id>
                        <phase>process-sources</phase>
                        <goals>
                            <goal>enforce</goal>
                        </goals>
                        <configuration>
                            <rules>
                                <Java24FeatureRule />
                            </rules>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

- name: Configure Bazel Remote Cache
  run: |
    echo "build --remote_cache=grpc://bazel-remote.example.com:9092" >> ~/.bazelrc
    echo "build --remote_upload_local_results=true" >> ~/.bazelrc
    echo "build --experimental_strict_action_env=true" >> ~/.bazelrc
    echo "build --remote_max_input_file_megabytes=1024" >> ~/.bazelrc

org.gradle.configuration-cache=true
org.gradle.configuration-cache.problems=warn

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.12.1</version>
    <configuration>
        <incremental>true</incremental>
        <release>24</release>
        <compilerArgs>
            <arg>--enable-preview</arg>
        </compilerArgs>
        <outputTimestamp>2024-01-01T00:00:00Z</outputTimestamp>
    </configuration>
</plugin>