Plugins & Goals

The <configuration> block sets a plugin's parameters in the pom.xml. Each child element name matches a plugin parameter (for example <source>17</source> for the compiler), and Maven injects those values into the plugin Mojo when it runs.

Core build plugins handle the standard build steps: clean removes target/, resources copies non-code files, jar packages a JAR, install copies the artifact to the local repository, and deploy uploads it to a remote repository.

A Maven plugin is a bundle of related tasks. Each task is a 'goal', implemented by a class called a mojo. You run a goal like mvn compiler:compile, where compiler is the plugin and compile is the goal.

A Mojo is the Java class behind one Maven goal. You extend AbstractMojo, annotate the class with @Mojo(name = "..."), implement execute(), and package it as a maven-plugin artifact so Maven can run it.

You annotate fields with @Parameter. Users set them in the plugin's <configuration> block in the POM using the field name as the XML element, or via -D using the parameter's property name.

<source>/<target> set the language level and bytecode version separately. <release> sets both at once AND links against that JDK's API, preventing accidental use of newer APIs. Prefer <release>.

An <execution> binds a plugin's goal(s) to a lifecycle phase. <id> names it, <phase> says when it runs, <goals> lists which goals to run, and an execution-scoped <configuration> sets parameters only for that execution.

The packaging type selects a default set of goal-to-phase bindings. For example jar binds jar:jar at package, while pom binds almost nothing and war binds war:war instead.

A plugin is identified by coordinates groupId:artifactId:version, just like a dependency. The groupId org.apache.maven.plugins is the default Maven assumes for core plugins, so you can sometimes omit it.

<pluginManagement> declares plugin versions and default config in a parent POM without actually enabling the plugin. Child modules that list the plugin (by groupId/artifactId, no version) inherit the pinned version and config, giving consistent, reproducible builds.

The plugin ships a descriptor file, META-INF/maven/plugin.xml, generated from your @Mojo/@Parameter annotations by the maven-plugin-plugin. To bind a goal to a phase, set defaultPhase on @Mojo or add an <execution> with a <phase> in the consumer POM.

-parameters tells javac to keep real method parameter names in the bytecode. Without it, names become arg0, arg1. Frameworks like Spring MVC and JPA queries use them via reflection.

The -proc flag controls whether javac runs annotation processing. proc:none compiles without running any processors; proc:only runs processors but skips compilation. Disable processing to speed builds or avoid unwanted code generation.

Plugin-level <configuration> applies to all the plugin's goals/executions and to direct CLI calls; execution-scoped config applies only to that execution. The <inherited>false</inherited> flag stops a plugin or execution from being inherited by child modules.

maven-resources-plugin copies files from src/main/resources into target/classes. With filtering enabled, it replaces ${...} placeholders in those files with property values during the copy.

Extensions are add-ons that plug into Maven's core to add capabilities like new packaging types, lifecycles, or transport protocols. Unlike plugins, which run goals during a build, extensions participate in how Maven itself works.

Set parameters in the plugin's <configuration> block. To run goals at build time, add <executions>: each <execution> lists <goals>, an optional <phase>, an <id>, and its own <configuration>. Multiple executions = multiple runs.

Unit tests check the Mojo class in isolation, but integration tests run the plugin inside a real Maven build. The maven-invoker-plugin executes small sample projects under src/it/, runs goals against your freshly-installed plugin, and verifies the results.

It tells Maven to resolve the project's dependencies (for a given scope) before running the Mojo, so the Mojo can read the resolved artifacts/classpath. You need it whenever your goal inspects or uses the project's dependencies.

Use <annotationProcessorPaths> to list processor artifacts (like Lombok or MapStruct) separately from your project dependencies. This keeps processors off the runtime/compile classpath while still running them during compilation.

By default Maven merges inherited and child plugin config, appending list items. The combine.children attribute controls list merging (merge vs append), and combine.self controls whether the child element merges with, overrides, or removes the parent's element.

deploy uploads the artifact and POM to a remote repository. SNAPSHOT versions go to the snapshots repo and can be re-deployed (overwritten with timestamps); release versions go to the releases repo and are immutable.

An extension ships component metadata that registers a new <packaging> value and maps which plugin goals run in each lifecycle phase. You then set extensions=true on the plugin and use that packaging.

A wagon is Maven's transport provider for talking to a repository over a given protocol (http, scp, ftp). To use a protocol Maven doesn't ship, you add the matching wagon as a build/core extension so the protocol's URLs resolve.

Maven looks up the prefix in maven-metadata.xml files stored under each configured plugin group in the repositories. That metadata maps a prefix (e.g. help) to a plugin artifactId, so prefix:goal can be resolved to a real plugin.

If you don't pin core plugin versions, Maven picks defaults that can change between Maven releases, making builds non-reproducible. Pin them in <pluginManagement> in a parent POM so every module uses the same versions.

maven-site-plugin generates a static HTML website for a project, including reports like javadoc, test results, and dependency info. It runs on the separate site lifecycle via mvn site.

Polyglot Maven lets you write the build model in formats other than XML — like YAML, Groovy, Kotlin, or Atom — instead of pom.xml. It works by installing a core extension that parses the alternative format.

Set <fork>true</fork> to run javac in a separate JVM, then size it with <meminitial> and <maxmem> for big modules. Incremental compilation (the default) only recompiles changed/stale classes instead of everything.