------
 Creating Skinny WARs
 ------
 Mike Perham
 Karl-Heinz Marbaise
 ------
 2014-10-01
 ------

~~ Licensed to the Apache Software Foundation (ASF) under one
~~ or more contributor license agreements.  See the NOTICE file
~~ distributed with this work for additional information
~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~   http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an
~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html

Creating Skinny WARs

 In a typical J2EE environment, a WAR is packaged within an EAR for deployment.  The
 WAR can contain all its dependent JARs in <<<WEB-INF/lib>>> but then the EAR can quickly grow
 very large if there are multiple WARs, due to the presence of duplicate JARs.  Instead
 the J2EE specification allows WARs to reference external JARs packaged within the EAR
 via the <<<Class-Path>>> setting in their <<<MANIFEST.MF>>>.

 The Maven EAR Plugin has direct support for creating skinny wars which simply
 means to {{{http://maven.apache.org/plugins/maven-ear-plugin/examples/skinny-wars.html}configure the maven-ear-plugin}}
 accordingly.

 You need to change the EAR project's <<<pom.xml>>> to package those dependent JARs in the EAR.
 Notice that we package everything into a <<<lib/>>> directory within the EAR.  This is
 just my own personal preference to distinguish between J2EE modules (which will
 be packaged in the root of the EAR) and Java libraries (which are packaged in <<<lib/>>>).

+-----------------+
  ...
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-ear-plugin</artifactId>
        <version>2.9.1</version>
        <configuration>
          <defaultLibBundleDir>lib/</defaultLibBundleDir>
          <skinnyWars>true</skinnyWars>
        </configuration>
      </plugin>
    </plugins>
  </build>
  ...
+-----------------+

 Now the painful part.  Your EAR project's <<<pom.xml>>> needs to list every dependency that the WAR has.
 This is because Maven assumes fat WARs and does not include transitive dependencies
 of WARs within the EAR.

+-----------------+
  ....
  <dependencies>
    <dependency>
      <groupId>com.acme</groupId>
      <artifactId>shared-jar</artifactId>
      <version>1.0.0</version>
    </dependency>
    <dependency>
      <groupId>com.acme</groupId>
      <artifactId>war1</artifactId>
      <version>1.0.0</version>
      <type>war</type>
    </dependency>
    <dependency>
      <groupId>com.acme</groupId>
      <artifactId>war2</artifactId>
      <version>1.0.0</version>
      <type>war</type>
    </dependency>
  </dependencies>
  ...
+-----------------+

 Your EAR will contain something like this:

+-----------------+
 .
 |-- META-INF
 |   `-- application.xml
 |-- lib
 |   `-- shared-jar-1.0.0.jar
 |-- war1-1.0.0.war
 `-- war2-1.0.0.war
+-----------------+


* Alternatives

 Our users have submitted alternatives to the above recipe on
 {{{http://docs.codehaus.org/display/MAVENUSER/Solving+the+Skinny+Wars+problem}the Wiki}}.