Maven

Maven is a project Management Tool that can

Manage source code

Testing

Manage the project Structure

Manage Libraries/Dependencies

Manage Configurations

Task Runner - build, test, run

Reporting

Maven does it using the Project Object Model. Maven is an open source Apache
project

It provides project structure and manages contents and it helps manage

dependencies

Maven simplifies and standardises the project build process. It handles compilation,
distribution, documentation, team collaboration and other tasks seamlessly. Maven
increases reusability and takes care of most of the build related tasks.

Characteristics

Convention over Configuration

Consistent

Configurable

IDE Agnostic

IDE Supported

Declarative dependency management

Plugin based architecture

Maven 1
 As an example, following table shows the default values for project source code files,
resource files and other configurations. Assuming, ${basedir} denotes the project
location −

Item Default

source code ${basedir}/src/main/java

Resources ${basedir}/src/main/resources

Tests ${basedir}/src/test

Complied byte code ${basedir}/target

distributable JAR ${basedir}/target/classes

For example, Maven expects your code under src/main/java , but if you want to
change this format, you can change it as well and Maven will configure it accordingly.

Maven POM
The POM contains information about the project and various configuration detail
used by Maven to build the project(s).

POM also contains the goals and plugins. While executing a task or goal, Maven
looks for the POM in the current directory. It reads the POM, gets the needed
configuration information, and then executes the goal. Some of the configuration that
can be specified in the POM are following −

project dependencies

plugins

goals

build profiles

project version

developers

mailing list

It should be noted that there should be a single POM file for each project.

Maven 2
 All POM files require the project element and three mandatory fields: groupId,
artifactId, version.

Projects notation in repository is groupId:artifactId:version.

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.

Maven use the effective POM (configuration from super pom plus project
configuration) to execute relevant goal. It helps developers to specify minimum
configuration detail in his/her pom.xml. Although configurations can be overridden
easily.

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

Maven - Project Templates

Maven has the ability to create the project for you based on the conventional
template, called archetypes.

mvn archetype:generate

What is Archetype?
Archetype is a Maven plugin whose task is to create a project structure as per its
template. We are going to use quickstart archetype plugin to create a simple java
application here.

Maven gets a huge list of projects form which we need to choose.

GroupId - Analogous to package name. Let’s say someone working for Google, will
have groupId as com.Google

Maven 3
 ArtifactId - What is the current maven project about ? Weather app, Calculator app
?

version - Changes made during the project lifecycle, updates the version. We start
with 1.0.0

How did Maven create the project using Archetype ?

The machine doesn’t have a project. Maven gets that information from repository
repo1.maven.apache.org (This is the central repository). You can change this
repository.
This repository has these archetypes that you can choose for maven.

Repository returns a list of items and then we choose one, which maven downloads
and creates a project which is based on this template.

Project Structure
src

main
java

io
javabrains
App.java

test

java
io

javabrains
AppTest.java
pom.xml

How are naming artifacts/ version related conflicts avoided ?

Maven 4
 GroupId, ArtifactId, Version and Packaging together form a maven coordinate. A
maven coordinate has to be unique. Maven coordinates are specified in pom.xml

Version is the one that causes changes to be made. So, with a new version a new
jar is generated

Maven compile command - mvn compile. Maven puts the compiled files(class files)
into a folder called target.
target/classes/App.class

Every maven project has a lifecycle.

To run a maven test use the command - mvn test

To generate a jar/war from maven use the command - mvn package

The jar file gets created under the target folder

After we make new changes, we just need to change the version and do a jar build,
another jar will be created under the target folder with the new version number.

Dependency Management
Maven remote repo contains repository of archetypes and artifacts.

One way to download libraries is to go get the jar file and add to classpath, which is
error prone and tedious.
Other way is declarative dependency management. We specify the list of
dependencies with version(maven coordinates). Maven gets the artifacts from the
repository and makes them available, just by getting the entries from the pom.xml.

Dependencies section is present in pom.xml. This is where we declare list of

dependencies that we require maven to fetch.

After adding a dependency, mvn compile needs to be run for maven to get the
dependency. We don’t get to observe this in IDE, as it all happens behind the scene.

Maven 5
 Transitive Dependencies
Let’s say we have 2 dependencies A and B
Now, A and B are artifacts themselves, so they have dependencies of their own.

A→C
For A to work, we need C.

Maven downloads C’s dependencies.

A is a direct dependency, C is a transitive dependency

Now, consider the scenario

Project has two dependencies, A and B

A → B(3.0)
B(2.0)

Now, maven cannot download both 2.0 and 3.0

Maven will follow dependency mediation.

Nearest Definition - 2.0 is nearer to 1.0, so it will download B(2.0)

First Declaration - Get the first declaration

What if we want to override, we declare the required dependency directly.

Dependency Scope

Maven - Snapshots
Consider a team is working on the front end of the application as app-ui project (app-
ui.jar:1.0) and they are using data-service project (data-service.jar:1.0).
Now it may happen that team working on data-service is undergoing bug fixing or
enhancements at rapid pace and they are releasing the library to remote repository
almost every other day.
Now if data-service team uploads a new version every other day, then following
problems will arise −

Maven 6
 data-service team should tell app-ui team every time when they have released
an updated code.

app-ui team required to update their pom.xml regularly to get the updated
version.

To handle such kind of situation, SNAPSHOT concept comes into play.

If a version is SNAPSHOT, then maven waits for a day and gets a newer version.

For example 2.1.0 - 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.

Now data-service team will release SNAPSHOT of its updated code every time to
repository, say data-service: 1.0-SNAPSHOT, replacing an older SNAPSHOT jar.

Snapshot vs Version
In case of Version, if Maven once downloaded the mentioned version, say data-
service:1.0, it will never try to download a newer 1.0 available in repository. To
download the updated code, data-service version is be upgraded to 1.1.

In case of SNAPSHOT, Maven will automatically fetch the latest SNAPSHOT (data-
service:1.0-SNAPSHOT) every time app-ui team build their project.

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.
For example, let us do the following changes to the project created in ‘Creating Java
Project’ chapter.

Add lib folder to the src folder.

Copy any jar into the lib folder. We've used ldapjdk.jar, which is a helper library
for LDAP operations.

Here you are having your own library, specific to the project, which is an usual case
and it contains jars, which may not be available in any repository for maven to

Maven 7
 download from. If your code is using this library with Maven, then Maven build will
fail as it cannot download or refer to this library during compilation phase.

To handle the situation, let's add this external dependency to maven pom.xml using
the following way.

<dependency>
<groupId>ldapjdk</groupId>
<artifactId>ldapjdk</artifactId>
<scope>system</scope>
<version>1.0</version>
<systemPath>${basedir}\src\lib\ldapjdk.jar</systemPath>
</dependency>

Maven Architecture in Enterprise

Enterprises may create artifacts that are not publicly available. So, these internal
artifacts are kept in a local maven repository. This local repository acts a cache. So,
the setting would be to contact the local repository and not the central repository.

If an artifact is not available, maven will contact the global repository and add it to
the local repository cache.

You can also publish your artifact, so that you can use it in another project.

This works by using the command - mvn install

Maven Build Lifecycle

A Build Lifecycle is a well-defined sequence of phases, which define the order in
which the goals are to be executed. Here phase represents a stage in life cycle. As
an example, a typical Maven Build Lifecycle consists of the following sequence of
phases.

Validate

Compile

Test

Package

Maven 8
 Verify

Install

Deplo

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.

The order of execution depends on the order in which the goal(s) and the build
phase(s) are invoked. For example, consider the command below.
The clean and package arguments are build phases while the dependency:copy-
dependencies is a goal.

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.

mvn clean

mvn site - Generates reports related to dependencies, plugins, project management

Maven Plugins
Maven is actually a plugin execution framework where every task is actually done by
plugins. Maven Plugins are generally used to −

create jar file

Maven 9
 create war file

compile code files

unit testing of code

create project documentation

create project reports

A plugin generally provides a set of goals, which can be executed using the following
syntax −

mvn [plugin-name]:[goal-name]

For example, a Java project can be compiled with the maven-compiler-plugin's

compile-goal by running the following command.

mvn compiler:compile

Plugin Types
Maven provided the following two types of Plugins

Plugins are specified in pom.xml using plugins element.

Each plugin can have multiple goals.

You can define phase from where plugin should starts its processing using its
phase element. We've used clean phase.

You can configure tasks to be executed by binding them to goals of plugin.

We've bound echo task with run goal of maven-antrun-plugin.

Maven will then download the plugin if not available in local repository and start
its processing.

Maven Repository
A repository is a directory where all the project jars, library jar, plugins or any other
project specific artifacts are stored and can be used by Maven easily.

Maven 10
 Maven repository are of three types. The following illustration will give an idea
regarding these 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.

Maven maintains cache locally, so each time it does not contact the remote
repository. It’s present in .m2 directory.
Maven local repository by default get created by Maven in %USER_HOME%
directory. To override the default location, mention another path in Maven
settings.xml file available at %M2_HOME%\conf directory.

Central Repository

Maven 11
 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/
Key concepts of Central repository are as follows −

This repository is managed by Maven community.

It is not required to be configured.

It requires internet access to be searched.

Remote Repository
Sometimes, Maven does not find a mentioned dependency in central repository as
well. It then stops the build process and output error message to console. To prevent
such situation, Maven provides concept of Remote Repository, which is developer's
own custom repository containing required libraries or other project jars.
For example, using below mentioned POM.xml, Maven will download dependency
(not available in central repository) from Remote Repositories mentioned in the
same pom.xml.

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).

Maven 12