Schwierige Beziehung

Hibernate als Persistenz für Eclipse RCP-Anwendungen

Stefan Isele

Jede geschäftliche Anwendung enthält eigentlich eine Komponente für den Zugriff auf eine Datenbank und eine für die Bearbeitung durch den Anwender. Für die Persistenz hat sich Hibernate in vielen Projekten bewährt, für die Präsentation bietet sich die Eclipse Rich Client Platform (RCP) an. Doch wie erstellt man eine RCP-Anwendung mit Hibernate und teilt diese in Plug-ins so auf, dass die Zieldatenbank einfach durch Austausch eines Plug-ins gewechselt werden kann.

Eine der wichtigsten Eigenschaften beim Einsatz von Eclipse ist die Möglichkeit, eine Anwendung in Module aufzuteilen, so genannte Plug-ins. Hibernate wiederum entkoppelt die eigentliche Anwendung von der eingesetzten Datenbank, sodass diese relativ einfach ausgetauscht werden kann, ohne dass Änderungen an der Anwendung nötig sind. So kann man z.B. gegen eine MySQL-Datenbank entwickeln, auch wenn das fertige Produkt später gegen DB2 laufen soll. Für eine typische Anwendung bietet sich daher eine Aufteilung in folgende Module an:

  • den Anwendungskern
  • die Präsentation
  • Hibernate
  • den JDBC-Treiber

Für jedes dieser Module wird es in der Regel mindestens ein Plug-in geben. Manchmal macht es auch Sinn, ein Modul auf mehrere Plug-ins aufzuteilen. Ich werde einige Klassen erstellen, die ich für die Konfiguration von Hibernate brauche. Für diese werde ich ein eigenes Plug-in namens hibernatehelper verwenden. Auf die Trennung von Anwendungskern und Präsentation gehe ich aus Platzgründen nicht ein. Plug-ins werden in der Regel mit einem URL-ähnlichen Namen versehen, also z.B. de.xyz.plugin. Die Anwendung besteht also aus folgenden Plug-ins:

  • de.xyz.anwendung
  • de.xyz.hibernate
  • de.xyz.hibernatehelper
  • de.xyz.mysql
Tabelle 1: Verwendete Software und Bibliotheken
Was Woher
Eclipse 3.1.2 englisch www.eclipse.org/downloads/
Hibernate prdownloads.sourceforge.net/hibernate/hibernate-3.1.3.zip?download
MySQL dev.mysql.com/downloads/connector/j/3.1.html

Den Code für die Projekte finden Sie in der Heft-CD und die Projekte können Sie über Menu FILE | NEW | NEW PROJECT | JAVA PROJECT und Create project from existing source importieren.

Das Plug-in für den Anwendungskern erstellen

Für jedes dieser Plug-ins wird in Eclipse ein eigenes Projekt erstellt.
Also: im Menu FILE | NEW | NEW PROJECT | PLUG-IN PROJECT auswählen, NEXT klicken und
den Projektnamen angeben: de.xyz.anwendung. Alle Einstellung bleiben so wie vorgegeben, gegebenenfalls können Sie einen anderen Ordner auswählen, in dem das Projekt gespeichert werden soll. Dann NEXT klicken. Im Feld Classpath den Namen des JARs angeben, in das die Anwendung später gepackt werden soll, hier anwendung.jar. Diese Angabe wird erst beim Export der Anwendung wichtig. Solange die Anwendung nur innerhalb von Eclipse läuft, ist der Name des JARs ohne Bedeutung. Den Radiobutton „Yes“ für die Option Would you like to create a rich client application aktivieren. Dadurch erstellt der Wizard das Gerüst für den Rich Client, der beim Start der Anwendung aktiviert wird. Bei allen anderen Plug-ins werden wir diese Einstellung auf „No“ belassen. NEXT klicken. Das Template RCP Mail Template aktivieren, dieses entspricht am meisten dem, was man von einem RCP-Client erwartet. Dieses Template werden wir dann etwas missbrauchen. NEXT klicken. Die Standardwerte unverändert lassen und FINISH klicken. Es kommt eventuell eine Meldung, dass für diese Projektart das Perspective Plug-in Development verwendet wird. OK klicken. Das war es schon. Die so generierte Anwendung kann durch Klick auf den Link Launch an Eclipse application im Manifest jetzt schon gestartet werden.

Abb. 1: Starten der Anwendung über Link im Manifest
Das Plug-in für Hibernate erstellen

Wenn noch nicht geschehen, muss Hibernate heruntergeladen werden (siehe auch Heft-CD). Das ZIP-File entpacken Sie in einen beliebigen, aber leeren Ordner. Auf den werden wir dann gleich zugreifen. Im Eclipse-Menu wählen Sie FILE | NEW PROJECT, dort den Ordner Plug-in Development öffnen und PLUG-IN FROM EXISTING JAR ARCHIVES auswählen. NEXT klicken. Den Button ADD EXTERNAL klicken. Zu dem Verzeichnis navigieren, in das Sie eben das Hibernate-Zip entpackt haben. Dort ins Unterverzeichnis lib wechseln. Alle JARs auswählen. (Es werden nicht unbedingt alle dort vorhandenen JARs benötigt, aber der Einfachheit halber nehmen wir erst einmal alle.) Dann NEXT klicken. Den Namen für das Projekt angeben, hier de.xyz.hibernate. Die Option unzip the JAR archives into the project deaktivieren!! FINISH klicken. Das Plug-in für Hibernate ist fertig!

Das Plug-in für MySQL erstellen

Dieses Plug-in wird im Grunde genommen genau so erstellt, wie das für Hibernate. Den JDBC-Treiber für MySQL herunterladen (siehe Heft-CD). Das Zip-File wieder in einen beliebigen, aber leeren Ordner entpacken. In Eclipse FILE | NEW PROJECT den Ordner Plug-in Development öffnen und PLUG-IN FROM EXISTING JAR ARCHIVES auswählen. NEXT klicken. Den Button ADD EXTERNAL betätigen, zu dem Verzeichnis mit dem mysql.jar navigieren und das mysql-connector-java-3.x.yy-stable-bin.jar auswählen. Dann NEXT klicken und den Namen für das Projekt angeben, hier de.xyz.mysql. Die Option unzip the JAR archives into the project deaktivieren!! Schließlich FINISH klicken.

Das Plug-in für die Hibernate-Hilfsklassen

Im Eclipse-Menu wählen Sie FILE | NEW PROJECT, dort PLUG-IN PROJECT auswählen, NEXT klicken, den Namen für das Projekt eingeben : de.xyz.hibernatehelper, dann NEXT klicken.
Die Checkboxen „Generate an Activator….“ und „This plug-in will make contrbutions….“ deaktivieren. Unter Rich Client Application bei „Would you like to create a rich client application“ die Option „No“ klicken. NEXT klicken. Die Checkbox „Create a plug-in using one of these templates“ deaktivieren. FINISH klicken.

In diesem neuen Projekt die Datei plugin.xml öffnen und auf den Reiter DEPENDENCIES klicken.
Dort im Fenster Required Plug-ins den Button ADD klicken und folgende Plug-ins hinzufügen :
de.xyz.hibernate, org.eclipse.core.runtime, org.eclipse.ui
In diesem Projekt werden nur zwei Klassen erstellt: ConfigurationHelper und HinernatehelperPlugin.Diese erleichtern den Aufbau der Hibernate-Konfiguration. Den Quelltext für diese Klasse finden Sie auf der Heft-CD.

Die Anwendung

Die Anwendung in diesem Beispiel fällt extrem dünn aus, sie soll lediglich zeigen, dass die Plug-ins richtig konfiguriert sind und Hibernate die Verbindung zur Datenbank herstellen kann. Der von dem RCP Mail Template angezeigte Text wird in unserem Plug-in de.xyz.anwendung in der Class View ab Zeile 73 gesetzt.
text.setText(„This RCP Application was……..
Das ändern wir ab und zeigen stattdessen Daten der Datenbank-Verbindung an (Listing 1).

ConfigurationHelper ch=new ConfigurationHelper();          
          String catalog="???";
          Session ssn = ch.getSession();
          Connection con = ssn.connection();
          try {
               catalog = con.getCatalog();               
               
          } catch (SQLException e1) {
               // TODO Auto-generated catch block
               e1.printStackTrace();
          }
          text.setText("JDBCDriver : " + ch.getConnectiondriverclass() + "n" +
                     "SQLDialect : " + ch.getSqldialect() + "n" +
                     "User       : " + ch.getUser() + "n" +
                     "Password   : " + ch.getPassword() + "n" +
                     "Ip-Adresse : " + ch.getIp() + "n" +
                     "ConnectionURL : " +ch.getConnectionurl() + "n" +
                     "Verbunden mit Catalog    : " + catalog
                     );               

Wenn Sie den Quelltext selbst eingeben, werden Sie feststellen, dass das Plug-in de.xyz.anwendung weder die Klasse de.xyz.hibernatehelper.ConfigurationHelper noch org.hibernate.Session findet. Unsere Plug-ins sind bis jetzt völlig unabhängig voneinander und kennen sich nicht.

Man könnte im BuldPath des Projektes de.xyz.anwendung eine Referenz auf die Projekte de.xyz.hibernate und de.xyz.hibernatehelper angeben. Dann könnte das Projekt kompiliert werden. Aber spätestens, wenn die Anwendung außerhalb der Eclipse-Entwicklungsumgebung laufen soll, funktioniert dieser Ansatz nicht! Die Beziehungen über Plug-ins müssen alle über deren Manifeste deklariert werden! Eclipse nutzt diese Beziehungen dann sowohl für den buildpath als auch für den classpath zur Laufzeit.

Required Plug-ins, ich brauch das einfach!

Das Plug-in de.xyz.anwendung braucht das Plug-in de.xyz.hibernatehelper, denn es benutzt ja dessen Klasse ConfigurationHelper. Die Konfiguration eines Plug-ins wird im so genannten Manifest beschrieben. Das ist die Datei MANIFEST.MF im Verzeichnis META-INF, die es in jedem Plug-in gibt. Wir wechseln also in das Manifest des Plug-ins de.xyz.anwendung und klicken auf den Reiter DEPENDENCIES. Dort im Feld Required Plug-ins werden die benötigten Plug-ins aufgeführt.
Klicken Sie dort auf ADD, wählen Sie das Plug-in de.xyz.hibernatehelper aus, und klicken Sie OK.

Da de.xyz.anwendung auch die Hibernate-Klassen braucht, wiederholen Sie diese Schritte und deklarieren auch das Plug-in de.xyz.hibernate als benötigt. Das Manifest von de.xyz.anwendung sieht dann aus wie in Abbildung 2.

Abb. 2: Vom Plug-in de.xyz.anwendung benötigte Plug-ins

Das Plug-in de.xyz.hibernatehelper braucht das Plug-in de.xyz.hibernate, denn es benutzt z.B. dessen Klasse Configuration. Also muss im Manifest von de.xyz.hibernatehelper das Plug-in de.xyz.hibernate unter Required Plug-ins angegeben werden. Jetzt lassen sich die Projekte problemlos kompilieren.

Hibernate-Konfiguration

In der Hibernate-Konfiguration werden der verwendete JDBC-Treiber und der SQL-Dialekt angegeben sowie die IP-Adresse, der Anwender, das Passwort und die Datenbank, die Hibernate verwenden soll. Außerdem muss noch der ConnectionURL angegeben werden. Für MySQL ist das z.B. jdbc:mysql://localhost/dbname. Der zweite Teil dieses ConnectionURL ist das so genannte Subprotokoll, für MySQL ist das mysql. Dieser Teil muss zum eingesetzten JDBC-Treiber passen. In den meisten Dokumentationen wird diese Konfiguration in einer XML-Datei abgelegt, ich finde es jedoch wesentlich praktischer, das in Java zu programmieren.

In der Klasse de.xyz.hibernatehelper.ConfigurationHelper wird dafür ein Objekt der Klasse org.hibernate.cfg.Configuration erzeugt. IP-Adresse, Anwender, Passwort und Datenbank sind hier hart codiert, für eine echte Anwendung bestimmt keine gute Lösung. Ich möchte mich in diesem Beispiel aber darauf beschränken zu zeigen, wie nur durch Austausch des Plug-ins mit dem JDBC-Treiber die Anwendung auf eine komplett andere Datenbank umgestellt werden kann. Soll eine andere Datenbank verwendet werden, z.B. DB2, so muss neben dem JDBC-Treiber auch die Hibernate-Konfiguration geändert werden.

Praktisch wäre es daher, wenn das Plug-in, das den JDBC-Treiber enthält, gleichzeitig auch diese Konfigurationsdaten bereitstellen könnte. Das sind der Name der Klasse des JDBC-Treibers, der Name der Klasse mit dem SQL-Dialekt sowie der String für das Subprotokoll. Das Plug-in de.xyz.hibernatehelper soll sich dieser Daten bedienen und sie in der Konfiguration von Hibernate verwenden. Andersherum betrachtet erwartet das Plug-in de.xyz.hibernatehelper von dem Plug-in, das den JDBC-Treiber enthält, auch die Namen der Klassen für JDBCDriver und SQLDialect und den String für das Subprotokoll.

Extension Points und Extensions

Konfigurationsdaten, die ein Plug-in von einem anderen erwartet, werden im Manifest deklariert. Das Plug-in, das Konfigurationsdaten erwartet, de.xyz.hibernatehelper, deklariert dazu Extension Points. Das Plug-in, das Konfigurationsdaten liefert, de.xyz.mysql, deklariert Werte für diese Extension Points, in Eclipse werden diese Extensions genannt.

Extension Point für die Konfiguration deklarieren

In Eclipse in das Manifest des Plug-ins de.xyz.hibernatehelper wechseln. Auf den Reiter EXTENSION POINTS klicken. Im linken Teil des Editors neben ALL EXTENSION POINTS den Button ADD klicken. Im Feld Extension Point ID „Configuration“ eintragen. Die ist der interne Namen, über den das Plug-in auf diesen Wert zugreifen kann. Im Feld Extension Point Name „Konfiguration“ eintragen, das ist der Name, der im Manifest für diesen Extension Point angezeigt wird. Im Feld Extension Point Schema den vorgegebenen Wert belassen. Das Extension Point Schema definiert, aus wie vielen Werten der Extension Point besteht, von welcher Art diese sind (z.B. String) und ob diese angegeben werden müssen oder optional sind. Die Checkbox Edit Extension point schema when done lassen wir ebenfalls aktiviert, nach Klick auf FINISH wird dann ein Editor für das Extension Point Schema geöffnet. Also Klick auf FINISH. Eclipse öffnet den Editor für den Extension Point. Unter Extension Point Elements ist bereits ein Element „extension“ eingetragen, das lassen wir unverändert. Klicken Sie auf den Button NEW ELEMENT. Unter Extension Point Elements wird ein neues Element eingetragen mit Namen „new-element“. Auf dieses machen Sie einen Rechtsklick und klicken im lokalen Menu auf PROPERTIES. Daraufhin wird unten die View Properties geöffnet. Dort ändern Sie den Namen in „Configuration“. Sobald Sie die Zeile verlassen, wird im Fenster Extension Point Elements der Name auch in „Configuration“ geändert. Das sieht dann so aus wie in Abbildung 3.

Abb. 3: Eigenschaften des Extension Point
Element Reference deklarieren

Der folgende Schritt ist unbedingt nötig, sonst können wir später im Plug-in de.xyz.mysql die Werte für „Configuration“ nicht editieren! Also: In der Box Extension Point Elements das erste Element „extension“ markieren. Daraufhin wird in der Box Element Grammar ein Eintrag „Sequence“ angezeigt. Diesen Eintrag rechtsklicken und im lokalen Menu NEW | REFERENCE | CONFIGURATION auswählen. Das Ganze sieht dann aus wie in Abbildung 4. (Dort sehen Sie auch schon die Attribute des Extension Point, die erst im nächsten Schritt angelegt werden.)

Abb. 4: Die vollständige Deklaration des Extension Point

In den Properties der Element Reference kann deklariert werden, wie oft dieser Wert angegeben werden kann. In unserem Fall sind die Standardwerte richtig, minOccurs = 1 und maxOccurs =1.
Das heißt, es dürfen genau einmal Werte für die Configuration angegeben werden.

Das Plug-in für Hibernate erstellen

Im Fenster Extension Point Elements das Element „Configuration“ markieren und den Button NEW ATTRIBUTE klicken. Es wird ein neues Attribut unter „Configuration“ angezeigt, das hat erst einmal den Namen „new_atribute“. Den ändern wir ebenfalls in der View Properties ab und setzen ihn auf „JDBCDriverClass“. In derselben View gibt es eine Eigenschaft „Use“, deren Wert setzen wir auf „required“. Die Eigenschaft „Kind“ bleibt auf dem Wert „string“. Die Properties des Attributes sehen Sie in Abbildung 5.

Abb. 5: Eigenschaften des Extension Point Attribute

Im Manifest ist jetzt deklariert, dass es einen Extension Point gibt, der „Configuration“ heißt. Dieser stellt einen Wert vom Typ String zur Verfügung, dieser Wert heißt „JDBCDriverClass“ und muss angegeben werden. Für die anderen beiden Konfigurationswerte, SQLDialectClass und Subprotocol, müssen genauso Extension-Point-Attribute deklariert werden. Danach muss das Schema aussehen wie in Abbildung 6.

Abb. 6: Die konkreten Werte für
Das Plug-in für Hibernate erstellen

Das Plug-in de.xyz.mysql muss jetzt die konkreten Werte für die Konfiguration setzen, die dann das Plug-in de.xyz.hibernatehelper verwenden soll. Damit ein Plug-in einen Wert für einen Extension Point angeben kann, muss es das Plug-in, das diesen Extension Point deklariert hat, als „Required Plug-in“ markieren. Schwieriger zu erklären, als zu zeigen! Also: Wir wechseln in das Manifest des Plug-ins de.xyz.mysql. Klick auf das Register DEPENDENCIES. Klick auf den Button ADD neben der Box Required-Plug-in. Das Plug-in de.xyz.hibernatehelper auswählen, OK klicken. Jetzt können wir die Werte für die Extension Points setzen. Wir bleiben im Manifest des Plug-ins de.xyz.mysql. Klick auf das Register EXTENSIONS, dann auf den Button ADD neben der Box All Extensions. Den Extension Point de.xyz.hibernatehelper.Configuration auswählen. Klick auf den Button FINISH. In der Box All Extensions wird der Extension Point jetzt angezeigt. Diesen rechtsklicken und im lokalen Menu NEW | CONFIGURATION auswählen. In der rechten Box Extension Element Details können wir jetzt die konkreten Werte für die Konfiguration angeben:

  • JDBCDriverClass ist com.mysql.jdbc.Driver.
  • QLDialectClass ist org.hibernate.dialect.MySQLDialect.
  • Subprotocol ist mysql.

Das sollte dann aussehen wie in Abbildung 7.

Abb. 7: Fehlermeldung
Das Plug-in für Hibernate erstellen

Jetzt können wir die Anwendung fast schon laufen lassen. Damit das überhaupt eine Chance auf Erfolg hat, müssen wir Eclipse mitteilen, welche Plug-ins beim Start alle geladen werden sollen. Das machen wir in der Runtime Configuration. Dazu im Eclipse-Menü RUN klicken, dort den Menüpunkt RUN… klicken. In der linken Box Configurations den Eintrag „Eclipse Application“ auswählen und links unten den Button NEW klicken. Im Feld Name „anwendung“ eintragen, in der Gruppe Program to Run die Option Run an an application aktivieren und in der Liste daneben unsere Anwendung de.xyz.anwendung auswählen. Das soll dann aussehen wie Abbildung 8. Auf das Register PLUG-INS klicken. Dort die Option Choose plug-ins and fragments to launch from the list aktivieren und unter Workspace Plug-ins die Plug-ins de.xyz.anwendung, de.xyz.hibernate, de.xyz.hibernatehelper und de.xyz.mysql mit einem Haken versehen. Den Button APPLY klicken, dann erwartungsvoll den Button RUN. Und? Mist: Fehler!! „JDBC Driver not found: com.mysql.jdbc.Driver“ (Abb. 9).

Abb. 8: Runtime Configuration

Abb. 9: Die laufende Anwendung
Das Plug-in für Hibernate erstellen

Was ist passiert? Offensichtlich hat die Anwendung den Namen der Klasse für den JDBC-Treiber richtig aus dem Plug-in de.xyz.mysql ermittelt. Wenigstens etwas. Hibernate versucht dann, eine Instanz der Klasse com.mysql.jdbc.Driver zu erzeugen. Das passiert im Plug-in de.xyz.hibernate. Dieses Plug-in kann diese Klasse aber nicht finden, denn es kennt ja das Plug-in de.xyz.mysql gar nicht. Und jedes Plug-in hat nur Zugriff auf seine eigenen Klassen und die Klassen der Plug-ins, die als erforderlich deklariert wurden.

Eine erste Idee wäre, im Plug-in de.xyz.hibernate das Plug-in de.xyz.mysql als erforderlich (unter Required Plug-ins) anzugeben. Das würde sogar funktionieren. Wir wollen aber das Plug-in mit dem JDBC-Treiber austauschen können, z.B. gegen ein Plug-in de.xyz.db2. Dann müsste auch das als erforderlich eingetragen werden. Und Eclipse würde verlangen, dass beide Plug-ins, de.xyz.mysql und de.xyz.db2, beim Start anwesend sind. Beide würden versuchen, die Konfiguration (JDBC-Treiber, SQLDialect und Subprotokoll) zu setzen. So geht es also nicht!

Das Plug-in für Hibernate erstellen

Das gleiche Problem tritt auf, wenn Hibernate Objekte der Anwendung aus der Datenbank laden soll. Dann muss Hibernate die Klassen der Anwendung finden, kann es aber nicht, und es kommt zu ClassNot Found Exceptions. Auch in dem Fall können wir im Plug-in de.xyz.hibernate nicht jede Anwendung, die jemals mit dem Plug-in de.xyz.hibernate arbeiten soll, als erforderlich eintragen.

Das Plug-in für Hibernate erstellen

Eclipse bietet natürlich eine Lösung dafür. Noch einmal das Problem: Das Plug-in de.xyz.hibernate weiß nicht, mit welchen Plug-ins es zur Laufzeit zusammenarbeiten wird. Es muss dann aber auf Klassen dieser Plug-ins zugreifen. Das kann der JDBC-Treiber sein, der z.B. im Plug-in de.xyz.mysql oder de.xyz.db2 liegt. Oder es können Klassen des Plug-ins de.xyz.anwendung oder einer anderen Anwendung sein, die auch mit de.xyz.hibernate arbeiten soll.

Und die Lösung: Im Manifest des Plug-ins de.xyz.hibernate wird durch einen Eintrag deklariert, dass sich andere Plug-ins als Buddy (englisch Kumpel) registrieren können. Und Eclipse gewährt de.xyz.hibernate dann Zugriff auf die Klassen dieser Kumpels. Wir wechseln in das Manifest des Plug-ins de.xyz.hibernate. Klick auf das Register MANIFEST.MF. Dort fügen wir in Zeile 2 den Eintrag „Eclipse-BuddyPolicy: registered“ ein. Das bedeutet so viel wie: Meine Buddies registrieren sich. Wir wechseln in das Manifest des Plug-ins de.xyz.mysql. Klick auf das Register MANIFEST.MF. Dort fügen wir in Zeile 2 den Eintrag „Eclipse-RegisterBuddy: de.xyz.hibernate“ ein. Das bedeutet so viel wie: Registriere mich als Buddy von de.xyz.hibernate. Damit Eclipse diesen Eintrag richtig verarbeitet, muss das Plug-in de.xyz.mysql außerdem noch das Plug-in de.xyz.hibernate als erforderlich deklarieren! Also bleiben wir im Manifest des Plug-ins de.xyz.mysql. Klick auf das Register DEPENDENCIES. Klick auf den Button ADD neben der Box Required Plug-ins. Das Plug-in de.xyz.hibernate auswählen, OK klicken. Das Plug-in de.xyz.mysql hat jetzt die beiden Plug-ins de.xyz.hibernatehelper und de.xyz.hibernate als erforderlich deklariert. Wenn Sie das Plug-in de.xyz.anwendung erweitern wollen, sodass Klassen daraus von Hibernate persistiert werden, dann müssen Sie dort genauso den Eintrag „Eclipse-BuddyPolicy: registered“ einfügen und auch das Plug-in de.xyz.hibernate als erforderlich deklarieren.

Das Plug-in für Hibernate erstellen

Noch einmal laufen lassen (STRG + F11). Jetzt muss es klappen und ungefähr aussehen wie in Abbildung 10. Natürlich werden die von Ihnen in der Klasse ConfiguratioonHelper angegebenen Werte für IP-Adresse, User und Passwort angezeigt. Der in der letzten Zeile „Verbunden mit Catalog“ angezeigte Datenbankname wird über die JDBCConnection ermittelt und belegt, dass tatsächlich eine Verbindung zustande gekommen ist.

Das Plug-in für Hibernate erstellen

Wenn Sie Plug-ins für andere JDBC-Treiber erstellen wollen, müssen Sie Folgendes tun: ein Plug-in für den JDBC-Treiber erstellen, wie in „Das Plug-in für MySQL erstellen“. In diesem Plug-in die Plug-ins de.xyz.hibernate und de.xyz.hibernatehelper als notwendig deklarieren, die Werte für die Konfiguration setzen wie in „Die konkreten Werte für Konfiguration im Plug-in de.xyz.mysql setzen“ und dieses Plug-in zu einem Buddy von de.xyz.hibernate machen wie in „I need someBuddys help“ (Eintrag „Eclipse-RegisterBuddy: de.xyz.hibernate“), anschließend eine weitere RuntimeConfiguration erstellen wie in „Runtime Configuration“, diese mit einem anderen Namen versehen und vor allem im Register „Plug-ins“ nicht das Plug-in de.xyz.mysql auswählen, sondern stattdessen das neue Plug-in. Alleine durch Auswahl der RuntimeConfiguration können Sie dann zwischen den verwendeten Datenbanken umschalten. Da aber IP-Adresse, User und Anwender in der Klasse ConfigurationHelper hart codiert sind, klappt das so noch nicht ganz. Wie und wo man diese Daten am besten unterbringt, zeige ich in einem weiteren Artikel.

Stefan Isele ist freiberuflicher Softwarearchitekt. Sein Schwerpunkt liegt auf der Entwicklung von Business Solutions in Java unter anderem für die IBM iSeries (ehemals AS/400). Kontakt: stefan-isele[at]gmx.de.
Geschrieben von
Stefan Isele
Kommentare

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.