Overview

Convention over Configuration

Maven uses Convention  over Configuration , which means developers are not required to create build process themselves.

Following table shows the default values for project source code files, resource files and other configurations. Assuming, ${basedir}  denotes the project location.

POM

POM stands for Project Object Model. It is fundamental unit of work in Maven. It is an XML file that resides in the base directory of the project as 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.companyname.project-group</groupId>
    <artifactId>project</artifactId>
    <version>1.0</version>
</project>

Minimal requirements for a POM:

Super POM

The Super POM is Maven’s default POM. All POMs inherit from a parent or default (despite explicitly defined or not). This base POM is known as the Super POM , and contains values inherited by default.

An easy way to look at the default configurations of the super POM is by running the following command: mvn help:effective-pom.

Build Life Cycle

A Build Lifecycle is a well-defined sequence of phases, which define the order in which the goals are to be executed. A typical Maven Build Lifecycle consists of the following sequence of phases:

There are always pre and post phases to register goals , which must run prior to, or after a particular phase.
When Maven starts building a project, it steps through a defined sequence of phases and executes goals, which are registered with each phase.

Maven has the following three standard lifecycles:

• clean
• default(or build)
• site

A goal represents a specific task which contributes to the building and managing of a project. It may be bound to zero or more build phases. A goal not bound to any build phase could be executed outside of the build lifecycle by direct invocation.

mvn clean dependency:copy-dependencies package

Here the clean phase will be executed first, followed by the dependency:copy-dependencies goal , and finally package phase will be executed.

Clean Lifecycle

When we execute mvn post-clean command, Maven invokes the clean lifecycle consisting of the following phases:

• pre-clean
• clean
• post-clean

Maven clean goal (clean:clean) is bound to the clean  phase in the clean lifecycle.

We can customize this behavior by mentioning goals in any of the above phases of clean life cycle.

<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.companyname.project-group</groupId>
    <artifactId>project</artifactId>
    <version>1.0</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-antrun-plugin</artifactId>
                <version> 1.1 </version>
                <executions>
                    <execution>
                        <id>id.pre-clean</id>
                        <phase>pre-clean</phase>
                        <goals>
                            <goal>run</goal>
                        </goals>
                        <configuration>
                            <tasks>
                                <echo>pre-clean phase</echo>
                            </tasks>
                        </configuration>
                    </execution>
                    <execution>
                        <id>id.clean</id>
                        <phase>clean</phase>
                        <goals>
                            <goal>run</goal>
                        </goals>
                        <configuration>
                            <tasks>
                                <echo>clean phase</echo>
                            </tasks>
                        </configuration>
                    </execution>
                    <execution>
                        <id>id.post-clean</id>
                        <phase>post-clean</phase>
                        <goals>
                            <goal>run</goal>
                        </goals>
                        <configuration>
                            <tasks>
                                <echo>post-clean phase</echo>
                            </tasks>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

You can try tuning mvn clean command, which will display pre-clean and clean. Nothing will be executed for post-clean phase.

Default (or Build) Lifecycle

This is the primary life cycle of Maven and is used to build the application. It has the following 21 phases:

There are few important concepts related to Maven Lifecycles, which are worth to mention:

• When a phase is called via Maven command, for example mvn compile, only phases up to and including that phase will execute.
• Different maven goals will be bound to different phases of Maven lifecycle depending upon the type of packaging (JAR / WAR / EAR).

Site Lifecycle

Maven Site plugin is generally used to create fresh documentation to create reports, deploy site, etc. It has the following phases:

• pre-site
• site
• post-site
• site-deploy

Build Profiles

What is Build Profile?

A Build profile is a set of configuration values, which can be used to set or override default values of Maven build.

Profiles are specified in pom.xml file using its activeProfiles/profiles elements and are triggered in variety of ways. Profiles modify the POM at build time, and are used to give parameters different target environments.

Repositories

What is a Maven Repository?

Maven repository are of three types:

• local
• central
• remote

Local Repository

Maven local repository is a folder location on your machine. It gets created when you run any maven command for the first time.

Maven local repository keeps your project’s all dependencies (library jars, plugin jars etc.). When you run a Maven build, then Maven automatically downloads all the dependency jars into the local repository. It helps to avoid references to dependencies stored on remote machine every time a project is build.

Central Repository

Maven central repository is repository provided by Maven community. It contains a large number of commonly used libraries.
When Maven does not find any dependency in local repository, it starts searching in central repository using following URL(https://repo1.maven.org/maven2/).

Remote Repository

Maven provides concept of Remote Repository , which is developer’s own custom repository containing required libraries or other project jars.

Maven Dependency Search Sequence

When we execute Maven build commands, Maven starts looking for dependency libraries in the following sequence:

• Step 1: Search dependency in local repository, if not found, move to step 2 else perform the further processing.
• Step 2: Search dependency in central repository, if not found and remote repository/repositories is/are mentioned then move to step 4. Else it is downloaded to local repository for future reference.
• Step 3: If a remote repository has not been mentioned, Maven simply stops the processing and throws error (Unable to find dependency).
• Step 4: Search dependency in remote repository or repositories, if found then it is downloaded to local repository for future reference. Otherwise, Maven stops processing and throws error (Unable to find dependency).

Plugins

What are Maven Plugins?

Maven is actually a plugin execution framework where every task is actually done by plugins.

Plugin Types

Maven provided the following two types of Plugins:

• Build plugins: They execute during the build process and should be configured in the <build/> element of pom.xml.
• Reporting plugins: They execute during the site generation process and they should be configured in the <reporting/> element of the pom.xml.

Creating Project

Maven uses archetype plugins to create projects. To create a simple java application, we’ll use maven-archetype-quickstart plugin.

mvn archetype:generate \
    -DgroupId=com.companyname.bank \
    -DartifactId=consumerBanking \
    -DarchetypeArtifactId=maven-archetype-quickstart \
    -DinteractiveMode=false

External Dependencies

What happens if dependency is not available in any of remote repositories and central repository? Maven provides answer for such scenario using concept of External Dependency.

<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.companyname.bank</groupId>
    <artifactId>consumerBanking</artifactId>
    <packaging>jar</packaging>
    <version>1.0</version>
    <name>consumerBanking</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>ldapjdk</groupId>
            <artifactId>ldapjdk</artifactId>
            <scope>system</scope>
            <version>1.0</version>
            <systemPath>${basedir}\src\lib\ldapjdk.jar</systemPath>
        </dependency>
    </dependencies>
</project>

Snapshots

What is SNAPSHOT?

SNAPSHOT is a special version that indicates a current development copy. Unlike regular versions, Maven checks for a new SNAPSHOT version in a remote repository for every build.

Manage Dependencies

Transitive Dependencies Discovery

With transitive dependencies, the graph of included libraries can quickly grow to a large extent. Cases can arise when there are duplicate libraries. Maven provides few features to control extent of transitive dependencies.

Dependency Scope

Transitive Dependencies Discovery can be restricted using various Dependency Scope as mentioned below: