In Maven2, qual è il modo più semplice per costruire un WAR e l'EAR per contenere quel WAR in un singolo POM?

Question

La situazione è piuttosto semplice. Ho una webapp Java che sto convertendo per essere costruita con Maven. Al momento, l'app è costruita con Ant in un singolo file WAR, che viene poi raggruppato in un EAR con un semplicissimo application.xml.

maven-war-plugin e maven-ear-plugin entrambi sembrano abbastanza semplici per me, e sembra che mi stiano impostando per essere costretti a considerare quanto sopra due progetti distinti, con il progetto WAR come dipendenza del progetto EAR. Questo mi sembra un po 'scomodo, specialmente perché cambierà l'impostazione del profilo del progetto WAR per ogni ambiente, il che sembra che mi costringerebbe a duplicare quel tweaking di build ogni volta che ho tentato di costruire anche l'EAR.

Tutto questo per dire: c'è un modo semplice per costruire la WAR e inserirla in questo EAR banalmente semplice? Mi piacerebbe evitare di mantenere questi come due progetti separati, ma preferirei analogamente non ricorrere a un hack troppo complicato usando gli assembly per realizzare questo.

Answer 1

Tutto questo per dire: esiste un modo semplice per creare WAR e includerlo in questo EAR banalmente semplice? Mi piacerebbe evitare di mantenere questi come due progetti separati, ma preferirei analogamente non ricorrere a un hack troppo complicato usando gli assembly per realizzare questo.

Risposta breve: no, non v'è alcuna semplice Maven-modo per farlo in quanto ciò sarebbe in contrasto con una norma Maven che è "un artefatto per progetto" (capire un'uscita per ogni progetto che è vero in 99 % dei casi).

E in realtà, mi raccomando vivamente di non andare in modo hacky e dimenticare di utilizzare gli assiemi per creare un EAR. Invece, creare due moduli, uno con una confezione di tipo war, l'altro con una confezione di tipo ear a seconda degli artefatti di guerra e dichiararli come moduli di un genitore pom.xml. Come questo:

my-project 
|-- pom.xml  // packaging of type pom and my-war and my-ear as modules 
|-- my-war 
| `-- pom.xml // packaging of type war 
`-- my-ear 
    `-- pom.xml // packaging of type ear 

Se si va per Maven, adottare la filosofia Maven, non combattere contro di esso, vi farà risparmiare molto dolore. Seriamente, l'hacking degli assembly per fare ciò che il plug-in di maven-ear sta già facendo è solo anti-DRY. Faresti meglio ad attenersi a Ant in quel caso.

Answer 2

In Maven ogni singolo progetto produce un aritifatto. Nella tua situazione suggerisco di creare due progetti uno per la guerra e uno per l'orecchio. Se hai bisogno di più versioni dei tuoi progetti, puoi ottenerli utilizzando classificatori e profili.

Questo è un estratto di esempi di interfacce pom.

<plugin> 
     <artifactId>maven-war-plugin</artifactId> 
     <executions> 
      <execution> 
      <id>jee5</id> 
      <phase>package</phase> 
      <goals> 
       <goal>war</goal> 
      </goals> 
      <configuration> 
       <webappDirectory>${project.build.directory}/${project.build.finalName}-jee5</webappDirectory> 
       <classifier>jee5</classifier> 
       <packagingExcludes>WEB-INF/lib/jsf-api*,WEB-INF/lib/jsf-impl*,WEB-INF/lib/el-*</packagingExcludes> 
       <warSourceExcludes>WEB-INF/lib/jsf-api*,WEB-INF/lib/jsf-impl*,WEB-INF/lib/el-*</warSourceExcludes> 
      </configuration> 
      </execution> 
      <execution> 
      <id>tomcat6</id> 
      <phase>package</phase> 
      <goals> 
       <goal>war</goal> 
      </goals> 
      <configuration> 
       <webappDirectory>${project.build.directory}/${project.build.finalName}-tomcat6</webappDirectory> 
       <classifier>tomcat6</classifier> 
       <packagingExcludes>WEB-INF/lib/el-*</packagingExcludes> 
       <warSourceExcludes>WEB-INF/lib/el-*</warSourceExcludes> 
      </configuration> 
      </execution> 
     </executions> 
     <configuration> 
      <webResources> 
      <resource> 
       <directory>${basedir}/src/main/java</directory> 
       <targetPath>/WEB-INF/src</targetPath> 
      </resource> 
      </webResources> 
     </configuration> 
     </plugin> 

nell'orecchio profili d'uso pom alla dipendenza dalle importazioni richiesto con adeguate classificatore.

<profile> 
    <id>jee5</id> 
    <dependencies> 
    <dependency> 
     <groupId>org.richfaces.samples</groupId> 
     <artifactId>richfaces-demo</artifactId> 
     <version>${richfaces-version}</version> 
     <classifier>jee5</classifier> 
     <type>war</type> 
     <scope>runtime</scope> 
    </dependency> 
    </dependencies> 
</profile> 

Answer 3

So che questo ha 5 anni ora, ma era ancora la prima risposta che è venuta fuori quando ho cercato. Inoltre, mentre "quello non è il modo di pensare" è una risposta perfettamente ragionevole per alcune persone, altri potrebbero preferire ancora usare un singolo pom come richiesto dall'OP, e non è davvero così complicato.

Innanzitutto, creare un pom.xml di guerra standard per generare il file di guerra che si desidera includere nell'orecchio. Lascia la confezione come guerra.

Poi scrivere il proprio application.xml (in src/main/applicazione o dovunque) utilizzando un segnaposto per il nome del file di guerra:

<application xmlns="http://java.sun.com/xml/ns/javaee" ... > 
    <module> 
    <web> 
     <web-uri>${project.build.finalName}.war</web-uri> 
     <context-root>myapp</context-root> 
    </web> 
    </module> 
</application> 

E includere altri file XML specifici del server (weblogic-application .xml ecc.) nella stessa posizione.

Avanti, aggiungere una sezione di risorse per sostituire il segnaposto con il nome del file di guerra:

<resources> 
    <resource> 
    <directory>src/main/application</directory> 
    <filtering>true</filtering> 
    <includes> 
     <include>META-INF/*.xml</include> 
    </includes> 
    </resource> 
</resources> 

Infine, aggiungere un compito orecchio formica per costruire l'orecchio:

<plugin> 
    <artifactId>maven-antrun-plugin</artifactId> 
    <executions> 
    <execution> 
     <phase>package</phase> 
     <goals> 
     <goal>run</goal> 
     </goals> 
     <configuration> 
     <tasks> 
      <ear destfile="${project.build.directory}/${project.build.finalName}.ear" 
       appxml="${project.build.outputDirectory}/META-INF/application.xml"> 
      <fileset dir="${project.build.outputDirectory}" includes="META-INF/*.xml"/> 
      <fileset dir="${project.build.directory}" includes="${project.build.finalName}.war"/> 
      </ear> 
     </tasks> 
     </configuration> 
    </execution> 
    </executions> 
</plugin> 

E questo è tutto.