wake-up-neo.net

Maven2: Best Practice für Enterprise Project (EAR-Datei)

Ich wechsele gerade von Ant zu Maven und versuche, die beste Vorgehensweise zum Einrichten eines EAR-dateibasierten Enterprise-Projekts zu finden.

Angenommen, ich möchte ein hübsches Standardprojekt mit einer JAR-Datei für die EJBs, einer WAR-Datei für die Webschicht und der einkapselnden EAR-Datei mit den entsprechenden Implementierungsdeskriptoren erstellen.

Wie würde ich vorgehen? Erstellen Sie das Projekt mit archetypeArtifactId=maven-archetype-webapp wie bei einer kriegsakte, und von dort aus verlängern? Was ist die beste Projektstruktur (und das beste Beispiel für eine POM-Datei)? Woher nehmen Sie die Bereitstellungsbeschreibungen für die EAR-Datei usw.?

Vielen Dank für jede Hilfe.

96
Maik

Sie legen ein neues Projekt an. Das neue Projekt ist Ihr EAR Assembly-Projekt, das Ihre beiden Abhängigkeiten für Ihr EJB-Projekt und Ihr WAR-Projekt enthält.

Sie haben hier also tatsächlich drei Maven-Projekte. Ein EJB. Ein KRIEG. Ein Ohr, das die beiden Teile zusammenzieht und das Ohr erzeugt.

Bereitstellungsdeskriptoren können von maven generiert oder im Ressourcenverzeichnis in der EAR-Projektstruktur abgelegt werden.

Das Maven-Ear-Plugin ist das, was Sie verwenden, um es zu konfigurieren, und die Dokumentation ist gut, aber nicht ganz klar, ob Sie noch herausfinden, wie Maven im Allgemeinen funktioniert.

Als Beispiel könnten Sie so etwas machen:

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

Was mir sehr geholfen hat, war das Ausführen des Maven-Archetyps: Ziel generieren und einen der Archetypen auswählen, von denen einige regelmäßig aktualisiert werden (insbesondere JBoss scheint gut gepflegt zu sein).

mvn archetype:generate

Hunderte von Archetypen erschienen in einer nummerierten Liste zur Auswahl (ab sofort 519!). Das noch laufende Ziel veranlasste mich, eine Auswahl zu treffen, indem ich eine Zahl oder einen Suchbegriff eingab, z.

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

Ich habe den Suchbegriff "ear" eingegeben, wodurch die Liste auf nur noch 8 Einträge reduziert wurde (Stand heute):

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

Ich habe "org.jboss.spec.archetypes: jboss-javaee6-ear-webapp" ausgewählt (indem ich in diesem Beispiel die Auswahl "5" eingebe).

Als Nächstes wurde ich aufgefordert, die Gruppen-ID, die Artefakt-ID, die Paketnamen usw. einzugeben. Anschließend wurde die folgende gut dokumentierte Beispielanwendung generiert:

[[email protected] 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

Nachdem ich die vier POM-Dateien gelesen hatte, die gut kommentiert waren, hatte ich so ziemlich alle Informationen, die ich brauchte.

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

ich habe ein Github-Repository erstellt, um zu zeigen, was meiner Meinung nach eine gute (oder bewährte) Startprojektstruktur ist ...

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

einige Schlüsselwörter:

  • Maven 3
  • Stückliste (DependencyManagement eigener Abhängigkeiten)
  • Übergeordnet für alle Projekte (DependencyManagement von externen Abhängigkeiten und PluginManagement für die globale Projektkonfiguration)
  • JUnit/Mockito/DBUnit
  • Clean War-Projekt ohne WEB-INF/lib, da sich Abhängigkeiten im Ordner EAR/lib befinden.
  • Clean Ear-Projekt.
  • Minimale Implementierungsbeschreibungen für Java EE7
  • Keine lokale EJB-Schnittstelle, da @LocalBean ausreicht.
  • Minimale Maven-Konfiguration durch Maven-Benutzereigenschaften
  • Aktuelle Bereitstellungsbeschreibungen für Servlet 3.1/EJB 3.2/JPA 2.1
  • verwendung des Macker-Maven-Plugins zur Überprüfung der Architekturregeln
  • Integrationstests aktiviert, aber übersprungen. (skipITs = false) Nützlich für die Aktivierung auf dem CI Build Server

Maven-Ausgabe:

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 definiert automatisch die Struktur, die fast der von Patrick Garner vorgeschlagenen ähnelt. Für NetBeans-Benutzer

Datei -> Neues Projekt -> Wählen Sie auf der linken Seite Maven und auf der rechten Seite Maven Enterprise Application und drücken Sie Weiter -> Fragt nach Projektnamen für War, EJB und Einstellungen.

Die IDE erstellt automatisch die Struktur für Sie.

7
stackOverflow

Ich habe auf der Suche nach einem End-to-End-Beispiel für eine vollständige maven-basierte, ohrenverpackte Anwendung und bin schließlich auf this gestoßen. In den Anweisungen wird angegeben, dass Option 2 ausgewählt werden soll, wenn die CLI ausgeführt wird. Verwenden Sie für Ihre Zwecke jedoch Option 1.

3
Roy Truelove

Dies ist ein gutes Beispiel für das Maven-Ear-Plugin Teil.

Sie können auch die als Beispiel verfügbaren Maven-Archetypen überprüfen. Wenn Sie nur mvn archetype: generate ausführen, erhalten Sie eine Liste der verfügbaren Archetypen. Einer von ihnen ist

maven-archetype-j2ee-simple
3
hcpl