Em Maven2, qual é a maneira mais simples de construir um WAR e EAR para conter essa guerra em um único POM?

Question

Situação é bastante simples. Eu tenho um webapp Java que eu estou convertendo a ser construído com Maven. No momento, o aplicativo é construído com Ant em um único arquivo WAR, que é então empacotados em um EAR com um application.xml muito simples.

maven-war-plugin e maven-ear-plugin tanto olhar bastante simples para mim, e parece que eles estão armando para mim ser forçado a considerar os acima como dois projectos distintos, com o projeto da guerra como uma dependência do projeto EAR. Este parece ser um inconveniente pouco, especialmente porque a definição do perfil do projeto da guerra vai mudar para cada ambiente, que parece que ele iria me forçar a duplicar esse acúmulo aprimorando cada vez que eu tentava construir o EAR também.

Tudo isso para dizer: há uma maneira simples de construir o WAR e pacote que neste trivialmente-simples EAR? Eu gostaria de evitar manter estes como dois projectos distintos, mas seria semelhante preferir não recorrer a uma corte excessivamente confuso usando montagens para alcançar este objetivo.

Answer 1

Tudo isso para dizer: há uma maneira simples de construir o WAR e pacote que neste trivialmente-simples EAR? Eu gostaria de evitar manter estes como dois projectos distintos, mas seria semelhante preferir não recorrer a uma corte excessivamente confuso usando montagens para alcançar este objetivo.

Resposta curta: não , não há simples maven-maneira de fazer isso, pois isso iria contra uma regra Maven que é "um artefato por projeto" (entender uma saída por projeto que é verdade em 99% dos casos).

E, na verdade, eu recomendo fortemente para não ir a maneira hacky e esquecer utilizando conjuntos para criar um EAR. Em vez disso, criar dois módulos, um com uma embalagem do tipo war, o outro com uma embalagem do tipo ear dependendo do artefato guerra e declará-los como módulos de um pom.xml pai. Como esta:

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 você vai para Maven, adotar a filosofia Maven, não lutar contra ela, ela vai lhe poupar muita dor. Sério, cortando montagens para fazer o que a orelha-plugin Maven já está fazendo é apenas anti DRY. É melhor vara para Ant nesse caso.

Answer 2

Eu sei que este é de 5 anos de idade agora, mas ainda era a primeira resposta que veio quando eu procurei. Além disso, enquanto "essa não é a maneira maven" é uma resposta perfeitamente razoável para algumas pessoas, outros ainda podem preferir usar um único pom como o OP pediu, e que não é realmente complicado.

Primeiro, crie um pom.xml guerra padrão para gerar o arquivo de guerra que deseja incluir no ouvido. Deixe a embalagem como a guerra.

Em seguida, escreva sua própria application.xml (em src / main / aplicação ou onde) utilizando um espaço reservado para o nome do arquivo 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 incluir quaisquer outros arquivos específicos do servidor xml (weblogic-application.xml etc.) no mesmo local.

Em seguida, adicione uma seção de recursos para substituir o espaço reservado com o nome do arquivo de guerra:

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

Finalmente, adicione uma tarefa ouvido formiga para construir a orelha:

<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 é isso.

Answer 3

Em Maven cada projecto produzir um aritifact. Em sua situação Sugiro criar dois um projeto para a guerra e um para orelha. Se você precisar de versões mutltiple de seus projetos você pode achive que o uso de classificadores e perfis.

Esta é trecho de richfaces exemplos 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>

em seu ouvido perfis de uso pom para importar dependência necessária com classificador apropriado.

<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>