Da ist gerade Ruby on Rails Version 2.0 freigegeben und ich schreibe etwas über Java EE, obwohl ich mich schon darauf freue, die Rails-Unterstützung des iPhones auszuprobieren….
Ich habe in den vergangenen Jahren Erfahrungen mit verschiedenen Applikationsservern gesammelt. Um zu sehen, was der aktuelle Apache Geronimo kann, habe ich mal ein wenig damit herum gespielt.
Meine Experimente unterteile ich in drei Teile:
- Ein Durchstich (erledigt)
- Verwendung in der Entwicklung / Hot deployment und Entwicklung mit Exploded-Verzeichnissen (erledigt)
- Austesten der Persistenz-Engine
Eigentlich sollte sich noch ein vierter Teil anschließen: Last- und Dauerlasttests. Allerdings würde dieser Nutzungsszenarien und implementierte (Fach- bzw. Prozess-)Logik erfordern, um ein für meine typischen Szenarien aussagekräftiges Ergebnis zu liefern, da ich unterstelle, dass Geronimo grundsätzlich skalierbar und stabil ist.
Der Durchstich
Ich habe mit einem minimalen Durchstich begonnen. Dazu habe ich eine Reihe von Projekten in meiner Entwicklungsumgebung angelegt. Die Abhängigkeiten sind so in in der folgenden Abbildung dargestellt.
Abbildung 1. Die Projektstruktur.
Weiter habe ich dann ein paar Klassen geschrieben, die für einen kleinen Durchstich nötig waren. Die nächste Abbildung zeigt die beteiligten Klassen.
Abbildung 2. Die Projektstruktur.
Die Entitäten werden zwar nur von der Management-Komponente bearbeitet allerdings als Transferobjekte auch an die Web-Schicht übergeben. In den folgenden Abschnitten stelle ich auszugsweise die Implementierungen vor. Dabei habe ich mich auf den Fall Partner anlegen beschränkt. Die Ausgabe der Antwortseiten mittels einfachen JSPs habe ich ausgelassen…
Folgende Auszüge von Java-Klassen erwarten Sie:
sowie die erforderlichen Konfigurationen:
Die Web-Schicht
Dank Java EE und insbesondere der Servlet-API 2.5 kann man EJBs in Servlets injizieren lassen. Einerseits spart man sich den Lookup und andererseits sind Home-Interfaces obsolet.
Die Zeilen 3 und 4 in Listing 1 deklarieren ein Attribut, dass annotiert ist und die Client-Sicht (das Local-Interface) der gewünschten EJB injiziert bekommt. Zwar kann man auf die EJB nun direkt über das Attribut zugreifen, allerdings empfehle ich hier immer den Zugriff über einen Getter, da man auch nachträglich ohne viel Aufwand Anpassungen machen kann, wenn man beispielsweise das Servlet doch in einem Kontainer deployen muss, der nur Servlet-API 2.4 unterstützt und daher das Einweben von EJBs nicht funktioniert. Aus Darstellungsgründen habe ich den Getter hier weggelassen…
1 public class PartnerServlet extends HttpServlet {
2
3 @EJB( beanName = "ejb/PartnerService")
4 PartnerServiceLocal partnerService;
5
6 protected void doGet(HttpServletRequest request,
7 HttpServletResponse response)
8 throws ServletException, IOException
9 {
10 // ...
11 }
12
13 protected void doPost(HttpServletRequest request,
14 HttpServletResponse response)
15 throws ServletException, IOException
16 {
17 // ...
18
19 partnerService.partnerAnlegen(
20 createPartnerFor(
21 request.getParameterMap()));
22 response.sendRedirect( "/partner/" );
23 }
24
25 private Partner createPartnerFor(Map values) {
26 //...
27 }
28 }
Listing 1. PartnerServlet (mit eingewebter EJB)
1 <?xml version="1.0" encoding="UTF-8"?>
2 <web-app xmlns="http://java.sun.com/xml/ns/javaee"
3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
5 http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
6 version="2.5">
7
8 <servlet>
9 <servlet-name>partner</servlet-name>
10 <servlet-class>
11 de.ghadir.partner.web.PartnerServlet
12 </servlet-class>
13 </servlet>
14
15 <servlet-mapping>
16 <servlet-name>partner</servlet-name>
17 <url-pattern>/</url-pattern>
18 </servlet-mapping>
19
20 <ejb-local-ref>
21 <ejb-ref-name>ejb/PartnerService</ejb-ref-name>
22 <ejb-link>ejb/PartnerService</ejb-link>
23 </ejb-local-ref>
24 </web-app>
Listing 2. web.xml konfiguriert das PartnerServlet und die lokale Referenz auf PartnerService
PartnerManagement - die Session-Komponente
Die PartnerManagement-Komponente realisiert alle Anwendungsfälle im Zusammenhang mit der Entität Partner. Über eine Menge von Session-Beans können Bearbeitungs-Prozesse realisiert werden und verschiedenen Clients zur Verfügung gestellt werden. In dem Durchstich sind vorerst die einfachen Lebenszyklus-Methoden für zwei Entitäten realisiert. In Listing 3 und Listing 4 wird stellvertretend der Fall Partner anlegen dargestellt.
1 @Local
2 public interface PartnerServiceLocal {
3
4 void partnerAnlegen( Partner p );
5
6 // ...
7 }
Listing 3. Lokale Client-Sicht von PartnerService
1 @Stateless( name="ejb/PartnerService")
2 public class PartnerServiceBean
3 implements PartnerServiceLocal
4 {
5
6 @PersistenceContext( name = "partnerPU" )
7 EntityManager em;
8
9 public void partnerAnlegen( Partner p ) {
10 em.persist( p );
11 }
12
13 // ...
14 }
Listing 4. Bean-Implementierung von PartnerService
Entitätskomponente Partner
1 @Entity
2 public class Partner {
3
4 @Id
5 @GeneratedValue
6 private long id;
7
8 // ... Attribute etc. ...
9
10 // ...
11 }
Listing 5. JPA-Entität Partner
1 <?xml version="1.0" encoding="UTF-8"?>
2 <persistence
3 xmlns="http://java.sun.com/xml/ns/persistence">
4 <persistence-unit name="partnerPU">
5 <description> ... </description>
6 <provider>
7 org.apache.openjpa.persistence.PersistenceProviderImpl
8 </provider>
9 <class>de.ghadir.partner.entities.Partner</class>
10 <properties>
11 <property name="openjpa.ConnectionURL"
12 value="jdbc:derby:PartnerDB" />
13 <property name="openjpa.ConnectionDriverName"
14 value="org.apache.derby.jdbc.EmbeddedDriver" />
15 <property name="ConnectionUserName" value="app" />
16 <property name="openjpa.jdbc.SynchronizeMappings"
17 value="false" />
18 </properties>
19 </persistence-unit>
20 </persistence>
Listing 6. persistence.xml
Hot-Deployment / Exploded
Leider kann ich noch keine Aussage darüber treffen, wie Apache Geronimo mit großen Enterprise Anwendungen zurecht kommt. Aber für meine Experimente funktionierte das Hot-Deployment sehr gut.
| Anpassung an Komponente |
Hot-Deployment |
| Entitätskomponente Partner |
als Teil der anderen Komponenten |
| EJB-JAR PartnerManagement |
funktioniert |
| WebApp PartnerWeb |
funktioniert |
Tabelle 1. Hot-Deployment und Exploded-Modus
Fazit
Die Entwicklung mit dem Geronimo Server funktioniert sehr gut. Der Entwicklungszyklus ist dank des Hot-Deployment kurz. Die Unterstützung der aktuellen Java EE Standards erleichtert die Entwicklung ungemein. Ich freue mich schon, die Persistenz-Engine in Bezug auf Beziehungen (einschließlich verschiedener Lade- und Speicherstrategien), Query-Hints, Aggregationen und Co. auszuprobieren.
Meiner Ansicht nach sollte man auf Füllsätze verzichten und Informationen kurz und präzise darstellen. Die Form eines Textes so anzupassen, dass auch einem unaufmerksamen Leser darin enthaltene Kernpunkte auffallen, sollte meiner Meinung nach durch sinnvolle Übergänge und Erläuterungen erfolgen. Sinnlose Füllsätze haben da nichts zu suchen. Frau Minto beschreibt in ihrem Buch 
