Conditional Dependency Management Using Maven Profiles

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.

• Allows adding dependencies based on active profile
• Helps manage environment-specific libraries (dev, test, prod)
• Avoids unnecessary dependencies in the final build

Maven Profiles

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.

Setting Up a Maven Project with Profiles.

Step 1: Create a New Maven Project

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:

Step 2: Configure pom.xml

Edit the pom.xml file and add profiles. 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.

Step 3: Create Java Classes

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!");
    }
}

Using Maven Profiles

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

Building with the Default Profile

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.

Building with a Specific Profile

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.

Advanced Profile Usage

Profile Activation:

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>

Resource Filtering:

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.