Beispiel: Stateless Session Bean (IBM WebSphere)


Beispiel für eine Stateless Session Bean, auf die per Webclient und mittels Application Client zugegriffen wird.
Die Deployanleitung bezieht sich auf IBM WebSphere.
Hier gibt es das WebSphere-Projekt zum Download (dies ist ein Projektaustausch-Export, die Importanleitung findet man am Ende dieses Dokuments): StatelessExport.zip

Aufbau des Beispieles


a) Bean-Klasse mit Local und Remote-Interfaces.
b) Webclient: JSP-Seite
c) WebClient: Servlet
d) App-Client.


Anlegen der Application

Schritt 1: In der Karteikarte "J2EE-Hierarchie" einen Rechtsklick auf "Unternehmensanwendungen" ausführen und im Menü "Neu -> Unternehmensanwendungsprojekt" wählen.
Erzeugen einer Application (Schritt 1)
Schritt 2: Im Assisten auf Seite 1 die Option "J2EE1.3-Projekt erstellen" wählen.
Erzeugen einer Application (Schritt 2)
Schritt 3: Projektnamen vergeben.
Erzeugen einer Application (Schritt 3)
Schritt 4: Modulprojekte zufügen. Dazu auf den Button "Neues Modul" klicken.
Erzeugen einer Application (Schritt 4)
Schritt 5: Zu erzeugende Module definieren. Dieses Beispiel benötigt ein EJB-Projekt, einen Anwendungsclient und ein Webprojekt. Connectorprojekte werden wir in dieser Veranstaltung nie benötigen.
Erzeugen einer Application (Module erstellen)
Nach dem Klick auf "Fertigstellen kommt man wieder zum Assistenten zurück:
Erzeugen einer Application (Schritt 4a)
Man klickt auf "Fertigstellen" und hat folgende J2EE-Hierarchie angelegt:
Erzeugte J2EE-Hierarchie


Anlegen der StatelessBean

Schritt 1: In der J2EE-Hierarchie den Knoten "EJB-Module" \ "StatelessEJB" \ "Session-Beans" wählen. Rechtsklick, im Contextmenü den Punkt "Neu -> Session-Bean" wählen.
Stateless Session Bean, Step 1
Schritt 2: Die Bean wird dem eben erzeugten EJB-Projekt "StatelessEJB" zugefügt.
Stateless Session Bean, Step 2
Schritt 3: Typ der Bean (Session Bean), Bean-Name (ohne Zusatz "Bean") und Package angeben.
Stateless Session Bean, Step 3
Schritt 4: In diesem Dialog kann man fast alle Einstellungen auf dem Default belassen. Nur der Haken bei "Sicht lokaler Client" wird gesetzt, da unser Webclient auch die Local Interfaces verwenden soll.
Stateless Session Bean, Step 4
Schritt 5: Im nächsten Fenster beläßt man alle Werte auf den Defaults und klickt auf "Fertig stellen". Die J2EE-Hierarchie sieht jetzt so aus:
Erzeugte J2EE-Hierarchie mit Bean
Schritt 6: Vorbereiten der Business-Methoden:
Die beiden Business-Methoden werfen eine eigene Exception. Diese wird dem Projekt so zugefügt: Wechseln zur Ansicht "Projektnavigator", Package "com.knauf.ejb.stateless" im Projekt "StatelessEJB" auswählen. Rechtsklick, "Neu" -> "Klasse". Eine Klasse namens "InvalidParameterException" zufügen, die von "java.lang.Exception abgeleitet ist.
Stateless Session Bean, Step 6
Schritt 7: Hinzufügen der Business-Methoden:
Die Bean-Klasse "StatelessBean" wird bearbeitet und zwei methoden "computeCuboidVolume" und "computeCuboidSurface" zugefügt. Zu beachten ist, dass das Logging wie im Sun Application Server - Beispiel hier nicht funktioniert, da das Package "java.util.logging" erst in JDK 1.4 verfügbar ist.
Schritt 8: Business-Methoden in die Remote-Interfaces zufügen.
Dazu wählt man in der Gliederung (Fenster/TabPage links unten) die Methode "computeCuboidVolume" aus und klickt mit rechts darauf. Im Contextmenü wählt man den Punkt "Enterprise Bean" -> "Auf lokale Schnittstelle hochstufen" und "Auf Remote-Schnittstelle hochstufen". Das gleiche führt man für "computeCuboidSurface" durch.
Geschäftsmethoden in Interfaces überführen


Anlegen des Webclients

Schritt 1: In der J2EE-Hierarchie einen Rechtsklick auf "Webmodule" ausführen und im Contextmenü "Neu" -> "Andere..." wählen.
Webclient, Schritt 1
Schritt 2: Ein neues Web-Element, nämlich eine JSP-Datei, zufügen.
Webclient, Schritt 2
Schritt 3: Definition der JSP-Seite. Als Dateiname wird "GeometricModelTest" angegeben. Den Ordner wählt man nach einem Klick auf "Durchsuchen..." als "StatelessWeb\WebContent".
Webclient, Schritt 3a
Die Einstellungen sollten so aussehen:
Webclient, Schritt 3
Nach dem Klick auf "Fertig stellen" hat man die JSP-Seite erstellt und kann den Quellcode der JSP-Datei aus dem SunAppserver-Beispiel einfügen.
Nachbearbeitung:
Damit die JSP-Seite die EJB referenzieren kann, muss eine Referenz auf die JAR-Datei zugefügt werden.
Dazu einen Rechtsklick auf den J2EE-Hierarchie-Knoten "Webmodule \ StatelessWeb" ausführen und "Eigenschaften" wählen.
Webclient, EJB-Referenz
Unter dem Punkt "Java-JAR-Abhängigkeiten" wählt man die Option "EJB-Client-JARs verwenden" und setzt den Haken beim JAR der EJB-Datei.
Webclient, EJB-Referenz, Schritt 2
Achtung: Die Local-Interfaces haben hier andere Namen als im SunAppServer-Beispiel, d.h. hier die JSP-Seite anpassen.
Deklaration der EJB-Referenzen:
Per Doppelklick auf "Webmodule" \ "StatelessWeb" in der J2EE-Hierarchie gelangt man zum Bearbeiten des Webimplementierungsdeskriptors. Über die Karteikarten am unteren Rand wechselt man zu "Verweise" und kann dann am oberen Rand eine Referenz auf das Home-Interface sowie eine Referenz auf das LocalHome-Interface zufügen.
Webclient, EJB-Referenz, Schritt 3
Das gleiche wiederholt man für die Referenz auf die Local Interfaces. Webclient, EJB-Referenz, Schritt 4
Die so definierten Referenzen tauchen jetzt in der J2EE-Hierarchie auf:
Webclient, EJB-Referenz, Schritt 5


Server einrichten

Beim Ausführen der Anwendung (Rechtsklick auf das auszuführende Modul, "Auf Server ausführen" wählen) erscheint ein Dialog zum Einstellen des Servers. Beim ersten Mal müssen wir hier einen Server erstellen und wählen dazu die Testumgebung.
Server erstellen, Schritt 1
Die Portnummer belassen wir bei 9080.
Server erstellen, Schritt 2
In Schritt 3 belassen wir die Option "EJB-Beans implementieren" auf dem Defaultwert.
Server erstellen, Schritt 3


Testen der EJB

Die Entwicklungsumgebung bietet einen Testclient, mit dem es möglich ist, Methoden der EJBs ohne eigenen Client aufzurufen. Hier wird in der J2EE-Hierarchie ein Rechtsklick auf das zu testende EJB-Modul durchgeführt und die Option "Auf Server ausführen..." gewählt.
Auf Server ausführen, Schritt 1
Nach der Auswahl des Servers wird er gestartet (die Ausgabe erscheint in der Konsole unten rechts).
Es erscheint der Testclient. Man wählt als erstes die Option "JNDI-Browser", um sich eine Instanz einer Bean zu erstellen.
Auf Server ausführen, Schritt 2
Man klickt sich im Zweig "ejb" bis zum Home-Interface unserer GeometricModelBean durch (Achtung: scheint nur für Remote Interfaces zu funktionieren !).
Auf Server ausführen, Schritt 3
Nach einem Klick auf das Home-Interface gelangt man zur übersicht der EJB- und Objekt-Verweise, die man in diesem Testdurchlauf erzeugt hat. Man klickt sich im Home-Interface zur Create-Methode durch und wählt sie aus. Auf der rechten Seiten erscheint der Button "Aufrufen". Wenn man darauf klickt, erhält man eine Instanz der Bean. Man klickt auf "Mit Objekt arbeiten" und kann mit dieser Bean-Instanz arbeiten.
Auf Server ausführen, Schritt 4
In der Übersicht links erscheint die so erzeugt Instanz als "GeometricModel_1". Man klickt sie auf und wählt eine der "compute"-Methoden. Rechts kann man jetzt Parameter eingeben und die Methode mit diesen Parameter aufrufen.
Auf Server ausführen, Schritt 5


Testen des Webclients

In der J2EE-Hierarchie mit Rechts auf das Webmodul "StatelessWeb" klicken und "Auf Server ausführen..." wählen.
Es erscheint ein eingebettetes Browserfenster (Internet-Explorer). Die URL muss angepaßt werden, da dieses Beispiel keine Index-Seite bietet:
http://localhost:9080/StatelessWeb/GeometricModelTest.jsp


Anlegen des Application Clients

In der J2EE-Hierarchie "Anwendungsclientmodule" \ "StatelessApplicationClient" auswählen. Rechtsklick, und dann "Neu" -> "Andere..." wählen. Application Client, Schritt 1
Es wird eine neue Java-Klasse zugefügt:
Application Client, Schritt 2
Man gibt den Namen der Klasse an. Den Quellenordner wählt man durch Klick auf "Durchsuchen...", er liegt im Unterprojekt "StatelessApplicationClient", dieses hat per Default den Quell-Ordner "appClientModule". Außerdem soll eine "main"-Methode erzeugt werden.
Application Client, Schritt 3
Wie im Webclient muss hier eine Abhängigkeit zum EJB-Projekt definiert werden (Rechtsklick auf "StatelessApplicationClient", "Eigenschaften" wählen). Man wählt unter "Java-JAR-Abhängigkeiten" das Bean-JAR aus.
Application Client, Schritt 4

Nachbearbeitung:
Es muss festgelegt werden, welche Klasse die Startklasse der Anwendung ist. Dazu einen Doppelklick auf "StatelessApplicationClient" ausführen und im Clientimplementierungsdeskriptor unter "Hauptklasse" auf "Bearbeiten" klicken.
Application Client, Schritt 5
Man gelangt in das Fenster "Editor für JAR-Abhängigkeit", in dem man die Hauptklasse auswählen kann.
Application Client, Schritt 6
Als letzten Schritt muss man die EJB-Referenz auf das LocalInterface definieren. Dazu wählt man im "Clientimplementierungsdeskriptor" am unteren Rand die Karteikarte "Verweise" und im sich öffnenden Fenster "Hinzufügen..." (im Screenshot ist bereits das Ergebnis zu sehen).
Application Client, EJB-Referenzen, Schritt 1
Es öffnet sich ein Assistent für das Hinzufügen einer EJB-Referenz. Wir möchten einen "EJB-Verweis" zufügen.
Application Client, EJB-Referenzen, Schritt 2
Der Name des Verweises ist "ejb/GeometricModel", er bezieht sich auf die Bean "GeometricModel" im Projekt "StatelessEJB".
Application Client, EJB-Referenzen, Schritt 3
Damit haben wir erfolgreich die EJB-Referenz zugefügt.


Ausführen des Application Clients

Im Menü "Ausführen" den Punkt "Ausführen..." wählen.
Application Client ausführen, Schritt 1
Es muss zuerst ein neuer "WebSphere v5.1-Anwendungsclient" angelegt werden. Dazu auf "Neu" klicken und rechts den Namen ("StatelessApplicationClient") angeben sowie die Unternehmensanwendung und den Anwendungsclient auswählen. Auf "Anwenden" klicken, um die Änderungen zu speichern. Anschließend den Client mit "Ausführen" starten. Fertisch !

Austausch des Workspace

Um den kompletten Workspace so zu exportieren, dass er auf einem anderen Rechner wieder importiert werden kann, im Menü "Datei" den Punkt "Exportieren..." wählen. Als Exportziel wählen wir "Projektaustausch".
Export, Schritt 1
Im nächsten Schritt alle zu exportierenden Komponenten auswählen. Außerdem eine Zieldatei angeben.
Export, Schritt 2
Damit erhält man eine frei austauschbare Zip-Datei.

Re-Import:
Man öffnet WebSphere Studio und wählt beim Start ein leeres Verzeichnis als Arbeitsbereich.
Im Menü "Datei" ruft man "Importieren..." auf. Man wählt wiederum den Typ "Projektaustausch".
Import, Schritt 1
Im nächsten Schritt wählt man die Quelldatei (unsere eben exportierte Zip-Datei), den Zielpfad (per Default ist dies der Projekt-Workspace), und die zu importierenden Komponenten in der Zip-Datei.
Import, Schritt 2