Maven is a build automation or a project management and comprehension tool. It is used by a developer to compile an application. It provides a complete build lifecycle framework to the developers.

Likewise, it is an automated build tool and the development team can easily automate the project’s build infrastructure in almost no time as Maven uses a standard directory layout and a default build lifecycle.

Maven is generally used for various purposes such as documentation, project development, reporting and releases.

POM stands for Project Object Model. It is the basic unit of work in Maven. It is an XML file that always resides in the base directory of the project as “pom.xml”.

It contains the information about the project and various configuration details that are being used by Maven to build the project, such as Project dependencies, plugins, goals, build profiles, Project version, developers, etc.

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

It works as a whole library of files that can be easily accessible and can be easily located in our system without any issue, and then it can be used by Maven.

There are three types of repositories in Maven. These are as follows:

Local Repository: It is located in our local system. It is created when we run any Maven commands for the first time. In Maven Local Repository we can find all our project’s dependencies like library jars, plugin jars, etc.

Central Repository: Central Repository is provided by Maven community and contains a large collection of commonly used libraries. When any dependency is not found in local repository by Maven, it starts searching it in Central repository using URL- https://repo1.maven.org/maven2/

Remote Repository: Remote Repository is a developer’s own custom repository that contains required libraries or other project jars. When Maven does not find a dependency in both local and central repository, it stops the build process and give an error. To prevent this situation, the concept of Remote Repository was discovered by Maven.

When Maven build command is executed, it starts looking for libraries dependency in the following sequence:

Step 1: It searches the dependency in Local Repository. If dependency is found, it performs the further processing, else it moves to the next step.

Step 2: It now starts searching it in Central Repository. If the dependency is found in Central repository, it is now downloaded to local repository for future reference and performs the further processing. If dependency is not found and remote repositories are mentioned, then it moves to step 4.

Step 3: If a remote repository is not mentioned, then Maven stops processing and throws the error that it is unable to find dependency.

Step 4: If remote repository is mentioned, it searches dependency in remote repository. If the dependency is found then it is downloaded to local repository for future reference and performs the further processing, otherwise the processing is stopped by Maven and will throw an error that it is unable to find the dependency.

Dependency Scope usually includes all the dependencies as per the current stage of the build.

The various dependency scope used in maven are as follows:

1. Compile: This is the default scope of Maven, and it indicates which dependency is available in the class path of the project.

2. Runtime: This dependency indicates that the dependency is not needed for compilation, but it is required during execution.

3. Provided: It indicates that dependency is provided by JDK or container or web server at run-time.

4. System: This indicates that we have to provide the system path.

5. Test: It indicates that dependency is available only for the test compilation and execution.

6. Import: It indicates that the specified POM should be replaced with the dependencies in that POM’s section.

A maven artifact is a file, basically a JAR file, that gets deployed to a Maven repository. One or more artifacts, such as a compiled JAR and a sources JAR, are being produced by a Maven build.

Each artifact has a group ID (generally a reversed domain name), an artifact ID (it’s just a name) and a version string. The combination of these three uniquely identifies the artifact. The project’s dependencies are being specified as artifacts.

A build lifecycle is defined as a well-defined sequence of phases that defines the order in which the goals need to be executed. Each phase represents a stage in the life cycle.

A default Maven Build Lifecycle consists of the following sequence of phases:

• Prepare-resources
• Validate
• Compile
• Test
• Package
• Install
• Deploy

Following are the built-in build lifecycles in Maven:

Default: this phase handles the complete build and deployment of the project.

Clean: this phase handles the cleaning of the project. It cleans up all the artifacts created by prior builds.

Site: this phase handles the generation of project site documentation.

Maven Plugins are used for performing following tasks:

• Creating a jar file
• Creating a war file
• Compiling code files
• Unit testing of code
• Documenting Projects
• Reporting

There are 2 types of Maven Plugins:

Build Plugins: Build Plugins are executed during the build and are configured in the element of pom.xml

Reporting Plugins: Reporting plugins are executed during the site generation, and they are configured in the element of the pom.xml

The various aspects that are being provided by Maven to developers to manage the following:

• Build
• Dependencies
• Documentation
• Reporting
• Releases
• Source Code Management
• Distribution
• Mailing List

The different phases of a Maven Build Lifecycle are:

Validate: It validates the project and verify that everything is correct, and all necessary information is available.

Compile: It is used to compile the source code of the project.

Test: This phase tests the compiled source code using a suitable unit testing framework. These tests do not require the code to be packaged or deployed.

Package: In this phase, compiled code is taken and packaged it in its distributable format, such as a JAR.

Integration-test: This phase process and deploy the package in an environment, if necessary, where integration tests can be run.

Verify: In this phase, it runs any checks to verify that package is valid and meeting quality criteria.

Install: This phase installs the package into the local repository. This is used as a dependency in other projects locally.

Deploy: This is done in an integration or release environment. It copies the final package to a remote repository and is then shared with other developers and projects.

A Build Profile is defined as a set of configuration values, that can be used to set or override default values of Maven build. We can customize build for different environments such as Production vs Development environments using Build profile.

Profiles are being specified in pom.xml using its active profile elements and are triggered in various ways. They are used to modify the POM at build time and are used to give parameters to different target environments.

For e.g.: The path of the database server is provided for development, testing and production environments.

There are majorly three types of Build Profiles:

Per Project: It is defined in the project POM file, i.e. pom.xml

Per user: It is defined in the Maven setting XML file (%USER_HOME%/.m2/settings.xml)

Global: It is defined in Maven global settings xml file. (%M2_HOME%/conf/settings.xml)

We can activate Maven Build Profiles in the following ways:

• Through Maven settings.
• Explicitly using command console input.
• Through OS Settings (for example, Windows family).
• Based on environment variables like User or System variables.
• Through present or missing files.

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

A Snapshot version is the one that has not been released. Usually snapshot dependencies should only exist during development and no released version, i.e. no non-snapshot version should have a dependency on a snapshot version.

The snapshot is not necessarily more stable, it is just the latest build. The snapshot precedes the actual release, it does not come after the actual release.

We can download and install Maven on Windows, Linux and macOS platforms. We need to follow the below steps to install Maven on Windows:

• Firstly, download Maven and extract it.
• Add JAVA_HOME and MAVEN_HOME to the list of environment variables.
• Add the environment path in Maven variables.
• Verify Maven by checking its version.

Maven version can be checked by using the below command:

mvn –version