Maven Goals and Phases

1. Overview

In this tutorial, we’ll explore different Maven build lifecycles and their phases.

We’ll also discuss the core relation between Goals and Phases.

2. Maven Build Lifecycle 

The Maven build follows a specific lifecycle to deploy and distribute the target project.

There are three built-in lifecycles:

• default: the main lifecycle, as it’s responsible for project deployment
• clean: to clean the project and remove all files generated by the previous build
• site: to create the project’s site documentation

Each lifecycle consists of a sequence of phases. The default build lifecycle consists of 23 phases, as it’s the main build lifecycle.

On the other hand, the clean life cycle consists of 3 phases, while the site lifecycle is made up of 4 phases.

3. Maven Phase

A Maven phase represents a stage in the Maven build lifecycle. Each phase is responsible for a specific task.

Here are some of the most important phases in the default build lifecycle:

• validate: check if all information necessary for the build is available
• compile: compile the source code
• test-compile: compile the test source code
• test: run unit tests
• package: package compiled source code into the distributable format (jar, war, …)
• integration-test: process and deploy the package if needed to run integration tests
• install: install the package to a local repository
• deploy: copy the package to the remote repository

For the full list of each lifecycle’s phases, check out the Maven Reference.

Phases are executed in a specific order. This means that if we run a specific phase using the command:

mvn <PHASE>

It won’t only execute the specified phase, but all the preceding phases as well.

For example, if we run the deploy phase, which is the last phase in the default build lifecycle, it’ll execute all the phases before the deploy phase as well, which is the entire default lifecycle:

mvn deploy

4. Maven Goal 

Each phase is a sequence of goals, and each goal is responsible for a specific task.

When we run a phase, all goals bound to this phase are executed in order.

Here are some of the phases and default goals bound to them:

• compiler:compile – the compile goal from the compiler plugin is bound to the compile phase
• compiler:testCompile is bound to the test-compile phase
• surefire:test is bound to the test phase
• install:install is bound to the install phase
• jar:jar and war:war is bound to the package phase

We can list all goals bound to a specific phase and their plugins using the command:

mvn help:describe -Dcmd=PHASENAME

For example, to list all goals bound to the compile phase, we can run:

mvn help:describe -Dcmd=compile

Then we’d get the sample output:

compile' is a phase corresponding to this plugin:
org.apache.maven.plugins:maven-compiler-plugin:3.1:compile

As mentioned above, this means the compile goal from the compiler plugin is bound to the compile phase.

5. Maven Plugin 

A Maven plugin is a group of goals; however, these goals aren’t necessarily all bound to the same phase.

For example, here’s a simple configuration of the Maven Failsafe plugin, which is responsible for running integration tests:

<build>
    <plugins>
        <plugin>
            <artifactId>maven-failsafe-plugin</artifactId>
            <version>${maven.failsafe.version}</version>
            <executions>
                <execution>
                    <goals>
                        <goal>integration-test</goal>
                        <goal>verify</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

As we can see, the Failsafe plugin has two main goals configured here:

• integration-test: run integration tests
• verify: verify all integration tests passed

We can use the following command to list all goals in a specific plugin:

mvn <PLUGIN>:help

For example, to list all goals in the Failsafe plugin, we can run:

mvn failsafe:help

And the output will be:

This plugin has 3 goals:

failsafe:help
  Display help information on maven-failsafe-plugin.
  Call mvn failsafe:help -Ddetail=true -Dgoal=<goal-name> to display parameter
  details.

failsafe:integration-test
  Run integration tests using Surefire.

failsafe:verify
  Verify integration tests ran using Surefire.

To run a specific goal without executing its entire phase (and the preceding phases), we can use the command:

mvn <PLUGIN>:<GOAL>

For example, to run the integration-test goal from the Failsafe plugin, we need to run:

mvn failsafe:integration-test

6. Building a Maven Project

To build a Maven project, we need to execute one of the lifecycles by running one of their phases:

mvn deploy

This will execute the entire default lifecycle. Alternatively, we can stop at the install phase:

mvn install

But usually, we’ll clean the project first by running the clean lifecycle before the new build:

mvn clean install

We can also run only a specific goal of the plugin:

mvn compiler:compile

Note that if we try to build a Maven project without specifying a phase or goal, we’ll get an error:

[ERROR] No goals have been specified for this build. You must specify a valid lifecycle phase or a goal

7. Conclusion

In this article, we discussed Maven build lifecycles, as well as the relation between Maven phases and goals.