Master Maven: Why It’s Essential and How to Build Your First Java Project

Why Use Maven

1) A large project should be split into multiple modules (each module as a separate Maven project) to facilitate collaboration. 2) Manually copying JARs into each project's lib folder is error‑prone; Maven stores JARs in a central repository. 3) Maven downloads required JARs automatically, avoiding manual downloads. 4) Consistent JAR versions across projects prevent runtime errors. 5) Maven resolves transitive dependencies automatically.

What Is Maven

Maven is an automated build tool for the Java platform, succeeding Ant and preceding Gradle. It defines a build lifecycle that includes cleaning, compiling, testing, packaging, installing, and deploying.

Installing Maven

1) Ensure JAVA_HOME is set. 2) Download Maven and extract it to a path without spaces or non‑ASCII characters. 3) Add M2_HOME (the Maven root directory) and M2_HOME\bin to the system PATH. 4) Verify installation with mvn -v.

First Maven Project

Create the standard Maven directory layout:

project‑root/

├─ src/main/java/ (source code)

├─ src/main/resources/ (configuration files)

├─ src/test/java/ (test code)

├─ pom.xml (project descriptor)

Example Hello.java placed in src/main/java/com/hzg/maven:

package com.hzg.maven;

public class Hello {
    public String sayHello(String name) {
        return "Hello " + name + "!";
    }
}

Corresponding pom.xml (simplified):

<?xml version="1.0" encoding="UTF-8"?>
<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.hzg.maven</groupId>
    <artifactId>Hello</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

Common Maven Commands

mvn clean

– remove previous build output. mvn compile – compile main sources. mvn test-compile – compile test sources. mvn test – run unit tests. mvn package – package compiled code into a JAR/WAR. mvn install – install the artifact into the local repository.

All commands must be executed from the directory containing pom.xml.

Repository and Coordinates

The pom.xml file is the Project Object Model that defines a Maven project. Each artifact is uniquely identified by three coordinates: groupId, artifactId, and version. Maven stores artifacts in a local repository (default location C:\Users\<username>\.m2\repository) and can fetch missing artifacts from remote repositories such as Maven Central or a private Nexus server.

Dependencies

Maven resolves dependencies from the local repository first; if not found, it downloads them from remote repositories. For multi‑module projects, you must run mvn install on a dependent module before the dependent project can compile. Dependency scopes control where a dependency is available: compile – default, available in all phases. provided – available at compile and test time, not packaged. runtime – needed at runtime but not for compilation. test – only for testing. system – similar to provided but requires an explicit path.

Lifecycle

Maven defines three independent lifecycles:

Clean Lifecycle : pre-clean, clean, post-clean.

Default Lifecycle : phases from validate through deploy, including compile, test, package, install, etc.

Site Lifecycle : pre-site, site, post-site, site-deploy.

Each phase is bound to a plugin that performs the actual work.

Using Maven in Eclipse

Configure Maven in Eclipse via Window → Preferences → Maven → Installations to point to the extracted Maven directory, and set the settings.xml file to customize the local repository path. Create a Maven project through File → New → Maven Project, then adjust the Java Build Path, Project Facets, and add required libraries (e.g., Tomcat) as needed.

Advanced Dependency Features

Transitive dependencies are automatically included unless excluded. Maven resolves version conflicts using the “shortest path” rule; if paths are equal, the version declared first in the pom.xml wins. Centralized version management can be achieved with <properties> and referencing them via ${propertyName}.

Build Configuration

A typical <build> section defines the final artifact name, resource directories, includes/excludes, and plugins such as maven-compiler-plugin (setting source/target to 1.8) and maven-war-plugin (defining the WAR name).

After configuring the build, running mvn package generates the JAR/WAR in the target directory.

For a comprehensive list of Maven dependency versions, visit mvnrepository.com .