Are you often puzzled by Maven’s lifecycle, with its talk of “phases” and “goals”? You’re not alone. While these concepts are fundamental, in your daily development, you interact with Maven by running specific commands like mvn package or mvn install. What truly happens when you execute these commands? Maven quietly orchestrates a series of predefined phases to achieve your desired outcome.

This article will guide you through the Maven lifecycle by focusing on the actual commands you use, explaining precisely what each one triggers.

The Core Maven Lifecycles

Maven operates primarily with three distinct lifecycles:

• Default Lifecycle: This is the main build lifecycle, encompassing everything from compiling your code to packaging and deploying your artifacts.
• Clean Lifecycle: As its name suggests, this lifecycle is dedicated to cleaning up your project, typically by deleting the target/ directory to ensure a fresh build.
• Site Lifecycle: This lifecycle is responsible for generating project documentation and reports.

A crucial concept to grasp is that when you execute a command like mvn package, Maven doesn’t just run the package phase in isolation. Instead, it executes all the phases in the default lifecycle that precede package, in their correct, sequential order.

Maven Commands and Their Lifecycle Journeys

Let’s break down the common mvn commands and the sequence of phases they invoke:

1. mvn validate

• Executes: Only the validate phase.
• Purpose: Ensures your project’s structure and its pom.xml file are correct and valid.

2. mvn compile

• Executes: validate, initialize, generate-sources, process-sources, generate-resources, process-resources, compile.
• Purpose: Compiles your main application’s source code, placing the compiled classes into the target/classes directory.

3. mvn test-compile

• Executes: All phases up to compile, plus process-classes, generate-test-sources, process-test-sources, generate-test-resources, process-test-resources, test-compile.
• Purpose: Compiles your test source code, outputting it to target/test-classes.

4. mvn test

• Executes: All phases up to test-compile, plus process-test-classes, test.
• Purpose: Runs your project’s unit tests (e.g., using JUnit or TestNG).

5. mvn package

• Executes: All phases up to test, plus prepare-package, package.
• Purpose: Takes the compiled code and packages it into a distributable format, such as a JAR, WAR, or EAR file, found in the target/ directory.

6. mvn verify

• Executes: All phases up to package, plus pre-integration-test, integration-test, post-integration-test, verify.
• Purpose: Runs integration tests and performs any checks to ensure the quality and correctness of the packaged artifact.

7. mvn install

• Executes: All phases up to verify, plus install.
• Purpose: Places the project’s artifact into your local Maven repository (typically located at ~/.m2/repository), making it available for other local projects.

8. mvn deploy

• Executes: All phases up to install, plus deploy.
• Purpose: Uploads the final artifact to a remote repository (like Nexus or Artifactory), making it accessible to other developers and build systems.

Clean and Site Lifecycle Commands

Beyond the default build process, Maven provides commands for cleaning and documentation:

• mvn clean
  • Executes: pre-clean, clean, post-clean.
  • Purpose: Deletes the target/ directory, ensuring that your next build starts from a clean slate.
• mvn site
  • Executes: pre-site, site, post-site, site-deploy.
  • Purpose: Generates a comprehensive project documentation website, usually placed in target/site.

Key Takeaway

The fundamental principle to remember is this: when you run mvn <phase>, Maven doesn’t just execute that single phase. Instead, it systematically runs every preceding phase within that lifecycle, leading up to and including the phase you specified. This implicit execution is why a command like mvn install performs compilation, testing, and packaging before finally installing the artifact.

Understanding this sequential flow empowers you to better anticipate Maven’s behavior, troubleshoot build issues more effectively, and confidently manage your Java projects.