Maven - Building a single java/servlet based war file from multiple modules

Question

I posted a question last week on how i can build dependent modules and the result was that it was recommended that i use a build tool like Maven or Ivy. I decided to use Maven to try and achieve what i would like to do. My project basically builds a single war file which is deployed to Tomcat. The modules themselves are part of the final war file. Here is an example structure of the modules

Module 1

customerModule
    |-webapp
        |-jsp
            |-customer
                |-findCustomer.jsp
                |-addNewCustomer.jsp
                |-deleteCustomer.jsp
    |-src
        |-com
            |-mycompany
                |-customer
                    |-FindCustomerAction.java
                    |-AddCustomerAction.java
                    |-DeleteCustomer.java

Module2

productModule
    |-webapp
        |-jsp
            |-product
                |-productCustomer.jsp
                |-addNewProduct.jsp
                |-deleteProduct.jsp
    |-src
        |-com
            |-mycompany
                |-product               
                    |-FindProductAction.java
                    |-AddProductAction.java
                    |-DeleteProduct.java            

Module3

commonModule
    |-webapp
        |-css
            |-style.css
        |-jsp
            |-templates
                |-coreTemplate.jsp
    |-src
        com
            |-mycomany
                |-common
                    |-Logger.java
                    |-Access.java
    |-META-INF
        |-MANIFEST.MF
        |-context.xml
    |-WEB-INF
        |-lib
            |-oraclejdbc.lib
            |-log4j.lib
            |-common.lib
        |-struts-config.xml
        |-tiles-def.xml
        |-web.xml

As you can probably see, the above will all collectively form one application. What i would like to do is to end up with an artifact for each module. Because of the mixture of file types(jsp,css,java) i am not quite sure what is a suitable artifact. The diagram below show the structure of the war file i would like to end up with.

MyApp.war
    |-webapp
        |-css
            |-style.css
        |-jsp
            |-customer
                |-findCustomer.jsp
                |-addNewCustomer.jsp
                |-deleteCustomer.jsp
            |-product
                |-productCustomer.jsp
                |-addNewProduct.jsp
                |-deleteProduct.jsp     
            |-templates
                |-coreTemplate.jsp
    |-META-INF
        |-MANIFEST.MF
        |-context.xml
    |-WEB-INF
        |-lib
            |-oraclejdbc.lib
            |-log4j.lib
            |-common.lib
            |-customerModule.jar
            |-productModule.jar
        |-classes
            |-com
                |-mycomany
                    |-common
                        |-Logger.class
                        |-Access.class
        |-struts-config.xml
        |-tiles-def.xml
        |-web.xml   

A couple of notes - The java files in commonModule are built and end up in WEB-INF/classes - The java files for the customerModule end up as a jar file in WEB-INF/lib - The java files for the productModule end up as a jar file in WEB-INF/lib - All of the jsps,css end up in the root of the war file

What is the best way i should store the artifact for each module in the repository?

• I could use a jar file but this cant hold the html type files(jsp,css,js etc)
• Each module (except the commonModule) will contain a jar file + the jsp, css files. I am thinking of storing the built artifact as a zip file and extract it when the MyApp.war is built to build the war file?
• Can i store the artifact for each module as a war file even though only one has a web.xml file?

How can i implement this using Maven

• I have been investigating Maven and found that it might be possible to have a multi module project with the following structure

  MyApp.pom (parent project) commonModule.pom customer.pom product.pom

• If i zipped up the modules in the repository how would i refer to them from the parent project and unzip them to build the final war file?

• Is it possible to automatically trigger the build of the parent project if any of the child projects are built?
• I havent figured out how to maintain the version of each of the child projects. If i build the customer project, how does the parent project know that there is a newer version of the customer.zip (or .jar) in the repository?

• Assuming the repository currently contains the following

  |-productModule.v.0.1.zip

  |-customerModule.v.0.1.zip

  |-commonModule.v.0.1.zip

If i rebuild, the customerModule and then rebuild the war file buy building the parent project, does maven rebuild all of the other modules in the repository even if they have not changed? How exactly will this work?

Is there an example project anywhere that demonstrate how to achieve the above? Any links or resources which show an example of the above would be very useful.

Answer 1

First your structure looks wrong, cause the default folder layout for a war project looks like:

  +-- pom.xml (war packaging)
  +-- src/main/java (java Sources)
  +-- src/main/webapp (jsp pages etc.)
  +-- src/main/resources (language bundles etc.)

Furthermore if you like to end up with all modules into a same war file but you would like to separate those given modules. The best way is to create a multi-module build which looks like:

  root
  +-- pom.xml (parent of all)
  +-- mod-war (incl. pom.xml)
  +-- mod-1 (incl. pom.xml)
  +-- mod-2 (incl. pom.xml)

and make dependencies to mod-1 and mod-2 in the mod-war pom. this will result in having them be packaged into a single war file which contains separate mod-1-VERSION.jar etc. This artifact (war file) can be deployed to an appropriate repository which itself can be used as an dependency if needed.

You can take a look here as an example.

Answer 2

Honestlly, the best thing to do in your situation is make a .ear file containing each individual war. Otherwise, if you really want to have the resources from all 3 wars into a single war you should manually merge them. Java EE doesn't have any specs for merging wars like this so even if you manage to do it with some Maven plugin/workAround it will still not be something kusher.