Core Concepts and Functionality

Apache Maven functions as a project management and comprehension tool, abstracting the build process into a Project Object Model (POM). It enforces a uniform structural standard across projects.

• Modular Architecture: Large codebases can be decomposed into distinct sub-modules. Each module undergoes isolated compilation, testing, and deployment, significantly enhancing reusability.
• Automated Build Process: Through defined lifecycles and a robust plugin ecosystem, routine operations like compilation, testing, and deployment are executed automatically without manual script intervention.
• Centralized Dependency Resolution: Maven fetches external libraries from remote repositories using POM definitions. This ensures version consistency and eliminates manual JAR management.
• Standardized Directory Layout: By enforcing a conventional folder structure for source code, resources, and tests, Maven minimizes onboarding overhead for new developers.

Resource Coordinates

Maven coordinates serve as unique identifiers to locate project artifacts. They consist of three fundamental elements:

• groupId: Identifies the organization or group (e.g., reversed domain name).
• artifactId: Specifies the unique name of the project module.
• version: Denotes the specific release iteration.

Environment Configuration

Once Maven is installed and environment variables are set, integrate it with your IDE.

Project-Level vs. Global IDE Settings

To apply Maven settings to a single project, configure the JDK, Maven home directory, settings.xml path, and bytecode target within the project's specific settings.

To establish Maven globally for all workspaces, close active projects, access the global settings dialog, and apply the identical JDK, Maven home, and configuration file specifications.

Project Creation and Structure

When a new Maven module is created, specify the coordinates. The IDE will resolve and download required foundational dependencies.

Upon compilation, a target directory is generated, housing the compiled bytecode (.class files) and packaged artifacts.

To import an existing Maven project, use the IDE's Maven tool window and link the external project's pom.xml file.

Dependency Management

Dependencies represent external code libraries required for project execution. Maven supports transitive dependencies, meaning an imported library's own required libraries are automatically resolved.

Declaring Dependencies

Dependencies are declared within the pom.xml file. If an artifact cannot be located locally, triggering a Maven refresh forces the download from the configured repository.

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.9.3</version>
    </dependency>
</dependencies>

Locating Coordinates

If IDE auto-completion fails, coordinates can be found by searching the Maven Central Repository directly at mvnrepository.com, copying the XML snippet provided for the desired version.

Excluding Transitive Dependencies

To prevent a transitive dependency from being included, define an <exclusion> block. The version tag is omitted for excluded artifacts.

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>3.1.0</version>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

Dependency Scopes

By default, dependencies are available across all phases. The <scope> element restricts availability:

• compile: Default scope. Available in main, test, and runtime.
• test: Restricted to test execution paths.
• provided: Available during compilation and testing, but not packaged.
• runtime: Not required at compile time, but needed during execution and testing.

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.9.3</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Build Lifecycle

The Maven lifecycle represents a sequence of standardized build phases.

• clean: Deletes the target directory and previous build artifacts.
• compile: Transforms source code into bytecode.
• test: Executes unit tests.
• package: Bundles compiled code into a JAR or WAR archive.
• install: Deploys the packaged artifact to the local repository.
• deploy: Pushes the artifact to a remote repository for sharing.

Phases can be executed directly via the IDE's Maven tool window or through the terminal:

mvn clean
mvn compile
mvn package
mvn install