JPA Reverse Engineering mit Eclipse

veröffentlicht am 22. April 2013

Momentan arbeite ich beim Kunden an einer Webanwendung mit einer sehr generischen Datenbank, die zahlreiche Tabellen enthält. Noch wird MyBatis als Persistenz Framework eingesetzt, für die Zukunft ist jedoch zumindest ein Test von Hibernate als OR-Mapper geplant. Da die Datenbank wirklich viele Tabellen besitzt, wäre ein manuelles Anlegen der JPA Entitäten ziemlich zeitaufwändig. Glücklicherweise verfügt Eclipse über die Möglichkeit, JPA Entitäten direkt aus einer bestehenden Datenbank zu erzeugen. Sofern die Datenbank ordentlich entworfen wurde und über entsprechende Foreign Keys verfügt, funktioniert das Reverse Engineering wirklich gut. An der ein oder anderen Stelle muss trotzdem noch Hand angelegt werden (so werden z.B. TEXT Spalten mit @Lob annotiert), aber man spart trotzdem eine Menge Zeit.

Bevor mit Eclipse losgelegt werden kann, muss der passende JDBC Treiber für die Datenbank heruntergeladen werden. In diesem Beispiel verwende ich eine MySQL Datenbank. Der passende Treiber für MySQL kann von der Connector/J Downloadseite heruntergeladen werden. Aus dem Archiv wird die Datei mysql-connector-java-<version>.jar benötigt.

Für das Reverse Engineering wird ein Eclipse mit installierter Eclipse Data Tools Platform benötigt. Diese muss manuell nachinstalliert werden, sofern nicht die Eclipse Distribution für Java EE Entwickler oder Java and Report Developers verwendet wird.

Sobald der Treiber und das passende Eclipse bereit sind, kann auch schon losgelegt werden. Zunächst wird ein neues JPA Project erstellt.

jpa-reverse-engineer-step01

Im folgenden Fenster wird der Projektname eingegeben. Alle anderen Einstellungen werden auf Standard belassen. Es muss lediglich darauf geachtet werden, dass bei der JPA version der Eintrag 2.0 ausgewählt ist. Danach geht es per Next > weiter.

jpa-reverse-engineer-step02

Dieser Dialog kann getrost mit einem beherzten Klick auf Next > überflogen werden:

jpa-reverse-engineer-step03

Jetzt wird es wieder interessanter. In diesem Dialog sollte bei Platform der Eintrag Generic 2.0 und bei JPA implementation der Eintrag Disable Library Configuration ausgewählt werden. Bevor es weiter geht, sollte noch mit Add connection… eine Datenbankverbindung eingerichtet werden.

jpa-reverse-engineer-step04

In dem folgenden Dialog muss zunächst die gewünschte Datenbank Engine ausgewählt werden. Ich wähle in diesem Beispiel den Eintrag MySQL und vergebe den Namen newsreader (ein privates Projekt von mir):

jpa-reverse-engineer-step05

Im nächsten Dialog wird nun die eigentliche Verbindung eingerichtet. Klicke hierzu auf das Symbol mit dem grünen Plus.

jpa-reverse-engineer-step06

Es erscheint folgender Dialog. Wähle hier nun die entsprechende Datenbank Version aus (hier ist es MySQL 5.1) und vergebe unten einen Namen (MySQL 5.1):

jpa-reverse-engineer-step07

Im zweiten Tabreiter (JAR List) muss nun die eben heruntergeladene JAR Datei eingebunden werden. Entferne hierzu zunächst den bestehenden Eintrag mit einem Klick auf Clear All. Füge dann die JAR Datei per Add JAR/Zip… hinzu.

jpa-reverse-engineer-step08

Beim Reiter Properties können nun die Verbindungsdaten eingetragen werden. Der Screenshot sollte selbsterklärend sein. Mit OK geht es wieder zurück zum vorherigen Dialog.

jpa-reverse-engineer-step09

Hier wird nun eventuell die Checkbox Save password aktiviert, um das Passwort zu speichern. Ein Verbindungstest über den Button Test Connection kann auch nicht schaden. Ist alles korrekt eingerichtet, sollte die Meldung Ping succeeded! erscheinen. Mit Next > geht es weiter.

jpa-reverse-engineer-step10

Auf der letzten Seite des Wizards  werden noch einmal alle wichtigen Informationen aufgelistet. Mit einem Klick auf Finish wird der Wizard beendet.

jpa-reverse-engineer-step11

Jetzt kann optional die JPA Perspektive geöffnet werden. Ist nicht unbedingt nötig.

jpa-reverse-engineer-step13

Nachdem das Projekt fertig angelegt wurde, kann mit dem Reverse Engineering begonnen werden. Wähle nun unter File → New → Other… (oder per Tastenkombination STRG + N) den Eintrag JPA Entities from Tables und klicke auf Next >.

jpa-reverse-engineer-step14

Im folgenden Dialog muss nun die Verbindung ausgewählt und eventuell hergestellt werden (mit einem Klick auf das Symbol neben Note: You must have an active connection to select schema.). Das Schema muss unter Umständen auch noch ausgewählt werden. Das Sammeln der Informationen kann nun abhängig von der Tabellenanzahl eine Weile dauern. Wähle dann die Tabellen aus, für die JPA Entitäten erzeugt werden sollen, und klicke auf Next >.

jpa-reverse-engineer-step15

Im folgenden Dialog werden die automatisch erkannten Assoziationen aufgelistet. Fehlende oder fehlerhafte Assoziationen können hier ergänzt bzw. bearbeitet werden. Mit Next > geht es weiter.

jpa-reverse-engineer-step16

Jetzt können die Standardeinstellungen für das Erzeugen der JPA Entitäten angegeben werden.

Als Key generator habe ich den Eintrag auto gewählt, da in meinem Fall alle Primärschlüssel per AUTO_INCREMENT von der Datenbank erzeugt werden.

Die Auswahl bei Entity access bestimmt, ob eine Variable oder dessen Getter mit JPA Annotationen versehen werden soll. Ich bevorzuge das annotieren der Variable und habe deshalb Field gewählt.

Weiterhin sollen Assoziationen standardmäßig Lazy (d.h. beim Aufrufen eines Getters der auf eine Assoziation verweist) und nicht Eager (beim Laden eines Objektes mit Assoziationen) aus der Datenbank geladen werden.

Als Collection properties type sollte man bevorzugt java.util.Set auswählen, da Hibernate in einigen Fällen Probleme mit java.util.List bereitet und die List Funktionalitäten in der Regel nicht benötigt wird. Aktiviert man den Haken bei Always generate optional JPA annotations and DDL parameters, werden auch optionale JPA Annotationen und Parameter (z.B. die Parameter unique, length oder nullable bei der Annotation @Column) generiert.

Jetzt kann noch das gewünschte Package für die zu generierenden Klassen angegeben werden. Den Eintrag Superclass habe ich bis jetzt noch nicht getestet, eventuell ist das Reverse Engineering intelligent genug, um vererbbare Variablen wie z.B. eine ID per @MappedSuperclass abzubilden. Mit Next > geht es weiter.

jpa-reverse-engineer-step17

Im folgenden Dialog können noch einmal die eben gezeigten Einstellungen für jede Entität einzeln bearbeitet werden. Per Klick auf Finish werden die Entitäten letztendlich erzeugt.

jpa-reverse-engineer-step18

Da am Anfang keine JPA Implementierung konfiguriert wurde, werden die erzeugten Entitäten nun als fehlerhaft markiert, da benötigte Imports nicht zur Verfügung stehen. Entweder ergänzt man nun das Projekt oder kopiert die Entitäten einfach in ein anderes Projekt (bei mir z.B. in ein bestehendes Maven Projekt).

jpa-reverse-engineer-step19

Kleine Schlussbemerkung: ich hatte bereits mit Eclipse Indigo den Fall, dass das Generieren der Entitäten an einem Tag problemlos funktionierte, das Reverse Engineering am darauf folgenden Tag (ohne Datenbankänderung) jedoch den Dienst verweigerte. Die Ursache konnte ich leider nicht finden, eine frische Eclipse Installation hat jedoch Abhilfe geschafft. Zur Not sichert man sich das Eclipse Archiv, entpackt es, erzeugt die Entitäten und löscht die Installation wieder.

Sollten noch Fragen bestehen, immer her damit :)

Hinterlasse einen Kommentar