Now that we have a clear view of the project's structure and context, we can start getting our hands dirty.

In Maven, a multimodule project simply consists of a folder containing all submodule projects and a central POM file referencing these modules. This file is usually referred to as parent POM or aggregate POM. In this book, we will comply with this naming.

To start working, we simply need to open our IDE and create the project. Through the m2e plugin, Eclipse provides a wizard specific for Maven project creation.

The project creation starts as any other project. Open the new project window by navigating to File | New | Project….

When the window opens, select the Maven Project option from the Maven folder. As we can see in the following screenshot, the last two steps consist of creating a simple project and filling in the form with the project's coordinates and packaging:

We finally have our Maven project. Our pom.xml file will look a bit desolate, but it will soon grow up. In the following sections, we will start structuring this POM file:

<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.packt.examples</groupId>
  <artifactId>transportation-project</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>
  <name>transportation-project</name>
  <description>The Transportation Project</description>
</project>

Actually, we created an empty project. In order to start structuring our project, we will start adding the project modules that we saw in the earlier sections. The easiest way to add a module is to exploit the m2e functionalities. Just right-click on the pom.xml file and navigate to Maven | New Maven Module Project from the context menu. After this, we can fill in the modules, as shown in the following screenshot:

New Maven module creation

Now, our project will have the first module. We can iterate the same operation for the remaining modules, taking care to choose the right packaging for each module.

Once we stop adding modules, we will see that m2e created all the submodules. Each module that is stored as a folder into the project has its own pom.xml file, which will specify its specific coordinates and settings. In order to distinguish between the POM file of the project and the POM files of its modules, we will call the aggregate POM that we created earlier. The following screenshot shows the added modules and submodules:

As we might notice, this multimodular project follows the standard that we discussed in the Core concepts section.

While terminating the structuration of our project, we take the chance to deepen two more concepts, plugins and dependencies.

As we mentioned earlier, Maven's core functionalities do not cover all needs; most of them are implemented in external plugins. We can add plugins to our project by right-clicking on our pom.xml file and navigating to Maven | Add Plugin from the context menu, as shown in the following screenshot. We can see that the Version field is not mandatory; if we don't specify its value, Maven will download the latest version.

In the following example, we add the maven-surefire-plugin to transportation project. This plugin is used during the test phase to execute the unit tests of the applications. It supports different unit-test frameworks such as JUnit and TestNG.

Since we want to use JUnit, we can simply add JUnit as a dependency of our project. We can add a new dependency the same way as we added a plugin before.

Of course, it is possible to add more plugins and dependencies by manually editing the POM file of each project. In order to add the Maven compiler plugin in our parent POM, we simply add the following tags as a child of the <plugins> tag:

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-compiler-plugin</artifactId>
  <configuration>
    <source>1.7</source>
    <target>1.7</target>
  </configuration >
</plugin>

After we add all the modules and plugins described earlier, our pom.xml file will look like this:

<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.packt.examples</groupId>
  <artifactId>transportation-project</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>
  <name>transportation-project</name>
  <description>The Transportation Project</description>

  <modules>
    <module>transportation-acq-ear</module>
    <module>transportation-acq-war</module>
    <module>transportation-acq-ejb</module>
    <module>transportation-reporting-ear</module>
    <module>transportation-reporting-war</module>
    <module>transportation-reporting-ejb</module>
    <module>transportation-common-jar</module>
    <module>transportation-statistics-batch-jar</module>
  </modules>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.17</version>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.5.1</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration >
      </plugin>
    </plugins>
  </build>
</project>

We have finally structured our project. Actually, it contains all of its modules, a single plugin, and one dependency.

Before exploring the concepts we introduced in this chapter in more detail, it is important to focus on the best practice described in the following snippet. This practice concerns dependency management and will allow us to avoid some common problems related to this topic.