maven.tar.gz

Maven is the de-facto build tool of choice for Java projects and has wide adoption at the enterprise level.

In this course, you will learn the fundamentals of Maven so that you can start to inject build automation into your own projects. You’ll start by exploring the basics such as plugins, goals, coordinates, and lifecycles.

In the latter half, you will dive into more advanced concepts such as dependencies, inheritance, aggregation, and build profiles. 

By the end of this course, you will have just the right amount of knowledge for you to quickly become productive when working with Maven.

Build Java Projects with Maven

Maven at its heart is a plugin execution framework. It can get new capabilities by including plugins and leveraging their goals. This opens up Maven for constant innovation and enables it to address new use cases as they come up. There are two kinds of plugins:

1. **Build Plugins**: These plugins run during build and are configured in the `<build>` element.

2. **Reporting Plugins**: These plugins run during site generation and are configured in the `<reporting>` element.

For this course, we'll be discussing only the build plugins since they are the most commonly used. Additionally, once you get the hang of build plugins, you should be able to work your way around reporting plugins.
Some of the important plugins are listed [here](https://maven.apache.org/plugins/index.html) on the official Maven documentation and worth a cursory look. 

A plugin is identified by an artifactId, groupId, and a version. When we execute a maven command in the format `mvn <phase>`, plugin goals tied to the phase are executed. But we can also invoke a particular plugin goal individually using one of the following commands:

1. **groupId:artifactId:version:goal** e.g., `mvn org.apache.maven.plugins:maven-clean-plugin:2.5:clean`

2. **groupId:artifactId:goal** e.g., `mvn org.apache.maven.plugins:maven-clean-plugin:clean`

3. **prefix:goal** e.g., `mvn clean:clean`. We don't cover prefixes for plugins in this course, but you can think of a prefix as an easy-to-type alias for a long-winded plugin name.

A plugin goal is nothing but some coded logic that executes when the goal is invoked. In Maven parlance, a goal is called a **Maven plain Old Java Object** or **Mojo**. Each mojo is an executable goal in Maven, and a plugin is a distribution of one or more related mojos. We won't dive into plugin development in this course, but we'll study how to configure and run plugins.

Let's look at the example of the `maven-clean-plugin`. It has only two goals (or mojos), `clean` and `help`. The code for the `clean` goal appears [here](https://github.com/apache/maven-clean-plugin/blob/master/src/main/java/org/apache/maven/plugins/clean/CleanMojo.java) and is reproduced below for easy reference.


This lesson explains the use of plugins in the Maven ecosystem.

Theory

Working with Plugins