Maven is a standard tool for Java project management and construction. The answer lies in the fact that it can standardize the project structure, dependency management, build lifecycle automation and plug-in extensions through pom.xml; 1. Use pom.xml to define groupId, artifactId, version and dependencies; 2. Master core commands such as mvn clean, compile, test, package, install and deploy; 3. Use dependencyManagement and exclusions to manage dependency versions and conflicts; 4. Organize large applications through a multi-module project structure and manage them uniformly by the parent POM; 5. Configure compiler, surefire and other plug-ins to customize build behavior; 6. Follow best practices such as using semantic versions, avoid SNAPSHOT, enable parallel builds, and use Maven Wrapper Ensure environmental consistency and ultimately achieve a repeatable, maintainable, and efficient construction process for teamwork.

Maven isn't just a build tool—it's a project management and comprehension tool that brings consistency, automation, and structure to Java development. If you're building Java applications, especially in teams or across multiple projects, Maven helps standardize how you build, test, package, and deploy your code. Here's a practical guide to using Maven effectively as a developer.

Why Use Maven?

Before diving into how it works, understand why Maven matters:

• Standardized project structure : Everyone on your team knows where source files, resources, and tests live.
• Dependency management : No more manually downloading JARs. Maven pulls them from repositories (like Maven Central).
• Build lifecycle : Compile, test, package, and deploy with consistent commands.
• Plugins ecosystem : Extend functionality for code coverage, documentation, Docker builds, etc.
• Reproducible builds : With a pom.xml , anyone can rebuild your project the same way.

Maven removes guesswork. That's its real power.

Understanding the POM (Project Object Model)

The heart of every Maven project is the pom.xml file. It defines everything about your project: metadata, dependencies, plugins, profiles, and more.

Here's a minimum example:

 <project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

Key elements:

• groupId : Your organization or project namespace.
• artifactId : Name of your project.
• version : Version number (follow semantic versioning).
• dependencies : Libraries your project needs.
• properties : Define reusable values like Java version.

? Pro tip: Use http://ipnx.cn/link/9c6ebba8ac5389aed2beda98d31e91af to search for dependency coordinates quickly.

Core Maven Commands Every Developer Should Know

You don't need to memorize dozens of goals—just a handful of key commands.

Common combo:

 mvn clean install

This wipes old builds, compiles, runs tests, packages, and installs the artifact locally—perfect for integration or CI pipelines.

?? If tests fail, install stops. Use mvn install -DskipTests to bypass (but don't overuse it).

Managing Dependencies Like a Pro

Maven handles transitive dependencies automatically. If you add Spring Web, it pulls in Jackson, Spring Core, etc.—no need to declare them all.

But this can lead to conflicts. Here's how to manage:

1. Dependency Scope

Use scopes to control when a dependency is available:

• compile (default): Available in all phases.
• test : Only for testing (eg, JUnit).
• provided : Expected to be provided by runtime (eg, Servlet API in Tomcat).
• runtime : Needed at runtime but not compile time (eg, JDBC driver).
• system / import : Rare; use with caution.

2. Excluding Transitive Dependencies

If a library pulls in an outdated or conflicting dependency:

 <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.3.0</version>
    <exclusions>
        <exclusion>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

3. Dependency Management

Use <dependencyManagement> in parent POMs to centralize versions across modules:

 <dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.21</version>
        </dependency>
    </dependencies>
</dependencyManagement>

Now child modules can include spring-core without specifying version.

Multi-Module Projects Made Simple

For larger applications (eg, API, service layer, domain models), break your app into modules.

Structure:

 parent-project/
├── pom.xml (packaging: pom)
├── api/
│ └── pom.xml
├── service/
│ └── pom.xml
└── persistence/
    └── pom.xml

Parent pom.xml :

 <packaging>pom</packaging>
<modules>
    <module>api</module>
    <module>service</module>
    <module>persistence</module>
</modules>

Each submodule can depend on another:

 <dependency>
    <groupId>com.example</groupId>
    <artifactId>persistence</artifactId>
    <version>1.0.0</version>
</dependency>

Run mvn clean install from the parent, and Maven builds modules in the correct order.

Customizing Builds with Plugins

Maven plugins perform tasks like compiling, testing, or generating code.

Common examples:

• Compiler Plugin : Set Java version

   <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.11.0</version>
      <configuration>
          <source>11</source>
          <target>11</target>
      </configuration>
  </plugin>

• Surefire Plugin : Control test execution

   <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-surefire-plugin</artifactId>
      <version>3.1.2</version>
      <configuration>
          <includes>
              <include>**/*Test.java</include>
          </includes>
      </configuration>
  </plugin>

• JAR Plugin : Customize manifest

   <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <version>3.3.0</version>
      <configuration>
          <archive>
              <manifest>
                  <addClasspath>true</addClasspath>
                  <mainClass>com.example.MainApp</mainClass>
              </manifest>
          </archive>
      </configuration>
  </plugin>

You can even run shell scripts or Docker builds via plugins like exec-maven-plugin or spotify/dockerfile-maven-plugin .

Best Practices for Real-World Use

• ? Use a consistent versioning scheme (eg, semantic versioning).
• ? Keep pom.xml clean —avoid hardcoding versions; use <dependencyManagement> .
• ? Leverage parent POMs (like Spring Boot's spring-boot-starter-parent ) to inherit sensitive defaults.
• ? Enable parallel builds in multi-module projects: mvn -T 4 clean install
• ? Use profiles for environment-specific configs (dev, prod, test).
• ? Don't commit target/ directories—add to .gitignore .
• ? Avoid SNAPSHOT versions in production.

Also consider using Maven Wrapper ( mvnw ) so teammates don't need Maven pre-installed:

 ./mvnw clean install

It downloads Maven automatically if missing.

Final Thoughts

Maven has been around for years—and for good reason. It's stable, widely supported, and deeply integrated into tools like IDEs (IntelliJ, Eclipse), CI/CD systems (Jenkins, GitHub Actions), and frameworks (Spring, Jakarta EE).

You don't need to master every detail upfront. Start with:

• Writing a solid pom.xml
• Running basic lifecycle commands
• Managing dependencies properly

From there, grow into multi-module settings, custom plugins, and automation.

Basically, if you're doing Java, Maven should be in your toolkit.

The above is the detailed content of A Developer's Guide to Maven for Java Project Management. For more information, please follow other related articles on the PHP Chinese website!