Estructuration of multi module project. how to packaging modules?

Question

i'm creating the estructure of a multi modul project with maven. The parent's pom:

<?xml version="1.0" encoding="UTF-8"?>
  <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>cat.base.gpt</groupId>
  <artifactId>gpt</artifactId>
  <version>0.0.1</version> <!-- application version -->
  <packaging>pom</packaging>
  <name>gpt</name>

  <parent>
        <groupId>cat.base.baseframe</groupId>
        <artifactId>projecte-pare-baseframe</artifactId>
        <version>0.0.11.a</version>
  </parent>

  <modules>
    <module>gpt.domini</module>
    <module>gpt.ui</module>
    <module>gpt.logica</module>
    <module>gpt.ejb</module>
    <module>gpt.ear</module>
  </modules>
  <dependencies>
  <!-- dependencies pel testeig TDD -->
          <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>6.7</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.4</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <version>1.9.5-rc1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.kubek2k</groupId>
            <artifactId>springockito</artifactId>
            <version>1.0.4</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.4</version>
            <scope>provided</scope>
        </dependency>
    <!--  A més, en el cas de provatures UI, s'ha d'afegir la següent dependència:-->
        <dependency>
            <groupId>cat.base.baseframe</groupId>
            <artifactId>baseframe-test-swf</artifactId>
            <version>1.0.0-SNAPSHOT</version>
            <scope>test</scope>
        </dependency>
       </dependencies>
  </project>

Ok, first question, i put all the dependencies at paren's pom is this really correct?

and the most interesting part, i don't know hos to compile the grafic interfade project,(i call ui), it's better create a war or create and ear with all the necessary (ui+logica+domini+ejb) i 'm a litlle bit confused about that, i uset o work with projects already estructure created. I hope you to unsderstand my question, i put the rest of pom to keep an eye. ty.

pom's gpt.domini. 

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <artifactId>gpt</artifactId>
    <groupId>cat.base.gpt</groupId>
    <version>0.0.1</version>
  </parent>

  <groupId>cat.base.gpt.domini</groupId>
  <artifactId>gpt.domini</artifactId>
  <packaging>jar</packaging>

  <name>gpt.domini</name>
  <description>Definició del model de dades i de la façana del servei</description>
  </project>

pom's gpt.ear

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <artifactId>gpt</artifactId>
    <groupId>cat.base.gpt</groupId>
    <version>0.0.1</version>
  </parent>

  <groupId>cat.base.gtp.ear</groupId>
  <artifactId>gpt.ear</artifactId>
  <name>gpt.ear</name>


  <packaging>ear</packaging>
  <description>Paquet de l'aplicació J2EE</description>

  <dependencies>
        <dependency>
            <groupId>${project.parent.groupId}</groupId>
            <artifactId>${project.parent.artifactId}.domini</artifactId>
            <version>${project.parent.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>${project.parent.groupId}</groupId>
            <artifactId>${project.parent.artifactId}.ejb</artifactId>
            <version>${project.parent.version}</version>
            <type>ejb</type>
        </dependency>
        <dependency>
            <groupId>${project.parent.groupId}</groupId>
            <artifactId>${project.parent.artifactId}.logica</artifactId>
            <version>${project.parent.version}</version>
            <type>jar</type>
        </dependency>

  </dependencies>
</project>

pom's gpt.logica

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <artifactId>gpt</artifactId>
    <groupId>cat.base.gpt</groupId>
    <version>0.0.1</version>
  </parent>


  <groupId>cat.base.gtp.logica</groupId>
  <artifactId>gpt.logica</artifactId>
  <name>climbing.logica</name>
  <packaging>jar</packaging>
  <description>Implementació del servei</description>


  <dependencies>
  <!-- de moment nomes el domini -->
    <dependency>
            <groupId>${project.parent.groupId}</groupId>
            <artifactId>${project.parent.artifactId}.domini</artifactId>
            <version>${project.parent.version}</version>
            <scope>provided</scope>
        </dependency>
  </dependencies>
</project>

pom's gpt.ejb

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <artifactId>gpt</artifactId>
    <groupId>cat.base.gpt</groupId>
    <version>0.0.1</version>
  </parent>

  <groupId>cat.base.gtp.ejb</groupId>
  <artifactId>gpt.ejb</artifactId>
  <name>gpt.ejb</name>
  <packaging>ejb</packaging>
  <description>Publicació d'un servei en forma EJB</description>


  <dependencies>
        <dependency>
            <groupId>${project.parent.groupId}</groupId>
            <artifactId>${project.parent.artifactId}.domini</artifactId>
            <version>${project.parent.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>${project.parent.groupId}</groupId>
            <artifactId>${project.parent.artifactId}.logica</artifactId>
            <version>${project.parent.version}</version>
        </dependency>
        <dependency>
            <groupId>${project.parent.groupId}</groupId>
            <artifactId>${project.parent.artifactId}.logica</artifactId>
            <version>${project.parent.version}</version>
            <classifier>tests</classifier>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.ejb</groupId>
            <artifactId>ejb-api</artifactId>
            <version>3.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>jboss</groupId>
            <artifactId>jboss-annotations-ejb3</artifactId>
            <version>4.2.2.GA</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>2.5.6</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.jboss.client</groupId>
            <artifactId>jbossall-client</artifactId>
            <version>4.2.3.GA</version>
            <scope>test</scope>
        </dependency>
  </dependencies>
</project>

pom's gpt.logica

   <?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <artifactId>gpt</artifactId>
    <groupId>cat.base.gpt</groupId>
    <version>0.0.1</version>
  </parent>


  <groupId>cat.base.gtp.logica</groupId>
  <artifactId>gpt.logica</artifactId>
  <name>climbing.logica</name>
  <packaging>jar</packaging>
  <description>Implementació del servei</description>


  <dependencies>
  <!-- de moment nomes el domini -->
    <dependency>
            <groupId>${project.parent.groupId}</groupId>
            <artifactId>${project.parent.artifactId}.domini</artifactId>
            <version>${project.parent.version}</version>
            <scope>provided</scope>
        </dependency>
  </dependencies>
</project>

pom's gpt.ui

here all the dependencies of spring-rich.faces..or better at parent's pom? packaging like a war?? or inside de module ear?? ty.

Answer 1

Although there is already an accepted answer, I believe it worth to give more information to you as it seems to me that, both the questioner and the accepted answer got messed up with different concepts in Maven.

---

1) Aggregation vs Parent POM

There are two concepts in Maven often got mixed up. Aggregation (aka Multi-module) POM and Parent POM are something irrelevant, although it is fine to use one POM to serve for both purpose.

Multi-module project aims to describe the aggregation relationship between projects, so that we can build multiple related project as a whole, and all sub-projects are built in the same reactor. Parent project aims to provide shared project settings. It can even exists out of the project structure (e.g. I may have a company-wise parent POM)

Personally I recommend to have a multi-module POM only to declare the aggregation (hierarchy) of projects, and having a separate parent POM to be used to declare shared settings.

i.e.

my-proj    // aggregation only
    + my-proj-parent    // parent POM
    + my-proj-main
    + my-proj-web
    + my-proj-ear

---

2) Shared Dependency for POM vs in EAR

Again, these are two separate concepts.

It is fine to put dependencies in parent POM. When you put it there, it means the inherited project is going to have such dependency. There is no right or wrong on this, as long as you know what you are doing (personally I am using different way, will be described later).

However, whether to put shared JARs in EAR and keep skinny WAR, or have a plain EAR with a "full" WAR has nothing to do with your dependency. It is more about the packaging strategy of EAR. Therefore, changing scope of Maven dependency just because you are going to package the project as skinny war, such approach is simply messing up the whole concept of maven dependency. Even more horrible is, when creating your EAR, you need to find out all the dependencies of its included WARs and add it one by one to the EAR POM, that's doubtless not an optimal solution

A pity that current Maven EAR plugin still has no way to declare a skinny war packaging strategy. However there are some workarounds which allow you to do so, without messing around the Maven dependency scope. http://maven.apache.org/plugins/maven-ear-plugin/examples/skinny-wars.html http://maven.apache.org/plugins/maven-war-plugin/examples/skinny-wars.html

(Update: The skinny war receipe seems updated and one of the workaround seems gone. http://docs.codehaus.org/display/MAVENUSER/Solving+the+Skinny+Wars+problem?focusedCommentId=212631587#comment-212631587 This is to include WAR type POM as POM type, so that we do no need to declare the dependencies again in EAR)

---

3) Use of shared dependencies in parent POM

As I mentioned before, there is no right or wrong to put dependencies in parent. However you should know that, such way actually means all inherited project is going to have such dependency, which is mostly incorrect.

for example, I have a foo-a and foo-b projects under foo, which both inherits foo-parent. Assume foo-a is using spring-core while whole logic of foo-b has nothing to do with it, if you put spring-core as dependency in foo-parent, when you look at foo-b, it is unncessarily having unrelated dependencies spring-core.

The proper way to do is only include dependencies (and other settings) in parent POM that should be shared across all inherited projects. For example, unit testing related dependencies may be a good choice. Dependencies for integration testing may be another example.

However, it doesn't mean we should declare dependencies in each project individually. One of the biggest problem is such approach is going to be hard to maintain same version of dependencies across the whole project.

In order to solve such issue, my recommendation is to make use of dependencyManagement in parent POM, which declares the version (and maybe other settings like scope, excludes). Declaring dependencyManagement is not introducing actual dependencies in inherited POM. It simply declare: "If you declare such dependency, this will be the settings to use". In each inherited POM, simply declare the dependencies' group and artifact (and maybe some project specific settings), so that you can follow the version declared in parent POM.

Maybe a bit hard to understand, here is an example:

foo-parent

<project>
  <dependencyManagement>  // dependency management doesn't bring actual dependency
    <dependencies>
      <dependency>
         <groupId>org.springframework<groupId>
         <artifactId>spring-core<artifactId>
         <version>3.1.0.RELEASE</version>
      </dependency>
      <dependency>
         <groupId>org.hibernate<groupId>
         <artifactId>hibernate-core<artifactId>
         <version>3.6</version>
      </dependency>
    </dependencies>
  <dependencyManagement>

  <dependencies>    // actual shared dependency
    <dependency>
       <groupId>junit<groupId>
       <artifactId>junit<artifactId>
       <version>4.11</version>
       <scope>test</scope>
    </dependency>
  </dependencies>
  .....
<project>

foo-a

<project>
  <dependencies>
    <dependency> // note: no version declared
      <groupId>org.springframework<groupId>
      <artifactId>spring-core<artifactId>
    </dependency>

    // junit dependency is inherited
  <dependencies>
<project>

Answer 2

Ok, first question, i put all the dependencies at paren's pom is this really correct?

No, your shared dependencies should be put in the ear pom. In the other poms you have to reference the shared dependencies using <scope>provided</scope>.

For example in your ear pom add a dipendency:

<dependency>
    <groupId>somegroup</groupId>
    <artifactId>someartifact</artifactId>
    <version>1.0</version>
</dependency>

In the logica and ui module pom, for example, add these lines:

<dependency>
    <groupId>somegroup</groupId>
    <artifactId>someartifact</artifactId>
    <version>1.0</version>
    <scope>provided</scope>
</dependency>

In this way the dependency artifact is added only once in the ear package.

and the most interesting part, i don't know hos to compile the grafic interfade project,(i call ui), it's better create a war or create and ear with all the necessary (ui+logica+domini+ejb) i 'm a litlle bit confused about that, i uset o work with projects already estructure created. I hoper unsderstand my question, i put the rest of pom to keep an eye. ty.

I don't know if I understand it right. EAR is better suited for project that can have multiple war and/or ejb modules. In your case you can get rid of modularization at all and use a single war package.

Answer 3

finally this is my ear's pom.

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <artifactId>gpt</artifactId>
    <groupId>cat.base.gpt</groupId>
    <version>0.0.1</version>
  </parent>

  <groupId>cat.base.gpt.ear</groupId>
  <artifactId>gpt.ear</artifactId>
  <name>gpt.ear</name>


  <packaging>ear</packaging>
  <description>Paquet de l'aplicació J2EE</description>

  <dependencies>
        <dependency>
            <groupId>${project.groupId}</groupId>
            <artifactId>gpt.domini</artifactId>
            <version>${project.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>${project.groupId}</groupId>
            <artifactId>gpt.ejb</artifactId>
            <version>${project.version}</version>
            <type>ejb</type>
        </dependency>
        <dependency>
            <groupId>${project.groupId}</groupId>
            <artifactId>gpt.logica</artifactId>
            <version>${project.version}</version>
            <type>jar</type>
        </dependency>
        <dependency>
            <groupId>${project.groupId}</groupId>
            <artifactId>gpt.ui</artifactId>
            <version>${project.version}</version>
            <type>war</type>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-ear-plugin</artifactId>
                <configuration>
                    <description>GPT</description>
                    <displayName>Gestió posicions tributarias</displayName>
                    <encoding>${project.build.sourceEncoding}</encoding>
                    <version>1.4</version>
                    <generateApplicationXml>true</generateApplicationXml>
                    <modules>
                        <ejbModule>
                            <groupId>${project.groupId}</groupId>
                            <artifactId>${project.parent.artifactId}.ejb</artifactId>
                            <bundleFileName>${project.parent.artifactId}-ejb.jar</bundleFileName>
                        </ejbModule>
                        <jarModule>
                            <groupId>${project.groupId}</groupId>
                            <artifactId>gpt.logica</artifactId>
                            <includeInApplicationXml>true</includeInApplicationXml>
                        </jarModule>                        

                        <webModule>
                            <groupId>${project.groupId}</groupId>
                            <artifactId>gpt.ui</artifactId>
                            <contextRoot>/gpt</contextRoot>
                        </webModule>
                    </modules>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <configuration>
                    <excludeScope>runtime</excludeScope>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>