Maven Core Practice Guide: From Underlying Logic to High-Frequency Commands Summary

In the Java backend development ecosystem, Maven remains the undisputed king of build tools. Although Gradle is close behind, Maven, with its stability of "convention over configuration" and extremely mature dependency management mechanism, is still the first choice for enterprise-level projects.

This article summarizes the Maven commands and core logic I use most frequently in actual production environments, aiming to help developers manage project lifecycles more efficiently.

---

1. Build Lifecycle

Maven's power lies in its standardized build process. Every command you execute actually triggers a specific phase in the lifecycle.

Phase	Description	Practical Use
clean	Deletes the target directory	Cleans old compilation caches, solves "code not taking effect due to caching" issues
compile	Compiles source code	Checks for syntax errors, generates .class files
test	Runs unit tests	Ensures logic changes do not break existing functionality
package	Packages (JAR/WAR)	Generates deployable artifact products
install	Installs to local repository	Allows other local modules to reference this component via GAV coordinates
deploy	Pushes to remote private repository	Allows team members or production pipelines to pull the latest version

---

2. Basic Build

This is the most frequently used combination during development. It is recommended to get into the habit of cleaning before packaging to ensure a clean artifact.

# Clean and package, skip unit tests (most common combination for development, deployment)
mvn clean package -DskipTests

# Clean and install to local repository (essential for local multi-module collaborative development)
mvn clean install

# Build with a specified Profile (e.g., switching configuration files for dev/test/prod)
mvn clean package -Pprod

Maven Core Practice Guide: From Underlying Logic to High-Frequency Commands Summary

In the Java backend development ecosystem, Maven remains the undisputed king of build tools. Although Gradle is close behind, Maven, with its stability of "convention over configuration" and extremely mature dependency management mechanism, is still the first choice for enterprise-level projects.

This article summarizes the Maven commands and core logic I use most frequently in actual production environments, aiming to help developers manage project lifecycles more efficiently.

---

3. Dependency Troubleshooting

When facing Jar package conflicts such as NoSuchMethodError or ClassNotFoundException, this set of commands is your lifesaver.

# View the complete dependency tree (the most intuitive tool for troubleshooting conflicts)
mvn dependency:tree

# Fuzzy search the introduction path of a specific dependency (quickly locate which parent package brought in this dependency)
mvn dependency:tree -Dverbose -Dincludes=com.fasterxml.jackson.*

# Analyze project dependencies (find "invisible" dependencies that are introduced but unused, or used but not explicitly declared)
mvn dependency:analyze

---

4. Advanced Tips for Production Environment

These are "black magic" commands optimized for multi-module projects and CI/CD pipelines.

# Force update packages from remote Snapshot repository (solves the problem of remote packages being updated but not refreshed locally)
mvn clean compile -U

# Targeted build: only build specified modules and their upstream dependencies (significantly shortens build time for large projects)
# -pl (project list): Specify module name
# -am (also make): Also build modules that it depends on
mvn clean install -pl bitleaf-service -am

# View the complete effective POM for the current project (the final form after merging all Parents and default configurations)
mvn help:effective-pom

# Print the status of currently active profiles (confirm which environment's configuration is loaded)
mvn help:active-profiles

---

5. Architect-Level POM Optimization Suggestions

1. Unified Version Management: Consolidate all third-party library version numbers into the <properties> tag of the root POM, strictly forbidding hardcoding version numbers in sub-modules.
2. Dependency Convergence: Endeavor to use <dependencyManagement> in the parent POM to coordinate versions. Sub-modules should only be responsible for introducing dependencies without specifying version numbers, ensuring consistent dependencies across the entire project and avoiding Jar package conflicts.
3. Scope Optimization:
   • Lombok / MapStruct: Mark as <scope>provided</scope> (only needed during compilation, not included in the package).
   • MySQL Driver: Mark as <scope>runtime</scope> (not needed during compilation, needed at runtime).
   • JUnit / Mockito: Mark as <scope>test</scope> (only needed during testing). Properly setting Scope can effectively reduce the size of the final release package and speed up deployment.