Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/advance-java/conditional-dependency-management-using-maven-profiles/ below:

Conditional Dependency Management Using Maven Profiles

Last Updated : 23 Jul, 2025

Maven is an efficient build tool and project management tool mainly known for effectively building projects in Java. It is one of the most useful features in Maven, to effectively manage the consumers and producers of dependencies in a project.

In complex projects, you might need different dependencies or configurations based on various conditions such as the development environment, target platform, or specific build requirements. This is where Maven Profiles come into play.

Maven Profiles is a set of parameters that can be adapted to set or alter the default parameters of Maven build. They enable you to define the application construction process according to specific contexts like development, testing, or production.

• Profile Activation: Activations can be of several types depending on the option keys like command-line, Maven option settings, system environment variables, and system preferences.
• Dependency Management: It is possible to use profiles to specify which dependencies should be included and which ones should be excluded based on the currently active profile.
• Build Customization: With profiles, you can control how your build process is set up in aspects like plug-in settings, resources being filtered etc.

Let's walk through the process of setting up a Maven project that uses profiles for conditional dependency management.

First, let's create a new Maven project using the command line:

mvn archetype:generate -DgroupId=com.example -DartifactId=profile-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

This command will create a new Maven project with a basic structure. Here is what the output should look like:

Now, let's take a look at the directory structure that Maven has created for us:

Now, let's modify the pom.xml file to include profiles. We'll create two profiles: development and production, each with its own set of dependencies.

<project xmlns="https://maven.apache.org/POM/4.0.0"
         xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>profile-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- Common dependencies -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <profiles>
        <profile>
            <id>development</id>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
            <dependencies>
                <dependency>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-simple</artifactId>
                    <version>1.7.32</version>
                </dependency>
            </dependencies>
        </profile>
        <profile>
            <id>production</id>
            <dependencies>
                <dependency>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-classic</artifactId>
                    <version>1.2.6</version>
                </dependency>
            </dependencies>
        </profile>
    </profiles>
</project>

In this configuration:

• We have a common dependency (JUnit) that's always included.
• The development profile includes the slf4j-simple logger.
• The production profile includes the logback-classic logger.
• The development profile is set as the default profile.

Let's create a simple Java class that uses the logger:

package com.example;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class App {
    private static final Logger logger = LoggerFactory.getLogger(App.class);

    public static void main(String[] args) {
        logger.info("Hello, Maven Profiles!");
    }
}

Now that we have set up our project with profiles, let's see how to use them.

To build the project with the default profile (development in our case), simply run:

mvn clean package

This will include the slf4j-simple logger in the build.

To build the project with the production profile, use the -P flag:

mvn clean package -Pproduction

This will include the logback-classic logger in the build instead.

Profiles can be activated in various ways:

1. Command Line: As shown above, using -P<profile-id>.

For example, To activate the 'development' profile:

mvn clean package -Pdevelopment

2. Maven Settings: In the settings.xml file:

<activeProfiles>
  <activeProfile>production</activeProfile>
</activeProfiles>

3. Environment Variable: In the pom.xml:

<activation>
  <property>
    <name>env</name>
    <value>prod</value>
  </property>
</activation>

Then activate using: mvn clean package -Denv=prod

4. OS Settings: Activate based on the operating system:

<activation>
  <os>
    <name>Windows 10</name>
    <family>Windows</family>
    <arch>amd64</arch>
    <version>10.0</version>
  </os>
</activation>

Profiles can also be used for resource filtering. For example:

<profile>
    <id>development</id>
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
                <includes>
                    <include>application-dev.properties</include>
                </includes>
            </resource>
        </resources>
    </build>
</profile>

This will only include the application-dev.properties file when the development profile is active.

Maven Profiles provide a powerful way to manage conditional dependencies and configurations in your Java projects. By using profiles, you can easily switch between different build configurations for various environments or conditions. This flexibility allows for more maintainable and adaptable projects, especially when dealing with complex build requirements or multiple deployment scenarios.

1. GeeksforGeeks: Apache Maven
2. GeeksforGeeks: Maven Lifecycle and Basic Maven Commands
   

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4