The structure I would suggest in these cases is to have a maven multimodule project providing your application module (jar packaging), a war module (war packaging) and an ear module (ear packaging) in order to have a clear separation of concerns and have maven build a single artifact per module.
If your project is currently a classic maven project, you can create an aggregator module project (pom packaging) as following:
<?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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>your.group.id</groupId>
<artifactId>your.artifact.id-aggregator</artifactId>
<packaging>pom</packaging>
<version>your.version</version>
<modules>
<module>your.artifact.id-application</module>
<module>your.artifact.id-war</module>
<module>your.artifact.id-ear</module>
</modules>
</project>
This means the aggregator project will point to maven modules existing in subfolders your.artifact.id-application, your.artifact.id-war and your.artifact.id-ear.
The application module is a simple Maven project providing your application logic and building a jar file out of it. It is not mandatory, but it can also point as a parent to the aggregator project (aggregation and inheritance are two different things in Maven, which can be mixed together or used differently).
You can declare the parent project in modules as following:
<parent>
<groupId>your.group.id</groupId>
<artifactId>your.artifact.id-aggregator</artifactId>
<version>your.version</version>
</parent>
In the application module, you don't need to specify packaging, since by default it will jar, while in the ear and war module, packaging will be respectively ear and war.
The war module will need to have the application module as its dependency. The WAR module is also a good location to place integration tests. You could also configure here a jetty maven plugin start/stop as part of pre/post-integration-test phase.
The war module will also provide the required src\main\webapp\WEB-INF structure
The ear module will need to have the war module as its dependency and it is important to specify its type, war, as following:
<dependencies>
<dependency>
<groupId>your.group.id</groupId>
<artifactId>your.application.id-war</artifactId>
<version>your.version</version>
<type>war</type>
</dependency>
</dependencies>
Note the war.
The ear module will also provide the required src\main\application\META-INF structure.
The ear module can configure the maven-ear-plugin simply as following:
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-ear-plugin</artifactId>
<configuration>
<modules>
<webModule>
<groupId>your.group.id</groupId>
<artifactId>your.artifact.id-war</artifactId>
<bundleFileName>your.artifact.id.war</bundleFileName>
<contextRoot>/your.artifact.id</contextRoot>
</webModule>
</modules>
</configuration>
</plugin>
</plugins>
</build>
its application.xml file (under src\main\application\META-INF) can simply look like below:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE application PUBLIC "-//Sun Microsystems, Inc.//DTD J2EE Application 1.3//EN" "http://java.sun.com/dtd/application_1_3.dtd">
<application>
<display-name>your.group.id.your.artifact.id_ear</display-name>
<module>
<web>
<web-uri>your.artifact.id.war</web-uri>
<context-root>/your.artifact.id</context-root>
</web>
</module>
</application>
It might look over-complicated as a structure, but it gives you control over modules and artefacts, meets maven best practices and improves your focus (i.e. application code only on the application module, integration tests only on the war module).
