Introduction to Maven

Apache Maven is a build automation tool for Java projects. It takes your source code and produces a deliverable (a .jar or .war file) by orchestrating every step: compilation, tests, packaging, and dependency management.

In practice, Maven meets three fundamental needs:

Maven's core is a single file, the pom.xml (Project Object Model), which describes the project: its identity, its dependencies, and how to build it. It is the “recipe” Maven executes.

Without Maven, building a Java project means compiling by hand with javac, downloading every library manually, and managing the classpath yourself. Maven automates all of that from a single file.

🔧 Mini-exercise — Name the three fundamental needs Maven addresses.

Before Maven, every Java project was built “by hand” or with homemade scripts. That led to several recurring problems:

The key idea: a developer who joins a Maven project immediately knows where the code is, where the tests are, and how to launch the build — regardless of the company or the project.

# With Maven, building an unknown project comes down to:
mvn package

Maven turns “how do I build this project?” — a question that sometimes took hours — into a single universal command.

🔧 Mini-exercise — Write the one command that is enough to build an unknown Maven project.

mvn package

Maven's central principle is “convention over configuration”. Rather than describing everything explicitly, Maven starts from sensible defaults. If you follow the conventions, you barely have to configure anything.

Examples of default conventions:

Comparing the philosophies:

You can always override the conventions if needed, but 95% of projects stick with the defaults. Less configuration = fewer bugs.

Every Maven project follows the same tree. Knowing it lets you navigate instantly in any project.

Folder details:

🔧 Mini-exercise — In which folder should you put a unit-test class, and in which one an application.properties file?

# Typical tree seen from the command line
mon-projet/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/        # e.g. com/exemple/App.java
│   │   └── resources/   # e.g. application.properties
│   └── test/
│       └── java/        # e.g. com/exemple/AppTest.java
└── target/              # generated: do not version (.gitignore)

⚠️ The target/ folder is regenerated on every build. Add it to your .gitignore: compiled artifacts are never versioned.

Maven needs a JDK (Java Development Kit) already installed, because it relies on the javac compiler. The JAVA_HOME variable must point to that JDK.

Depending on your system:

Manual installation (all platforms):

# 1. First check that Java is present
java -version
# Should display a version such as 17+

# 2. Set JAVA_HOME (Linux/macOS example)
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk

# 3. Download Maven from maven.apache.org, extract it,
#    then add the bin/ folder to the PATH
export PATH=$PATH:/opt/apache-maven-3.9.6/bin

On Windows, JAVA_HOME is set in “Environment Variables”. On Linux/macOS, add the export line to your ~/.bashrc or ~/.zshrc so it is permanent.

Once Maven is installed, you verify that it works and generate a first project skeleton.

# Check the installed version
mvn -version

Typical output:

Apache Maven 3.9.6
Maven home: /opt/apache-maven-3.9.6
Java version: 17.0.9, vendor: Eclipse Adoptium

To generate an empty project that follows the conventions, you use an archetype (a template):

# Generates a standard “quickstart” project
mvn archetype:generate \
  -DgroupId=com.exemple \
  -DartifactId=mon-app \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DinteractiveMode=false

The first mvn is slow: Maven downloads its own plugins into a local cache (~/.m2/repository). Later builds are much faster.

🔧 Mini-exercise — Write the command that displays the installed Maven version (and the Java version).

mvn -version

Question 1: What does the pom.xml file represent in a Maven project?

a) The application's main source code

b) The Project Object Model: the recipe that describes the project and its build

c) The project's compiled result

d) A log file

Question 2: Where does Maven expect to find the main source code by default?

a) code/

b) target/main

c) src/main/java

d) java/source

Question 3: What does “convention over configuration” mean?

a) Everything must be configured explicitly

b) Maven uses sensible defaults, reducing the configuration you need

c) You can never change Maven's behavior

d) Maven has no configuration file

Question 4: Which folder is generated automatically by Maven and must not be versioned?

a) src/main/java

b) src/test/java

c) target/

d) resources/

Question 5: What does Maven need in order to work?

a) A web server

b) An installed JDK and a configured JAVA_HOME

c) A database

d) Node.js

Instructions

Verify your Maven installation, generate a “quickstart” project named mon-app in the com.exemple group, then build it and locate the produced artifact.

Suggested correction — Expected command sequence

# 1. Check Maven and Java
mvn -version

# 2. Generate the project from the quickstart archetype
mvn archetype:generate \
  -DgroupId=com.exemple \
  -DartifactId=mon-app \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DinteractiveMode=false

# 3. Enter the project and inspect the layout
cd mon-app
ls -R          # or “tree” if available

# 4. Build the project
mvn package

# 5. Locate the generated artifact
ls target/

Expected result:

target/
├── classes/
├── mon-app-1.0-SNAPSHOT.jar   <-- the produced artifact
└── ...
BUILD SUCCESS

The generated tree should contain:

mon-app/
├── pom.xml
└── src/
    ├── main/java/com/exemple/App.java
    └── test/java/com/exemple/AppTest.java

If mvn package prints BUILD SUCCESS and a .jar appears in target/, your Maven toolchain is working. The -SNAPSHOT suffix marks a version still in development (see lesson 02).

Key takeaways

1. Maven is a Java build-automation tool: it compiles, tests, packages, and manages dependencies.
2. The pom.xml is the single recipe that describes the project and its build.
3. Convention over configuration: defaults minimize what you have to write.
4. Standard layout: src/main/java, src/test/java, src/main/resources, output in target/.
5. Maven needs a JDK and JAVA_HOME; you verify with mvn -version.

What's next

Lesson 02 — The pom.xml file: dissect Maven's recipe in detail — project coordinates, properties, and parent inheritance.