En Maven2, quelle est la façon la plus simple de construire une guerre et l'AER pour contenir que WAR en un seul POM?

Question

La situation est assez simple. J'ai Java webapp que je convertir à construire avec Maven. À l'heure actuelle, l'application est construite avec Ant dans un seul fichier WAR, qui est ensuite empaqueté dans une oreille avec un application.xml très simple.

maven-war-plugin et moi maven-ear-plugin à la fois l'air assez simple, et il semble qu'ils me mettre en place pour être forcé de considérer ce qui précède comme deux projets distincts, avec le projet WAR en tant que dépendance du projet EAR. Cela semble un peu gênant, surtout parce qu'un paramètre de profil du projet WAR va changer pour chaque environnement, ce qui semble que ce serait me forcer à dupliquer cette construction peaufinage chaque fois que je tentais de construire l'AER ainsi.

Tout cela pour dire: est-il un moyen simple de construire la guerre et que dans ce package EAR trivialement-simple? Je voudrais éviter de maintenir comme deux projets distincts, mais préférerais pas non plus d'avoir recours à une bidouille trop désordonnée en utilisant des ensembles pour accomplir cette tâche.

Answer 1

  

Tout cela pour dire: est-il un moyen simple de construire la guerre et que dans ce package EAR trivialement-simple? Je voudrais éviter de maintenir comme deux projets distincts, mais préférerais pas non plus d'avoir recours à une bidouille trop désordonnée en utilisant des ensembles pour accomplir cette tâche.

Réponse courte: pas , il n'y a pas maven-moyen simple de le faire, car cela irait à l'encontre d'une règle Maven qui est « un artefact par projet » (comprendre une sortie par projet qui est vrai dans 99% des cas).

Et en fait, je recommande fortement à pas aller dans le sens aki et oublier l'utilisation des ensembles pour créer un EAR. Au lieu de cela, créez deux modules, l'un avec un emballage de type war, l'autre avec un emballage de type ear en fonction de l'artefact de guerre et de les déclarer en tant que modules d'une pom.xml mère. Comme ceci:

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

Si vous optez pour Maven, adopter la philosophie Maven, ne pas lutter contre, il vous permettra d'économiser beaucoup de douleur. Sérieusement, les assemblées de piratage pour faire ce que l'maven-plugin-oreille est déjà en train de faire est juste contre SEC. Vous feriez mieux de tenir à Ant dans ce cas.

Answer 2

Je sais que c'est de 5 ans maintenant, mais il était toujours la première réponse qui est venu quand je cherchais. En outre, alors que « ce n'est pas la façon dont Maven » est une réponse tout à fait raisonnable pour certaines personnes, d'autres encore préfèrent utiliser un seul pom comme l'OP a demandé, et il est vraiment pas si compliqué que ça.

Tout d'abord, créez un pom.xml de guerre standard pour générer le fichier de guerre que vous voulez inclure dans l'oreille. Laissez l'emballage guerre.

Ensuite, écrivez votre propre application.xml (dans src / main / application ou chaque fois) en utilisant un espace réservé pour le nom du fichier de guerre:

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

et inclure tous les autres fichiers xml spécifiques au serveur (weblogic-application.xml etc.) au même endroit.

Ensuite, ajoutez une section de ressources pour remplacer l'espace réservé avec le nom du fichier de guerre:

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

Enfin, ajoutez une tâche d'oreille fourmi construit l'oreille:

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

Et voilà.

Answer 3

Dans Maven chaque projet produire un aritifact. Dans votre situation, je suggère de créer deux un projet pour la guerre et un pour l'oreille. Si vous avez besoin versions mutltiple de vos projets, vous pouvez achive que l'utilisation des classificateurs et des profils.

Ceci est extrait de richfaces exemples 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>

Dans vos oreilles profils pom utiliser pour importer la dépendance requise avec classificateur approprié.

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