Maven2: Best practice per Enterprise Project (file EAR)

100

Sto solo passando da Ant a Maven e sto cercando di capire la migliore pratica per impostare un progetto Enterprise basato su file EAR?

Diciamo che voglio creare un progetto piuttosto standard con un file jar per gli EJB, un file WAR per il livello Web e il file EAR incapsulante, con i descrittori di distribuzione corrispondenti.

Come lo farei? Creare il progetto con archetypeArtifactId=maven-archetype-webappun file war ed estenderlo da lì? Qual è la migliore struttura del progetto (e un esempio di file POM) per questo? Dove si inseriscono i descrittori di distribuzione relativi al file ear, ecc.?

Grazie per qualsiasi aiuto.

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

Risposte:

96

Crei un nuovo progetto. Il nuovo progetto è il progetto di assembly EAR che contiene le due dipendenze per il progetto EJB e il progetto WAR.

Quindi in realtà hai tre progetti esperti qui. Un EJB. Una guerra. Un ORECCHIO che unisce le due parti e crea l'orecchio.

I descrittori di distribuzione possono essere generati da maven o inseriti nella directory delle risorse nella struttura del progetto EAR.

Il plug-in maven-ear è ciò che usi per configurarlo e la documentazione è buona, ma non del tutto chiara se stai ancora cercando di capire come funziona maven in generale.

Quindi, ad esempio, potresti fare qualcosa del genere:

<?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
fonte
98
Ho trovato la mia risposta un anno dopo, quando ho avuto la stessa domanda. Buon lavoro da solo!
— Mike Cornell
1
Per me ha funzionato quando ho impostato typecomeejb <type>ejb</type>
— gammay
Quel pom lancia alcuni avvertimenti: 'build.plugins.plugin.version' for org.apache.maven.plugins:maven-ear-plugin is missinge 'build.plugins.plugin.version' for org.apache.maven.plugins:maven-compiler-plugin is missing, quindi potresti voler aggiornare la tua altrimenti ottima risposta
— DiegoAlfonso
46

Ciò che mi ha aiutato molto è stato eseguire l'archetipo Maven: generare obiettivi e selezionare da uno degli archetipi, alcuni dei quali sembrano essere aggiornati regolarmente (in particolare JBoss sembra essere ben mantenuto).

mvn archetype:generate

Centinaia di archetipi sono apparsi in un elenco numerato da cui selezionare (519 per ora!). L'obiettivo, ancora in corso, mi ha spinto a effettuare una selezione inserendo un numero o inserendo una stringa di ricerca es:

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

Ho inserito la stringa di ricerca "ear", che ha ridotto l'elenco a soli 8 elementi (ad oggi):

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

Ho selezionato "org.jboss.spec.archetypes: jboss-javaee6-ear-webapp" (inserendo la selezione "5" in questo esempio).

Successivamente, l'obiettivo mi ha chiesto di inserire groupId, artifactId, i nomi dei pacchetti, ecc., E quindi ha generato la seguente applicazione di esempio ben documentata:

[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

Dopo aver letto i quattro file POM, che erano ben commentati, avevo praticamente tutte le informazioni di cui avevo bisogno.

./pom.xml
./Foo-ear/pom.xml
./Foo-ejb/pom.xml
./Foo-web/pom.xml
— Patrick Garner
fonte
3
Funziona, ma finisce per inserire un mucchio di dipendenze specifiche di jboss nel tuo progetto, che potresti o meno voler ripulire dopo il fatto.
— Ian McLaird
24

ho creato un repository GitHub per mostrare quella che penso sia una buona (o best practice) struttura del progetto di avvio ...

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

alcune parole chiave:

  • Maven 3
  • BOM (DependencyManagement delle proprie dipendenze)
  • Genitore per tutti i progetti (DependencyManagement da dipendenze esterne e PluginManagement per la configurazione globale del progetto)
  • JUnit / Mockito / DBUnit
  • Progetto Clean War senza WEB-INF / lib perché le dipendenze sono nella cartella EAR / lib.
  • Progetto Clean Ear.
  • Descrittori di distribuzione minimi per Java EE7
  • Nessuna interfaccia EJB locale perché @LocalBean è sufficiente.
  • Configurazione Maven minima tramite le proprietà utente Maven
  • Descrittori di distribuzione effettivi per Servlet 3.1 / EJB 3.2 / JPA 2.1
  • utilizzo del plugin macker-maven per controllare le regole dell'architettura
  • Test di integrazione abilitati, ma ignorati. (skipITs = false) utile da abilitare su CI Build Server

Uscita 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
fonte
2
Mi piace molto il tuo approccio al packaging e all'architettura. Dovresti pensare a confezionare il tuo progetto come un archetipo esperto.
— Jörg
2
Soluzione molto bella! Tuttavia, ho una domanda: perché non impacchettare il materiale della distinta base nel progetto principale? perché lo strato aggiuntivo?
— sschober
1
causa di separazione delle preoccupazioni. il bom potrebbe essere importato da altri progetti. hanno bisogno solo della gestione delle dipendenze delle tue dipendenze e non della gestione delle dipendenze che stai utilizzando. ok. puoi dire che se nessuno sta usando il tuo progetto questo strato aggiuntivo non è necessario .. ma penso che abbia anche senso ... leggibilità. la gestione delle dipendenze del progetto genitore non è mescolata con le tue dipendenze ... in un progetto più grande con> 50 progetti maven interni la gestione delle dipendenze all'interno del progetto genitore potrebbe essere un disastro ..
— StefanHeimberg
2
un altro motivo è che questa è la stessa struttura documentata su maven.apache.org/guides/introduction/… . questo aiuta a lavorare in un team in cui i membri del team cambiano spesso perché è il modo documentato "predefinito".
— StefanHeimberg
2
BTW. Ho creato una volta un progetto GitHub per mostrare come potrebbe essere eseguita una configurazione multi-progetto: github.com/StefanHeimberg/maven3-multiapplication-setup (per una discussione interna all'azienda)
— StefanHeimberg
7

NetBeans IDE definisce automaticamente la struttura che è quasi simile a quella suggerita da Patrick Garner. Per gli utenti NetBeans

File -> Nuovo progetto -> Nel lato sinistro selezionare Maven e Nel lato destro selezionare Maven Enterprise Application e premere Avanti -> Chiede i nomi dei progetti per war, ejb e impostazioni.

L'IDE creerà automaticamente la struttura per te.

— StackOverflow
fonte
Sono d'accordo con te, specialmente quando aderisco alle specifiche JEE6
— Sym-Sym
3

Questo è un buon esempio della parte del plugin maven-ear .

Puoi anche controllare gli archetipi Maven disponibili come esempio. Se esegui solo mvn archetype: generate otterrai un elenco di archetipi disponibili. Uno di essi è

maven-archetype-j2ee-simple
— HCPL
fonte
10
maven-archetype-j2ee-simplesembra inutilmente complessa nella struttura, in particolare con i moduli all'interno dei moduli e moduli separati per cose come la registrazione. Non ho capito la logica alla base di questa struttura
— Vihung
2

Ho cercato in alto e in basso per un esempio end-to-end di un'applicazione completa per le orecchie basata su maven e alla fine sono incappato in questo . Le istruzioni dicono di selezionare l'opzione 2 quando si esegue la CLI, ma per i propri scopi, utilizzare l'opzione 1.

— Roy Truelove
fonte
Il collegamento genera un errore non autorizzato. E questo è il motivo per scrivere soluzioni complete invece di fare affidamento sui link.
— Paco Abato
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.