Maven Profiles → Gradle Equivalents

Maven Profiles → Gradle Equivalents

Table of Contents

1. Property-activated profiles
2. Default-active profiles
3. JDK-activated profiles
4. OS-activated profiles
5. Environment-specific configurations
6. Dependency profiles
7. CI/CD profiles

1. Property-Activated Profiles

Maven:

<profile>
    <id>integration-tests</id>
    <activation>
        <property><name>it</name></property>
    </activation>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-failsafe-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</profile>

Activated with: mvn verify -Dit

Gradle:

if (project.hasProperty("it")) {
    testing {
        suites {
            val integrationTest by registering(JvmTestSuite::class) {
                useJUnitJupiter()
            }
        }
    }
    tasks.named("check") {
        dependsOn(testing.suites.named("integrationTest"))
    }
}

Activated with: ./gradlew check -Pit

2. Default-Active Profiles

Maven:

<profile>
    <id>dev</id>
    <activation>
        <activeByDefault>true</activeByDefault>
    </activation>
    <properties>
        <spring.profiles.active>dev</spring.profiles.active>
    </properties>
</profile>

Gradle — use gradle.properties for defaults, override with -P:

# gradle.properties
springProfile=dev

// build.gradle.kts
val springProfile: String by project  // reads from gradle.properties

tasks.bootRun {
    systemProperty("spring.profiles.active", springProfile)
}

Override: ./gradlew bootRun -PspringProfile=prod

3. JDK-Activated Profiles

Maven:

<profile>
    <id>jdk17-args</id>
    <activation>
        <jdk>[17,)</jdk>
    </activation>
    <properties>
        <jvm.args>--add-opens java.base/java.lang=ALL-UNNAMED</jvm.args>
    </properties>
</profile>

Gradle:

val javaVersion = JavaVersion.current()
if (javaVersion >= JavaVersion.VERSION_17) {
    tasks.withType<Test> {
        jvmArgs("--add-opens", "java.base/java.lang=ALL-UNNAMED")
    }
}

4. OS-Activated Profiles

Maven:

<profile>
    <id>mac</id>
    <activation>
        <os><family>mac</family></os>
    </activation>
    <dependencies>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-resolver-dns-native-macos</artifactId>
            <classifier>osx-aarch_64</classifier>
        </dependency>
    </dependencies>
</profile>

Gradle:

val osName = System.getProperty("os.name").lowercase()
val osArch = System.getProperty("os.arch")

if (osName.contains("mac")) {
    dependencies {
        runtimeOnly("io.netty:netty-resolver-dns-native-macos:${libs.versions.netty.get()}:osx-aarch_64")
    }
}

5. Environment-Specific Configurations (Dev/Staging/Prod)

Maven:

<profiles>
    <profile>
        <id>dev</id>
        <properties>
            <db.url>jdbc:h2:mem:devdb</db.url>
        </properties>
    </profile>
    <profile>
        <id>prod</id>
        <properties>
            <db.url>jdbc:postgresql://prod-host/db</db.url>
        </properties>
    </profile>
</profiles>

Gradle — prefer Spring profiles over build-time property injection:

// build.gradle.kts
val env = project.findProperty("env")?.toString() ?: "dev"

tasks.processResources {
    filesMatching("application.properties") {
        expand("env" to env)
    }
}

tasks.bootRun {
    systemProperty("spring.profiles.active", env)
}

Or better — use Spring Boot's own profile mechanism with application-dev.yml, application-prod.yml and no build-time switching.

6. Dependency Profiles

Maven:

<profile>
    <id>with-testcontainers</id>
    <dependencies>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>postgresql</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</profile>

Gradle — use feature variants or simple property checks:

if (project.hasProperty("withTestcontainers")) {
    dependencies {
        testImplementation(libs.testcontainers.postgresql)
    }
}

For reusable feature-based dependencies, use Gradle's feature variants:

java {
    registerFeature("testcontainersSupport") {
        usingSourceSet(sourceSets["test"])
    }
}

dependencies {
    "testcontainersSupportImplementation"(libs.testcontainers.postgresql)
}

7. CI/CD Profiles

Maven:

<profile>
    <id>ci</id>
    <activation>
        <property><name>env.CI</name></property>
    </activation>
    <properties>
        <maven.test.failure.ignore>false</maven.test.failure.ignore>
    </properties>
</profile>

Gradle:

val isCi = System.getenv("CI") != null

tasks.withType<Test> {
    if (isCi) {
        maxParallelForks = Runtime.getRuntime().availableProcessors()
        testLogging {
            events("passed", "skipped", "failed")
            showStandardStreams = true
        }
    }
}