The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Maven

Next ►
►

Maven is a powerful build automation tool used primarily for Java projects. It simplifies the build process, dependency management, and project configuration. Maven uses a Project Object Model (POM) file to manage project dependencies, build configurations, and plugins.

Key Concepts

  1. Project Object Model (POM)

  • POM File: The core of a Maven project, typically named pom.xml.
  • Coordinates: Unique identifiers for a project, including groupId, artifactId, and version.
  • Dependencies: External libraries required by the project, specified in the POM file.

  1. Maven Repositories

  • Local Repository: A directory on your local machine where Maven stores downloaded dependencies.
  • Central Repository: A default repository provided by Maven, containing a vast collection of libraries.
  • Remote Repository: Additional repositories specified in the POM file or settings.

  1. Maven Lifecycle

  • Default Lifecycle: The main build lifecycle, consisting of phases like validate, compile, test, package, verify, install, and deploy.
  • Clean Lifecycle: Handles project cleaning, with phases like pre-clean, clean, and post-clean.
  • Site Lifecycle: Manages the creation of project documentation, with phases like pre-site, site, and post-site.

  1. Plugins

  • Build Plugins: Extend Maven's capabilities, such as compiling code, packaging binaries, and running tests.
  • Reporting Plugins: Generate project reports, such as test coverage and code quality.

Setting Up Maven

Prerequisites

  • Java Development Kit (JDK): Ensure JDK is installed and configured.
  • Maven: Download and install Maven from the official website.

Installation Steps

  1. Download Maven: Visit the Maven download page and download the latest version.
  2. Extract Files: Extract the downloaded archive to a directory of your choice.
  3. Set Environment Variables:
    • Add MAVEN_HOME environment variable pointing to the Maven directory.
    • Add MAVEN_HOME/bin to the PATH environment variable.

Verify Installation

Open a terminal or command prompt and run:

mvn -version

You should see the Maven version and Java version details.

Creating a Maven Project

Using Command Line

  1. Open Terminal: Navigate to the directory where you want to create the project.
  2. Run Maven Archetype Command: 
    mvn archetype:generate -DgroupId=com.example -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
    This command generates a simple Maven project with a basic structure.

Project Structure

my-app
├── pom.xml
└── src
    ├── main
    │   └── java
    │       └── com
    │           └── example
    │               └── App.java
    └── test
        └── java
            └── com
                └── example
                    └── AppTest.java

POM File 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-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

Building and Running the Project

Build the Project

Navigate to the project directory and run:

mvn clean install

This command cleans the project, compiles the source code, runs tests, and packages the project into a JAR file.

Run the Application

Navigate to the target directory and run:

java -cp my-app-1.0-SNAPSHOT.jar com.example.App

Practical Exercise

Exercise: Create a Maven Project

  1. Objective: Create a Maven project that includes a dependency on the Apache Commons Lang library.
  2. Steps:
    • Create a new Maven project using the command line.
    • Modify the pom.xml to include the Apache Commons Lang dependency.
    • Write a simple Java program that uses a utility method from the Apache Commons Lang library.
    • Build and run the project.

Solution

  1. Create Project: 
    mvn archetype:generate -DgroupId=com.example -DartifactId=my-commons-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
  2. Modify pom.xml: 
    <dependencies>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.12.0</version>
    </dependency>
</dependencies>
  3. Write Java Program: 
    package com.example;

import org.apache.commons.lang3.StringUtils;

public class App {
    public static void main(String[] args) {
        String message = "Hello, Maven!";
        System.out.println(StringUtils.reverse(message));
    }
}
  4. Build and Run: 
    mvn clean install
java -cp target/my-commons-app-1.0-SNAPSHOT.jar com.example.App

Conclusion

In this section, you learned about Maven, its key concepts, and how to set it up. You also created a Maven project, modified the POM file to include dependencies, and built and ran the project. Maven simplifies project management and builds automation, making it an essential tool for Java developers. In the next module, you will explore building real-world applications using Java frameworks and libraries.

◄ Previous
◄
Next ►
►

Java Programming Course

Module 1: Introduction to Java

Module 2: Control Flow

Module 3: Object-Oriented Programming

Module 4: Advanced Object-Oriented Programming

Module 5: Data Structures and Collections

Module 6: Exception Handling

Module 7: File I/O

Module 8: Multithreading and Concurrency

Module 9: Networking

Module 10: Advanced Topics

Module 11: Java Frameworks and Libraries

Module 12: Building Real-World Applications

The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved