Parth Agarwal — Software Engineer | Full Stack Developer Portfolio

Maven Cheat SheetQuick Reference

mvn --versionmvn -X (debug)mvn -U (force update)

Core Concepts

POM — Project Object Model, heart of Maven

GAV — groupId · artifactId · version (unique ID)

Local Repo ~/.m2/repository/

Central Repo — public Maven Central

Remote Repo — Nexus / Artifactory

Resolution order: Local → Custom Remote (pom order) → Central

Directory Layout

src/main/java ← source code

src/main/resources ← config files

src/test/java ← test code

target/ ← .class + .jar output

pom.xml ← project config

pom.xml Structure

<groupId>com.company</>

<version>1.0-SNAPSHOT</>

<properties> ← versions, encoding

<dependencyManagement> ← version table

<dependencies> ← actual includes

<build><plugins> ← plugins config

<profiles> ← env variants

<repositories> ← remote repos

</project>

POM Types

Type	Purpose
Super POM	Maven default; all projects inherit it
Parent POM	Shares config across modules; enforces versions
BOM	Version lookup table only; imported via scope=import
Effective POM	Final merged result (project + parent + BOM + super)

Key diff: Parent POM enforces versions; BOM suggests them. A project can have only 1 parent but multiple BOMs.

Build Lifecycle

3 Lifecycles:

cleandefaultsite

Default lifecycle phases (sequential):

1validateCheck project & info

2compile.java → .class

3testRun unit tests (Surefire)

4packageCreate JAR/WAR

5verifyRun integration tests

6installCopy to ~/.m2

7deployPush to remote repo

⚠ Phases run sequentially — can't skip earlier ones. mvn package runs 1→4.

Common Commands

Command	Action
mvn clean	Delete /target
mvn compile	Compile src
mvn test	Run unit tests
mvn package	Build JAR/WAR
mvn install	Install to local repo
mvn deploy	Deploy to remote
mvn clean install	Full clean build
mvn clean install -U	Force dependency update
mvn -DskipTests	Skip test execution (compile only)
mvn -Dmaven.test.skip=true	Skip compile + execution
mvn dependency:tree	Show dep tree
mvn -P prod	Activate profile
mvn spring-boot:run	Run Spring Boot app
mvn exec:java	Run Java program
mvn site	Generate project site

Phase → Plugin → Goal

Phase — lifecycle stage

Goal — plugin task, format: plugin:goal

Phase	Plugin : Goal bound by default
process-resources	resources:resources
compile	compiler:compile
process-test-resources	resources:testResources
test-compile	compiler:testCompile
test	surefire:test
package	jar:jar (or war:war)
verify	failsafe:verify
install	install:install
deploy	deploy:deploy
clean	clean:clean

Goals can be run directly, bypassing the lifecycle:
mvn compiler:compile (no validate/initialize first)

One phase can have multiple goals bound to it (executed in declaration order).

Dependency Scopes

Scope	Compile	Runtime	Test	In JAR?
compile (default)	✓	✓	✓	✓
provided	✓	✗	✓	✗
runtime	✗	✓	✓	✓
test	✗	✗	✓	✗

provided: Tomcat supplies servlet-api. runtime: JDBC drivers.

Dependency Resolution

Nearest-Wins Rule:

Your POM (L1): dep v2.0 ← wins

L2 dep needs: v1.0 ← wins over L3

L3 dep needs: v1.1 ← loses

Force a version (override Nearest):

Option A — Exclusions:

</exclusion></exclusions>

Option B — dependencyManagement in Parent POM

Version conflicts? Delete ~/.m2 or run mvn clean install -U

Plugins · Goals · Phases

maven-compiler-plugincompile · test-compile

Goal	Phase	Does	Direct cmd
compiler:compile	compile	Compiles src/main/java	mvn compiler:compile
compiler:testCompile	test-compile	Compiles src/test/java	mvn compiler:testCompile

</configuration>

maven-surefire-plugintest

Goal	Phase	Does	Direct cmd
surefire:test	test	Runs JUnit / TestNG unit tests, generates XML/txt reports in target/surefire-reports	mvn surefire:test

← parallel execution config:

<parallel>methods</> <threadCount>10</>

maven-failsafe-pluginintegration-test · verify

Goal	Phase	Does	Direct cmd
failsafe:integration-test	integration-test	Runs *IT.java tests	mvn failsafe:integration-test
failsafe:verify	verify	Checks if IT tests passed; fails build here (not mid-test)	mvn failsafe:verify

⚠ Always need both goals. Run with mvn verify

Packaging pluginspackage

Plugin : Goal	Phase	Output	Direct cmd
jar:jar	package	Thin JAR (no deps)	mvn jar:jar
shade:shade	package	Fat/Uber JAR (all deps merged)	mvn package
assembly:single	package	Custom zip/tar/dir distribution	mvn assembly:single
war:war	package	WAR file (web apps)	mvn war:war

maven-dependency-pluginno default phase

Goal	Does	Direct cmd
dependency:tree	Print full dependency tree	mvn dependency:tree
dependency:analyze	Find unused/undeclared deps	mvn dependency:analyze
dependency:copy-dependencies	Copy all dep JARs to a folder	mvn dependency:copy-dependencies
dependency:unpack	Extract a dep's contents	mvn dependency:unpack

spring-boot-maven-pluginpackage / no default

Goal	Phase	Does	Direct cmd
spring-boot:repackage	package	Rewraps JAR into executable fat JAR	mvn package
spring-boot:run	—	Start app without building JAR	mvn spring-boot:run
spring-boot:build-image	—	Build OCI/Docker image (Buildpacks)	mvn spring-boot:build-image

Plugin : Goal	Phase	Does	Direct cmd
exec:java	—	Run main() class directly	mvn exec:java
exec:exec	—	Run any shell command	mvn exec:exec
clean:clean	clean	Delete /target dir	mvn clean:clean
install:install	install	Copy artifact to ~/.m2	mvn install:install
deploy:deploy	deploy	Push artifact to remote repo	mvn deploy:deploy
release:prepare	—	Strip -SNAPSHOT, tag in Git	mvn release:prepare
release:perform	—	Build & deploy tagged release	mvn release:perform
versions:set	—	Update version in pom.xml	mvn versions:set -DnewVersion=2.0

Custom Goal→Phase Binding (executions):

← bind dependency:copy-dependencies to package phase:

<phase>package</phase>

<goals><goal>copy-dependencies</goal></goals>

</execution></executions>

Any goal can be re-bound to any phase using <executions>. Multiple executions of the same plugin are allowed.

Maven Profiles

Different config per environment (Dev/Test/Prod):

<db.url>jdbc:postgresql://...</>

</properties>

<activation><activeByDefault>false</></>

</profile></profiles>

mvn install -P prodmvn install -P dev

Also use profiles to conditionally skip tests.

Multi-Module Projects

Parent POM declares modules; children inherit config:

<module>service</module>

</modules>

BOM Import pattern:

<groupId>org.springframework.boot

<artifactId>spring-boot-dependencies

<scope>import</>

</dependency>

</dependencies></dependencyManagement>

1 parent max | multiple BOMs ok | prevents inheritance bloat

Maven + Git

⚠ Never deploy uncommitted code

Artifact must map to a specific Git commit for traceability & reproducibility.

Release Flow (maven-release-plugin):

1.1.0.0-SNAPSHOT → 1.0.0 (remove -SNAPSHOT)

2.Commit & tag: v1.0.0 in Git

3.Deploy final artifact to remote repo

4.Bump to 1.0.1-SNAPSHOT for next dev

.gitignore (always exclude):

target/

.idea/ .classpath .project

.m2/repository (if inside project)

SNAPSHOT = in-development | RELEASE = immutable artifact

settings.xml vs pom.xml

File	Controls
pom.xml	What project needs (deps, plugins, repos)
settings.xml	How Maven behaves (auth credentials, mirrors, local repo location, global repos)

Troubleshooting

Problem	Fix
Missing artifact	Verify GAV coords → mvn clean install -U
Version conflict	mvn dependency:tree → add exclusion or pin in depMgmt
Corrupt local cache	Delete ~/.m2/repository or run -U
Can't find artifact	Check company Nexus/Artifactory
Debug build	mvn -X for full stack trace
Test failures blocking	-DskipTests or use fast-build profile

Best Practices

✦Pin versions in <properties>, reference with ${var}

✦Use Parent POM for shared plugin config across modules

✦Use BOM for version consistency without inheritance

✦Remove unused deps → smaller JAR, faster build

✦Use <scope>test</scope> — keep test libs out of prod JAR

✦Commit before mvn deploy — ensure traceability

✦Use -SNAPSHOT for dev; release to remove it

Maven Build Automation · Standard Directory Layout · Convention over Configuration

mvn clean installmvn dependency:treemvn clean install -U