Simplifying Maven POM files using Parent and Child POMs
Maven is a powerful tool for building Java projects, but it can be overwhelming when it comes to managing project dependencies and configurations. One way to simplify Maven pom files is by organising them into parent and child poms and utilising the inheritance feature of the poms.
In this article, we will explore how to organise Maven pom files into parent and child poms, how to utilise inheritance, and provide examples to illustrate these concepts.
What are Parent and Child Poms?
In Maven, a parent pom is a Maven project that other projects can inherit from. The parent pom defines common configurations and dependencies that can be shared across multiple child projects. Child poms, on the other hand, are Maven projects that inherit from a parent pom. Child poms can override parent pom configurations and dependencies or add their own.
Organising Pom Files into Parent and Child Poms
To organise Maven pom files into parent and child poms, you need to create a new Maven project for the parent pom. This project should have a pom.xml file that defines common configurations and dependencies for all child projects. Then, you can create child projects that inherit from the parent pom by specifying the parent pom in the child pom.xml file.
Here is an example of a parent pom.xml file:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
<project> <groupId>com.example</groupId> <artifactId>parent-project</artifactId> <version>1.0</version> <packaging>pom</packaging> <properties> <spring.version>5.3.9</spring.version> </properties> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>${spring.version}</version> </dependency> </dependencies> </dependencyManagement> </project> |
In this example, the parent pom defines a property for the Spring framework version and a dependency management section that includes two Spring dependencies. The <packaging> element is set to “pom” to indicate that this is a parent pom.
Now, let’s create a child project that inherits from this parent pom:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
<project> <parent> <groupId>com.example</groupId> <artifactId>parent-project</artifactId> <version>1.0</version> </parent> <groupId>com.example</groupId> <artifactId>child-project</artifactId> <version>1.0</version> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> </dependency> </dependencies> </project> |
In this example, the child pom.xml file includes a <parent> element that specifies the parent project. The child pom.xml file also includes a dependency on the Spring Web MVC module, which is not defined in the parent pom.xml file.
Utilising Inheritance in Maven Poms
Inheritance is a powerful feature of Maven poms that allows child projects to inherit configurations and dependencies from their parent project. Child projects can override parent configurations or dependencies, or add their own.
Here is an example of how to override a parent configuration in a child pom.xml file:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
<project> <parent> <groupId>com.example</groupId> <artifactId>parent-project</artifactId> <version>1.0</version> </parent> <groupId>com.example</groupId> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.1</version> <configuration> <source>1.8</source> <target>1.8</target> </configuration> </plugin> </plugins> </build> </project> |
In this example, the child pom.xml file includes a <build> section that overrides the <configuration> element of the Maven Compiler Plugin defined in the parent pom.xml file. The child project uses Java 8 as the source and target version, which is different from the parent project.
Here is an example of how to add a dependency to a child pom.xml file:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
<project> <parent> <groupId>com.example</groupId> <artifactId>parent-project</artifactId> <version>1.0</version> </parent> <groupId>com.example</groupId> <artifactId>child-project</artifactId> <version>1.0</version> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.9</version> </dependency> </dependencies> </project> |
In this example, the child pom.xml file includes a dependency on the Apache Commons Lang 3 library, which is not defined in the parent pom.xml file.
Conclusion
Organising Maven pom files into parent and child poms and utilising the inheritance feature of the poms can help simplify project configurations and dependencies. By creating a parent pom that defines common configurations and dependencies, you can reduce duplication and make it easier to manage projects. By using child poms that inherit from the parent pom, you can easily override or add project-specific configurations and dependencies.
With these concepts in mind, you can simplify your Maven projects and make them easier to manage.
