# Mastering Maven: A Developer’s Handbook for Parent and Child Projects

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1694216998836/01c5b898-4ebe-4275-82d0-b027e91a61f3.png align="center")

### Introduction

Welcome to the next instalment in our [*Maven series*](https://blog.anilgulati.tech/maven-made-simple-your-guide-to-effortless-project-management), where we continue our exploration of this powerful project management tool. In this article, we’ll dive deeper into Maven’s capabilities by delving into the concept of parent and child projects/modules. By understanding and effectively using parent-child project relationships, you’ll significantly enhance your software development efficiency.

#### Why Do We Need Parent-Child Projects?

Before we proceed, let’s take a moment to understand why parent-child projects are essential:

* Modular Development with Maven: Achieve modularity by breaking down large software systems into smaller, manageable components or modules. This promotes code reusability and simplifies maintenance.
    
* Streamlined Dependency Management: Maven simplifies the management of dependencies between modules. Each child module can specify its dependencies, ensuring that only the necessary components are included.
    
* Consistent Builds: Parent-child projects ensure that all modules within a project share a consistent build process. This consistency is invaluable when working on complex systems.
    

![](https://cdn-images-1.medium.com/max/1000/1*Lx9YXPhYi__FQmfmFHitQg.png align="left")

#### Creating a Parent Project

Let’s start by creating a parent project. Execute the following command to generate a new project and set up the parent POM:

```java
mvn archetype:generate -DgroupId=tech.anilgulati -DartifactId=parent-project -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```

Make sure to replace `tech.anilgulati` with your desired group ID. This command generates the basic structure for your parent project.

#### Configuring the Parent POM Packaging to `pom`

In the generated `pom.xml` of your parent project, find the `<packaging>` element and change its value to `pom`. This step is crucial because the parent project doesn't produce any output of its own; it acts as a container for child modules.

```java
<packaging>pom</packaging>
```

#### Creating Submodules with Consistent Group ID

Now, let’s create three submodules to illustrate how they work. Please note that the group ID should remain the same for consistency:

> UserManagement: This module handles user-related functionality.

```java
mvn archetype:generate -DgroupId=tech.anilgulati -DartifactId=user-management -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```

> ProductCatalog: This module manages product information.

```java
mvn archetype:generate -DgroupId=tech.anilgulati -DartifactId=product-catalog -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```

> OrderProcessing: This module is responsible for processing customer orders.

```java
mvn archetype:generate -DgroupId=tech.anilgulati -DartifactId=order-processing -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```

#### Configuring Output Types for Modules

For our project, we’ll configure one submodule to produce a WAR (Web Application Archive) file. To do this, edit the `pom.xml` of the `order-processing` module and adjust the `<packaging>` element as needed.

```java
<packaging>war</packaging>
```

> Adding WAR Plugin for the WAR Module

In the `pom.xml` of the `order-processing` module, you should also include the WAR plugin to configure your WAR file effectively. Add the following plugin configuration within the `<build>` section:

```java
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>3.3.2</version> <!-- Adjust the version if needed -->
        </plugin>
    </plugins>
</build>
```

#### Generating Output Files

To generate output files for individual modules, navigate to the module directory (e.g., `order-processing`) and use the following command:

```java
mvn package
```

To generate outputs for all modules at once, execute the same command from the parent project’s directory. Maven will build each module in the correct order, taking care of dependencies.

#### Understanding `mvn clean` Impact

Using `mvn clean` at the module level removes the target folder and cleans up the module's workspace. At the parent level, it does the same for all child modules. This is handy for ensuring that your builds start fresh, especially when modifications have been made.

To solidify your understanding, let’s try an interactive exercise. Open your terminal and navigate to the `parent-project` directory. Run the following command to clean the entire project:

```java
mvn clean
```

Observe how Maven cleans all modules, ensuring a fresh start for your builds.

#### Conclusion

Mastering parent-child projects in Maven not only enhances your software development skills but also opens doors to exciting career opportunities. As organizations increasingly adopt modular development practices, your expertise in Maven’s parent-child project structure will make you a valuable asset. You’ll be well-prepared to tackle complex software projects with confidence and efficiency, setting you on a path to success in the software development industry.

### Enjoyed This Article?

> *If you enjoy reading this post, got help, knowledge through it, and want to support my efforts please clap this article and follow.  
> To explore more of my work, visit my portfolio at* [*anilgulati.com*](https://anilgulati.com/?utmSource=hashnode&article=mastering-maven)