5. Anhänge

Hier beschreiben wir die Installation und grundlegende Verwendung der Tools, die im Dokument „Java 5 Persistence in Practice“ verwendet werden. Die unten aufgeführten Informationen entsprechen dem Stand von Mai 2007. Sie werden schnell veralten. In diesem Fall wird dem Leser empfohlen, ähnliche, aber nicht identische Vorgehensweisen zu befolgen. Die Installationen wurden auf einem Rechner mit Windows XP Professional durchgeführt.

5.1. Java

Wir verwenden die neueste Java-Version, die bei Sun [http://www.sun.com] erhältlich ist. Die Downloads sind über die URL [http://java.sun.com/javase/downloads/index.jsp] zugänglich:

Führen Sie die JDK-Installation aus der heruntergeladenen Datei aus. Standardmäßig wird Java unter [C:\Program Files\Java] installiert:

5.2. Eclipse

5.2.1. Grundlegende Installation

Eclipse ist eine IDE, die unter der URL [http://www.eclipse.org/] verfügbar ist und von der URL [http://www.eclipse.org/downloads/] heruntergeladen werden kann. Im Folgenden laden wir Eclipse 3.2.2 herunter:

Sobald die ZIP-Datei heruntergeladen ist, entpacken Sie sie in einen Ordner auf Ihrer Festplatte:

Wir bezeichnen den oben gezeigten Eclipse-Installationsordner [C:\devjava\eclipse 3.2.2\eclipse] als <eclipse>. [eclipse.exe] ist die ausführbare Datei und [eclipse.ini] ist die Konfigurationsdatei. Werfen wir einen Blick auf deren Inhalt:

-vmargs
-Xms40m
-Xmx256m

Diese Argumente werden beim Starten von Eclipse wie folgt verwendet:

eclipse.exe -vmargs -Xms40m -Xmx256m

Dies führt zum gleichen Ergebnis wie die Verwendung der .ini-Datei, indem eine Verknüpfung erstellt wird, die Eclipse mit denselben Argumenten startet. Lassen Sie uns diese erläutern:

1. -vmargs: Gibt an, dass die folgenden Argumente für die Java Virtual Machine bestimmt sind, auf der Eclipse ausgeführt wird. Eclipse ist eine Java-Anwendung.
2. -Xms40m: ?
3. -Xmx256m: Legt die Speichergröße in MB fest, die der Java Virtual Machine (JVM) zugewiesen wird, auf der Eclipse läuft. Standardmäßig beträgt diese Größe 256 MB, wie hier gezeigt. Wenn das System es zulässt, sind 512 MB vorzuziehen.

Diese Argumente werden an die JVM übergeben, auf der Eclipse ausgeführt wird. Die JVM wird durch eine [java.exe]- oder [javaw.exe]-Datei repräsentiert. Wo befindet sich diese Datei? Tatsächlich gibt es mehrere Möglichkeiten:

• im PATH des Betriebssystems
• im Ordner <JAVA_HOME>/jre/bin, wobei JAVA_HOME eine Systemvariable ist, die den Stammordner eines JDK definiert.
• an einem Ort, der als Argument an Eclipse in der Form -vm <Pfad>\javaw.exe übergeben wird

Diese letzte Lösung ist vorzuziehen, da die beiden anderen von den Unwägbarkeiten späterer Anwendungsinstallationen abhängig sind, die entweder den OS-PATH oder die Variable JAVA_HOME ändern können.

Wir erstellen daher die folgende Verknüpfung:

Ziel	<eclipse>\eclipse.exe" -vm "C:\Program Files\Java\jre1.6.0_01\bin\javaw.exe" -vmargs -Xms40m -Xmx512m
Starten in	Eclipse-Installationsordner <eclipse>

Sobald dies erledigt ist, starten Sie Eclipse über diese Verknüpfung. Es erscheint ein Dialogfeld:

Ein [Arbeitsbereich] ist ein Arbeitsbereich. Übernehmen wir die vorgeschlagenen Standardwerte. Standardmäßig werden Eclipse-Projekte in dem in diesem Dialogfeld angegebenen Ordner <Arbeitsbereich> erstellt. Es gibt eine Möglichkeit, dieses Verhalten zu überschreiben. Genau das werden wir systematisch tun. Daher ist die in diesem Dialogfeld gegebene Antwort nicht wichtig.

Sobald dieser Schritt abgeschlossen ist, wird die Eclipse-Entwicklungsumgebung angezeigt:

Wir schließen die Ansicht [Willkommen] wie oben vorgeschlagen:

Bevor wir ein Java-Projekt erstellen, konfigurieren wir Eclipse, um das JDK festzulegen, das für die Kompilierung von Java-Projekten verwendet werden soll. Dazu wählen wir die Option [Fenster / Einstellungen / Java / Installierte JREs]:

Normalerweise sollte die JRE (Java Runtime Environment), die zum Starten von Eclipse selbst verwendet wird, in der Liste der JREs vorhanden sein. Dies ist in der Regel die einzige. Sie können JREs über die Schaltfläche [Hinzufügen] hinzufügen. Anschließend müssen Sie das Stammverzeichnis der JRE angeben. Die Schaltfläche [Suchen] startet eine Suche nach JREs auf der Festplatte. Dies ist eine gute Möglichkeit, den Überblick über die JREs zu behalten, die Sie installieren und dann beim Upgrade auf eine neuere Version vergessen haben, zu deinstallieren. Oben ist das markierte JRE dasjenige, das zum Kompilieren und Ausführen von Java-Projekten verwendet wird. Dies ist das in Abschnitt 5.1 installierte JRE, das auch zum Starten von Eclipse verwendet wird. Ein Doppelklick darauf öffnet dessen Eigenschaften:

Erstellen wir nun ein Java-Projekt [Datei / Neu / Projekt]:

Wählen Sie [Java-Projekt] und dann [Weiter] ->

In [2] geben wir einen leeren Ordner an, in dem das Java-Projekt installiert werden soll. In [1] geben wir dem Projekt einen Namen. Es muss nicht nach seinem Ordner benannt werden, wie das obige Beispiel vermuten lassen könnte. Sobald dies erledigt ist, klicken wir auf die Schaltfläche [Weiter], um zur nächsten Seite des Erstellungsassistenten zu gelangen:

Oben erstellen wir einen speziellen Ordner innerhalb des Projekts, um die Quelldateien (.java) zu speichern:

• In [1] sehen wir den Ordner [src], der die .java-Quelldateien enthalten wird
• Unter [2] sehen wir den Ordner [bin], in dem die kompilierten .class-Dateien gespeichert werden

Wir schließen den Assistenten ab, indem wir auf [Fertigstellen] klicken. Wir haben nun ein Java-Projektgerüst:

Klicken Sie mit der rechten Maustaste auf das Projekt [test1], um eine Java-Klasse zu erstellen:

1. In [1] den Ordner, in dem die Klasse erstellt werden soll. Standardmäßig schlägt Eclipse den aktuellen Projektordner vor.
2. In [2] das Paket, in dem die Klasse abgelegt wird
3. In [3] der Name der Klasse
4. In [4] geben wir an, dass die statische Methode [main] generiert werden soll

Wir bestätigen den Assistenten durch Klicken auf [Fertigstellen]. Das Projekt wird daraufhin um eine Klasse erweitert:

Eclipse hat das Klassenskelett generiert. Darauf kann durch Doppelklick auf [Test1.java] oben zugegriffen werden:

Wir ändern den obigen Code wie folgt:

Wir führen das Programm [Test1.java] aus: [Rechtsklick auf Test1.java -> Ausführen als -> Java-Anwendung]

Das Ergebnis der Ausführung wird im Fenster [Konsole] angezeigt:

Das [Console]-Fenster sollte standardmäßig angezeigt werden. Ist dies nicht der Fall, können Sie es über [Window/Show View/Console] aufrufen:

5.2.2. Auswahl eines Compilers

Mit Eclipse können Sie Code generieren, der mit Java 1.4, Java 1.5 und Java 1.6 kompatibel ist. Standardmäßig ist das Programm so konfiguriert, dass es Code generiert, der mit Java 1.4 kompatibel ist. Die JPA-API erfordert Java 1.5-Code. Wir ändern den Typ des generierten Codes über [Fenster / Einstellungen / Java / Compiler]:

• in [1]: Auswahl der Option [Java / Compiler]
• in [2]: Wählen Sie „Java 5.0-Kompatibilität“

5.2.3. Installation der Callisto-

Mit der oben installierten Basisversion können Sie Java-Konsolenanwendungen erstellen, jedoch keine Web- oder Swing-Anwendungen; andernfalls müssen Sie alles selbst erledigen. Wir werden verschiedene Plugins installieren:

Gehen Sie wie folgt vor [Hilfe/Software-Updates/Suchen und installieren]:

• Geben Sie unter [2] an, dass Sie neue Plugins installieren möchten

• Geben Sie in [3] die Websites an, auf denen nach Plugins gesucht werden soll
• Markieren Sie in [4] die gewünschten Plugins

• In [5] weist Eclipse darauf hin, dass Sie ein Plugin ausgewählt haben, das von anderen Plugins abhängt, die nicht ausgewählt wurden
• Verwenden Sie in [6] die Schaltfläche [Select Required], um die fehlenden Plugins automatisch auszuwählen
• Akzeptieren Sie in [7] die Lizenzbedingungen für diese verschiedenen Plugins

• In [8] sehen Sie eine Liste aller Plugins, die installiert werden
• Starten Sie in [9] den Download dieser Plugins
• Installieren Sie in [10] alle Plugins, sobald sie heruntergeladen wurden, ohne deren Signaturen zu überprüfen

• In [11] lassen Sie Eclipse neu starten, sobald die Plugins installiert sind
• Wenn Sie in [12] zu [Datei/Neu/Projekt] gehen, werden Sie feststellen, dass Sie nun Webanwendungen erstellen können, was zuvor nicht möglich war.

5.2.4. Installation des [ TestNG]-Plugins

TestNG (Test Next Generation) ist ein Tool für Unit-Tests, das vom Konzept her JUnit ähnelt. Es bietet jedoch Verbesserungen, weshalb wir es hier JUnit vorziehen. Wir gehen wie zuvor vor: [Hilfe/Software-Updates/Suchen und installieren]:

• Unter [2] geben wir an, dass wir neue Plugins installieren möchten

• In [3a] ist die [TestNG]-Downloadseite nicht aufgeführt. Wir fügen sie über [3b] hinzu
• In [4b]: Die Website des Plugins lautet [http://beust.com/eclipse]. In [4a] geben Sie ein, was Sie möchten.

• In [5a] wird das [TestNG]-Plugin für die Aktualisierung ausgewählt. In [5b] starten wir die Aktualisierung.
• In [6] wurde die Verbindung zur Website des Plugins hergestellt. Uns werden alle auf der Website verfügbaren Plugins angezeigt. Hier gibt es nur eines, das wir auswählen, bevor wir zum nächsten Schritt übergehen.

• In [7] akzeptieren wir die Lizenzbedingungen des Plugins
• In [8] sehen wir eine Liste aller Plugins, die installiert werden – in diesem Fall eines. Wir starten den Download. Dann läuft alles wie oben für Callisto-Plugins beschrieben ab.

Sobald Eclipse neu gestartet ist, können wir das Vorhandensein des neuen Plugins überprüfen, indem wir beispielsweise die verfügbaren Ansichten anzeigen [Fenster / Ansicht anzeigen / Sonstige]:

Wie oben gezeigt, gibt es nun eine [TestNG]-Ansicht, die zuvor nicht vorhanden war.

5.2.5. Installation des Plugins [ Hibernate Tools]

Hibernate ist ein JPA-Anbieter, und das [Hibernate Tools]-Plugin für Eclipse ist nützlich für die Entwicklung von JPA-Anwendungen. Stand Mai 2007 unterstützt nur die neueste Version (3.2.0beta9) die Arbeit mit Hibernate/JPA, und sie ist über den gerade beschriebenen Mechanismus nicht verfügbar. Es sind nur ältere Versionen verfügbar. Wir werden daher anders vorgehen.

Das Plugin ist auf der Hibernate Tools-Website verfügbar: http://tools.hibernate.org/.

• Wählen Sie in [1] die neueste Version von Hibernate Tools aus
• Laden Sie es unter [2] herunter

• Verwenden Sie unter [3] ein Entpackungsprogramm, um die heruntergeladene ZIP-Datei in den Ordner <eclipse> zu entpacken (am besten schließen Sie Eclipse vorher)
• In [4] bestätigen Sie, dass während des Vorgangs einige Dateien überschrieben werden

Starten Sie Eclipse neu:

• in [1]: Öffnen Sie eine Ansicht
• in [2]: Es gibt nun eine [Hibernate Console]-Perspektive

Wir werden das [Hibernate Tools]-Plugin nicht weiter verwenden (in [2] auf „Abbrechen“ klicken). Die Verwendung wird in den Beispielen des Tutorials erklärt.

Manchmal erkennt Eclipse neue Plugins nicht. Sie können das Programm mit der Option -clean dazu zwingen, alle Plugins erneut zu scannen. Die ausführbare Eclipse-Verknüpfung würde dann wie folgt geändert:

"<eclipse>\eclipse.exe" -clean -vm "C:\Program Files\Java\jre1.6.0_01\bin\javaw.exe" -vmargs -Xms40m -Xmx512m

Sobald die neuen Plugins von Eclipse erkannt wurden, entfernen Sie die oben genannte Option -clean.

5.2.6. Installation des [ SQL Explorer]-Plugins

Wir werden nun ein Plugin installieren, mit dem wir den Inhalt einer Datenbank direkt aus Eclipse heraus erkunden können. Die für Eclipse verfügbaren Plugins finden Sie auf der Website [http://eclipse-plugins.2y.net/eclipse/plugins.jsp]:

• unter [1]: die Eclipse-Plugins-Website
• unter [2]: Wählen Sie die Kategorie [Datenbank]
• [3]: Wählen Sie in der Kategorie [Database] eine nach Bewertung sortierte Ansicht aus (angesichts der geringen Anzahl an Abstimmenden nicht sehr zuverlässig)
• in [4]: QuantumDB steht an erster Stelle
• in [5]: Wir wählen SQLExplorer, das zwar älter ist und einen niedrigeren Rang einnimmt (3.), aber dennoch sehr gut ist. Wir gehen zur Website des Plugins [plugin-homepage]

• in [6] und [7]: Laden Sie das Plugin herunter.

• in [8]: Entpacken Sie die ZIP-Datei des Plugins in den Eclipse-Ordner.

Starten Sie zur Überprüfung Eclipse neu, optional mit der Option -clean:

• in [1]: Öffnen Sie eine neue Perspektive
• in [2]: Wir sehen, dass eine [SQL Explorer]-Perspektive verfügbar ist. Darauf kommen wir später zurück.

5.3. Tomcat 5.5 Servlet-Container

5.3.1. Installation

Um Servlets auszuführen, benötigen wir einen Servlet-Container. Hier stellen wir einen davon vor, Tomcat 5.5, verfügbar unter http://tomcat.apache.org/. Wir beschreiben die Vorgehensweise (Stand: Mai 2007) für die Installation. Falls bereits eine frühere Version von Tomcat installiert ist, sollte diese am besten zuerst entfernt werden.

Um das Produkt herunterzuladen, folgen Sie dem obigen Link [Tomcat 5.x]:

Sie können die .exe-Datei für die Windows-Plattform herunterladen. Starten Sie nach dem Herunterladen die Tomcat-Installation durch Doppelklick auf die Datei:

Akzeptieren Sie die Lizenzbedingungen ->

Klicken Sie auf [Weiter] ->

Übernehmen Sie den vorgeschlagenen Installationsordner oder ändern Sie ihn über [Durchsuchen] ->

Legen Sie den Benutzernamen und das Passwort für den Tomcat-Serveradministrator fest. Hier haben wir [admin / admin] verwendet ->

Tomcat 5.x benötigt JRE 1.5. Normalerweise sollte das auf Ihrem Rechner installierte JRE automatisch erkannt werden. Oben ist der Pfad zu der in Abschnitt 5.1 heruntergeladenen JRE 1.6 angegeben. Wenn kein JRE gefunden wird, geben Sie dessen Stammverzeichnis über die Schaltfläche [1] an. Sobald dies erledigt ist, klicken Sie auf die Schaltfläche [Installieren], um Tomcat 5.x zu installieren ->

Die Schaltfläche [Finish] schließt die Installation ab. Die Installation von Tomcat wird durch ein Symbol auf der rechten Seite der Windows-Taskleiste angezeigt:

Ein Rechtsklick auf dieses Symbol ermöglicht Ihnen den Zugriff auf die Befehle zum Starten und Stoppen des Servers:

Wir verwenden die Option [Dienst beenden], um den Webserver jetzt anzuhalten:

Beachten Sie die Änderung des Symbolstatus. Das Symbol kann aus der Taskleiste entfernt werden:

Tomcat wurde in dem vom Benutzer ausgewählten Ordner installiert, den wir nun als <tomcat> bezeichnen. Die Verzeichnisstruktur für die heruntergeladene Version Tomcat 5.5.23 sieht wie folgt aus:

Durch die Tomcat-Installation wurden dem [Start]-Menü mehrere Verknüpfungen hinzugefügt. Wir verwenden den unten stehenden Link [Monitor], um das Tomcat-Tool zum Stoppen und Starten zu starten:

Anschließend sehen wir das zuvor gezeigte Symbol:

Der Tomcat-Monitor kann durch Doppelklick auf dieses Symbol gestartet werden:

Mit den Schaltflächen [Start – Stopp – Pause] – Neustart können wir den Server starten, stoppen und neu starten. Wir starten den Server, indem wir auf [Start] klicken, und geben dann in einem Browser die URL http://localhost:8080 ein. Es sollte eine Seite ähnlich der folgenden angezeigt werden:

Über die folgenden Links können Sie überprüfen, ob Tomcat korrekt installiert wurde:

Alle Links auf der Seite [http://localhost:8080] sind einen Blick wert, und wir empfehlen dem Leser, sie sich anzusehen. Wir werden noch Gelegenheit haben, auf die Links zurückzukommen, mit denen Sie die auf dem Server bereitgestellten Webanwendungen verwalten können:

5.3.2. Bereitstellung einer Webanwendung auf dem Tomcat-Server

5.3.3. Bereitstellung

Eine Webanwendung muss bestimmte Regeln befolgen, um in einem Servlet-Container bereitgestellt werden zu können. Sei <webapp> das Verzeichnis einer Webanwendung. Eine Webanwendung besteht aus:

Klassen	im Ordner <webapp>\WEB-INF\classes
Java-Archiven	im Ordner <webapp>\WEB-INF\lib
Ansichten, Ressourcen (.jsp, .html, ...)	im Ordner <webapp> oder in Unterordnern

Die Webanwendung wird über eine XML-Datei konfiguriert: <webapp>\WEB-INF\web.xml. Diese Datei ist in einfachen Fällen nicht erforderlich, insbesondere wenn die Webanwendung nur statische Dateien enthält. Erstellen wir die folgende HTML-Datei:

<html>
    <head>
      <title>Application exemple</title>
  </head>
  <body>
      Application exemple active ....
  </body>
</html>

und speichern wir es in einem Ordner:

Wenn wir diese Datei in einem Browser laden, erhalten wir die folgende Seite:

Die vom Browser angezeigte URL zeigt, dass die Seite nicht von einem Webserver bereitgestellt, sondern direkt vom Browser geladen wurde. Wir möchten nun, dass sie über den Tomcat-Webserver verfügbar ist.

Kehren wir zum Verzeichnisbaum <tomcat> zurück:

Auf dem Tomcat-Server bereitgestellte Webanwendungen werden mithilfe von XML-Dateien konfiguriert, die sich im Ordner [<tomcat>\conf\Catalina\localhost] befinden:

Diese XML-Dateien können manuell erstellt werden, da ihre Struktur einfach ist. Anstelle dieses Ansatzes werden wir jedoch die von Tomcat bereitgestellten Web-Tools verwenden.

5.3.4. Tomcat-Verwaltung

Auf der Anmeldeseite http://localhost:8080 bietet der Server Links zur Verwaltung an:

Über den Link [Tomcat-Verwaltung] können wir die Ressourcen konfigurieren, die Tomcat den darin bereitgestellten Webanwendungen zur Verfügung stellt, wie beispielsweise einen Datenbank-Verbindungspool. Folgen wir dem Link:

Die angezeigte Seite weist darauf hin, dass für die Verwaltung von Tomcat 5.x ein spezielles Paket namens „admin“ erforderlich ist. Kehren wir zur Tomcat-Website [http://tomcat.apache.org/download-55.cgi] zurück:

Laden wir die ZIP-Datei mit der Bezeichnung [Web Application Administration] herunter und entpacken sie anschließend. Ihr Inhalt sieht wie folgt aus:

Der Ordner [admin] muss in den Ordner [<tomcat>\server\webapps] kopiert werden, wobei <tomcat> der Ordner ist, in dem Tomcat 5.x installiert wurde:

Der Ordner [localhost] enthält eine Datei [admin.xml], die in den Ordner [<tomcat>\conf\Catalina\localhost] kopiert werden muss:

Beenden Sie Tomcat und starten Sie es neu, falls es bereits lief. Rufen Sie dann über einen Browser erneut die Anmeldeseite des Webservers auf:

Klicken Sie auf den Link [Tomcat-Verwaltung]. Es wird eine Anmeldeseite angezeigt (möglicherweise müssen Sie die Seite neu laden oder aktualisieren, um sie zu sehen):

Hier müssen Sie die Anmeldedaten eingeben, die Sie bei der Tomcat-Installation angegeben haben. In unserem Fall geben wir als Benutzernamen und Passwort „admin“ ein. Wenn Sie auf die Schaltfläche [Login] klicken, gelangen Sie zur folgenden Seite:

Auf dieser Seite kann der Tomcat-Administrator

• Datenquellen,
• die für den E-Mail-Versand erforderlichen Informationen (Mail-Sessions)
• Umgebungsdaten, auf die alle Anwendungen zugreifen können (Umgebungseinträge),
• Tomcat-Benutzer und -Administratoren zu verwalten (Benutzer),
• Verwaltung von Benutzergruppen (Gruppen),
• Rollen definieren (d. h. was ein Benutzer tun darf und was nicht),
• die Eigenschaften der vom Server bereitgestellten Webanwendungen (Catalina-Dienst) definieren

Folgen wir dem obigen Link [Rollen]:

Eine Rolle ermöglicht es Ihnen, festzulegen, was ein Benutzer oder eine Gruppe von Benutzern tun darf und was nicht. Mit einer Rolle sind bestimmte Rechte verbunden. Jeder Benutzer ist einer oder mehreren Rollen zugeordnet und verfügt über die damit verbundenen Rechte. Die unten stehende Rolle [manager] gewährt das Recht, in Tomcat bereitgestellte Webanwendungen zu verwalten (Bereitstellung, Start, Herunterfahren, Entladen). Wir erstellen einen [manager]-Benutzer und ordnen ihm die Rolle [manager] zu, damit er Tomcat-Anwendungen verwalten kann. Dazu folgen wir dem Link [Users] auf der Verwaltungsseite:

Wir sehen, dass bereits eine Reihe von Benutzern vorhanden ist. Wir verwenden die Option [Create New User], um einen neuen Benutzer anzulegen:

Wir geben dem Benutzer „manager“ das Passwort „manager“ und weisen ihm die Rolle „manager“ zu. Wir bestätigen diese Hinzufügung über die Schaltfläche [Speichern]. Der neue Benutzer erscheint in der Benutzerliste:

Dieser neue Benutzer wird der Datei [<tomcat>\conf\tomcat-users.xml] hinzugefügt:

deren Inhalt wie folgt lautet:

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
  <role rolename="tomcat"/>
  <role rolename="role1"/>
  <role rolename="manager"/>
  <role rolename="admin"/>
  <user username="tomcat" password="tomcat" roles="tomcat"/>
  <user username="role1" password="tomcat" roles="role1"/>
  <user username="both" password="tomcat" roles="tomcat,role1"/>
  <user username="manager" password="manager" fullName="" roles="manager"/>
  <user username="admin" password="admin" roles="admin,manager"/>
</tomcat-users>

• Zeile 10: Der Benutzer [manager], der erstellt wurde

Eine weitere Möglichkeit, Benutzer hinzuzufügen, besteht darin, diese Datei direkt zu bearbeiten. Diese Vorgehensweise ist beispielsweise dann anzuwenden, wenn Sie das Passwort für das Admin- oder Manager-Konto vergessen haben.

5.3.5. Verwaltung bereitgestellter Webanwendungen

Kehren wir nun zur Anmeldeseite [http://localhost:8080] zurück und folgen wir dem Link [Tomcat Manager]:

Daraufhin wird eine Authentifizierungsseite angezeigt. Wir melden uns als manager / manager an, d. h. mit dem Benutzer mit der Rolle [manager], den wir gerade erstellt haben. Tatsächlich kann nur ein Benutzer mit dieser Rolle diesen Link verwenden. In Zeile 11 von [tomcat-users.xml] sehen wir, dass der Benutzer [admin] ebenfalls die Rolle [manager] hat. Wir könnten daher auch die Anmeldedaten [admin / admin] verwenden.

Wir gelangen zu einer Seite, auf der die derzeit in Tomcat bereitgestellten Anwendungen aufgelistet sind:

Über die Formulare am Ende der Seite können wir eine neue Anwendung hinzufügen:

Hier möchten wir die zuvor erstellte Beispielanwendung in Tomcat bereitstellen. Dazu gehen wir wie folgt vor:

Kontextpfad	/example	Der Name, der zur Identifizierung der Webanwendung verwendet wird , die bereitgestellt werden soll
Verzeichnis-URL	C:\data\work\2006-2007\eclipse\dvp-jpa\annexes\tomcat\example	Der Ordner der Webanwendung

Um die Datei [C:\data\work\2006-2007\eclipse\dvp-jpa\annexes\tomcat\example\example.html] abzurufen, fordern wir die URL [http://localhost:8080/exemple/exemple.html] von Tomcat an. Der Kontext wird verwendet, um den Stamm des Verzeichnisbaums der bereitgestellten Webanwendung zu benennen. Wir verwenden die Schaltfläche [Deploy], um die Anwendung bereitzustellen. Wenn alles gut läuft, erhalten wir die folgende Antwortseite:

und die neue Anwendung erscheint in der Liste der bereitgestellten Anwendungen:

Lassen Sie uns die obige Zeile „/example context“ auskommentieren:

/example	Link zu http://localhost:8080/exemple
Start	ermöglicht es Ihnen, die Anwendung zu starten
Stopp	ermöglicht es Ihnen, die Anwendung zu beenden
Neu laden	lädt die Anwendung neu. Dies ist beispielsweise erforderlich, wenn Sie bestimmte Klassen zur Anwendung hinzugefügt, bestimmte Klassen zur Anwendung hinzugefügt, geändert oder daraus gelöscht haben.
Entfernen	Entfernt den Kontext [/example]. Die Anwendung verschwindet aus der Liste der verfügbaren Anwendungen.

Nachdem unsere Anwendung /example nun bereitgestellt ist, können wir einige Tests durchführen. Wir rufen die Seite [example.html] über die URL [http://localhost:8080/exemple/vues/exemple.html] auf:

Eine weitere Möglichkeit, eine Webanwendung auf dem Tomcat-Server bereitzustellen, besteht darin, die über die Weboberfläche eingegebenen Informationen in einer [context].xml-Datei im Ordner [<tomcat>\conf\Catalina\localhost] anzugeben, wobei [context] der Name der Webanwendung ist.

Kehren wir zur Tomcat-Verwaltungsoberfläche zurück:

Entfernen wir die Anwendung [/example] über den Link [Undeploy]:

Die Anwendung [/example] ist nicht mehr in der Liste der aktiven Anwendungen enthalten. Definieren wir nun die folgende Datei [example.xml]:

<Context docBase="C:/data/travail/2006-2007/eclipse/dvp-jpa/annexes/tomcat/exemple">
</Context>

Die XML-Datei besteht aus einem einzigen <Context>-Tag, dessen docBase-Attribut den Ordner definiert, der die zu installierende Webanwendung enthält. Speichern wir diese Datei unter <tomcat>\conf\Catalina\localhost:

Stoppen und starten Sie Tomcat gegebenenfalls neu und zeigen Sie dann die Liste der aktiven Anwendungen über den Tomcat-Administrator an:

Die Anwendung [/example] ist tatsächlich vorhanden. Rufen wir die URL in einem Browser auf:

[http://localhost:8080/exemple/exemple.html]:

Eine auf diese Weise bereitgestellte Webanwendung kann wie zuvor über den Link [Undeploy] aus der Liste der bereitgestellten Anwendungen entfernt werden:

In diesem Fall wird die Datei [example.xml] automatisch aus dem Ordner [<tomcat>\conf\Catalina\localhost] entfernt.

Um eine Webanwendung in Tomcat bereitzustellen, können Sie schließlich auch ihren Kontext in der Datei [<tomcat>\conf\server.xml] definieren. Auf diesen Punkt werden wir hier nicht näher eingehen.

5.3.6. Webanwendung mit einer Startseite

Wenn wir die URL [http://localhost:8080/exemple/] aufrufen, erhalten wir folgende Antwort:

Bei einigen früheren Versionen von Tomcat hätten wir den Inhalt des physischen Verzeichnisses der Anwendung [/example] erhalten.

Wir können das System so konfigurieren, dass bei einer Anfrage an den Kontext eine sogenannte Startseite angezeigt wird. Dazu erstellen wir eine [web.xml]-Datei und legen sie im Ordner <example>\WEB-INF ab, wobei <example> der physische Ordner der Webanwendung [/example] ist. Die Datei sieht wie folgt aus:

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">

  <display-name>Application Exemple</display-name>
  <description>Application web minimale</description>
    <welcome-file-list>
        <welcome-file>/exemple.html</welcome-file>
    </welcome-file-list>    
</web-app>

• Zeilen 2–5: Das Stamm-Tag <web-app> mit Attributen, die aus der Datei [web.xml] der Tomcat-Anwendung [/admin] (<tomcat>/server/webapps/admin/WEB-INF/web.xml) kopiert und eingefügt wurden.
• Zeile 7: Der Anzeigename der Webanwendung. Dies ist ein frei wählbarer Name mit weniger Einschränkungen als der Name des Anwendungskontexts. Er kann beispielsweise Leerzeichen enthalten, was beim Kontextnamen nicht möglich ist. Dieser Name wird beispielsweise vom Tomcat-Administrator angezeigt:

1. Zeile 8: Beschreibung der Webanwendung. Dieser Text kann anschließend programmgesteuert abgerufen werden.
2. Zeilen 9–11: Die Liste der Willkommensdateien. Das <welcome-file-list>-Tag wird verwendet, um die Liste der Ansichten zu definieren, die angezeigt werden sollen, wenn ein Client den Anwendungskontext anfordert. Es kann mehrere Ansichten geben. Die erste gefundene Ansicht wird dem Client präsentiert. Hier haben wir nur eine: [/example.html]. Wenn ein Client also die URL [/example] anfordert, wird ihm tatsächlich die URL [/example/example.html] bereitgestellt.

Speichern wir diese [web.xml]-Datei in <example>\WEB-INF:

Wenn Tomcat noch läuft, können Sie es über den Link [Reload] zwingen, die Webanwendung [/example] neu zu laden:

Während dieses „Neuladevorgangs“ liest Tomcat die in [<example>\WEB-INF] enthaltene Datei [web.xml] erneut ein, sofern sie vorhanden ist. Dies ist hier der Fall. Falls Tomcat angehalten wurde, starten Sie es neu.

Rufen Sie über einen Browser die URL [http://localhost:8080/exemple/] auf:

Der Host-Datei-Mechanismus hat funktioniert.

5.3.7. Tomcat in Eclipse integrieren

Wir werden nun Tomcat in Eclipse integrieren. Diese Integration ermöglicht es Ihnen:

• Tomcat aus Eclipse heraus zu starten/zu stoppen
• Java-Webanwendungen zu entwickeln und auf Tomcat auszuführen. Die Eclipse/Tomcat-Integration ermöglicht es Ihnen, die Ausführung der Anwendung zu verfolgen (zu debuggen), einschließlich der Ausführung von Java-Klassen (Servlets), die von Tomcat ausgeführt werden.

Starten wir Eclipse und öffnen wir dann die Ansicht [Servers]:

• in [1]: Fenster/Ansicht anzeigen/Sonstige
• in [2]: Wählen Sie die Ansicht [Server] aus und klicken Sie auf [OK]

• in [1] haben wir nun eine neue Ansicht [Server]
• Klicken Sie in [2] mit der rechten Maustaste auf die Ansicht und wählen Sie [Neu/Server]
• Wählen Sie in [3] den Server [Tomcat 5.5] aus und klicken Sie dann auf [Weiter]

• Geben Sie in [4] das Installationsverzeichnis von Tomcat 5.5 an
• Geben Sie in [5] an, dass derzeit keine Eclipse-/Tomcat-Projekte vorhanden sind. Klicken Sie auf [Fertigstellen]

Durch das Hinzufügen des Servers erscheint ein Ordner im Eclipse-Projekt-Explorer [6] und ein Server in der Ansicht [Servers] [7]:

Die Ansicht [Servers] zeigt alle registrierten Server an; hier nur den soeben hinzugefügten Tomcat 5.5-Server. Ein Rechtsklick darauf öffnet ein Menü mit Befehlen zum Starten, Stoppen oder Neustarten des Servers:

Oben starten wir den Server. Beim Start werden eine Reihe von Protokollen in die Ansicht [Console] geschrieben:

16 mai 2007 09:51:57 org.apache.catalina.core.AprLifecycleListener lifecycleEvent
...
16 mai 2007 09:51:57 org.apache.coyote.http11.Http11BaseProtocol init
INFO: Initialisation de Coyote HTTP/1.1 sur http-8080
...
INFO: Find registry server-registry.xml at classpath resource
16 mai 2007 09:51:58 org.apache.catalina.startup.Catalina start
INFO: Server startup in 828 ms

Das Verständnis dieser Protokolle ist etwas gewöhnungsbedürftig. Wir werden uns vorerst nicht näher damit befassen. Es ist jedoch wichtig zu überprüfen, ob sie keine Fehler beim Laden des Kontexts anzeigen. Tatsächlich versucht der Tomcat/Eclipse-Server beim Start, den Kontext der von ihm verwalteten Anwendungen zu laden. Das Laden des Kontexts einer Anwendung umfasst die Verarbeitung ihrer [web.xml]-Datei und das Laden einer oder mehrerer Klassen, die sie initialisieren. Dabei können verschiedene Arten von Fehlern auftreten:

• Die Datei [web.xml] enthält einen Syntaxfehler. Dies ist der häufigste Fehler. Es wird empfohlen, ein Tool zu verwenden, das ein XML-Dokument während seiner Erstellung validieren kann.
• bestimmte zu ladende Klassen wurden nicht gefunden. Sie werden in [WEB-INF/classes] und [WEB-INF/lib] gesucht. Sie sollten generell das Vorhandensein der erforderlichen Klassen sowie die Schreibweise der in der Datei [web.xml] deklarierten Klassen überprüfen.

Der von Eclipse gestartete Server verfügt nicht über dieselbe Konfiguration wie der in Abschnitt 5.3 installierte. Um dies zu überprüfen, rufen Sie die URL [http://localhost:8080] über einen Browser auf:

Diese Antwort bedeutet nicht, dass der Server nicht funktioniert, sondern dass die angeforderte Ressource nicht verfügbar ist. Bei dem in Eclipse integrierten Tomcat-Server handelt es sich bei diesen Ressourcen um Webprojekte. Darauf gehen wir später noch ein. Stoppen wir Tomcat vorerst:

Der bisherige Betriebsmodus kann geändert werden. Kehren wir zur Ansicht [Servers] zurück und doppelklicken wir auf den Tomcat-Server, um dessen Eigenschaften aufzurufen:

Das Kontrollkästchen [1] ist für das bisherige Verhalten verantwortlich. Wenn es aktiviert ist, werden in Eclipse entwickelte Webanwendungen nicht in den Konfigurationsdateien des zugehörigen Tomcat-Servers, sondern in separaten Konfigurationsdateien deklariert. Infolgedessen stehen die Standardanwendungen des Tomcat-Servers – [admin] und [manager], zwei nützliche Anwendungen – nicht zur Verfügung. Deaktivieren wir also [1] und starten Tomcat neu:

Nachdem dies erledigt ist, rufen wir die URL [http://localhost:8080] in einem Browser auf:

Wir sehen das in Abschnitt 5.3.4 beschriebene Verhalten.

In unseren vorherigen Beispielen haben wir einen Browser außerhalb von Eclipse verwendet. Wir können auch einen in Eclipse integrierten Browser verwenden:

Oben wählen wir den internen Browser aus. Um ihn aus Eclipse heraus zu starten, können Sie das folgende Symbol verwenden:

Der tatsächlich gestartete Browser ist derjenige, der über die Option [Fenster -> Webbrowser] ausgewählt wurde. Hier erhalten wir den internen Browser:

Starten Sie bei Bedarf Tomcat aus Eclipse heraus und geben Sie die URL [http://localhost:8080] in [1] ein:

Folgen Sie dem Link [Tomcat Manager]:

Sie werden zur Eingabe des [Benutzernamens/Passworts] aufgefordert, die für den Zugriff auf die [Manager]-Anwendung erforderlich sind. Basierend auf der zuvor eingerichteten Tomcat-Konfiguration können Sie [admin/admin] oder [manager/manager] eingeben. Anschließend wird die Liste der bereitgestellten Anwendungen angezeigt:

5.4. Firebird-DBMS

5.4.1. Firebird-DBMS

Das Firebird-DBMS ist unter der URL [http://www.firebirdsql.org/] verfügbar:

• in [1]: Wählen Sie die Option [Download.Firebird Relational Database]
• in [2]: Wählen Sie die gewünschte Version von Firebird aus
• in [3]: Laden Sie die Installationsdatei herunter

Sobald die Datei [3] heruntergeladen wurde, doppelklicken Sie darauf, um das Firebird-DBMS zu installieren. Das DBMS wird in einem Ordner installiert, dessen Inhalt in etwa wie folgt aussieht:

Die Binärdateien befinden sich im Ordner [bin]:

fbguard.exe	ermöglicht es Ihnen, das DBMS zu starten/zu stoppen
isql.exe	Befehlszeilen-Client zur Verwaltung von Datenbanken

Beachten Sie, dass der DBMS-Administrator standardmäßig [SYSDBA] heißt und das Passwort [masterkey] lautet. Unter [Start] wurden Menüs hinzugefügt:

Über die Option [Firebird Guardian] können Sie das DBMS starten/beenden. Nach dem Start bleibt das DBMS-Symbol in der Windows-Taskleiste:

Um Firebird-Datenbanken mit dem Befehlszeilen-Client [isql.exe] zu erstellen und zu verwalten, müssen Sie die im Lieferumfang des Produkts enthaltene Dokumentation lesen, die über die Firebird-Verknüpfungen unter [Start/Programme/Firebird 2.0] zugänglich ist.

Eine schnelle Möglichkeit, mit Firebird zu arbeiten und SQL zu erlernen, ist die Verwendung eines grafischen Clients. Ein solcher Client ist IB-Expert, der im folgenden Abschnitt beschrieben wird.

5.4.2. Arbeiten mit dem Firebird-DBMS mithilfe von IB- Expert

Die Hauptwebsite von IB-Expert lautet [http://www.ibexpert.com/].

• Wählen Sie in [1] „IBExpert“ aus
• Wählen Sie in [2] den Download aus, nachdem Sie gegebenenfalls Ihre bevorzugte Sprache ausgewählt haben
• Wählen Sie unter [3] die Version „Personal“ aus, da diese kostenlos ist. Sie müssen sich jedoch auf der Website registrieren.
• Laden Sie unter [4] IBExpert herunter

IBExpert wird in einem Ordner installiert, der in etwa wie folgt aussieht:

Die ausführbare Datei lautet [ibexpert.exe]. Normalerweise ist im [Start]-Menü eine Verknüpfung verfügbar:

Nach dem Start zeigt IBExpert das folgende Fenster an:

Verwenden Sie die Option [ -Datenbank/Datenbank erstellen], um eine Datenbank zu erstellen:

Server (Server)	kann [local] oder [remote] sein. Hier befindet sich unser Server auf demselben Rechner wie [IBExpert]. Wir wählen [lokal]
Datenbank (Datenbank)	Verwenden Sie die Schaltfläche [Ordner] im Dropdown-Menü, um die Datenbankdatei auszuwählen. Firebird speichert die gesamte Datenbank in einer einzigen Datei. Dies ist einer ihrer Vorteile. Sie können die Datenbank von einem Computer auf einen anderen übertragen, indem Sie die Datei einfach kopieren. Die Endung [.fdb] wird automatisch hinzugefügt.
Benutzername	SYSDBA ist der Standardadministrator für aktuelle Firebird-Distributionen
Passwort (Benutzername)	masterkey ist das Passwort für den SYSDBA-Administrator in aktuellen Firebird-Distributionen
Dialekt	Der zu verwendende SQL-Dialekt
Datenbank registrieren (Datenbank registrieren)	Wenn dieses Kontrollkästchen aktiviert ist, zeigt IBExpert nach der Erstellung der Datenbank einen Link zu dieser an

Wenn beim Klicken auf die Schaltfläche [OK] zum Erstellen der Datenbank die folgende Warnung angezeigt wird:

bedeutet dies, dass Sie Firebird noch nicht gestartet haben. Starten Sie es. Es erscheint ein neues Fenster:

Zeichensatz (Zeichensatz)

Der zu verwendende Zeichensatz. Es wird empfohlen, [ISO-8859-1] aus der Dropdown-Liste auszuwählen, da dieser die Verwendung von lateinischen Zeichen mit Akzenten ermöglicht.

Serverversion (Serverversion)

[IBExpert] ist in der Lage, verschiedene von Interbase abgeleitete DBMS zu verwalten. Wählen Sie die Version von Firebird aus, die Sie installiert haben.

Sobald Sie dieses neue Fenster durch Klicken auf [Registrieren] bestätigt haben, sehen Sie das Ergebnis [1] im Fenster [Datenbank-Explorer]. Dieses Fenster kann versehentlich geschlossen werden. Um es wieder aufzurufen, gehen Sie wie folgt vor [2]:

Um auf die erstellte Datenbank zuzugreifen, doppelklicken Sie einfach auf den entsprechenden Link. IBExpert zeigt dann eine Baumstruktur an, über die Sie auf die Eigenschaften der Datenbank zugreifen können:

5.4.3. Erstellen einer Datentabelle

Erstellen wir eine Tabelle. Klicken Sie mit der rechten Maustaste auf [Tabellen] (siehe Fenster oben) und wählen Sie die Option [Neue Tabelle]. Dadurch öffnet sich das Fenster zur Definition der Tabelleneigenschaften:

Beginnen wir damit, die Tabelle über das Eingabefeld [1] mit dem Namen [ARTICLES] zu versehen:

Verwenden Sie das Eingabefeld [2], um einen Primärschlüssel [ID] zu definieren:

Ein Feld wird durch Doppelklick auf das Feld [PK] (Primärschlüssel) zum Primärschlüssel gemacht. Fügen wir über die Schaltfläche oben [3] Felder hinzu:

Solange wir unsere Definition nicht „kompiliert“ haben, wird die Tabelle nicht erstellt. Verwenden Sie die Schaltfläche [Compile] oben, um die Tabellendefinition abzuschließen. IBExpert bereitet die SQL-Abfragen zur Erstellung der Tabelle vor und bittet um Bestätigung:

Interessanterweise zeigt IBExpert die ausgeführten SQL-Abfragen an. So können Sie sowohl die SQL-Sprache als auch eventuell verwendete proprietäre SQL-Dialekte erlernen. Die Schaltfläche [Commit] bestätigt die aktuelle Transaktion, während [Rollback] sie abbricht. Hier bestätigen wir sie durch Klicken auf [Commit]. Sobald dies geschehen ist, fügt IBExpert die erstellte Tabelle zu unserer Datenbankstruktur hinzu:

Durch Doppelklicken auf die Tabelle können wir auf ihre Eigenschaften zugreifen:

Über das Fenster [Einschränkungen] können wir der Tabelle neue Integritätsbeschränkungen hinzufügen. Öffnen wir es:

Wir sehen die von uns erstellte Primärschlüsselbeschränkung. Wir können weitere Beschränkungen hinzufügen:

• Fremdschlüssel [Foreign Keys]
• Feldintegritätsbeschränkungen [Checks]
• Eindeutigkeitsbeschränkungen für Felder [Uniques]

Lassen Sie uns das festlegen:

• die Felder [ID, PRICE, CURRENTSTOCK, MINIMUMSTOCK] müssen >0 sein
• das Feld [NAME] darf nicht leer sein und muss eindeutig sein

Öffnen Sie das Fenster [Prüfungen] und klicken Sie mit der rechten Maustaste in den Bereich für die Definition von Einschränkungen, um eine neue Einschränkung hinzuzufügen:

Definieren wir nun die gewünschten Einschränkungen:

Beachten Sie oben, dass die Einschränkung [NAME<>''] zwei einfache Anführungszeichen verwendet, keine doppelten. Kompilieren Sie diese Einschränkungen über die Schaltfläche [Compile] oben:

Erneut beweist IBExpert seine Benutzerfreundlichkeit, indem es die ausgeführten SQL-Abfragen anzeigt. Wechseln wir nun zum Bereich [Constraints/Unique], um festzulegen, dass der Name eindeutig sein muss. Das bedeutet, dass derselbe Name nicht zweimal in der Tabelle vorkommen darf.

Definieren wir die Einschränkung:

Anschließend kompilieren wir sie. Sobald dies erledigt ist, öffnen Sie den Bereich [DDL] (Data Definition Language) für die Tabelle [ARTICLES]:

In diesem Fenster wird der SQL-Code zur Erstellung der Tabelle mit all ihren Einschränkungen angezeigt. Sie können diesen Code in einem Skript speichern, um ihn später auszuführen:

SET SQL DIALECT 3;
SET NAMES ISO8859_1;
CREATE TABLE ARTICLES (
    ID            INTEGER NOT NULL,
    NOM           VARCHAR(20) NOT NULL,
    PRIX          DOUBLE PRECISION NOT NULL,
    STOCKACTUEL   INTEGER NOT NULL,
    STOCKMINIMUM  INTEGER NOT NULL
);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_ID check (ID>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_PRIX check (PRIX>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_STOCKACTUEL check (STOCKACTUEL>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_STOCKMINIMUM check (STOCKMINIMUM>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_NOM check (NOM<>'');
ALTER TABLE ARTICLES ADD CONSTRAINT UNQ_NOM UNIQUE (NOM);
ALTER TABLE ARTICLES ADD CONSTRAINT PK_ARTICLES PRIMARY KEY (ID);

5.4.4. Daten in eine Tabelle einfügen

Nun ist es an der Zeit, Daten in die Tabelle [ARTICLES] einzugeben. Verwenden Sie dazu das [Daten]-Fenster:

Die Eingabe der Daten erfolgt durch Doppelklick auf die Eingabefelder der einzelnen Zeilen in der Tabelle. Eine neue Zeile wird über die Schaltfläche [+] hinzugefügt, eine Zeile über die Schaltfläche [-] gelöscht. Diese Vorgänge werden innerhalb einer Transaktion ausgeführt, die über die Schaltfläche [Transaktion festschreiben] bestätigt wird (siehe oben). Ohne diese Bestätigung gehen die Daten verloren.

5.4.5. Der [IB-Expert] SQL-Editor

Die SQL (Structured Query Language) ermöglicht es einem Benutzer:

1. Tabellen anzulegen, indem er den Datentyp, den sie speichern sollen, und die Einschränkungen, denen die Daten genügen müssen, angibt
2. Daten in diese einzufügen
3. bestimmte Daten zu ändern
4. andere Daten zu löschen
5. die Daten nutzen, um Informationen abzurufen
6. ...

Mit IBExpert können Benutzer die Schritte 1 bis 4 grafisch ausführen. Das haben wir gerade gesehen. Wenn eine Datenbank viele Tabellen mit jeweils Hunderten von Zeilen enthält, benötigen Sie Informationen, die visuell nur schwer zu erfassen sind. Nehmen wir zum Beispiel an, dass ein Online-Shop monatlich Tausende von Kunden hat. Alle Käufe werden in einer Datenbank erfasst. Nach sechs Monaten stellt sich heraus, dass das Produkt „X“ fehlerhaft ist. Das Unternehmen möchte alle Käufer kontaktieren, damit diese das Produkt gegen einen kostenlosen Umtausch zurückgeben können. Wie lassen sich die Adressen dieser Käufer ermitteln?

1. Man könnte alle Tabellen manuell durchgehen und nach diesen Käufern suchen. Das würde einige Stunden dauern.
2. Wir können eine SQL-Abfrage ausführen, die innerhalb von Sekunden eine Liste dieser Personen liefert

SQL ist immer dann nützlich, wenn

• die Datenmenge in den Tabellen groß ist
• viele Tabellen miteinander verknüpft sind
• die abzurufenden Informationen über mehrere Tabellen verteilt sind
• ...

Wir stellen nun den SQL-Editor von IBExpert vor. Sie können ihn über die Option [Extras/SQL-Editor] oder durch Drücken der Taste [F12] aufrufen:

Dadurch erhalten Sie Zugriff auf einen erweiterten SQL-Abfrage-Editor, in dem Sie Abfragen ausführen können. Geben wir eine Abfrage ein:

Führen Sie die SQL-Abfrage über die Schaltfläche [Ausführen] oben aus. Sie erhalten das folgende Ergebnis:

Oben wird auf der Registerkarte [Ergebnisse] die Ergebnistabelle für den SQL-Befehl [Auswählen] angezeigt. Um einen neuen SQL-Befehl auszuführen, wechseln Sie einfach zurück zur Registerkarte [Bearbeiten]. Dort sehen Sie dann den ausgeführten SQL-Befehl.

Mehrere Schaltflächen in der Symbolleiste sind nützlich:

• Mit der Schaltfläche [Neue Abfrage] können Sie zu einer neuen SQL-Abfrage übergehen:

Sie sehen dann eine leere Bearbeitungsseite:

Sie können nun eine neue SQL-Abfrage eingeben:

und diese ausführen:

Kehren wir zur Registerkarte [Bearbeiten] zurück. Die verschiedenen ausgeführten SQL-Anweisungen werden von [IBExpert] gespeichert. Mit der Schaltfläche [Vorherige Abfrage] können Sie zu einer zuvor ausgeführten SQL-Anweisung zurückkehren:

Sie gelangen dann zur vorherigen Abfrage zurück:

Mit der Schaltfläche [Nächste Abfrage] gelangen Sie zur nächsten SQL-Anweisung:

Anschließend wird die nächste SQL-Anweisung in der Liste der gespeicherten SQL-Anweisungen angezeigt:

Mit der Schaltfläche [Abfrage löschen] können Sie eine SQL-Anweisung aus der Liste der gespeicherten Anweisungen löschen:

Mit der Schaltfläche [Aktuelle Abfrage löschen] löschen Sie den Inhalt des Editors für die angezeigte SQL-Anweisung:

Mit der Schaltfläche [Commit] können Sie die an der Datenbank vorgenommenen Änderungen dauerhaft speichern:

Mit der Schaltfläche [RollBack] können Sie die seit dem letzten [Commit] an der Datenbank vorgenommenen Änderungen rückgängig machen. Wenn seit der Verbindung mit der Datenbank kein [Commit] durchgeführt wurde, werden die seit dieser Verbindung vorgenommenen Änderungen rückgängig gemacht.

Schauen wir uns ein Beispiel an. Fügen wir eine neue Zeile in die Tabelle ein:

Die SQL-Anweisung wird ausgeführt, aber es wird nichts angezeigt. Wir wissen nicht, ob die Einfügung stattgefunden hat. Um das herauszufinden, führen wir die folgende SQL-Anweisung [New Query] aus:

Wir erhalten das folgende Ergebnis:

Die Zeile wurde tatsächlich eingefügt. Sehen wir uns nun den Inhalt der Tabelle auf andere Weise an. Doppelklicken Sie im Datenbank-Explorer auf die Tabelle [ARTICLES]:

Wir erhalten die folgende Tabelle:

Mit der Schaltfläche mit dem Pfeil oben können Sie die Tabelle aktualisieren. Nach der Aktualisierung ändert sich die obige Tabelle nicht. Es scheint, als wäre die neue Zeile nicht eingefügt worden. Kehren wir zum SQL-Editor (F12) zurück und bestätigen wir die SQL-Anweisung mit der Schaltfläche [Commit]:

Sobald dies erledigt ist, kehren wir zur Tabelle [ARTICLES] zurück. Wir können sehen, dass sich nichts geändert hat, selbst wenn wir die Schaltfläche [Refresh] verwenden:

Öffnen Sie oben die Registerkarte [Fields] und kehren Sie dann zur Registerkarte [Data] zurück. Diesmal wird die eingefügte Zeile korrekt angezeigt:

Wenn die Ausführung der verschiedenen SQL-Anweisungen beginnt, eröffnet der Editor eine sogenannte Transaktion in der Datenbank. Die durch diese SQL-Anweisungen im SQL-Editor vorgenommenen Änderungen sind nur so lange sichtbar, wie Sie sich im selben SQL-Editor befinden (Sie können mehrere öffnen). Es ist, als würde der SQL-Editor nicht an der eigentlichen Datenbank arbeiten, sondern an einer eigenen Kopie davon. In Wirklichkeit funktioniert das nicht ganz so, aber diese Analogie kann uns helfen, das Konzept einer Transaktion zu verstehen. Alle Änderungen, die während einer Transaktion an der Kopie vorgenommen werden, sind erst dann in der eigentlichen Datenbank sichtbar, wenn sie über [Transaktion festschreiben] festgeschrieben wurden. Die aktuelle Transaktion wird dann beendet und eine neue Transaktion beginnt.

Änderungen, die während einer Transaktion vorgenommen wurden, können durch einen Vorgang namens [Rollback] rückgängig gemacht werden. Versuchen wir folgendes Experiment. Starten wir eine neue Transaktion (einfach die aktuelle Transaktion [Commit]) mit der folgenden SQL-Anweisung:

Führen wir diesen Befehl aus, der alle Zeilen aus der Tabelle [ARTICLES] löscht, und führen wir anschließend [New Query] mit dem folgenden neuen SQL-Befehl aus:

Wir erhalten das folgende Ergebnis:

Alle Zeilen wurden gelöscht. Denken Sie daran, dass dies an einer Kopie der Tabelle [ARTICLES] durchgeführt wurde. Um dies zu überprüfen, doppelklicken Sie unten auf die Tabelle [ARTICLES]:

und sehen Sie sich die Registerkarte [Daten] an:

Selbst wenn wir die Schaltfläche [Aktualisieren] verwenden oder zur Registerkarte [Felder] und dann wieder zurück zur Registerkarte [Daten] wechseln, bleibt der oben angezeigte Inhalt unverändert. Dies wurde bereits erklärt. Wir befinden uns in einer anderen Transaktion, die mit einer eigenen Kopie arbeitet. Kehren wir nun zum SQL-Editor (F12) zurück und verwenden die Schaltfläche [RollBack], um die vorgenommenen Zeilenlöschungen rückgängig zu machen:

Wir werden um Bestätigung gebeten:

Lassen Sie uns das überprüfen. Der SQL-Editor bestätigt, dass die Änderungen rückgängig gemacht wurden:

Führen wir die obige SQL-Abfrage zur Überprüfung noch einmal aus. Die zuvor gelöschten Zeilen sind nun wieder vorhanden:

Der Vorgang [Rollback] hat die Kopie, an der der SQL-Editor arbeitet, in den Zustand zurückversetzt, in dem sie sich zu Beginn der Transaktion befand.

5.4.6. Exportieren einer Firebird-Datenbank in ein SQL-Skript

Bei der Arbeit mit verschiedenen DBMS, wie es im Tutorial „Java 5 Persistence in Practice“ der Fall ist, ist es nützlich, eine Datenbank aus DBMS 1 in ein SQL-Skript exportieren und dieses Skript dann in DBMS 2 importieren zu können. Dies erspart eine Reihe manueller Arbeitsschritte. Dies ist jedoch nicht immer möglich, da DBMS oft proprietäre SQL-Erweiterungen haben.

Wir zeigen nun, wie man die vorherige [dbarticles]-Datenbank in ein SQL-Skript exportiert:

• in [1]: Tools / Metadaten extrahieren, um die Metadaten zu extrahieren
• in [2]: Registerkarte „Meta-Objekte“
• in [3]: Wählen Sie die Tabelle [Articles] aus, deren Struktur (Metadaten) Sie extrahieren möchten
• in [4]: um das links ausgewählte Objekt nach rechts zu verschieben

• in [5]: Die Tabelle [ARTICLES] wird in die extrahierten Metadaten aufgenommen
• in [6]: Über die Registerkarte [Datentabelle] wählen Sie die Tabellen aus, aus denen Sie den Inhalt extrahieren möchten (im vorherigen Schritt wurde die Tabellenstruktur exportiert)
• in [7]: um das links ausgewählte Objekt nach rechts zu verschieben
• in [8]: das erzielte Ergebnis

• in [9]: Auf der Registerkarte [Optionen] können Sie bestimmte Extraktionseinstellungen konfigurieren
• in [10]: Deaktivieren Sie die Optionen zur Generierung von SQL-Anweisungen für die Verbindung zur Datenbank. Diese sind spezifisch für Firebird und daher für uns nicht relevant.
• in [11]: Auf der Registerkarte [Output] können Sie angeben, wo das SQL-Skript generiert werden soll
• in [12]: Geben Sie an, dass das Skript in einer Datei generiert werden soll
• in [13]: Geben Sie den Speicherort dieser Datei an
• in [14]: Starten Sie die Generierung des SQL-Skripts

Das generierte Skript, ohne Kommentare, sieht wie folgt aus:

SET SQL DIALECT 3;
SET NAMES ISO8859_1;

CREATE TABLE ARTICLES (
    ID            INTEGER NOT NULL,
    NOM           VARCHAR(20) NOT NULL,
    PRIX          DOUBLE PRECISION NOT NULL,
    STOCKACTUEL   INTEGER NOT NULL,
    STOCKMINIMUM  INTEGER NOT NULL
);

INSERT INTO ARTICLES (ID, NOM, PRIX, STOCKACTUEL, STOCKMINIMUM) VALUES (1, 'article1', 100, 10, 1);
INSERT INTO ARTICLES (ID, NOM, PRIX, STOCKACTUEL, STOCKMINIMUM) VALUES (2, 'article2', 200, 20, 2);
INSERT INTO ARTICLES (ID, NOM, PRIX, STOCKACTUEL, STOCKMINIMUM) VALUES (3, 'article3', 300, 30, 3);

COMMIT WORK;

ALTER TABLE ARTICLES ADD CONSTRAINT CHK_ID check (ID>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_PRIX check (PRIX>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_STOCKACTUEL check (STOCKACTUEL>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_STOCKMINIMUM check (STOCKMINIMUM>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_NOM check (NOM<>'');
ALTER TABLE ARTICLES ADD CONSTRAINT UNQ_NOM UNIQUE (NOM);
ALTER TABLE ARTICLES ADD CONSTRAINT PK_ARTICLES PRIMARY KEY (ID);

Hinweis: Die Zeilen 1–2 sind spezifisch für Firebird. Sie müssen aus dem generierten Skript entfernt werden, um generisches SQL zu erhalten.

5.4.7. Firebird-JDBC-Treiber

Ein Java-Programm greift über einen für das verwendete DBMS spezifischen JDBC-Treiber auf Daten aus einer Datenbank zu:

In einer mehrschichtigen Architektur wie der oben dargestellten wird der JDBC-Treiber [1] von der [DAO]-Schicht (Data Access Object) verwendet, um auf Daten aus einer Datenbank zuzugreifen.

Der Firebird-JDBC-Treiber ist unter der URL verfügbar, von der Firebird heruntergeladen wurde:

• in [1]: Wählen Sie den JDBC-Treiber zum Herunterladen aus
• in [2]: Wählen Sie einen JDBC-Treiber aus, der mit JDK 1.5 kompatibel ist
• in [3]: Das Archiv mit dem JDBC-Treiber heißt [jaybird-full-2.1.1.jar]. Entpacken Sie diese Datei. Sie wird für alle JPA-Beispiele mit Firebird verwendet.

Wir legen sie in einem Ordner ab, den wir als <jdbc> bezeichnen:

Um diesen JDBC-Treiber zu überprüfen, verwenden wir Eclipse und das SQL Explorer-Plugin (Abschnitt 5.2.6). Wir beginnen mit der Deklaration des Firebird-JDBC-Treibers:

• in [1]: Gehen Sie zu „Window“ / „Preferences“
• in [2]: Wählen Sie die Option „SQL Explorer / JDBC-Treiber“
• in [3]: Wählen Sie den JDBC-Treiber für Firebird
• in [4]: Fahren Sie mit der Konfiguration fort
• in [5]: Gehen Sie zur Registerkarte [Extra Class Path]
• Wählen Sie in [6] die JDBC-Treiberdatei aus. Nach der Auswahl erscheint sie in [7]. Wählen Sie hier den zuvor im Ordner <jdbc> abgelegten Treiber aus
• in [8]: der Java-Klassenname des JDBC-Treibers. Dieser kann durch Klicken auf die Schaltfläche [8b] abgerufen werden.
• Klicken Sie auf [OK], um die Konfiguration zu bestätigen

• in [9]: Der Firebird-JDBC-Treiber ist nun konfiguriert. Sie können ihn nun verwenden.

• In [1]: Öffnen Sie eine neue Perspektive
• in [2]: Wählen Sie die Perspektive [SQL Explorer] aus

• in [3]: Erstellen Sie eine neue Verbindung
• Schritt [4]: Geben Sie ihr einen Namen
• in [5]: Wählen Sie den Firebird-JDBC-Treiber aus der Dropdown-Liste aus
• in [6]: Geben Sie die URL der Datenbank an, zu der Sie eine Verbindung herstellen möchten, hier: [jdbc:firebirdsql:localhost/3050:C:\data\2006-2007\eclipse\dvp-jpa\annexes\jpa\jpa.fdb]. [jpa.fdb] ist die zuvor mit IBExpert erstellte Datenbank.
• in [7]: den Benutzernamen für die Verbindung, in diesem Fall [sysdba], den Firebird-Administrator
• in [8]: dessen Passwort [masterkey]
• Bestätigen Sie die Verbindungseinstellungen, indem Sie auf [OK] klicken

• in [1]: Doppelklicken Sie auf den Namen der Verbindung, die Sie öffnen möchten
• in [2]: Melden Sie sich an (sysdba, masterkey)
• in [3]: Die Verbindung ist geöffnet
• in [4]: Die Datenbankstruktur wird angezeigt. Die Tabelle [ARTICLES] ist sichtbar. Wählen Sie sie aus.

• In [5]: Im Fenster [Database Detail] sehen Sie die Details des in [4] ausgewählten Objekts, in diesem Fall der Tabelle [ARTICLES]
• in [6]: Auf der Registerkarte [Spalten] wird die Tabellenstruktur angezeigt
• in [7]: Die Registerkarte [Vorschau] zeigt die Tabellenstruktur an

Sie können SQL-Abfragen im Fenster [SQL-Editor] ausführen:

• in [1]: Wählen Sie eine offene Verbindung aus
• in [2]: Geben Sie die auszuführende SQL-Anweisung ein
• in [3]: Führen Sie sie aus
• in [4]: Überprüfen Sie die ausgeführte Anweisung
• in [5]: das Ergebnis

5.5. Das DBMS- t MySQL5

5.5.1. Installation

Das DBMS MySQL5 ist unter der URL [http://dev.mysql.com/downloads/] verfügbar:

• unter [1]: Wählen Sie die gewünschte Version
• in [2]: Wählen Sie eine Windows-Version

• in [3]: Wählen Sie die gewünschte Windows-Version
• in [4]: Die heruntergeladene ZIP-Datei enthält eine ausführbare Datei [Setup.exe] [4b], die Sie extrahieren und ausführen müssen, um MySQL5 zu installieren

• in [5]: Wählen Sie eine Standardinstallation
• in [6]: Sobald die Installation abgeschlossen ist, können Sie den MySQL5-Server konfigurieren

• in [7]: Wählen Sie eine Standardkonfiguration, bei der die wenigsten Fragen gestellt werden
• in [8]: Der MySQL5-Server wird als Windows-Dienst ausgeführt

• in [9]: Standardmäßig ist der Serveradministrator „root“ ohne Passwort. Sie können diese Konfiguration beibehalten oder ein neues Passwort für „root“ festlegen. Wenn die MySQL5-Installation auf die Deinstallation einer früheren Version folgt, kann dieser Schritt fehlschlagen. Es gibt keine Möglichkeit, dies rückgängig zu machen.
• in [10]: Sie werden aufgefordert, den Server zu konfigurieren

Die Installation von MySQL5 erstellt einen Ordner unter [Start / Programme]:

Sie können den [MySQL Server Instance Config Wizard] verwenden, um den Server neu zu konfigurieren:

• in [3]: Wir ändern das Root-Passwort (hier root/root)

5.5.2. MySQL5 starten / stoppen

Der MySQL5-Server wurde als Windows-Dienst installiert, der automatisch startet, d. h. er wird beim Start von Windows ausgeführt. Diese Betriebsweise ist unpraktisch. Wir werden sie ändern:

[Start / Systemsteuerung / Leistung und Wartung / Verwaltung / Dienste]:

• in [1]: Wir doppelklicken auf [Dienste]
• in [2]: Wir sehen, dass ein Dienst namens [MySQL] vorhanden ist, dass er läuft [3] und dass er automatisch startet [4].

Um diese Einstellung zu ändern, doppelklicken Sie auf den Dienst [MySQL]:

• in [1]: Stellen Sie den Dienst auf manuellen Start ein
• in [2]: Stoppen Sie ihn
• in [3]: Wir bestätigen die neue Dienstkonfiguration

Um den MySQL-Dienst manuell zu starten und zu stoppen, können wir zwei Verknüpfungen erstellen:

• in [1]: die Verknüpfung zum Starten von MySQL5
• in [2]: die Verknüpfung zum Beenden

5.5.3. MySQL-Verwaltungs-Clients

Auf der MySQL-Website finden Sie DBMS-Verwaltungs-Clients:

• [1]: Wählen Sie [MySQL GUI Tools], das verschiedene grafische Clients entweder zur Verwaltung des DBMS oder zur Nutzung desselben enthält
• in [2]: Wählen Sie die entsprechende Windows-Version

• in [3]: Laden Sie eine .msi-Datei zum Ausführen herunter
• in [4]: Sobald die Installation abgeschlossen ist, erscheinen neue Verknüpfungen im Ordner [Startmenü / Programme / MySQL].

Starten Sie MySQL (über die erstellten Verknüpfungen) und starten Sie dann [MySQL Administrator] über das Menü oben:

• in [1]: Geben Sie das Passwort des Root-Benutzers ein (hier „root“)
• in [2]: Sie sind angemeldet und können sehen, dass MySQL aktiv ist

5.5.4. Erstellen eines JPA-Benutzers und einer JPA-Datenbank

In diesem Tutorial wird MySQL 5 mit einer Datenbank namens jpa und einem Benutzer mit demselben Namen verwendet. Wir werden diese nun erstellen. Zunächst den Benutzer:

• in [1]: Wählen Sie [Benutzerverwaltung]
• in [2]: Klicken Sie mit der rechten Maustaste in den Bereich [Benutzerkonten], um einen neuen Benutzer anzulegen
• in [3]: Der Benutzer heißt jpa und sein Passwort lautet jpa
• in [4]: Bestätigen Sie die Erstellung
• in [5]: Der Benutzer [jpa] wird im Fenster [Benutzerkonten] angezeigt

Nun zur Datenbank:

• in [1]: Wählen Sie die Option [Kataloge]
• in [2]: Klicken Sie mit der rechten Maustaste auf das Fenster [Schemas], um ein neues Schema (bezeichnet eine Datenbank) zu erstellen
• in [3]: Benennen Sie das neue Schema
• in [4]: Es erscheint im Fenster [Schemata]

• in [5]: Wählen Sie das [jpa]-Schema aus
• in [6]: Die Objekte im [jpa]-Schema werden angezeigt, einschließlich der Tabellen. Es gibt noch keine. Mit einem Rechtsklick könnten Sie diese erstellen. Das überlassen wir dem Leser.

Kehren wir zum Benutzer [jpa] zurück, um ihm alle Berechtigungen für das [jpa]-Schema zu erteilen:

• in [1], dann [2]: Wählen Sie den Benutzer [jpa]
• in [3]: Wählen Sie die Registerkarte [Schema-Berechtigungen]
• in [4]: Wählen Sie das Schema [jpa] aus
• in [5]: dem Benutzer [jpa] alle Berechtigungen für das Schema [jpa] erteilen

• in [6]: Bestätigen Sie die Änderungen

Um zu überprüfen, ob der Benutzer [jpa] mit dem Schema [jpa] arbeiten kann, schließen Sie den MySQL-Administrator. Starten Sie ihn neu und melden Sie sich diesmal als [jpa/jpa] an:

• in [1]: Anmelden (jpa/jpa)
• in [2]: Die Verbindung wurde erfolgreich hergestellt, und unter [Schemas] sehen wir die Schemata, für die wir Berechtigungen haben. Wir sehen das [jpa]-Schema.

Wir werden nun dieselbe [ARTICLES]-Tabelle wie beim Firebird-DBMS erstellen, und zwar mithilfe des in Abschnitt 5.4.6 generierten SQL-Skripts [schema-articles.sql].

• in [1]: Verwenden Sie die Anwendung [MySQL Query Browser]
• in [2], [3], [4]: Melden Sie sich an (jpa / jpa / jpa)

• in [5]: Öffnen Sie ein SQL-Skript, um es auszuführen
• in [6]: Wählen Sie das in Abschnitt 5.4.6 erstellte Skript [schema-articles.sql] aus.

• in [7]: Das Skript wird geladen
• in [8]: Führen Sie es aus
• in [9]: Die Tabelle [ARTICLES] wurde erstellt

5.5.5. JDBC-Treiber für MySQL 5

Der MySQL-JDBC-Treiber kann von derselben Seite heruntergeladen werden wie das DBMS:

• in [1]: Wählen Sie den entsprechenden JDBC-Treiber
• in [2]: Wählen Sie die passende Windows-Version aus
• in [3]: In der heruntergeladenen ZIP-Datei ist das Java-Archiv mit dem JDBC-Treiber [mysql-connector-java-5.0.5-bin.jar]. Wir werden es extrahieren, um es in den JPA-Tutorial-Beispielen zu verwenden.

Wir legen es wie zuvor (Abschnitt 5.4.7) im Ordner <jdbc> ab:

Um diesen JDBC-Treiber zu testen, verwenden wir Eclipse und das SQL Explorer-Plugin. Der Leser ist eingeladen, die in Abschnitt 5.4.7 beschriebene Vorgehensweise zu befolgen. Wir zeigen einige relevante Screenshots:

• in [1]: Wir haben das Archiv des MySQL5-JDBC-Treibers ausgewählt
• in [2]: Der MySQL5-JDBC-Treiber ist verfügbar

• in [3]: Verbindungsdefinition (Benutzer, Passwort)=(jpa, jpa)
• in [4]: Die Verbindung ist aktiv
• in [5]: Die Datenbank ist verbunden

5.6. Das PostgreSQL-DBMS-

5.6.1. Installation

Das PostgreSQL-DBMS ist unter der URL [http://www.postgresql.org/download/] verfügbar:

• unter [1]: PostgreSQL-Download-Seiten
• in [2]: Wählen Sie eine Windows-Version
• unter [3]: Wählen Sie eine Version mit Installationsprogramm

• [4]: Der Inhalt der heruntergeladenen ZIP-Datei. Doppelklicken Sie auf die Datei [postgresql-8.2.msi]
• in [5]: die erste Seite des Installationsassistenten

• in [6]: Wählen Sie eine Standardinstallation, indem Sie die Standardwerte übernehmen
• in [6b]: Erstellen Sie das Windows-Konto, unter dem der PostgreSQL-Dienst ausgeführt wird; hier lautet das Konto „pgres“ mit dem Passwort „pgres“.

• in [7]: Lassen Sie PostgreSQL das Konto [pgres] erstellen, falls es noch nicht existiert
• in [8]: Definieren Sie das DBMS-Administratorkonto, hier „postgres“ mit dem Passwort „postgres“

• in [9] und [10]: Übernehmen Sie die Standardwerte bis zum Ende des Assistenten. PostgreSQL wird installiert.

Die PostgreSQL-Installation erstellt einen Ordner unter [Start / Programme]:

5.6.2. PostgreSQL starten / beenden

Der PostgreSQL-Server wurde als Windows-Dienst installiert, der automatisch startet, d. h. er wird gestartet, sobald Windows hochfährt. Diese Konfiguration ist nicht sehr praktisch. Wir werden sie ändern:

[Start / Systemsteuerung / Leistung und Wartung / Verwaltung / Dienste]:

• In [1]: Doppelklicken Sie auf [Dienste]
• in [2]: Wir sehen, dass ein Dienst namens [PostgreSQL] vorhanden ist, dass er läuft [3] und dass er automatisch startet [4].

Um diese Einstellung zu ändern, doppelklicken Sie auf den Dienst [PostgreSQL]:

• in [1]: Stellen Sie den Dienst auf manuellen Start ein
• in [2]: Stoppen Sie ihn
• in [3]: Wir bestätigen die neue Dienstkonfiguration

Um den PostgreSQL-Dienst manuell zu starten und zu stoppen, können Sie die Verknüpfungen im Ordner [PostgreSQL] verwenden:

• in [1]: die Verknüpfung zum Starten von PostgreSQL
• in [2]: die Verknüpfung zum Beenden

5.6.3. Verwaltung von PostgreSQL

Im obigen Screenshot können Sie mit der Anwendung [pgAdmin III] (3) das PostgreSQL-DBMS verwalten. Starten Sie zunächst das DBMS und rufen Sie dann [pgAdmin III] über das Menü oben auf:

• unter [1]: Doppelklicken Sie auf den PostgreSQL-Server, um eine Verbindung herzustellen
• in [2,3]: Melden Sie sich als DBMS-Administrator an, hier (postgres / postgres)

• in [4]: die einzige vorhandene Datenbank
• in [5]: der einzige vorhandene Benutzer

5.6.4. Erstellen eines JPA-Benutzers und einer JPA-Datenbank

Das Tutorial verwendet PostgreSQL mit einer Datenbank namens jpa und einem Benutzer mit demselben Namen. Wir werden diese nun anlegen. Zunächst den Benutzer:

• in [1]: Erstellen einer neuen Rolle (~user)
• in [2]: Erstellung des Benutzers „jpa“
• in [3]: Das Passwort lautet jpa
• in [4]: Wir wiederholen das Passwort
• in [5]: Wir erteilen dem Benutzer die Berechtigung, Datenbanken anzulegen
• in [6]: Der Benutzer [jpa] erscheint unter den Anmelderollen

Nun zur Datenbank:

• in [1]: Erstellen Sie eine neue Verbindung zum Server
• in [2]: Sie erhält den Namen jpa
• in [3]: den Rechner, mit dem wir uns verbinden möchten
• in [4]: der Benutzer, der sich anmeldet
• in [5]: sein Passwort. Wir bestätigen die Verbindungseinstellungen durch Klicken auf [OK]
• in [6]: Die neue Verbindung wurde erstellt. Sie gehört zum Benutzer jpa. Dieser Benutzer erstellt nun eine neue Datenbank:

• n [1]: neue Datenbank hinzufügen
• in [2]: Ihr Name lautet jpa
• in [3]: Der Eigentümer ist der zuvor erstellte Benutzer „jpa“. Klicken Sie auf [OK], um zu bestätigen
• in [4]: Die Datenbank „jpa“ wurde erstellt. Ein einfacher Klick darauf stellt eine Verbindung her und zeigt ihre Struktur an:

• in [5]: Die Objekte des [jpa]-Schemas werden angezeigt, insbesondere die Tabellen. Es gibt noch keine. Mit einem Rechtsklick könnten wir sie erstellen. Das überlassen wir dem Leser.

Wir werden nun dieselbe [ARTICLES]-Tabelle wie bei den vorherigen DBMS erstellen, und zwar mithilfe des in Abschnitt 5.4.6 generierten SQL-Skripts [schema-articles.sql].

• in [1]: Öffnen Sie den SQL-Editor
• in [2]: Öffnen Sie ein SQL-Skript
• in [3]: Wählen Sie das in Abschnitt 5.4.6 erstellte Skript [schema-articles.sql] aus

• in [4]: Das Skript wird geladen. Wir führen es aus.
• in [5]: Die Tabelle [ARTICLES] wurde erstellt.
• in [6, 7]: ihr Inhalt

5.6.5. PostgreSQL-JDBC-Treiber

Der PostgreSQL-JDBC-Treiber befindet sich im Ordner [jdbc] innerhalb des PostgreSQL-Installationsverzeichnisses:

Wir legen das JDBC-Archiv, wie bei den vorherigen (Abschnitt 5.4.7), im Ordner <jdbc> ab:

Um diesen JDBC-Treiber zu testen, verwenden wir Eclipse und das SQL Explorer-Plugin. Der Leser ist eingeladen, die in Abschnitt 5.4.7 beschriebene Vorgehensweise zu befolgen. Wir zeigen einige relevante Screenshots:

• in [1]: Wir haben das PostgreSQL-JDBC-Treiber-Archiv ausgewählt
• in [2]: Der PostgreSQL-JDBC-Treiber ist verfügbar

• in [3]: Verbindungsdefinition (Benutzer, Passwort) = (jpa, jpa)
• in [4]: Die Verbindung ist aktiv
• in [5]: die verbundene Datenbank
• in [6]: der Inhalt der Tabelle [ARTICLES]

5.7. Das Oracle 10g Express DBMS-

5.7.1. Installation

Das Oracle 10g Express DBMS ist unter [http://www.oracle.com/technology/software/products/database/xe/index.html] verfügbar:

• unter [1]: der Download-Seite für Oracle 10g Express
• unter [2]: Wählen Sie eine Windows-Version aus. Sobald die Datei heruntergeladen wurde, führen Sie sie aus:

• in [1]: Doppelklicken Sie auf die Datei [OracleXE.exe]
• unter [2]: die erste Seite des Installationsassistenten

• in [3]: Akzeptieren Sie die Lizenz
• in [4]: Übernehmen Sie die Standardeinstellungen.

• in [5,6]: Der Benutzer „SYSTEM“ erhält das Passwort „system“.
• in [7]: Starten Sie die Installation

Bei der Installation von Oracle 10g Express wird ein Ordner unter [Start / Programme] erstellt:

5.7.2. Oracle 10g starten / beenden

Wie bei früheren DBMS wurde Oracle 10g als Windows-Dienst installiert, der automatisch startet. Wir werden diese Konfiguration ändern:

[Start / Systemsteuerung / Leistung und Wartung / Verwaltung / Dienste]:

• in [1]: Wir doppelklicken auf [Dienste]
• in [2]: Wir sehen, dass ein Dienst namens [OracleServiceXE] vorhanden ist, dass er läuft [3] und dass er automatisch startet [4].
• in [5]: Ein weiterer Oracle-Dienst namens „Listener“ ist ebenfalls aktiv und so eingestellt, dass er automatisch startet.

Um dieses Verhalten zu ändern, doppelklicken Sie auf den Dienst [OracleServiceXE]:

• in [1]: Stellen Sie den Dienst auf manuellen Start ein
• in [2]: Wir stoppen ihn
• in [3]: Wir bestätigen die neue Dienstkonfiguration

Das Gleiche machen wir mit dem Dienst [OracleXETNSListener] (siehe [5] oben). Um den Dienst OracleServiceXE manuell zu starten und zu stoppen, können wir die Verknüpfungen im Ordner [Oracle] verwenden:

• in [1]: zum Starten des DBMS
• in [2]: um es zu beenden
• in [3]: um es zu verwalten (wodurch es gestartet wird, falls es noch nicht läuft)

5.7.3. Erstellen eines JPA-Benutzers und einer JPA-Datenbank

Im obigen Screenshot ermöglicht Ihnen die Anwendung [3] die Verwaltung des Oracle 10g Express DBMS. Starten wir zunächst das DBMS [1] und anschließend die Verwaltungsanwendung [3] über das Menü oben:

• in [1]: Melden Sie sich hier als DBMS-Administrator an (system/system)
• in [2]: Erstellen Sie einen neuen Benutzer

• in [4]: Benutzername
• in [5, 6]: sein Passwort, hier jpa
• in [7]: Der Benutzer jpa wurde erstellt

In Oracle wird ein Benutzer automatisch einer Datenbank mit demselben Namen zugeordnet. Die Datenbank „jpa“ existiert daher parallel zum Benutzer „jpa“.

5.7.4. Erstellen der Tabelle [ARTICLES] in der Datenbank jpa

OracleXE wurde mit einem SQL-Client installiert, der im Befehlszeilenmodus läuft. Mit der ebenfalls von Oracle bereitgestellten SQL-Developer- können Sie komfortabler arbeiten. Sie finden sie unter:

[http://www.oracle.com/technology/products/database/sql_developer/index.html]

• in [1]: die Download-Seite
• unter [2]: Wählen Sie eine Windows-Version ohne JRE, falls diese bereits installiert ist (wie es hier der Fall ist), da [SQL Developer] eine Java-Anwendung ist.

• [3]: Entpacken Sie die heruntergeladene Datei
• in [4]: Führen Sie die ausführbare Datei [sqldeveloper.exe] aus

• in [5]: Geben Sie beim ersten Start von [SQL Developer] den Pfad zur auf dem Rechner installierten JRE an
• in [5b]: Erstellen Sie eine neue Verbindung

• in [6]: Mit SQL Developer können Sie eine Verbindung zu verschiedenen DBMS herstellen. Wählen Sie Oracle aus.
• in [7]: Name der Verbindung, die Sie erstellen
• in [8]: Eigentümer der Verbindung
• in [9]: Das Passwort (jpa)
• in [10]: Behalten Sie die Standardwerte bei
• in [11]: Zum Testen der Verbindung (Oracle muss laufen)
• in [12]: zum Abschließen der Verbindungskonfiguration
• in [13]: die Objekte in der JPA-Datenbank
• in [14]: Sie können Tabellen erstellen. Wie in den vorherigen Fällen erstellen wir die Tabelle [ARTICLES] mithilfe des in Abschnitt 5.4.6 erstellten Skripts.

• in [15]: Öffnen Sie ein SQL-Skript
• in [16]: Wählen Sie das in Abschnitt 5.4.6 erstellte SQL-Skript aus
• in [17]: das auszuführende Skript

• in [18]: das Ergebnis der Ausführung: Die Tabelle [ARTICLES] wurde erstellt. Doppelklicken Sie darauf, um ihre Eigenschaften aufzurufen.
• in [19]: der Inhalt der Tabelle.

5.7.5. OracleXE JDBC-Treiber

Der OracleXE-JDBC-Treiber befindet sich im Ordner [jdbc/lib] innerhalb des OracleXE-Installationsverzeichnisses [1]:

Wir legen das JDBC-Archiv [ojdbc14.jar] im Ordner <jdbc> [2] ab, genau wie zuvor (Abschnitt 5.4.7):

Um diesen JDBC-Treiber zu testen, verwenden wir Eclipse und das SQL Explorer-Plugin. Der Leser ist eingeladen, die in Abschnitt 5.4.7 beschriebene Vorgehensweise zu befolgen. Wir zeigen einige relevante Screenshots:

• in [1]: Wir haben das OracleXE-JDBC-Treiberarchiv angegeben
• in [2]: Der OracleXE-JDBC-Treiber ist verfügbar

• in [3]: Verbindungsdefinition (Benutzer, Passwort)=(jpa, jpa)
• in [4]: Die Verbindung ist aktiv
• in [5]: die verbundene Datenbank
• in [6]: der Inhalt der Tabelle [ARTICLES]

5.8. Das DBMS- t SQL Server Express 2005

5.8.1. Installation

SQL Server Express 2005 ist unter [http://msdn.microsoft.com/vstudio/express/sql/download/] verfügbar:

• in [1]: Laden Sie zunächst die .NET 2.0-Plattform herunter und installieren Sie sie
• in [2]: Installieren und laden Sie anschließend SQL Server Express 2005 herunter
• Schritt [3]: Installieren und laden Sie anschließend SQL Server Management Studio Express herunter, mit dem Sie SQL Server verwalten können

Durch die Installation von SQL Server Express wird ein Ordner unter [Start / Programme] erstellt:

• in [1]: die SQL Server-Konfigurationsanwendung. Ermöglicht außerdem das Starten/Beenden des Servers
• in [2]: die Serververwaltungsanwendung

5.8.2. SQL Server starten / stoppen

Wie bei früheren DBMS wurde SQL Server Express als Windows-Dienst installiert, der automatisch startet. Wir werden diese Konfiguration ändern:

[Start / Systemsteuerung / Leistung und Wartung / Verwaltung / Dienste]:

• in [1]: Wir doppelklicken auf [Dienste]
• in [2]: Wir sehen, dass ein Dienst namens [SQL Server] vorhanden ist, dass er läuft [3] und dass er automatisch startet [4].
• in [5]: Ein weiterer Dienst im Zusammenhang mit SQL Server namens „SQL Server Browser“ ist ebenfalls aktiv und so eingestellt, dass er automatisch startet.

Um dieses Verhalten zu ändern, doppelklicken Sie auf den Dienst [SQL Server]:

• in [1]: Stellen Sie den Dienst auf manuellen Start ein
• in [2]: Wir stoppen ihn
• in [3]: Wir bestätigen die neue Dienstkonfiguration

Das Gleiche machen wir mit dem Dienst [SQL Server Browser] (siehe [5] oben). Um den SQL Server-Dienst manuell zu starten und zu stoppen, können wir die Anwendung [1] im Ordner [SQL Server] verwenden:

• in [1]: Stellen Sie sicher, dass das TCP/IP-Protokoll aktiviert ist, und rufen Sie dann die Protokolleigenschaften auf.
• in [2]: Auf der Registerkarte [IP-Adressen], Option [IPAll]:
  • Das Feld [TCP Dynamic Ports] bleibt leer
  • Der Listening-Port des Servers ist unter [TCP-Port] auf 1433 eingestellt

• In [3]: Ein Rechtsklick auf den Dienst [SQL Server] öffnet die Start-/Stopp-Optionen des Servers. Hier starten wir ihn.
• in [4]: SQL Server wird gestartet

5.8.3. Erstellen eines JPA-Benutzers und einer JPA-Datenbank

Starten Sie das DBMS wie oben beschrieben und anschließend die Verwaltungsanwendung [1] über das untenstehende Menü:

• in [1]: Melden Sie sich als Windows-Administrator bei SQL Server an
• in [2]: Konfigurieren Sie die Verbindungseigenschaften

• in [3]: Wir aktivieren den gemischten Modus für die Verbindung zum Server: entweder mit einer Windows-Anmeldung (einem Windows-Benutzer) oder mit einer SQL Server-Anmeldung (einem innerhalb von SQL Server definierten Konto, unabhängig von einem Windows-Konto).
• in [3b]: Erstellen Sie einen SQL Server-Benutzer

• in [4]: Registerkarte [Allgemein]
• in [5]: die Anmeldedaten
• in [6]: das Passwort (hier jpa)
• in [7]: Option [Serverrollen]
• in [8]: Der Benutzer jpa erhält das Recht, Datenbanken anzulegen

Bestätigen Sie diese Konfiguration:

• in [9]: Der Benutzer jpa wurde erstellt
• in [10]: abmelden
• in [11]: wieder anmelden

• in [12]: als Benutzer jpa/jpa anmelden
• in [13]: Nach der Anmeldung erstellt der Benutzer jpa eine Datenbank

• in [14]: Die Datenbank erhält den Namen jpa
• in [15]: und gehört dem Benutzer jpa
• in [16]: Die Datenbank jpa wurde erstellt

5.8.4. Erstellen der Tabelle [ARTICLES] in der Datenbank jpa

Wie in den vorherigen Beispielen erstellen wir die Tabelle [ARTICLES] mithilfe des in Abschnitt 5.4.6 erstellten Skripts.

• in [1]: Wir öffnen ein SQL-Skript
• in [2]: Wählen Sie das in Abschnitt 5.4.6, Seite 240, erstellte SQL-Skript aus.
• in [3]: Melden Sie sich erneut an (jpa/jpa)
• in [4]: das auszuführende Skript
• in [5]: Wählen Sie die Datenbank aus, in der das Skript ausgeführt werden soll
• in [6]: Führen Sie es aus

• in [7]: das Ergebnis der Ausführung: Die Tabelle [ARTICLES] wurde erstellt.
• in [8]: Wir fordern die Anzeige ihres Inhalts an
• in [9]: der Inhalt der Tabelle.

5.8.5. SQL Server Express JDBC-Treiber

• in [1]: Eine Google-Suche nach [Microsoft SQL Server 2005 JDBC-Treiber] führt uns zur Download-Seite für den JDBC-Treiber. Wir wählen die aktuellste Version
• in [2]: die heruntergeladene Datei. Wir doppelklicken darauf. Die Datei wird entpackt, wodurch ein Ordner mit dem JDBC-Treiber erstellt wird [3]
• in [4]: Wir legen das JDBC-Archiv [sqljdbc.jar] im Ordner <jdbc> ab, genau wie zuvor (Abschnitt 5.4.7)

Um diesen JDBC-Treiber zu testen, verwenden wir Eclipse und das SQL Explorer-Plugin. Der Leser ist eingeladen, die in Abschnitt 5.4.7 beschriebene Vorgehensweise zu befolgen. Wir zeigen einige relevante Screenshots:

• in [1]: Wir haben das Archiv des SQL Server-JDBC-Treibers angegeben
• in [2]: Der SQL Server-JDBC-Treiber ist verfügbar

• in [3]: Verbindungsdefinition (Benutzer, Passwort) = (jpa, jpa)
• in [4]: Die Verbindung ist aktiv
• in [5]: die verbundene Datenbank
• in [6]: der Inhalt der Tabelle [ARTICLES]

5.9. Das DBMS HSQLDB

5.9.1. Installation

Das HSQLDB-DBMS ist unter der URL [http://sourceforge.net/projects/hsqldb] verfügbar. Es handelt sich um ein in Java geschriebenes DBMS, das sehr wenig Speicherplatz beansprucht und Datenbanken im Arbeitsspeicher statt auf der Festplatte verwaltet. Das Ergebnis ist eine extrem schnelle Abfrageausführung. Dies ist sein Hauptvorteil. Die auf diese Weise im Speicher erstellten Datenbanken können wiederhergestellt werden, wenn der Server heruntergefahren und anschließend neu gestartet wird. Dies liegt daran, dass die zum Erstellen der Datenbanken ausgegebenen SQL-Befehle in einer Protokolldatei gespeichert werden, um beim nächsten Start des Servers wiedergegeben zu werden. Dies gewährleistet die Persistenz der Datenbanken über einen längeren Zeitraum.

Die Methode hat ihre Grenzen, und HSQLDB ist kein DBMS für den kommerziellen Einsatz. Sein Hauptnutzen liegt in Test- oder Demonstrationsanwendungen. Da HSQLDB beispielsweise in Java geschrieben ist, kann es in Ant-Aufgaben (Another Neat Tool), einem Java-Tool zur Aufgabenautomatisierung, eingebunden werden. So können die von Ant automatisierten täglichen Codetests für in der Entwicklung befindliche Software Datenbanktests umfassen, die vom HSQLDB-DBMS verwaltet werden. Der Server wird durch Java-Aufgaben gestartet, gestoppt und verwaltet.

• in [1]: die Download-Seite
• in [2]: Lade die neueste Version herunter

• in [3]: Entpacken Sie die heruntergeladene Datei
• in [4]: den durch das Entpacken entstandenen Ordner [hsqldb]
• in [5]: den Ordner [demo], der das Skript zum Starten des [hsql]-Servers [6] enthält, und in [7] das Skript zum Starten eines einfachen Server-Verwaltungstools.

5.9.2. HSQLDB starten / stoppen

Um den HSQLDB-Server zu starten, doppelklicken Sie auf die oben genannte Anwendung [runManager.bat] [6]:

• in [1]: Sie sehen, dass Sie den Server einfach durch Drücken von Strg-C im Fenster beenden können.

5.9.3. Die Datenbank [test]

Die Standarddatenbank befindet sich im Ordner [data]:

• in [1]: Beim Start führt das HSQL-DBMS das Skript mit dem Namen [test.script] aus

CREATE SCHEMA PUBLIC AUTHORIZATION DBA
CREATE USER SA PASSWORD ""
GRANT DBA TO SA
SET WRITE_DELAY 10

• Zeile 1: Ein [public]-Schema wird erstellt
• Zeile 2: Ein Benutzer [sa] mit leerem Passwort wird erstellt
• Zeile 3: Dem Benutzer [sa] werden Administratorrechte gewährt

Am Ende wurde ein Benutzer mit Administratorrechten erstellt. Dies ist der Benutzer, den wir im weiteren Verlauf verwenden werden.

5.9.4. HSQL-JDBC-Treiber

Der JDBC-Treiber für das HSQL-DBMS befindet sich im Ordner [lib]:

• in [1]: Das Archiv [hsqldb.jar] enthält den JDBC-Treiber für das HSQL-DBMS
• in [2]: Wir legen dieses Archiv, wie die vorherigen (Abschnitt 5.4.7), im Ordner <jdbc> ab

Um diesen JDBC-Treiber zu überprüfen, verwenden wir Eclipse und das SQL Explorer-Plugin. Der Leser ist eingeladen, die in Abschnitt 5.4.7 beschriebene Vorgehensweise zu befolgen. Wir zeigen einige relevante Screenshots:

• in [1]: [Fenster / Einstellungen / SQL Explorer / JDBC-Treiber]
• in [2]: Konfigurieren Sie den [HSQLDB]-Server
• in [3]: Geben Sie das Archiv [hsqldb.jar] an, das den JDBC-Treiber enthält
• in [4]: den Namen der Java-Klasse des JDBC-Treibers
• in [5]: Der JDBC-Treiber ist konfiguriert

Sobald dies erledigt ist, stellen wir eine Verbindung zum HSQL-Server her. Wir starten zunächst den Server.

• in [6]: Erstellen Sie eine neue Verbindung
• in [7]: Geben Sie ihr einen Namen
• in [8]: Wir möchten eine Verbindung zum HSQLDB-Server herstellen
• in [9]: die URL der Datenbank, mit der Sie sich verbinden möchten. Dies ist die zuvor erwähnte Datenbank [test].
• in [10]: Melden Sie sich als Benutzer [sa] an. Wir haben gesehen, dass er der DBMS-Administrator ist.
• in [11]: Der Benutzer [sa] hat kein Passwort.

Wir überprüfen die Verbindungskonfiguration.

• in [12]: Wir stellen eine Verbindung her
• in [13]: Wir melden uns an
• in [14]: Du bist angemeldet

• in [15]: Das Schema [PUBLIC] enthält noch keine Tabelle
• in [16]: Wir erstellen die Tabelle [ARTICLES] mit dem Skript [schema-articles.sql], das in Abschnitt 5.4.6 erstellt wurde.
• in [17]: Wählen Sie das Skript aus

• in [18]: das auszuführende Skript
• in [19]: Wir führen es aus, nachdem wir alle Kommentare entfernt haben, da HSQLB diese nicht akzeptiert.

• Sobald das Skript ausgeführt wurde, aktualisieren Sie die Datenbankansicht in [20]
• in [21]: Die Tabelle [ARTICLES] ist dort
• in [22]: ihr Inhalt

Lassen Sie uns den HSQLDB-Server anhalten und dann neu starten. Sobald das erledigt ist, sehen wir uns die Datei [test.script] an:

CREATE SCHEMA PUBLIC AUTHORIZATION DBA
CREATE MEMORY TABLE ARTICLES(ID INTEGER NOT NULL,NOM VARCHAR(20) NOT NULL,PRIX DOUBLE NOT NULL,STOCKACTUEL INTEGER NOT NULL,STOCKMINIMUM INTEGER NOT NULL,CONSTRAINT PK_ARTICLES PRIMARY KEY(ID),CONSTRAINT CHK_ID CHECK(ARTICLES.ID>0),CONSTRAINT CHK_PRIX CHECK(ARTICLES.PRIX>0),CONSTRAINT CHK_STOCKACTUEL CHECK(ARTICLES.STOCKACTUEL>0),CONSTRAINT CHK_STOCKMINIMUM CHECK(ARTICLES.STOCKMINIMUM>0),CONSTRAINT CHK_NOM CHECK(ARTICLES.NOM!=''),CONSTRAINT UNQ_NOM UNIQUE(NOM))
CREATE USER SA PASSWORD ""
GRANT DBA TO SA
SET WRITE_DELAY 10
SET SCHEMA PUBLIC
INSERT INTO ARTICLES VALUES(1,'article1',100.0E0,10,1)
INSERT INTO ARTICLES VALUES(2,'article2',200.0E0,20,2)
INSERT INTO ARTICLES VALUES(3,'article3',300.0E0,30,3)

Wir sehen, dass das DBMS die verschiedenen SQL-Anweisungen, die während der vorherigen Sitzung ausgeführt wurden, gespeichert hat und sie bei Beginn der neuen Sitzung erneut ausführt. Wir sehen außerdem (Zeile 2), dass die Tabelle [ARTICLES] im Arbeitsspeicher (MEMORY) angelegt wird. Zu Beginn jeder Sitzung werden die ausgeführten SQL-Anweisungen in [test.log] gespeichert, um zu Beginn der nächsten Sitzung in [test.script] kopiert und zu Beginn der Sitzung wiedergegeben zu werden.

5.10. Das Apache Derby-DBMS-

5.10.1. Installation

Das Apache Derby DBMS ist unter der URL [http://db.apache.org/derby/] verfügbar. Es handelt sich um ein ebenfalls in Java geschriebenes DBMS, das ebenfalls sehr speicherfreundlich ist. Es bietet ähnliche Vorteile wie HSQLDB. Auch es kann in Java-Anwendungen eingebettet werden, d. h. ein integraler Bestandteil der Anwendung sein und innerhalb derselben JVM laufen.

• in [1]: die Download-Seite
• in [2,3]: die neueste Version herunterladen

• in [3]: Entpacken Sie die heruntergeladene Datei
• in [4]: der durch das Entpacken entstandene Ordner [db-derby-*-bin]
• in [5]: den Ordner [bin], der das Skript zum Starten des [db-derby]-Servers [6] enthält, und in [7] das Skript zum Beenden des Servers.

5.10.2. Apache Derby (DB Derby) starten / stoppen

Um den Db-Derby-Server zu starten, doppelklicken Sie auf die oben genannte Anwendung [startNetworkServer] [6]:

• in [1]: Der Server wird gestartet. Er wird mit der oben genannten Anwendung [stopNetworkServer] [7] gestoppt.

5.10.3. Db Derby JDBC-Treiber

Der JDBC-Treiber für das Db Derby-DBMS befindet sich im Ordner [lib] des Installationsverzeichnisses:

• in [1]: Das Archiv [derbyclient.jar] enthält den JDBC-Treiber für das DBMS Db Derby
• in [2]: Wir legen dieses Archiv, wie die vorherigen (Abschnitt 5.4.7), im Ordner <jdbc> ab

Um diesen JDBC-Treiber zu testen, verwenden wir Eclipse und das SQL Explorer-Plugin. Der Leser ist eingeladen, die in Abschnitt 5.4.7 beschriebene Vorgehensweise zu befolgen. Wir zeigen einige relevante Screenshots:

• in [1]: [Fenster / Einstellungen / SQL Explorer / JDBC-Treiber]
• in [2]: Der Apache Derby JDBC-Treiber ist nicht in der Liste enthalten. Wir fügen ihn hinzu.

• in [3]: Wir geben dem neuen Treiber einen Namen
• in [4]: Geben Sie das vom JDBC-Treiber unterstützte URL-Format an
• in [5]: Wir geben die .jar-Datei für den JDBC-Treiber an
• in [5b]: den Namen der Java-Klasse des JDBC-Treibers
• in [5c]: Der JDBC-Treiber ist konfiguriert

Sobald dies erledigt ist, stellen Sie eine Verbindung zum Apache-Derby-Server her. Starten Sie den Server zuvor.

• in [6]: Erstelle eine neue Verbindung
• in [7]: Wir geben ihr einen Namen
• in [8]: Wir möchten eine Verbindung zum Apache-Derby-Server herstellen
• in [9]: die URL der Datenbank, mit der wir uns verbinden wollen. Nach dem Standardpräfix [jdbc:derby://localhost:1527] geben wir den Pfad zu einem Verzeichnis auf der Festplatte an, das eine Derby-Datenbank enthält. Die Option [create=true] ermöglicht es uns, dieses Verzeichnis zu erstellen, falls es noch nicht existiert.
• in [10,11]: Wir verbinden uns als Benutzer [jpa/jpa]. Ich habe mich damit noch nicht eingehend befasst, aber es scheint, als könne man beliebige Anmeldedaten verwenden. Hier geben wir den Datenbankbesitzer an, wenn create=true ist.

Wir überprüfen die Verbindungskonfiguration.

• in [12]: Anmelden
• in [13]: Anmelden (jpa/jpa)
• in [14]: Sie sind angemeldet

• in [15]: Das [jpa]-Schema wird noch nicht angezeigt.
• in [16]: Wir erstellen die Tabelle [ARTICLES] aus dem Skript [schema-articles.sql], das in Abschnitt 5.4.6 erstellt wurde.
• in [17]: Wählen Sie das Skript aus

• in [18]: das auszuführende Skript
• in [19]: Wir führen es aus, nachdem wir alle Kommentare entfernt haben, da Apache Derby, genau wie HSQLB, diese nicht akzeptiert.

• Sobald das Skript ausgeführt wurde, aktualisieren Sie die Datenbankansicht in [20]
• in [21]: Das [jpa]-Schema und die [ARTICLES]-Tabelle sind vorhanden
• in [22]: der Inhalt der Tabelle [ARTICLES]

• in [23]: den Inhalt des Ordners [derby\jpa], in dem die Datenbank erstellt wurde.

5.11. Das Spring 2- -Framework

Das Spring 2-Framework ist unter der URL [http://www.springframework.org/download] verfügbar:

• unter [1]: Laden Sie die neueste Version herunter
• unter [2]: Laden Sie die Version mit der Bezeichnung „with dependencies“ herunter, da diese die .jar-Dateien für die von Spring integrierten Tools von Drittanbietern enthält, die Sie immer benötigen.

• unter [3]: Entpacken Sie das heruntergeladene Archiv
• unter [4]: Der Installationsordner für Spring 2.1

• in [5]: Im Ordner <dist> finden Sie die Spring-Archive. Das Archiv [spring.jar] enthält alle Klassen des Spring-Frameworks. Diese sind auch nach Modulen geordnet im Ordner <modules> in [6] verfügbar. Wenn Sie wissen, welche Module Sie benötigen, finden Sie diese hier. Auf diese Weise vermeiden Sie, dass Archive in die Anwendung aufgenommen werden, die sie nicht benötigt.

• in [7]: Der Ordner <lib> enthält die Archive von Drittanbieter-Tools, die von Spring verwendet werden
• in [8]: einige Archive aus dem [jakarta-commons]-Projekt

Wenn im Tutorial Spring-Archive verwendet werden, müssen Sie diese entweder aus dem Ordner <dist> oder dem Ordner <lib> im Spring-Installationsverzeichnis abrufen.

5.12. Die JBoss EJB3-Container-

Der JBoss EJB3-Container ist unter der URL [http://labs.jboss.com/jbossejb3/downloads/embeddableEJB3] verfügbar:

• in [1]: JBoss EJB3 herunterladen. Beachten Sie das Produktdatum (September 2006), obwohl der Download im Mai 2007 erfolgt. Man könnte sich fragen, ob dieses Produkt noch weiterentwickelt wird.
• in [2]: die heruntergeladene Datei

• in [3]: die entpackte ZIP-Datei
• in [4]: Die Archive [hibernate-all.jar, jboss-ejb3-all.jar, thirdparty-all.jar] bilden den JBoss EJB3-Container. Sie müssen im Klassenpfad der Anwendung abgelegt werden, die diesen Container verwendet.