web-dev-qa-db-fra.com

Maven2: Meilleures pratiques pour les projets d'entreprise (fichier EAR)

Je passe simplement de Ant à Maven et j'essaie de déterminer la meilleure pratique pour mettre en place un projet d'entreprise basé sur un fichier EAR?

Supposons que je souhaite créer un projet plutôt standard avec un fichier jar pour les EJB, un fichier WAR pour le niveau Web et le fichier EAR d'encapsulation, avec les descripteurs de déploiement correspondants.

Comment pourrais-je m'y prendre? Créez le projet avec archetypeArtifactId=maven-archetype-webapp comme avec un fichier de guerre, et s'étendre à partir de là? Quelle est la meilleure structure de projet (et exemple de fichier POM) pour cela? Où collez-vous les descripteurs de déploiement liés au fichier ear, etc.?

Merci pour toute aide.

java-eemaven-2earmaven-ear-plugin
96
Maik

Vous créez un nouveau projet. Le nouveau projet est votre projet d'assemblage EAR qui contient vos deux dépendances pour votre projet EJB et votre projet WAR.

Donc, vous avez réellement trois projets maven ici. Un EJB. Une guerre. Une oreille qui rassemble les deux parties et crée l'oreille.

Les descripteurs de déploiement peuvent être générés par maven ou placés dans le répertoire des ressources de la structure du projet EAR.

Le plugin maven-ear est ce que vous utilisez pour le configurer, et la documentation est bon, mais pas tout à fait clair si vous voyez toujours comment fonctionne maven en général.

Donc, à titre d'exemple, vous pourriez faire quelque chose comme ceci:

<?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>com.mycompany</groupId>
  <artifactId>myEar</artifactId>
  <packaging>ear</packaging>
  <name>My EAR</name>

  <build>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.5</source>
          <target>1.5</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-ear-plugin</artifactId>
        <configuration>
          <version>1.4</version>
          <modules>
            <webModule>
              <groupId>com.mycompany</groupId>
              <artifactId>myWar</artifactId>
              <bundleFileName>myWarNameInTheEar.war</bundleFileName>
              <contextRoot>/myWarConext</contextRoot>
            </webModule>
            <ejbModule>
              <groupId>com.mycompany</groupId>
              <artifactId>myEjb</artifactId>
              <bundleFileName>myEjbNameInTheEar.jar</bundleFileName>
            </ejbModule>
          </modules>
          <displayName>My Ear Name displayed in the App Server</displayName>
          <!-- If I want maven to generate the application.xml, set this to true -->
          <generateApplicationXml>true</generateApplicationXml>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-resources-plugin</artifactId>
        <version>2.3</version>
        <configuration>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
    </plugins>
    <finalName>myEarName</finalName>
  </build>

  <!-- Define the versions of your ear components here -->
  <dependencies>
    <dependency>
      <groupId>com.mycompany</groupId>
      <artifactId>myWar</artifactId>
      <version>1.0-SNAPSHOT</version>
      <type>war</type>
    </dependency>
    <dependency>
      <groupId>com.mycompany</groupId>
      <artifactId>myEjb</artifactId>
      <version>1.0-SNAPSHOT</version>
      <type>ejb</type>
    </dependency>
  </dependencies>
</project>
91
Mike Cornell

Ce qui m'a beaucoup aidé, c'est de gérer l'archétype Maven: générer un objectif et sélectionner l'un des archétypes, dont certains semblent être mis à jour régulièrement (JBoss, en particulier, semble bien entretenu).

mvn archetype:generate

Des centaines d'archétypes sont apparus dans une liste numérotée parmi laquelle sélectionner (519 dès maintenant!). L’objectif, toujours en cours, m’a demandé de faire une sélection en entrant un nombre ou en entrant une chaîne de recherche, par exemple:

513: remote -> org.xwiki.commons:xwiki-commons-component-archetype
514: remote -> org.xwiki.rendering:xwiki-rendering-archetype-macro
515: remote -> org.zkoss:zk-archetype-component
516: remote -> org.zkoss:zk-archetype-webapp
517: remote -> ru.circumflex:circumflex-archetype (-)
518: remote -> se.vgregion.javg.maven.archetypes:javg-minimal-archetype (-)
Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains):

Je suis entré dans la chaîne de recherche "ear", ce qui a réduit la liste à 8 éléments (à ce jour):

Choose archetype:
1: remote -> org.codehaus.mojo.archetypes:ear-j2ee14 (-)
2: remote -> org.codehaus.mojo.archetypes:ear-javaee6 (-)
3: remote -> org.codehaus.mojo.archetypes:ear-jee5 (-)
4: remote -> org.hibernate:hibernate-search-quickstart (-)
5: remote -> org.jboss.spec.archetypes:jboss-javaee6-ear-webapp 
6: remote -> org.jboss.spec.archetypes:jboss-javaee6-webapp-ear-archetype
7: remote -> org.jboss.spec.archetypes:jboss-javaee6-webapp-ear-archetype-blank
8: remote -> org.ow2.weblab.tools.maven:weblab-archetype-searcher

J'ai sélectionné "org.jboss.spec.archetypes: jboss-javaee6-ear-webapp" (en entrant la sélection "5" dans cet exemple).

Ensuite, l’objectif m’a demandé de saisir le groupId, artifactId, les noms de paquetages, etc., puis il a généré l’exemple d’application bien documenté suivant:

[pgarner@localhost Foo]$ tree
.
|-- Foo-ear
|   `-- pom.xml
|-- Foo-ejb
|   |-- pom.xml
|   `-- src
|       |-- main
|       |   |-- Java
|       |   |   `-- com
|       |   |       `-- foo
|       |   |           |-- controller
|       |   |           |   `-- MemberRegistration.Java
|       |   |           |-- data
|       |   |           |   `-- MemberListProducer.Java
|       |   |           |-- model
|       |   |           |   `-- Member.Java
|       |   |           `-- util
|       |   |               `-- Resources.Java
|       |   `-- resources
|       |       |-- import.sql
|       |       `-- META-INF
|       |           |-- beans.xml
|       |           `-- persistence.xml
|       `-- test
|           |-- Java
|           |   `-- com
|           |       `-- foo
|           |           `-- test
|           |               `-- MemberRegistrationTest.Java
|           `-- resources
|-- Foo-web
|   |-- pom.xml
|   `-- src
|       `-- main
|           |-- Java
|           |   `-- com
|           |       `-- foo
|           |           `-- rest
|           |               |-- JaxRsActivator.Java
|           |               `-- MemberResourceRESTService.Java
|           `-- webapp
|               |-- index.html
|               |-- index.xhtml
|               |-- resources
|               |   |-- css
|               |   |   `-- screen.css
|               |   `-- gfx
|               |       |-- banner.png
|               |       `-- logo.png
|               `-- WEB-INF
|                   |-- beans.xml
|                   |-- faces-config.xml
|                   `-- templates
|                       `-- default.xhtml
|-- pom.xml
`-- README.md

32 directories, 23 files

Après avoir lu les quatre fichiers POM, qui ont été bien commentés, j'avais à peu près toutes les informations dont j'avais besoin.

./pom.xml
./Foo-ear/pom.xml
./Foo-ejb/pom.xml
./Foo-web/pom.xml
46
Patrick Garner

j'ai créé un référentiel github pour montrer ce que j'estime être une bonne (ou meilleure pratique) structure de projet de démarrage ...

https://github.com/StefanHeimberg/stackoverflow-1134894

quelques mots-clés:

  • Maven 3
  • BOM (DependencyManagement de ses propres dépendances)
  • Parent pour tous les projets (DependencyManagement à partir de dépendances externes et PluginManagement pour la configuration globale du projet)
  • JUnit/Mockito/DBUnit
  • Projet Clean War sans WEB-INF/lib car les dépendances se trouvent dans le dossier EAR/lib.
  • Projet Clean Ear.
  • Descripteurs de déploiement minimaux pour Java EE7
  • Aucune interface EJB locale car @LocalBean est suffisant.
  • Configuration minimale de maven via les propriétés d'utilisateur maven
  • Descripteurs de déploiement réels pour Servlet 3.1/EJB 3.2/JPA 2.1
  • utilisation de macker-maven-plugin pour vérifier les règles d'architecture
  • Tests d'intégration activés, mais ignorés. (skipITs = false) utile pour activer sur CI Build Server

Sortie Maven: 

Reactor Summary:

MyProject - BOM .................................... SUCCESS [  0.494 s]
MyProject - Parent ................................. SUCCESS [  0.330 s]
MyProject - Common ................................. SUCCESS [  3.498 s]
MyProject - Persistence ............................ SUCCESS [  1.045 s]
MyProject - Business ............................... SUCCESS [  1.233 s]
MyProject - Web .................................... SUCCESS [  1.330 s]
MyProject - Application ............................ SUCCESS [  0.679 s]
------------------------------------------------------------------------
BUILD SUCCESS
------------------------------------------------------------------------
Total time: 8.817 s
Finished at: 2015-01-27T00:51:59+01:00
Final Memory: 24M/207M
------------------------------------------------------------------------
21
StefanHeimberg

NetBeans IDE définit automatiquement la structure qui est presque similaire à celle suggérée par Patrick Garner. Pour les utilisateurs de NetBeans

Fichier -> Nouveau projet -> Dans le côté gauche, sélectionnez Maven et Dans le côté droit, sélectionnez Maven Enterprise Application et appuyez sur Next -> Demande les noms de projet pour war, ejb et settings.

Le IDE créera automatiquement la structure pour vous.

7
stackOverflow

Je cherchais de haut en bas un exemple complet d'application complète à base d'oreille basée sur Maven et je suis finalement tombé sur this . Les instructions disent de choisir l’option 2 lors de l’exécution de la CLI mais que, pour vos besoins, utilisez l’option 1.

3
Roy Truelove

Ceci est n bon exemple du plugin maven-ear-plugin partie.

Vous pouvez également vérifier les archétypes maven disponibles à titre d'exemple. Si vous venez d'exécuter mvn archetype: generate, vous obtiendrez une liste des archétypes disponibles. L'un d'eux est

maven-archetype-j2ee-simple
3
hcpl