Learn Apache Maven Key Features, How Does It Operate, and Its Commands

Maven Commands and Options

Maven is a build automation tool with a wide range of commands you can execute from the command line interface (CLI) to automate various tasks in the build process. They enable you to compile, test, package, and deploy your projects, manage project dependencies, generate reports, and more.

The construction is reproducible, quicker, and less prone to error when these processes are carried out automatically rather than by a human.

So, let's learn more about Maven, how it operates, its features, and its commands. You can easily Rent a VPS (free with a trial) to test Maven Commands.

What Is Maven?

The famous Apache Maven open-source build tool was developed by the Apache Group to build, publish, and deploy several projects for improved project management.

You can create a Maven project in C#, Scala, and Ruby using the Java project tool, Maven. Based on the POM, this tool has simplified Java developers to create reports, check to build phases, and test automated settings.

Apache Maven concentrates on streamlining and standardizing the building project demands by taking care of the following:

  • Build phase

  • Documentation

  • Checking snapshot dependencies

  • Report

  • SCMs

  • Distribution

  • Releases

  • Email list

    Image showing Maven logo on a white background.

Maven Key Features

Apache Maven is your way to build your Java projects with many great features, which go a long way toward explaining why it is so popular.

Here are some of the Maven's most notable features:

  • Transitive dependencies of the user libraries are available

  • Capacity to quickly establish projects utilizing best practices

  • Dependency management with automatic update

  • Compatibility with the earlier version of Maven

  • Robust reporting for errors and integration tests

  • Automatic parent visioning

  • Ensures uniform application across all project

  • Default configuration

  • Expandable compiler plugin that will compile the source code of the Maven project for you

The local system, the internet, or open repositories can all be used to source dependencies. The default method for looking for necessary libraries is to use the Maven Central repository for Java libraries.

The user's home directory structure contains the local Maven repository in the folder, and Maven utilizes this directory as a temporary storage location for downloaded items.

How Does Maven Operate?

Building life cycle serves as the foundation of Maven. This indicates that specific project building and distribution processes are well-defined.

Therefore, this means that the person creating a project needs to learn a few maven commands to create any Maven project, and the POM will ensure they receive the desired outcomes.

Three build lifecycles are preinstalled: default, clean, and site:

  • Default handles the deployment of your project

  • Clean handles the cleanup of your project

  • The site handles the construction of your project's website

A separate list of phases defines each build lifecycle, where a build phase stands for a stage in the lifecycle.

  • Validate: Verifies the project's accuracy and that the necessary information is present.

  • Test: Project source code must be complied with before being tested, using an appropriate unit testing framework

  • Package: Puts the compiled code in a format that can be distributed

  • Verify: Verifies the integration tests' results to ensure quality standards are fulfilled

  • Install: Install the package into the local repository to be used locally as a dependency in other projects.

  • Deploy the Process of sharing the completed package with other developers and projects. It is completed in the built environment.

    Image showing Maven lifecycle phases in green circles.

Plugin Goals Make Up the Build Lifecycle

A phase is accountable for a particular stage of the build lifecycle, although how it fulfills that responsibility can differ. Declaring the plugin goals associated with those phases is how this is accomplished.

A plugin objective is a specified activity that helps with project building and management (even more precise than a build process). It could be tied to 0 phases or more.

Direct invocation of a goal not associated with any phase enables goal execution outside the build lifecycle. The order of the execution is determined by the order in which the phases and goals are called.

Additionally, if a goal is linked to one or more phases, all of those phases will call the goal.

Moreover, a phase may be associated with zero or more goals. A phase won't run if it does not have any goals attached to it. But, if it is connected to one or more goals, it will carry them out.

Why Is Maven Required?

When downloading dependencies, which are libraries or JAR files, Maven is primarily used for Java projects. After you take the compiled code and package, the program obtains the appropriate JAR file for each project since several versions of distinct packages may exist.

After Maven is installed, accessing the official websites of various pieces of software is not necessary for installing dependencies. Libraries in other languages can be found by going to the maven command. The tool, along with the Maven wrapper, aids in establishing the appropriate project structure in struts, servlets, etc., which is crucial for execution.

Moreover, you can take advantage of Maven when it comes to:

  • Aids in the administration of all project management processes

  • Reduces the complexity of project development

  • Enhances the project's and the building process performance

  • JAR file is downloaded automatically to the remote repository

  • Enables quick access to all necessary information

  • Facilitates the developer's ability to build a project in many contexts without having to worry about dependencies, workflows

  • After adding the JUnit dependency, writing the code in the POM file makes it simple to add new dependencies to Maven projects

How Is Project Object Model (POM) Connected with Maven?

POM is an XML file containing all the project and configuration parameters data, making Maven useful for everyone. The project's description, versioning information, and configuration management information are all contained in the POM.

Maven looks for the POM in the current project directory when you run a task, and you can find your file in the project home directory.

Additionally, Maven coordinates a set of identifiers that can be used to uniquely identify project dependencies or a plugin in a Maven POM.

Image showing how Maven and POM work together.

Installing Maven

If you want to install Maven, your job is relatively simple. Like Java, it is just a zip file you need to download and put anywhere on your hardware to the Java release you are targeting. The .zip file content looks like this.

Image showing the zip file needed to install Maven.

Now, you must add the /bin directory to your PATH variable. Otherwise, you cannot call 'mvn' from anywhere. That's it.

Moreover, if you want to validate that Maven was correctly installed, open a console and use the following command line.

mvn -version

You should receive as output feedback on which version of Maven you have installed. Now, you have officially Maven installed.

Image showing output of installed Maven version.

After successful installation, you can start Maven build stages to build a project.

Stages of Developing a Maven Project

Maven supports multi-module projects running with a continuous integration tool, and the steps to establishing a Maven project are as follows.

Step 1: Coding for application creation that can be added or written, then processed into the source code git repository.

Step 2: Modify any configuration project POM, XML, or plugin information required and enter the complete Java project source code.

Step 3: Create the program.

Step 4: Save the results of your build process to a local server or another place, such as a WAR or EAR file.

Step 5: Deploy the file to the client or production site by accessing it locally or from a server.

Step 6: If necessary, change the date and update the application version number in the document.

Step 7: Generate and produce a report by the applications or the requirement's specifications.

Introduction to Maven Commands

Maven caches all of the information it downloads in a local repository for speed reasons and to prevent you from downloading it from the internet each time you run Maven commands.

Consider it a cache; Maven searches the remote repositories for items needed to execute command lines but not yet in the local maven repository.

Usually, the m2 directory houses the local repository. The settings XML file, which serves as the Maven configuration for the remote repository, is also kept in that directory. It can be used to set up remote repositories, access credentials, etc.

Maven Command Is Declarative

Since Maven is a declarative build system, you can specify what your command builds without specifying precisely what to perform.

For instance, you can set up the build to compile the Java sources using a maven-compiler plugin, but you can't specify a schedule for Maven to execute it.

Java source code and the POM file specify the project model where Maven gets all its configuration information to do its job. These include the build configuration, declared dependency management tools, and plugins that should be utilized.

The functionality of Maven plugins is separated into goals which are building blocks. The objectives are registered to be carried out throughout the build phases.

During the phases that result from the project's lifespan, the goals carry out the real work.

Introduction to Maven Options

Maven builds can be configured and customized utilizing the command line options. With Maven command line options, you can facilitate or accelerate your work, in addition to knowing the full Maven build lifecycle or what plugins are accessible.

Basic Maven Commands and Options [Cheat Sheet]

Maven is highly reliable and has a variety of plugins that can aid in creating PDF versions and lists of any most recent changes that have been made.

It is simple since every other command maven project has POM and an XML. Also, Maven makes it simple to migrate any new features.

Let's explore the most employed Maven commands!

#1: mvn version

This mvn command line helps us recognize what Maven version is installed.

mvn -v

Additionally, if you want to create a project using MVN architecture, you should utilize this Maven command below.

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

Templates that utilize Maven are called archetypes. With the command mentioned above, Maven will obtain all archetypes, including the maven archetype quickstart.

Moreover, it will complete all configurations and create a finished product.

#2: mvn package

This command is used to execute all Maven phases until the package phase. The mvn package compiles, verifies, and builds the project.

Additionally, the mvn package creates the JAR file and places it in a specific folder under a specific folder.

mvn package

#3: mvn clean install

This Maven command line aids in executing a clean build lifecycle and installs the build phase in the default build cycle. This build lifecycle may have its build phases, and there are different build goals within each build.

mvn clean install

Moreover, the mvn clean install command ensures that the build target is removed for a new build and adds the mvn clean install target.

#4: mvn compile

The Maven command: mvn compile is used to compile the source code. Additionally, the mvn compile compiles the classes stored at a particular target or a class.

The mvn compile is similar to the previous mvn compiler: compile command, but it runs the entire Maven life cycle up to compile. You can transform the Java files into class files along with the maven compiler plugin itself.

mvn compile

#5: mvn test

This maven command cleans the target directory and also provides the facility of unit tests for particular codes. Therefore, the mvn test command line option runs the tests using suitable testing frameworks.

If you want to run a test on a single test on your project, you can create a Maven run configuration for a single test with this command.

mvn test

#6: mvn deploy

Maven also has the facility of deploying the code for a project. This deployment is done in an integration or release environment.

It copies all final packages to the remote repository and becomes available for sharing with other developers.

mvn deploy

#7: mvn site

This Maven command line builds a site that is based upon the information of the project's pom. Maven executes the generated document, which can be seen under the target or the site.

mvn site

#8: mvn validate

This Maven command validates the project to ensure everything is correct and all the necessary information is available.

The command executes each lifecycle phase in order before executing verify. You must call the last phase to be executed, and in some cases, it can be similar to the mvn package command.

mvn validate

#9: mvn dependency tree

This Maven command generates the display as a tree of a given Maven project. Yours is to enter the command in the terminal if you want to get your project dependency tree.

mvn dependency tree

#10: mvn dependency analyze

This command line analyzes the Maven project to identify the unused declared or used undeclared dependencies.

It also helps reduce the build size by identifying the unused dependencies and removing them from the XML and pom files.

mvn dependency analyze

#11: mvn clean package

The mvn clean package command clears the target directory. It builds the project and packages in the resulting JAR file into the target directory without running unit tests during the build.

mvn clean package

#12: mvn archetype generates

This Maven command line generates a skeleton for projects of different types, such as website applications, Maven websites, JAR, etc.

mvn archetype generate

#13: mvn verify

This Maven command builds projects, runs all the test cases, and runs any checks on the results of the integration tests to ensure the quality criteria are met.

mvn verify

#14: mvn install

The Maven command: mvn install is used to build a Maven project, and mvn installs all project files, such as JAR file, WAR, POM, etc., to the local repository.

mvn install

#15: mvn q package

This command line option runs the Maven build in quiet mode so that only the test case results and errors are shown.

mvn q package

#16: mvn x package

This command line option prints the Maven version information and runs the build in debug mode so that all messages are displayed.

mvn x package

#17: mvn clean

The mvn clean command cleans the project and then rebuilds it. The mvn clean command runs a clean build life cycle made out of the plugin goal clean: clean.

mvn clean


One of the best tools for creating, unit tests, and deploying simple Java projects is Maven. It provides every step with more collaboration, better debugging, and more potent builds within a single tool.

Maven commands have a more standardized project structure that assists in avoiding duplication. The ultimate result of utilizing Maven commands and options is better hierarchical dependency trees incorporating all transitive dependencies and better dependency management.

With all the available tools, Maven is one of the better choices.

Bruno Mirchevski
The author
Bruno Mirchevski

Bruno Mirchevski is a seasoned hosting industry professional. With years of experience, Bruno is dedicated to helping individuals and businesses find the best web hosting solutions. As a hosting expert at HostAdvice, Bruno provides valuable insights and guidance to users seeking reliable hosting services. He also owns The Logician trademark and manages his personal brand and HE Group. His passion for the industry is reflected in his dedication to speaking at events and publishing articles and reviews on various online platforms. You can check out the most reliable and up-to-date information about web hosting directly on our blog, where Bruno shares his expertise and insights. Social profiles are available here: Twitter @brunomirchevski, LinkedIn and Quora

Frequently Asked Questions

What is the default Java version in Maven?

The default Java version used by Maven is Java 1.5.

Is platform encoding performed using a Maven wrapper?

No, it isn't. A user of your Maven build will have everything they need to utilize your Maven build, thanks to the Maven wrapper.

Why do I need Maven surefire plugin for my project dependencies?

The Maven surefire plugin helps perform unit tests, and if any tests fail, the Maven build will automatically abort them. While executing integration tests, the Maven surefire plugin will separate failing the build from running unit tests.

What is the purpose of the Maven resources plugin?

Project resources are copied to the output directory using the Maven resources plugin.

What is the purpose of encoding UTF-8?

While building your sites and databases, you should utilize encoding utf eight since it's the most used method for representing Unicode text. But remember, encoding utf 8 is merely one conceivable method for encoding Unicode characters in theory.

Does the file specify where the local maven repository is?

Yes, it does. The location of your local maven repository is indicated in the mentioned file.

Is there any difference between the mvn test and the mvn clean verification?

No. There isn't any difference between the two commands' outputs.

Which parameter on the Maven command line is used for logging errors?

Utilize one of the following three commands to regulate Maven's logging level: -errors, -e create execution-related error messages, and -debug.

How can I utilize Maven using the command line?

You use the mvn command from the command line to build a Maven project through the Maven home command line.

The required POM file must be located in the directory where the command is to be run. You supply this command with the build lifecycle, phase, or goal as an argument.