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

100

Je suis juste en train de passer d'Ant à Maven et j'essaie de trouver la meilleure pratique pour mettre en place un projet d'entreprise basé sur un fichier EAR?

Disons que je veux créer un projet assez 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 procéderais-je? Créez le projet avecarchetypeArtifactId=maven-archetype-webapp comme avec un fichier war, et étendre à partir de là? Quelle est la meilleure structure de projet (et exemple de fichier POM) pour cela? Où placez-vous les descripteurs de déploiement liés au fichier ear, etc.?

Merci pour toute aide.

jakarta-ee  maven-2  ear  maven-ear-plugin 
— Maik
source

Réponses:

96

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.

Vous avez donc ici trois projets maven. 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 dans la structure du projet EAR.

Le plugin maven-ear-plugin est ce que vous utilisez pour le configurer, et la documentation est bonne, mais pas tout à fait claire si vous êtes toujours en train de comprendre comment maven fonctionne en général.

Donc, à titre d'exemple, vous pouvez 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>
— Mike Cornell
source
98
J'ai trouvé ma propre réponse un an plus tard lorsque j'ai eu la même question. Bon travail moi-même!
— Mike Cornell
1
Pour moi, cela a fonctionné lorsque je me suis installé typecommeejb <type>ejb</type>
— gammay
Ce pom jette quelques avertissements: 'build.plugins.plugin.version' for org.apache.maven.plugins:maven-ear-plugin is missinget 'build.plugins.plugin.version' for org.apache.maven.plugins:maven-compiler-plugin is missing, vous voudrez peut-être mettre à jour votre excellente réponse
— DiegoAlfonso
46

Ce qui m'a beaucoup aidé a été d'exécuter 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 (en particulier JBoss semble être bien entretenu).

mvn archetype:generate

Des centaines d'archétypes sont apparus dans une liste numérotée à partir de laquelle sélectionner (519 à partir de maintenant!). L'objectif, toujours en cours d'exécution, m'a incité à 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):

J'ai entré la chaîne de recherche "oreille", ce qui a réduit la liste à seulement 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é d'entrer le groupId, artifactId, les noms de package, etc., et il a ensuite 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
— Patrick Garner
source
3
Cela fonctionne, mais cela finit par mettre un tas de dépendances spécifiques à jboss dans votre projet, que vous voudrez peut-être ou non nettoyer après coup.
— Ian McLaird
24

J'ai créé un référentiel github pour montrer ce que je pense être une bonne structure de projet de démarrage (ou des meilleures pratiques) ...

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

quelques mots clés:

  • Maven 3
  • BOM (DependencyManagement of own dependencies)
  • 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
  • Pas d'interface EJB locale car @LocalBean est suffisant.
  • Configuration minimale de maven via les propriétés utilisateur de 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 à 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
------------------------------------------------------------------------
— StefanHeimberg
source
2
J'aime beaucoup votre approche packaging et architecturale. Vous devriez penser à empaqueter votre projet comme un archétype maven.
— Jörg
2
Très belle solution! J'ai une question cependant: pourquoi ne pas intégrer le contenu de la nomenclature dans le projet parent? pourquoi la couche supplémentaire?
— sschober
1
cause de séparation des préoccupations. la bom pourrait être importée par d'autres projets. ils n'ont besoin que de la gestion des dépendances de vos dépendances et non de la gestion des dépendances que vous utilisez. D'accord. vous pouvez dire que si personne n'utilise votre projet, cette couche supplémentaire n'est pas nécessaire .. mais je pense que cela a du sens aussi ... la lisibilité. la gestion des dépendances du projet parent n'est pas mélangée avec vos dépendances ... dans un plus gros projet avec> 50 projets maven internes, la gestion des dépendances à l'intérieur du projet parent pourrait être un désordre ..
— StefanHeimberg
2
une autre raison est qu'il s'agit de la même structure que celle documentée sur maven.apache.org/guides/introduction/… . cela aide à travailler dans une équipe où les membres de l'équipe changent souvent parce que c'est la manière documentée «par défaut».
— StefanHeimberg
2
BTW. J'ai créé un projet GitHub une fois pour montrer comment une configuration multi-projets pourrait être effectuée: github.com/StefanHeimberg/maven3-multiapplication-setup (pour une discussion interne de l'entreprise)
— StefanHeimberg
7

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 Suivant -> Demande des noms de projet pour war, ejb et paramètres.

L'EDI créera automatiquement la structure pour vous.

— stackOverflow
source
Je suis d'accord avec vous, en particulier lorsque je respecte les spécifications JEE6
— Sym-Sym
3

Ceci est un bon exemple de la partie maven-ear-plugin .

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

maven-archetype-j2ee-simple
— hcpl
source
10
maven-archetype-j2ee-simplesemble inutilement complexe dans sa structure - en particulier avec des modules à l'intérieur de modules, et des modules séparés pour des choses comme la journalisation. Je n'ai pas compris la raison d'être de cette structure
— Vihung
2

J'ai cherché haut et bas un exemple de bout en bout d'une application complète basée sur l'oreille basée sur maven et je suis finalement tombé sur cela . Les instructions indiquent de sélectionner l'option 2 lors de l'exécution via l'interface de ligne de commande, mais pour vos besoins, utilisez l'option 1.

— Roy Truelove
source
Le lien génère une erreur non autorisée. Et c'est la raison pour laquelle écrire des solutions complètes au lieu de s'appuyer sur des liens.
— Paco Abato
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.