Learn Maven's lifecycle, phases, goals, and best practices. Understand Maven's role in managing projects with its plugins and commands.
OVERVIEW
The Maven lifecycle is the series of phases that follow to build and manage Maven projects, where each phase performs different goals/tasks required for the project. Each phase of the Maven lifecycle denotes a specific stage in the Maven build lifecycle.
Software developers use the Maven build tools to manage Maven projects, including phases and goals of the lifecycle. This involves project documentation, dependency management, and building. Understanding Maven's lifecycle is crucial for effectively configuring and managing project builds. This knowledge enables developers to modify and extend the build process according to project requirements. Leveraging the Maven lifecycle facilitates the implementation of various build tasks such as code compilation, deployment, and software testing.
This tutorial explains Maven's lifecycle by defining its phases, goals, and more. It will help you gain robust knowledge of one of the crucial concepts of the Maven. So, let us get started by understanding Maven.
Maven is a widely used project/page object model (POM) for managing and developing projects, especially for handling the Maven lifecycle. In software development, Maven functions like a project manager, organizing the project, overseeing dependencies, and orchestrating the build process.
As a project manager who handles tasks and resources, Maven oversees code compilation, testing, and packaging. It streamlines processes by automatically resolving dependencies from repositories, similar to procuring supplies from trusted vendors.
With Maven, developers can focus more on writing code, as Maven takes care of the project management tasks efficiently.
Its primary aim is to enable developers to grasp a development effort's complete state easily. To achieve this, Maven addresses several key areas:
In this section, we will learn the various features that Maven's lifecycle offers to effectively manage dependencies and external libraries.
To better understand the Maven lifecycle, you should clearly understand its core concepts like Maven commands, goals, and plugins. In the below section, we will cover all the concepts related to the Maven lifecycle.
In this section, we will learn various Maven commands commonly used by developers and testers.
Typically, when executing any of the commands above, it's customary to include the mvn clean step to ensure the removal of the target folder generated from the previous build before initiating a new build.
Maven's functionality primarily relies on plugins, which are the fundamental components. These plugins offer implementations for various goals and help extend the build process. Maven has a wide array of plugins that cover multiple tasks and integrations. Configuration of plugins can be done within the project's POM file, specifying the desired version and any custom configurations.
When necessary, Maven fetches and retrieves plugins from remote repositories. Prominent examples of Maven plugins include the Maven Compiler Plugin, Surefire Plugin for testing, and the Maven Assembly Plugin for creating customized distributions.
Every build comprises a set of objectives. A Maven goal denotes a particular task contributing to the development and administration of a project. While some Maven goals are associated with specific build phases, others can be executed via the command line.
To execute a goal, the syntax is as follows:
$ mvn plugin-prefix:goal
$ mvn plugin-group-id:plugin-artifact-id[:plugin-version]:goal
Goals enable the execution of specific tasks within the Maven build lifecycle, such as code compilation, test execution, project packaging, or report generation. Plugins enhance Maven's capabilities by implementing these goals, automating complex tasks, managing dependencies, generating documentation, and integrating with external tools.
Goals and plugins promote consistency across projects and facilitate collaboration by ensuring a standardized project construction and management approach. In short, Maven goals define precise tasks within the Maven build lifecycle, while plugins implement those tasks.
Maven is a widely used automation tool for projects, operating through predefined build phases and goals, collectively known as the Maven lifecycle.
It allows the execution of multiple Maven lifecycle phases sequentially, with each phase independent of the others. The complete Maven lifecycle is outlined in the pom.xml file within the project, where each phase corresponds to a specific goal.
The Maven lifecycle phases include various tasks, including:
Version 2.0 of Maven focuses on adhering to a distinct Maven build lifecycle to achieve the desired output after a successful Maven build process.
Three inherent Maven build lifecycles exist: clean, build (default), and site. The clean lifecycle handles project cleaning, the build (default) lifecycle manages project deployment, and the site lifecycle oversees the creation of the projects.
Note : Learn how to manage and streamline your Maven project by understanding its lifecycle and optimizing your development process. Try LambdaTest Now!
In the section below of this Maven build lifecycle tutorial, we will learn the various phases of the Maven lifecycle.
The Maven lifecycle has three phases, as shown in the diagram below. Let us describe each phase in detail.
During the Maven clean lifecycle phase, the operation deletes the target directory and its contents to prepare for a fresh compilation and deployment. This operation is initiated using the command > mvn clean.
$ mvn clean install
The command above directs Maven to execute the clean action in each module before proceeding with the install action for each module. This sequence of tasks eliminates temporary files created during the build process. Specifically, the mvn clean install removes any compiled files, guaranteeing that each module is compiled from scratch.
Commands such as mvn pre-clean and mvn post-clean are internally executed when running the mvn clean command. Maven executes the current clean command alongside its preceding clean process during mvn command execution.
The target folder has temporary files and artifacts generated by Maven. Occasionally, the target folder may grow excessively large, or specific cached files may need to be cleared from the folder. The mvn clean command addresses this by attempting to delete the target folder and all its contents.
The Maven clean command is appended to the target folder to eliminate all previously built files before initiating a new build. Combining the two steps, the command involves a clean step followed by an install step, as seen in the mvn clean install command. Similarly, one can include debug mode in Maven installation steps by adding –X to the install command, resulting in mvn -X install.
Executing mvn clean triggers the clean lifecycle, which includes three phases:
The following are sequences of clean commands:
mvn pre-clean
mvn clean
mvn post-clean
The Maven build lifecycle is also called the default lifecycle, which is Maven's primary engine that manages the entire build process. It comprises 21 phases, from validation to deployment. These phases are executed sequentially, and you can adjust them to meet your project's needs.
By associating goals with these phases, you can extend and customize the Maven build lifecycle to fit your project’s unique requirements. For example, you can perform unit tests, package your application, and perform various validations during the build process.
Following are the phases of the Maven build lifecycle:
The Maven build lifecycle phases outlined above indicate that when following the phases of the Maven build lifecycle, Maven begins by validating the project. Subsequently, it proceeds to compile the sources, perform tests, package the binaries (e.g., JAR), execute integration tests on the package, verify these tests, install the validated package to the local repository, and finally deploy the installed package to a remote repository.
When executing a Maven build command, we specify the desired phase to be executed. Maven also executes any preceding phases leading up to the specified phase. For instance, running the mvn package will perform the project's validate, compile, test, and package phases.
Typical Command Line Calls
Select the Maven build phase that aligns with your intended result. To create a JAR file, use the package phase. To run unit tests, use the test phase.
If you are unsure about the specific requirements, the recommended phase to invoke is
mvn verify
This command systematically executes each default lifecycle phase (validate, compile, package, etc.) before proceeding to the verify phase. Calling the final build phase verify, is usually sufficient. The verify phase generally aligns with the package phase; in scenarios involving integration tests, the verify phase also conducts these tests. Furthermore, the verify phase allows for additional checks, such as ensuring compliance with predefined rules.
In a production environment, you can use the following command to develop and deploy artifacts into the shared repository cleanly.
mvn clean deploy
The same command holds for a multi-module setup (e.g., a project with multiple subprojects). Maven traverses through each subproject, executing clean first, followed by deploy (including all preceding build phase tasks).
Certain Phases Aren't Typically Invoked Directly from Command Lines
The phases labeled with hyphenated words (pre-, post-, or process-*) are typically not directly invoked from the command line. These phases control the build flow, producing intermediate results that have little value beyond the build process. For example, the environment might remain unresolved when invoking the integration test phase.
Tools like JaCoCo, used for code coverage, and container execution plugins like Tomcat, Cargo, and Docker associate goals with the pre integration test phase to set up the integration test environment. Similarly, these plugins attach goals to the post integration test phase to gather coverage metrics or shut down the integration test environment.
The Maven Failsafe and code coverage plugins bind Maven goals to integration test and verify phases. Consequently, test and coverage reports become accessible after the verify phase. No reports would be generated if integration tests were invoked directly from the command line. Moreover, there's a risk of leaving the integration test environment hanging; for instance, the Tomcat server or Docker instance might remain active, and Maven might not terminate automatically.
The Failsafe plugin and code coverage plugins are configured to execute goals during the integration test and verify phases. As a result, test and coverage reports are only available after the verify phase is completed. If the integration test phase is directly invoked from the command line, no reports are generated, and there is a risk of leaving the integration test environment running. For example, the Tomcat server or Docker instance might remain active, and Maven might not terminate automatically.
Maven Build Phase Comprises Plugin Goals
Even though each Maven build phase is responsible for a specific action within the Maven build lifecycle, the way it accomplishes these tasks can differ. This variation is achieved by specifying the plugin goals associated with those build phases.
A plugin goal represents a specific task, more granular than a build phase, that contributes to project construction and management. It can be associated with none or multiple build phases. A goal not linked to any build phase can be executed independently from the build lifecycle through direct invocation. The execution sequence depends on the order of invocation of the goal(s) and build phase(s). For example, consider the following command: mvn clean package dependency:copy-dependencies. Here, clean and package are build phases, while dependency:copy-dependencies is a plugin goal.
mvn clean dependency:copy-dependencies package
Upon execution, the clean phase will be the initial step, followed by the dependency:copy-dependencies goal, and finally, the package phase, along with all its preceding build phases from the default lifecycle. Additionally, If a goal is linked to one or more build phases, it will be executed in each phase. A build phase can have none or several goals linked to it. If a build phase lacks any associated goals, it will not be executed. However, if it has one or more goals attached, it will execute all of them.
(Note: In Maven 2.0.5 and later versions, multiple goals associated with a phase are executed in the same order as declared in the POM. Nonetheless, multiple instances of the same plugin are not supported. In Maven 2.0.11 and later versions, multiple instances of the same plugin are grouped for execution and ordered accordingly).
Different Maven goals are assigned to various phases of the Maven lifecycle depending on the type of packaging (JAR / WAR / EAR).
Maven Build Lifecycle Bindings – Packaging ejb / ejb3 / jar / par / rar / war
Phase | Plugin:Goal |
---|---|
process-resources | resources:resources |
compile | compiler:compile |
process-test-resources | resources:testResources |
test-compile | compiler:testCompile |
test | surefire:test |
package | ejb:ejb or ejb3:ejb3 or jar:jar or par:par or rar:rar or war:war |
install | install:install |
deploy | deploy:deploy |
Maven Build Lifecycle Bindings – Packaging ear
Phase | Plugin:Goal |
---|---|
generate-resources | ear:generate-application-xml |
process-resources | resources:resources |
package | ear:ear |
install | install:install |
deploy | deploy:deploy |
Maven Build Lifecycle Bindings – Packaging maven-plugin
Phase | Plugin:Goal |
---|---|
generate-resources | plugin:descriptor |
process-resources | resources:resources |
compile | compiler:compile |
process-test-resources | resources:testResources |
test-compile | compiler:testCompile |
test | surefire:test |
package | jar:jar and plugin:addPluginArtifactMetadata |
install | install:install |
deploy | deploy:deploy |
POM's Role in Maven Build Lifecycle
When running Maven builds via the command line, phases, and goals are executed. The configuration within the pom.xml file significantly influences the project's build lifecycle. The packaging attribute in the pom.xml file specifies the goals to be executed during the Maven build. For example, if it's set to JAR, the following phases and goals will be executed.
Maven Build Lifecycle Bindings – Packaging pom
Phase | Plugin: Goal |
---|---|
package | jar:jar |
install | install:install |
deploy | deploy:deploy |
In the Maven build lifecycle, it is possible to configure the goals in a pom.xml file using plugin elements. However, it is mainly needed when you have custom plugins and want to run any particular goals for a Maven build phase.
Maven extends beyond building software artifacts; it facilitates project documentation and report generation for single or multiple projects. For this purpose, Maven offers a Site lifecycle to generate comprehensive project documentation and reports. This Maven site lifecycle has key phases like pre-site, site, post-site, and site-deploy, addressing various documentation and reporting requirements.
Phase | Description |
---|---|
pre-site | Undertakes essential tasks preceding the actual generation of the project's site documentation |
site | Creates the project’s site documentation |
post-site | Executes tasks required to conclude site generation and prepare for site deployment |
site-deploy | Deploys the generated site documentation to the designated web server |
Utilizing the site lifecycle enables the creation of informative project websites, ensuring easy access to project documentation for the team and stakeholders.
The default goals associated with the site lifecycle are:
site: site: This command is used for generating the project's site documentation
site-deploy: deploy: This command is used to deploy the generated site documentation to the designated web server.
The choice of packaging type typically doesn't affect this Maven lifecycle, as packaging primarily focuses on artifact creation rather than the site-generated type. The Site plugin executes Doxia document generation and other report generation plugins. To generate a site from a Maven project, you can use the following command:
$ mvn site
In the below section, we will learn how to set up a Maven project and the required libraries to help you build a site and start with Maven project creation.
The following are the steps that you can follow to establish a Maven project.
You have successfully set up MAVEN_HOME in your local environment and are good to start with Maven. To verify if the Maven is installed, follow the Maven verification process below.
mvn -version
mvn archetype:generate
Maven will establish a project structure for you.
mvn install
This command develops the Maven project and installs project files (e.g., JAR, WAR, pom.xml) into the local repository. You have successfully initialized your project after completing the build.
With the steps outlined above, you should be able to set up Maven on your local machine, use Maven commands, and create a Maven site.
Maven helps streamline project management by providing a standardized way to build, test, and package projects. It simplifies managing dependencies, compiling code, and deploying applications. This streamlining can lead to more efficient development workflows and easier collaboration among team members. It offers diverse functionalities, from managing JARs and dependencies to automating project lifecycles and facilitating the management of transitive dependencies. Understanding these features can greatly improve your development workflow, regardless of the specific project you are working on.
Managing multiple test environments with Maven projects can be challenging, as local setups often limit you to one environment at a time. This can lead to increased test execution times, especially when running tests sequentially across different environments is necessary.
According to the Future of Quality Survey, approximately 28% of large and 26% of mid-sized organizations spend over 60 minutes running their test builds. This challenge can be addressed by increasing parallelization or adopting smarter tools. Tools like SmartWaits and test orchestration can significantly reduce test execution times.
As Maven projects grow in complexity and size, managing and scaling test environments for integration testing can become increasingly challenging. Local environments may not effectively simulate real-world scenarios, and setting up and maintaining multiple environments can be time-consuming.
You can leverage cloud-based platforms like LambdaTest to overcome the challenge of maintaining multiple test environments. These platforms offer great flexibility by allowing you to run tests across multiple test environments while handling test infrastructure and security concerns for you. This platform allows you to perform cross-browser testing, and you can also leverage various automation testing frameworks allowing you to use two or more frameworks and perform your testing effectively.
LambdaTest is an AI-powered test orchestration and execution platform that lets you run manual and automated tests at scale with over 3000+ real devices, browsers, and OS combinations.
It offers on-demand access to a scalable grid of virtual machines, allowing teams to perform parallel testing, which helps significantly reduce test execution time. Additionally, this platform provides features for debugging, automated screenshot testing, and test automation, enhancing the overall testing process.
LambdaTest platform offers integration with Maven through plugins and APIs, allowing developers and testers to integrate cloud testing into the Maven build process seamlessly. Developers can configure Maven and trigger tests on the LambdaTest platform of the integration-test phase. With this approach, you can ensure that your application works as expected in different test environments.
To learn more about the LambdaTest platform and how to leverage its various functionalities, watch the complete video guide.
Subscribe to the LambdaTest YouTube Channel and stay up to date with the latest video tutorials on automation testing tools like Selenium, Cypress, Playwright, Appium, and more.
In the below section of this Maven lifecycle tutorial, we will learn the concept of the Maven lifecycle through a conceptual example.
Let us take an example of developing a RESTful web service using Java, Maven, and Spring Boot. In this, we will understand how to use the Maven lifecycle throughout its development.
Project setup:
When the project is in the initial development phase, the Maven project structure is set up using Spring Boot initializer. You can define the dependencies needed to develop a RESTful service. Maven's conventions will automatically create all required directories and files. This will include a pom.xml configuration file, source code directories (src/main/java), and resource directories (src/main/resources).
The file structure will look like this, as shown below.
spring-boot-rest-service/
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── example/
│ │ │ └── demo/
│ │ │ └── DemoApplication.java
│ │ └── resources/
│ │ └── application.properties
│ └── test/
│ └── java/
│ └── com/
│ └── example/
│ └── demo/
│ └── DemoApplicationTests.java
├── .gitignore
├── mvnw
├── mvnw.cmd
├── pom.xml
└── README.md
In the above file structure, you can find:
When all the files are in place, the team will move to the next phase of the development process, where they will leverage Maven’s dependency management ability. This is an important part of the project as it will include additional libraries and frameworks required for implementing particular features. It is crucial to note that dependencies like Spring Boot started dependencies will be declared in pom.xml. Here, Maven resolves and downloads these dependencies from remote repositories, ensuring consistent versions and resolving transitive dependencies automatically.
Below is the pom.xml file that shows how you will declare dependencies for a Spring Boot application:
<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>my-spring-boot-app</artifactId>
<version>0.0.1-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.6.2</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Other dependencies -->
</dependencies>
</project>
Maven will run the build process, and the service will undergo various Maven lifecycle phases. In the compile phase, it will compile the Java source code (src/main/java)into bytecode (target/classes). However, you have to ensure the correctness of the syntax. As we have learned above, the compilation phase is handled by the compile goal of the maven-compiler-plugin. Below is how you will configure the plugin in the pom.xml to compile your source code:
<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>
Next, in the test phase, Maven will run a unit test (src/test/java). It will validate the functionality of the REST endpoint. Following this, in the package phase, all the compiled classes and resources will be packed into deployable artifacts like JAR or WAR files.
Maven runs integration tests (src/test/java) during the integration test phase, verifying the behavior of the entire application in a runtime environment. Further, it will perform additional verification (verify phase) and install the artifact (install phase) into the local repository for reuse in other projects or environments.
In the above section, we learned that the testing phase is handled by the maven-surefire-plugin and maven-failsafe-plugin for unit and integration tests.
For unit tests, the configuration for the plugin will look as shown in the code below.
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.0.0-M5</version>
<configuration>
<includes>
<include>**/Test*.java</include>
<include>**/*Test.java</include>
<include>**/*Tests.java</include>
</includes>
</configuration>
</plugin>
</plugins>
</build>
For integration tests, the configuration for the plugin will look as shown in the code below.
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-failsafe-plugin</artifactId>
<version>3.0.0-M5</version>
<executions>
<execution>
<id>integration-test</id>
<goals>
<goal>integration-test</goal>
</goals>
</execution>
<execution>
<id>verify</id>
<goals>
<goal>verify</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
During development, you will enhance productivity using Maven plugins like the Spring Boot Maven plugin. It will simplify tasks like packaging the application into an executable JAR file and running it locally for testing purposes. Additionally, they integrate Maven builds with their CI/CD pipeline, ensuring that each code change triggers an automated build and test cycle, providing rapid feedback to developers.
In the final stage, you will deploy the packaged artifact to the staging environment for further testing and validation using Maven's deployment capabilities. Maven's deployment phase facilitates the seamless application distribution to remote or artifact repositories, streamlining the deployment process.
With the example above, we hope you understand how to implement the required dependencies to your Maven project to speed up your development process.
Here are some additional tips to troubleshoot the issue encountered during the Maven lifecycle.
Following are some of the best practices for managing the Maven lifecycle effectively.
Understanding the Maven build lifecycle is crucial for effective project management in software development. By comprehending and customizing these lifecycles, you gain exceptional project control, resulting in streamlined and well-organized development processes.
Maven's default plugins and Maven lifecycles simplify the execution of building tasks. All lifecycle configurations are maintained in the pom.xml, ensuring consistency and structured project implementation. Through the configuration file, users can set goals at the initial stage without needing frequent modifications in the configuration file.
Throughout the Maven lifecycle, goals bound to phases enable the execution of specific tasks. Maximizing Maven's lifecycles and goals empowers project management, facilitating software project delivery effortlessly.
On this page
Did you find this page helpful?
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!