Tutorial: Einfache Session
Bean, EJB3-Standard (Java_EJB_05) – Packen der Dateien in
Java-Archive (JAR) und 'deploy'
Voraussetzungen
für das Verständnis dieses Dokuments:
Grundkenntnisse in
der Programmierung von Java (Klassen, Methoden, Schleifen) oder
anderer Objekt-Orientierter Programmiersprachen (z.B. C++,
Modula-2, Pascal).
Kenntnisse im
Umgang mit Eclipse; empfohlen ist das Durcharbeiten der
Einführungsbeispiele
für das Programmieren mit Java.
|
Ungefährer
Zeitbedarf zum Durcharbeiten dieses Dokuments:
Arbeitszeit:
Ca. 15 bis 30 Minuten, je nach Routine im Umgang mit Eclipse.
|
Dieses
Dokument enthält die Anleitungen um die Dateien, die für
den Einsatz auf einem Java-Application-Server (JAS) und für die
Schnittstellen-Definition für Client-Programme erforderlich
sind, zu erstellen.
Zum
Erstellen der erforderlichen Dateien wird die Möglichkeit des
'Project archives', die das JBoss-IDE-Plugin für Eclipse
(Installation siehe Eclipse
Plugins installieren >
Installation
des JBoss-IDE-Plugins)
bietet, genutzt.
Die
damit erstellte JAR-Datei (Java-ARchiv) wird anschließend in
einem JAS (JBoss
in diesem Tutorial) 'deployed'; das heißt die Datei wird in das
dafür vorgesehene Verzeichnis des JAS kopiert und so an den JAS
'übergeben'.
Damit können Client-Programme (die noch
erstellt werden müssen) auf die Dienste des bisher erstellten
EJB zugreifen.
Als
letzter Teil dieses Schrittes werden jene Dateien, die die
Schnittstellen für die Client-Programme definieren, in eigene
JAR-Dateien gepackt.
Diese Dateien werden dann von den (noch zu
erstellenden) Client-Programmen importiert.
Inhaltsverzeichnis:
Vorigerer
Schritt: Codieren
Installationanleitung
für die frühere Version (vor EJB3-Standard)
Struktur
der JAR-Datei für den JAS
Vorbedingungen
'Project
archives' anlegen
Dateien
mit Java-Klassen hinzufügen
JAR-Datei
neu erstellen
JAR-Datei an den JAS
übergeben ('deploy')
* 'Deploy'
bei JBoss
* 'Deploy'
bei Glassfish
JAR-Datei für
Client-Programme erstellen
Test und
Fehlersuche (erst nach Fertigstellung des Client-Programms
möglich)
Weitere
Schritte und verwandte Dokumentation
Nächster
Schritt bzw. nächstes Tutorial:
Installationsanleitung
für die frühere Version (vor EJB3-Standard)
Wenn
Sie vor der Aufgabe stehen, Code für ältere EJBs adaptieren
zu müssen und die passende Anleitung dafür suchen dann
beginnen Sie bitte mit
Tutorial:
Einfache Session Bean (Java_EJB_01) – Einrichten des
Projects.
Das
äquivalente Dokument für das Erstellen von Archiven und
'deploy' am JAS ist Tutorial:
Einfache Session Bean (Java_EJB_01) – Packen der Dateien in
Java-Archive (JAR) und 'deploy'.
▲ zum
Inhaltsverzeichnis
Struktur
der JAR-Datei für den JAS
JAR-Dateien
enthalten Unterverzeichnisse mit Dateien in komprimierter (gepackter)
Form.
Der Algorithmus zum Komprimieren der Dateien kann nicht
beeinflußt werden und ist auch nicht von Interesse.
In
diesem Tutorial werden alle Dateien mit pre-compiliertem Java-Code in
die JAR-Datei für den JAS gepackt.
Im
EJB3-Standard ist die Beschreibungsdatei 'ejb-jar.xml' im
Unterverzeichnis 'META-INF' nicht mehr zwingend erforderlich.
Wenn
diese Datei fehlt wird als JNDI-Name der Name der Klasse für das
'Bean' mit der Erweiterung '/remote' verwendet.
Dieser
Name wurde in der Klasse ShowTimeDateBean (beschrieben im vorigen
Schritt: Tutorial:
Einfache Session Bean, EJB3-Standard (Java_EJB_05) - Codieren >
Gesamter Code > Klasse ShowTimeDateBean.java)
festgelegt.
Wie
ein beliebiger JNDI-Name zugeordnet werden kann wird im Tutorial:
Session Bean mit Datenbank-Zugriff, EJB3-Standard (Java_EJB_07) –
Packen der Dateien in Java-Archive (JAR) und 'deploy'
behandelt.
▲ zum
Inhaltsverzeichnis
Vorbedingungen
▲ zum
Inhaltsverzeichnis
'Project
archives' anlegen
|
Wenn
das bearbeitete Project das Erste im Eclipse-Workspace ist, für
das JAR-Dateien erstellt werden sollen (so wie vielleicht bei
diesem Tutorial), muss zuerst die View für die 'Project
archives' eröffnet werden.
Das
geschieht über die Auswahl Window > Show View >
Other... .
|
|
|
Im
darauf hin erscheinenden Fenster (Show View) wird Project
archives ausgewählt.
Project archives
ist innerhalb der Gruppe 'JBoss Tools' zu finden und wenn die
Auswahl nicht sichtbar ist, kann sie durch anklicken des kleinen
Dreiecks links neben 'JBoss Tools' sichtbar gemacht werden.
Anschließend
wird die Schaltfläche [ OK ] angeklickt um
einen neuen 'Reiter' im unteren Bereich zu öffnen.
|
|
|
Anschließend
wird das 'Project' ausgewählt für das die Anweisungen
festgelegt werden sollen.
Nach
dem Auswählen wird im Bereich für die 'Project archives'
eine Auswahlmöglichkeit der zu erstellenden Archive
angezeigt.
Aus diesen wird 'EJB JAR' ausgewählt.
|
 
|
|
Die
vorgegebenen Einstellungen werden beibehalten.
Nach
dem Anklicken der Schaltfläche [ Next > ]
wird eine Vorschau mit dem Namen und der Struktur der Datei mit
der Erweiterung 'jar' angezeigt.
|
|
|
Die
Datei ist derzeit noch leer; für sie werden später die
Regeln, was in diese Datei gepackt werden soll, festgelegt.
Durch
das Anklicken der Schaltfläche [ Finish ]
wird die Datei erstellt.
|
|
|
Die
neu erstellte Datei ist jetzt im Bereich des 'Project archives'
gelistet.
|
|
▲ zum
Inhaltsverzeichnis
Dateien
mit Java-Klassen hinzufügen
|
Die
Java-Klassen inklusive der durch die Java-'package's definierten
Verzeichnis-Struktur werden in das EJB aufgenommen.
Für
das Hinzufügen von Dateien (inklusive der
Verzeichnis-Struktur) wird die Datei 'Java_EJB_05.jar' mit der
rechten Maustaste angeklickt und aus dem Kontext-Menu New
Fileset ausgewählt.
|
|
|
Im
folgenden Fenster wird durch Anklicken der Schaltfläche
[ Workspace... ] (über dem Eingabefeld
'Includes') ein eigenes Fenster geöffnet, in dem als Nächstes
jenes Verzeichnis, in dem die Dateien mit den Java-Klassen –
inlusive der Verzeichnis-Struktur für die Java-'package's –
sind, ausgewählt werden kann.
|
|
|
Im
erscheinenden Auswahl-Fenster ('Folder Selection') wird wird zu
jenem Verzeichnis manövriert, in dem die Dateien mit den
Java-Klassen liegen.
Dieses Verzeichnis wurde in Schritt
1: Einrichten des Projects > Verzeichnisse für Quell-Code
und kompilierte Java-Klassen festlegen
definiert.
Die
Verzeichnis-Struktur wird angezeigt bzw. verborgen, wenn das
kleine Dreieck links neben einem Verzeichnis-Namen angeklickt
wird.
Die
Auswahl wird durch Anklicken der Schaltfläche [ OK ]
bestätigt und damit wird auch das Fenster geschlossen.
|
|
|
Im
Fenster für das 'New Fileset' werden dann die
Filter-Kriterien für die Dateien, die in die JAR-Datei
aufgenommen werden sollen, im Feld 'Includes' festgelegt:
**/*.class.
**/
bedeutet, dass alle Verzeichnisse in der Struktur auf Dateien mit
einem passenden Namen durchsucht werden.
*.class
bedeutet, dass alle Dateien, deren Namen mit .class
endet, in die JAR-Datei gepackt werden sollen.
Nach
Eingabe der Filter-Kriterien ist im Feld 'Preview' zu sehen,
welche Dateien ausgewählt sind.
Die
Definition wird durch Anklicken der Schaltfläche [ Finish ]
abgeschlossen und damit wird auch das Fenster geschlossen.
|
|
|
Im
Bereich des 'Project archives' ist dann sichtbar, welche Dateien
für das Packen in die JAR-Datei ausgewählt sind.
Die Struktur für
die JAR-Datei kann durch Anklicken des kleinen Dreiecks links
neben den Datei- bzw. Verzeichnis-Namen angezeigt oder verborgen
werden.
|
|
▲ zum
Inhaltsverzeichnis
JAR-Datei
neu erstellen
Bis
jetzt wurde nur festgelegt, welche Dateien in die JAR-Datei gepackt
werden.
In diesem kurzen Abschnitt wird beschrieben, wie die
JAR-Datei erstellt wird.
|
Dazu
wird die Datei 'Java_EJB_05.jar' mit der rechten Maustaste
angeklickt und aus dem Kontext-Menu Build Archive (Full)
ausgewählt.
Der
Vorgang des 'Packens' dauert nur Bruchteile einer Sekunde und es
wird keine Rückmeldung gegeben wenn der Vorgang beendet ist.
|
|
|
Die
erzeugte Datei ist in der Struktur des 'Package Explorer's zu
sehen und wenn Sie ganz sicher gehen wollen, können Sie diese
mit der rechten Maustaste anklicken und aus dem Kontext-Menu
Properties auswählen.
|
|
|
Im
anschließend angezeigten Fenster ist das Datum der
Datei-Erstellung zu sehen ('Last modified').
Damit
kann überprüft werden, ob die Datei neu erstellt wurde.
|
|
▲ zum
Inhaltsverzeichnis
JAR-Datei
an den JAS übergeben ('deploy')
Eclipse
bietet zwar die Möglichkeit die fertige JAR-Datei per
'Mausklicks' an verschiedene Java Application Server (JAS) zu
übergeben ('deploy').
Die Konfiguration und die
Benutzeroberfläche dieser Funktionalität ist aber häufigen
Änderungen unterzogen – deswegen verzichte ich auf eine
Beschreibung dieser Möglichkeit.
Neuere
Versionen verschiedener JAS bieten andere komfortable Möglichkeiten
eine Archiv-Datei zu übergeben:
JBoss
durch Kopieren der fertigen Archiv-Datei in das entsprechende
Verzeichnis des JAS.
Wenn JBoss manuell in einem
'Terminal'-Fenster gestartet ist, werden in diesem Fenster auch eine
Bestätigungsmeldung bzw. eventuelle Fehlermeldungen angezeigt.
Glassfish
ermöglicht das 'Hochladen' der Archiv-Datei über einen
Webbrowser.
Damit kann auch ein 'deploy' ausgeführt werden
wenn Glassfish auf einem anderen Computer gestartet ist.
▲ zum
Inhaltsverzeichnis
'Deploy'
bei JBoss
Im
folgenden Beispiel sind /workspace_and_project_directory
und
/jboss_home
Platzhalter
für das Verzeichnis mit der im vorigen Abschnitt erstellten
JAR-Datei und das Verzeichnis in dem JBoss installiert ist.
Zum
eingeben des Kommandos ist ein 'Terminal'-Window notwendig. Das kann
bei Fedora-Linux über die Auswahl Anwendungen
> Systemwerkzeuge > Terminal aufgerufen
werden.
Im
Terminal-Window wird folgendes Kommando eingegeben:
cp
/workspace_directory/Java_EJB_05.jar
/jboss_home/server/default/deploy
Im
nachfolgenden Beispiel ist /workspace_directory
jenes
Verzeichnis, in dem die Dateien des Projects innerhalb von Eclipse
enthalten sind, hier
/usr/JS_Data/eclipse_workspaces/java_ejb/Java_EJB_05.
/jboss_home
ist
das Stamm-Verzeichnis, in dem JBoss
installiert ist. Wenn die Installation so wie in JBoss
Java-Application-Server installieren > Installation von JBoss
beschrieben
erfolgt ist, ist dieses Verzeichnis /opt/jboss.
▲ zum
Inhaltsverzeichnis
'Deploy'
bei Glassfish
Im
folgenden Beispiel ist 192.168.0.99
die
TCP/IP-Adresse des Computer auf dem Glasfish gestartet ist.
4848
ist
das Port unter dem die Administrator-Konsole zum Übergeben des
Archivs aufgerufen werden kann.
8080
ist
das Port unter dem die mit dem Archiv übergebene Anwendung
aufgerufen werden kann.
Die
TCP/IP-Adresse (192.168.0.99)
wird bei Ihrer Installation mit hoher Wahrscheinlichkeit verschieden
sein.
Die Nummern der Ports (4848
und
8080)
werden vom Installationsprogramm so festgelegt und werden auch bei
Ihrer Installation gültig sein – sofern Sie die Ports
nicht nach der Installation geändert haben.
Eine
detaillierte Beschreibung für das 'deploy' bei Glassfish finden
Sie unter Glassfish
Java Application Server (JAS) installieren > Verwalten des JAS
über Webbrowser und 'deploy'eines WAR(Web-ARchive);
in diesem Abschnitt werden nur die wesentlichsten Schritte
dokumentiert
|
Eröffnen
Sie einen Webbrowser und geben Sie als URL die TCP/IP-Adresse (im
Beispiel: 192.168.0.99)
und den Port (Standardwert nach der Installation: 4848)
für die Glassfish-Administration ein.
Anschließend
erscheint die Anmeldekonsole (ohne Abbildung); auf dieser geben
Sie bitte den 'User Name' (Standardwert nach der Installation:
admin)
und das 'Password' (Standardwert nach der Installation:
adminadmin)
ein und klicken danach mit der linken Maustaste auf die
Schaltfläche [ Login ].
|
|
|
Im
folgenden Fenster klicken Sie zuerst bitte im linken Teil EJB
Modules an.
|
|
|
Im
neu erschienenen rechten Teil des Fensters klicken Sie bitte die
Schaltfläche [ Deploy ] an.
|
|
|
Im
folgenden Fenster klicken Sie zuerst auf die Schaltfläche
[ Durchsuchen ] und wählen im
anschließend geöffneten Fenster die erstellte
Archiv-Datei aus.
Die Auswahl der Datei wird durch einen Klick
auf die Schaltfläche [ Öffnen ]
bestätigt – damit wird auch das Fenster 'Datei
hochladen' geschlossen.
Durch
einen Klick auf die Schaltfläche [ OK ]
(rechts oben) wird das 'deploy' der Archiv-Datei ausgeführt.
|
|
|
Im
folgenden Fenster sehen Sie als Bestätigung eine Liste
aktiven Anwendungen des JAS.
|
|
▲ zum
Inhaltsverzeichnis
JAR-Datei
für Client-Programme erstellen
Für
das Client-Programm, das im Tutorial:
Client-Programm für einfache Session Bean, EJB3-Standard
(Java_EJB_06) erstellt
wird, ist eine JAR-Datei notwendig, die die Schnittstelle ('Remote')
des auf dem JAS laufenden EJB beschreibt. Die 'Beschreibung' legt
fest, welche Methoden (mit den zu übergebenden Parametern) des
EJB im Client-Programm aufgerufen werden können.
Wie
diese JAR-Datei erstellt wird ist in diesem Abschnitt beschrieben.
Das
Definieren der Dateien, die in diese JAR-Datei gepackt werden sollen,
erfolgt nach dem gleichen Schema wie in den vorigen Abschnitten (ab
'Project archives' anlegen)
beschrieben.
Aus diesem Grund werden nicht alle Schritte mit
Abbildungen dargestellt.
|
Durch
Anklicken des Bereiches 'project archives' mit der rechten
Maustaste wird das bekannte Kontext-Menu angezeigt.
Mit
der Auswahl von New Archive > JAR wird ein Fenster (New
JAR) geöffnet mit dem Parameterisierungen für die zu
erstellende Datei vorgenommen werden können.
|
|
|
Der
Name der Datei wird auf Java_EJB_05-client.jar
geändert.
Das ist notwendig, weil eine Datei mit dem
vorgegebenen Namen bereits existiert (Java_EJB_05.jar
als EJB-Container).
Anschließend
wird die Schaltfläche [ Workspace... ]
angeklickt.
|
|
|
Im
folgenden Fenster ('Select a destination') wird das Verzeichnis
'Java_EJB_05' ausgewählt. Damit wird eine eigene Datei
erstellt.
(Bei Auswahl von 'Java_EJB_05.jar' würde
innerhalb dieser Datei ein Unterverzeichnis eröffnet.).
Durch
Anklicken der Schaltfläche [ OK ] wird die
Auswahl des Verzeichnisses bestätigt.
|
|
|
Durch
das Anklicken der Schaltfläche [ Finish ] im
Fenster 'New JAR' wird die Datei erstellt.
|
|
|
Die
neu erstellte Datei ist jetzt im Bereich des 'Project archives'
gelistet.
|
|
|
In
die Datei werden nur Dateien mit Java-Klassen, die von
Client-Programmen importiert werden müssen, aufgenommen.
Für
das Hinzufügen dieser Dateien wird die gerade angelegte Datei
mit der rechten Maustaste angeklickt und aus dem Kontext-Menu New
Fileset ausgewählt.
|
|
|
Im
folgenden Fenster (Fileset Wizard) wird durch Anklicken der
Schaltfläche [ Workspace... ] ein weiteres
Fenster geöffnet.
|
|
|
Im
folgenden Fenster (Folder Selection) wird das Verzeichnis mit den
Dateien, die in die JAR-Datei aufgenommen werden sollen,
ausgewählt.
Darin
wird zum Verzeichnis gen/classes
manövriert.
Die Auswahl wird durch Anklicken der
Schaltfläche [ OK ] bestätigt.
|
|
|
Im
Fenster für das 'New Fileset' werden dann noch im Feld
'Includes' die Filterkriterien **/staticvalues/*.class
für die Auswahl der Dateien festgelegt.
Die
ausgewählte Klasse ('CountryConstants.class') ist dann im
Bereich 'Preview' gelistet.
Die
Auswahl wird durch Anklicken der Schaltfläche [ Finish ]
bestätigt und damit wird auch das Fenster geschlossen.
|
|
|
Das
Hinzufügen von 'Fileset's mit Dateien wird
* für
das Verzeichnis gen/classes
mit den Filterkriterien
**/remote/*.class
wiederholt.
Wenn
die Parameter korrekt definiert wurden, sind in den einzelnen
'Fileset's folgende Dateien
ausgewählt:
'js_ejb05/ejb/interfaces/ataticvalues/CountryConstants.class'
und
'js_ejb05/ejb/interfaces/remote/ShowTimeDateBeanRemote.class'
|
|
|
Im
Bereich des 'Project archives' ist dann sichtbar, welche Dateien
in die JAR-Datei gepackt werden.
Die
Struktur für die JAR-Datei kann durch Anklicken des kleinen
Dreiecks links neben den Datei- bzw. Verzeichnis-Namen angezeigt
oder verborgen werden.
|
|
|
Um
die JAR-Datei mit den definierten Inhaltsdateien zu erstellen wird
die Datei 'Java_EJB_05-client.jar' mit der rechten Maustaste
angeklickt und aus dem Kontext-Menu Build Archive (Full)
ausgewählt.
Der
Vorgang des 'Packens' dauert nur Bruchteile einer Sekunde und es
wird keine Rückmeldung gegeben wenn der Vorgang beendet ist.
Die
Methode wie geprüft werden kann, ob die Datei wie gewünscht
erstellt wurde, ist unter JAR-Datei
neu erstellen beschrieben.
|
|
▲ zum
Inhaltsverzeichnis
Test
und Fehlersuche (erst nach Fertigstellung des Client-Programms
möglich)
Ein
Test und eine eventuelle Suche nach Fehlern ist erst nach
Fertigstellung des Client-Programms (Tutorial:
Client-Programm für Einfache Session Bean, EJB3-Standard
(Java_EJB_06))
möglich.
In diesem Dokument finden Sie im Abschnitt >
Verbindungsdaten zum JAS codieren, Methode des EJB aufrufen und
Ergebnis anzeigen; Code testen
die
Anleitung für den Test.
Sollte der Test nicht das gewünschte
Ergebnis liefern finden Sie unter >
Hinweise zur Fehlersuche
eventuelle
Ursachen dafür.
▲ zum
Inhaltsverzeichnis
Weitere
Schritte und verwandte Dokumentation
|
Dokument
|
Inhalt
|
|
Client-Programm
für Einfache Session Bean, EJB3-Standard (Java_EJB_06)
|
Im nächsten
Tutorial wird ein einfaches Client-Programm, das die in diesem
Tutorial entwickelte EJB nutzt, vorgestellt.
Springen Sie zu
diesem Tutorial wenn Sie jetzt neugierig sind, wie die Methoden
des EJB durch ein Client-Programm ausgeführt werden und holen
Sie Schritt 4 dieses Tutorials anschließend nach.
|
|
Schritt
4: Packen in EAR-Datei und Ändern des JNDI-Namen
|
Im nächsten
Schritt dieses Tutorials wird eine Enterprise-ARchive- (EAR-)
Datei erstellt.
Das Verwenden einer EAR-Struktur ist notwendig,
wenn neben dem EJB (in eine Java-ARchiv-Datei) auch eine
zugehörige Web-Site (WAR-Datei) an den JAS
(Java-Application-Server) übergeben ('deployed') werden soll.
|
▲ zum
Inhaltsverzeichnis
