maven

Validate the project structure: download metadata, parse `pom.xml`, sanity-check dependencies.

-N only the root reactor (no submodules); -f <pom> use alternate POM; -P<profile> enable profile

Compile the project's main `src/main/java` into `target/classes`. Uses the configured JDK and `maven-compiler-plugin`.

-DskipTests; -T 4 parallel build threads; -q quiet

Run unit tests (Surefire) against compiled main + test sources. Skips `failsafe` (integration tests) — use `mvn verify` for that.

-Dtest=ClassName; -Dtest=Class#method; -DfailIfNoTests=false; -Dsurefire.useFile=false

Run every prior phase, then package the compiled output into a JAR / WAR / EAR under `target/`.

-DskipTests; -Dpackaging=jar

Run package plus integration tests (Failsafe), then verify everything is shippable. Does **not** install or deploy.

-DskipITs; -DskipTests

Run verify, then copy the produced artifact into the local Maven repository (`~/.m2/repository`) so other local projects can depend on it.

Build and push the artifact to the remote repository declared in `pom.xml`'s `<distributionManagement>` (Nexus / Artifactory / Maven Central via Sonatype).

-DskipTests; -P release use release profile

Delete the `target/` directory to start from a fresh state.

Wipe `target/` then run through `install`. The most common "rebuild from scratch" command.

-U force-update of snapshot dependencies

Print the resolved dependency tree (with conflict resolution) — invaluable for chasing `NoSuchMethodError` from version skew.

-Dincludes=<groupId>[:<artifactId>[:<version>]]; -Dverbose

Resolve every dependency into the local repo without executing the lifecycle.

Compare declared `<dependencies>` against actual `import` / `package` usage; flags unused / undeclared deps.

List every resolved dependency in the build as plain `groupId:artifactId:type:version` lines.

List every dependency that has a newer version available in the configured repositories.

Run a goal against one or more specific submodules by artifact ID (comma-separated).

-am also build the modules the target depends on

Build the named module plus every module it depends on. `-amd` (also-make-dependents) is the inverse.

Parallel reactor: `-T 4` uses 4 threads; `-T 1C` uses 1 thread per CPU core. Speeds up multi-module builds.

Print the final merged POM (super-POM + parent POM + active profiles + current settings) to a single file — the source of truth at build time.

-Doutput=<file>

Print merged `~/.m2/settings.xml` + global + CLI-`--settings`. Useful for chasing mirror / credential resolution.

Override the user `settings.xml` for one build — handy for CI with mirrored repos.

Run a single plugin goal directly. Common: `compiler:compile`, `surefire:test`, `jar:jar`, `deploy:deploy`, `dependency:tree`.

-D<param>=<value> goal parameter; -X debug (very verbose)

Show every goal and parameter of a plugin. Substitute `<id>` with the `groupId:artifactId`.

Activate one or more profiles declared under `<profiles>` in `pom.xml` or `settings.xml`.

Deactivate a profile that would otherwise be active by default.

Enable debug logging — prints every plugin execution, repository lookup, and download URL. Pipe to file.

-e full stack traces on errors

Print full stack traces on any failure. Combine with `-X` for maximum detail.

Start the build with the JVM suspended on a JDWP socket (default port 8000) so you can attach a debugger at line 1 of the Maven JVM.

Run a build through the Maven Wrapper — uses the Maven version pinned in `.mvn/wrapper/maven-wrapper.properties`. Always check in the wrapper.

-Dmaven.version=<ver> upgrade Maven for this run

Generate / refresh the Maven Wrapper files (`mvnw`, `mvnw.cmd`, `.mvn/wrapper/*`).

-Dmaven=<version> pin the Maven distribution version

Print Maven version, JDK, OS, and locale.

List every CLI flag and supported property.

Batch / non-interactive mode — disables interactive prompts and color output. Use in CI to avoid hanging on a missing property.

Disable the new transfer-progress bar (recommended in CI; reduces log noise and avoids CPU spikes on slow mirrors).

Offline mode — never call out to remote repositories. Fails fast if a required artifact isn't in the local repo.