Maven Build Profiles

 

In Maven, a Build Profile is a way to customize the build process for different environments, configurations, or deployment targets. Profiles allow you to specify certain build settings (like dependencies, plugins, properties, and goals) that should be used only in specific conditions — for example, development, testing, or production environments.

Why Use Build Profiles?

You might want to:

• Use different databases for dev and prod

• Deploy to different servers based on environment

• Include/exclude certain modules

• Set environment-specific properties (example: API keys, credentials, etc.)

Where Are Profiles Defined?

• In pom.xml file — most common place
• In ~/.m2/settings.xml — for user-specific configuration
• From command line — when triggering a build

Basic Syntax in pom.xml




<project>
  ...
  <profiles>
    <profile>
      <id>dev</id>
      <properties>
        <env.name>Development Environment</env.name>
      </properties>
      <activation>
        <activeByDefault>true</activeByDefault>
      </activation>
    </profile>

    <profile>
      <id>prod</id>
      <properties>
        <env.name>Production Environment</env.name>
      </properties>
    </profile>
  </profiles>
</project>

You can then use ${env.name} anywhere in your pom.xml.

Activating Profiles

 - From Command Line:

mvn clean install -Pdev
mvn clean install -Pprod

      

 - Automatically with Activation Block:

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

  - By OS, JDK, or File Presence:

• You can also activate profiles based on:

• Operating System

• JDK version

• Presence of a file or environment variable

Example:

<profiles>
  <profile>
    <id>qa</id>
    <build>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
          </configuration>
        </plugin>
      </plugins>
    </build>
  </profile>
</profiles>

To activate this:

mvn clean install -Pqa

POM in Maven

 

In Maven, POM stands for Project Object Model. It is the fundamental unit of work in Maven and is represented by an XML file named pom.xml.

What is pom.xml?

The pom.xml file is located at the root of every Maven project and contains information about the project and configuration details used by Maven to build the project.

Key Roles of POM in Maven:

Role	Description
Project Configuration	Defines project metadata such as groupId, artifactId, version, name, etc.
Dependency Management	Lists libraries (JARs) the project depends on. Maven automatically downloads them.
Build Settings	Specifies build plugins and goals (example: compiler, packaging, etc.).
Project Hierarchy	Supports inheritance and aggregation via parent and modules.
Plugin Configuration	Allows you to define behavior during build lifecycle phases.
Repository Configuration	Defines remote repositories (like Maven Central, or private repos).
Profiles	Supports build profiles for different environments (dev, test, prod).

Basic Structure of pom.xml:

<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">
  
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.example</groupId>        <!-- Like a package name -->
  <artifactId>my-app</artifactId>       <!-- Project name -->
  <version>1.0.0</version>              <!-- Version of your build -->

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.3.9</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

Important Tags in pom.xml:

Tag	Purpose
<groupId>	Defines the project's group (usually a domain in reverse).
<artifactId>	The name of the artifact (output like a JAR or WAR).
<version>	Project version.
<packaging>	Type of output: jar, war, pom, etc.
<dependencies>	Lists all the external libraries your project needs.
<build>	Customizes the build process using plugins.
<plugin>	Defines a build plugin and configuration.
<repositories>	Configures external repositories to search for dependencies.
<profiles>	Creates environment-specific configurations.
<parent>	Inherits configuration from a parent POM.

Example: Dependency Management

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

Example: Parent POM

<parent>
  <groupId>com.mycompany</groupId>
  <artifactId>parent-project</artifactId>
  <version>1.0.0</version>
</parent>

Maven Lifecycle

 

The Maven Build Lifecycle is a sequence of phases that define the order in which the goals (tasks) are executed to build and manage a project. Maven follows a well-defined standard lifecycle, which simplifies the build process and provides consistency across different projects.

What is a Build Lifecycle?

A build lifecycle is essentially a well-defined sequence of phases that need to be executed to build a project. Each phase represents a stage in the lifecycle.

Maven has three built-in lifecycles:

1. default – handles your project deployment (most commonly used).

2. clean – handles project cleaning (deletes old builds).

3. site – handles the creation of your project’s documentation.

1. Default Lifecycle (Core Build Lifecycle)

This is the main lifecycle and consists of 23 phases, out of which the most commonly used ones are:

Phase	Description
validate	Validates the project is correct and all necessary information is available.
initialize	Initializes build state, sets properties.
generate-sources	Generates any source code needed before compilation.
process-sources	Processes the source code, like filtering.
generate-resources	Generates resources for inclusion in the package.
process-resources	Copies and processes resources (like properties files) to the output directory.
compile	Compiles the source code.
process-classes	Post-processes the compiled classes (e.g., bytecode enhancement).
generate-test-sources	Generates test source code.
process-test-sources	Processes the test source code.
test-compile	Compiles test source code.
process-test-classes	Post-processes compiled test classes.
test	Runs tests using a suitable unit testing framework.
prepare-package	Performs operations before packaging like war/jar customization.
package	Packages the compiled code into a JAR/WAR.
pre-integration-test	Setup steps before running integration tests.
integration-test	Runs integration tests.
post-integration-test	Cleanup after integration tests.
verify	Runs checks to ensure the quality and correctness of the package.
install	Installs the package into the local Maven repository.
deploy	Copies the final package to the remote repository.

2. Clean Lifecycle

Used to clean the project before building. It has 3 phases:

Phase	Description
pre-clean	Executed before the actual project cleaning.
clean	Deletes the target/ directory (build output).
post-clean	Executed after the cleaning is complete.

3. Site Lifecycle

Used to generate documentation for the project. It has 4 phases:

Phase	Description
pre-site	Executed before generating the site.
site	Generates the project documentation.
post-site	Executes operations needed after the site is generated.
site-deploy	Deploys the site to a web server.

Example Command Execution

mvn clean install

Above command will:

• clean: delete the old target/ directory.

• install: run the full default lifecycle (validate → compile → test → package → install).

Maven Project Structure

 

What is a Maven Project?

A Maven project is a structured Java-based software project that uses Apache Maven as its build automation and dependency management tool. It is defined using a file called pom.xml (Project Object Model), which describes the project, its dependencies, build plugins, goals, and other configuration.

Standard Maven Project Folder Structure

Here's the default Maven directory structure (used in most Java projects):

project-root/
│
├── pom.xml                 # Main configuration file (Project Object Model)
├── src/
│   ├── main/
│   │   ├── java/           # Application/Source code
│   │   ├── resources/      # Configuration files, properties files, XMLs
│   ├── test/
│   │   ├── java/           # Unit and integration test code
│   │   ├── resources/      # Resources needed for testing
│
├── target/                 # Output directory for compiled classes and built artifacts (e.g., .jar/.war)
└── .mvn/                   # Maven wrapper files (optional)

Description of Important Folders and Files

Folder/File	Description
pom.xml	Core file. Contains project info, dependencies, plugins, build configurations, etc.
src/main/java/	Java source code for the application.
src/main/resources/	Non-code resources like application.properties, log configs, XMLs.
src/test/java/	Java unit or integration test source code.
src/test/resources/	Resource files used for testing (e.g., test configs or mock data).
target/	Auto-generated folder. Stores compiled classes, JAR/WAR files, and reports.
.mvn/	Optional folder for Maven wrapper support (mvnw, mvnw.cmd, .mvn/wrapper).

Build Lifecycle Overview

When you run a Maven build (mvn clean install), Maven:

• Compiles your source code
• Runs tests in src/test/java
• Packages the code into a .jar or .war file
• Installs it into your local Maven repository
  

pom.xml

<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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>myproject</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

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

Environment Setup for Maven

 

Setting up the Maven environment is a crucial step for managing Java-based projects efficiently. Below is a detailed step-by-step guide to install and set up Apache Maven on Windows, Linux, and macOS.

1. Prerequisites for All OS

Before you install Maven:

• Java (JDK) must be installed.

• Ensure the JAVA_HOME environment variable is set.

How to Check java installed on machine:

java -version
javac -version

If not installed, download Java JDK from: https://www.oracle.com/java/technologies/javase-downloads.html or use OpenJDK (https://jdk.java.net/)

Windows Installation Steps

Step 1: Download Maven

• Go to https://maven.apache.org/download.cgi

• Download the binary zip archive (example: apache-maven-3.9.6-bin.zip)

Step 2: Extract and Place Maven

• Extract it to a folder (example: C:\Program Files\Apache\Maven)

Step 3: Set Environment Variables

1. Search for “Environment Variables” in Start Menu.

2. Under System Variables:

   • Add MAVEN_HOME:
     
     

Variable Name: MAVEN_HOME
Variable Value: C:\Program Files\Apache\Maven\apache-maven-3.9.6

Edit the Path variable and add:

%MAVEN_HOME%\bin

Ensure JAVA_HOME is set:

If not, add:

Variable Name: JAVA_HOME
Variable Value: path to JDK (e.g., C:\Program Files\Java\jdk-17)

Step 4: Verify Installation

mvn -v

Linux Installation Steps:

Step 1: Install Java

sudo apt update
sudo apt install openjdk-17-jdk

Set JAVA_HOME:

echo "export JAVA_HOME=$(dirname $(dirname $(readlink -f $(which javac))))" >> ~/.bashrc
source ~/.bashrc

Step 2: Download Maven

wget https://downloads.apache.org/maven/maven-3/3.9.6/binaries/apache-maven-3.9.6-bin.tar.gz

Step 3: Extract and Move

tar -xvzf apache-maven-3.9.6-bin.tar.gz
sudo mv apache-maven-3.9.6 /opt/maven

Step 4: Set Environment Variables
Edit ~/.bashrc or ~/.zshrc:

export MAVEN_HOME=/opt/maven
export PATH=$MAVEN_HOME/bin:$PATH

Apply changes:

source ~/.bashrc

Step 5: Verify Installation

mvn -v

macOS Installation Steps

Option 1: Using Homebrew (Recommended)

brew install maven

Option 2: Manual Installation

Step 1: Install Java

Use brew install openjdk or download from Oracle.

Step 2: Download Maven

Download from https://maven.apache.org/download.cgi

Step 3: Extract and Move

tar -xvzf apache-maven-3.9.6-bin.tar.gz
sudo mv apache-maven-3.9.6 /opt/maven

Step 4: Set Environment Variables

Edit your shell profile (~/.zshrc, ~/.bash_profile, or ~/.bashrc):

export JAVA_HOME=$(/usr/libexec/java_home)
export MAVEN_HOME=/opt/maven
export PATH=$MAVEN_HOME/bin:$PATH

Apply changes:

source ~/.zshrc  # or relevant shell file

Step 5: Verify

mvn -v

Output:

Apache Maven 3.9.6
Java version: 17.0.1
Java home: C:\Program Files\Java\jdk-17
Default locale: en_US
OS name: "windows 10", version: "10.0", arch: "amd64"

Introduction to Apache Maven

  

What is Maven?

Maven is a build automation and project management tool primarily used for Java projects, although it can be used for other programming languages as well. It was developed by the Apache Software Foundation.

Why Maven?

Before Maven, Java developers used tools like Ant or wrote custom scripts to manage builds. However, these methods had drawbacks:

• Complex and inconsistent project structures

• Manual handling of dependencies

• Difficulties in project configuration sharing

Maven solves these issues by offering a standardized and automated way to manage:

• Project builds

• Dependencies

• Documentation

• Testing

• Deployment

Core Concepts of Maven

1. Project Object Model (POM)

• The heart of a Maven project.

• A file named pom.xml that contains:

  • Project details (name, version, etc.)

  • Dependencies

  • Plugins

  • Build configuration

  • Repository information

• It acts as a blueprint of the project.

2. Convention over Configuration

• Maven uses standard conventions to reduce the need for configuration.

• Default folder structure:

src/
  main/java     → source code
  main/resources → configuration files
  test/java      → unit test code

• You can override defaults, but following the convention simplifies project setup.

3. Dependency Management

• Maven can automatically download and manage external libraries (dependencies).

• It uses Maven Central Repository by default, but other repositories can be added.

• Transitive dependency resolution: if library A depends on B, and B depends on C, Maven includes all of them automatically.

4. Build Lifecycle

• Maven defines a set of phases for building a project:

Phase	Description
validate	Checks project structure
compile	Compiles source code
test	Runs unit tests
package	Packages compiled code (example: JAR or WAR)
verify	Runs checks (like integration tests)
install	Installs the package to local repository
deploy	Deploys the package to remote repository

5. Repositories

• Local Repository: Stored on your system. Maven downloads dependencies here.

• Central Repository: Official online repository (https://search.maven.org).

• Remote Repository: Custom or enterprise-level repositories like Nexus or Artifactory.

6. Plugins

• Provide additional functionality like:

• Compiling code

• Running tests

• Creating documentation

• Deploying applications

Advantages of Using Maven

• Standardization: Enforces consistent project structures and builds.

• Automation: Handles the full build lifecycle from compilation to deployment.

• Dependency Management: Automatically downloads and updates libraries.

• Portability: Same build works across machines/environments.

• Integration: Works with IDEs like IntelliJ, Eclipse, and build servers like Jenkins.

Maven can be used for:

• Building Java applications (JAR, WAR, EAR)

• Managing complex dependency trees

• Automating tests and deployment pipelines

• Sharing libraries across teams or organizations

Integration of Karate API with JUnit 4

  

Integrating JUnit 4 with Karate API

Karate is a powerful testing framework based on BDD (Behavior Driven Development), especially useful for testing web services and APIs. It uses Gherkin syntax (like Cucumber) and can be integrated with JUnit 4 for test execution.

Step-by-Step Integration of Karate with JUnit 4

Step 1: Add Dependencies

<dependencies>
    <!-- Karate Core -->
    <dependency>
        <groupId>com.intuit.karate</groupId>
        <artifactId>karate-junit4</artifactId>
        <version>1.4.1</version> <!-- or latest stable version -->
        <scope>test</scope>
    </dependency>

    <!-- For Assertions and Test Reporting -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Step 2: Create Feature File

Create a file named sample.feature under:

src/test/java/examples

Feature file:

Feature: Sample API Test

  Scenario: Verify GET request
    Given url 'https://jsonplaceholder.typicode.com/posts/1'
    When method get
    Then status 200
    And match response.userId == 1

Step 3: Create JUnit 4 Test Runner

Create a Java class to run the above feature with JUnit 4.

src/test/java/examples/SampleRunnerTest.java:

package examples;

import com.intuit.karate.junit4.Karate;
import org.junit.runner.RunWith;

@RunWith(Karate.class)
public class SampleRunnerTest {
    // No need to write any code inside
}

This class tells JUnit 4 to use Karate as the test runner and will automatically find the .feature file in the same package.

Step 4: Run the Test

• Right-click on SampleRunnerTest.java and choose Run As → JUnit Test

• Or run via Maven:

mvn test

Step 5: View Reports

Karate automatically generates reports in target/karate-reports:

• karate-summary.html

• karate.log

• karate-report.html

Optional: Run All Feature Files in a Folder

package examples;

import com.intuit.karate.junit4.Karate;
import org.junit.runner.RunWith;

@RunWith(Karate.class)
public class AllTests {
    // This will run all *.feature files in this package
}

Benefits of Karate + JUnit 4 Integration

Feature	Description
BDD Syntax	Simple, readable Gherkin language
JUnit Compatibility	Easily integrates into CI/CD
Rich Reporting	Auto HTML & JSON reports
No Java Code Needed	Scenarios are defined in .feature files