Quick & Dirty - JPA Constructor Expressions

JPA Constructor Expressions sind immer dann nützlich, wenn fein-granulare Objekte zum Austausch von Daten erzeugt werden sollen. Anstatt die Daten per Hand zusammenzustellen oder einen Assembler wie den GEDA DTO Assembler zu nutzen, können die Daten direkt in entsprechenden Objekte transferiert werden. Dabei hilft ein Hilfskonstruktor der JPA, die sogenannten Constructor Expressions.

Um diese einfach zu verstehen, an dieser Stelle ein kleines Tutorial zum Verständnis.

Wie immer muss die Basis für das Projekt geschaffen werden. Die Grundlage für das Tutorial bildet:

1. Eclipse
2. EclipseLink 2.10 (Helios) als JPA 2.0 Implementierung
3. JUnit4
4. HSQLDB als Datenbank

Das Projekt-Setup wird weitesgehend von Eclipse übernommen und soll an dieser Stelle nicht weiter vertieft werden.
Begonnen wird mit dem Einrichten des Workspaces. Dazu wird ein Projektordner erstellt und in diesen die entpackte Datenbank kopiert. Dies ist für den weiteren Verlauf des Einrichtens wichtig.

In diesem Ordner befinden sich sowohl die Datenbank, als auch die notwendigen Treiber.
Im zweiten Schritt wird ein JPA Projekt mit Eclipse angelegt.

Die Voreinstellungen können komplett übernommen werden. Nur der Name muss angegeben werden.

Im nächsten Schritt wird die Verbindung zur Datenbank und die eigentliche JPA Implementierung konfiguriert. Da es ein Quick & Dirty Tutorial ist, wird hier auf eine herunterladbare Bibliothek als JPA Implementierung verwiesen.

 

Im folgenden Schritt wird ein neues Connection-Profile angelegt. Hier wird die Verbindung zur HSQLDB festgelegt.

Als Treiber wird der vorher in den Projektordner kopierte Treiber gewählt.

Die Verbindungsdetails können aus den Defaulteinstellungen übernommen werden.

Somit sollte einer erfolgreichen Verbindung nichts im Wege stehen.

Nach dem Erstellen des Projektes müssen sowohl der Treiber, als auch die JUnit4 Bibliotheken dem Projekt hinzugefügt werden, so dass sich der folgende Aufbau ergibt.

Um später ohne Probleme eine Verbindung mit der Datenbank einzugehen, müssen die Eigenschaften der peristence.xml geringfügig modifiziert werden.

Die Einstellunge sorgen dafür, dass zum einen die Details für die Verbindung bekannt sind und zum anderen die Tabellen vor jedem Test wieder neu aufgesetzt werden.
Die Struktur der Klassen wird für den Test bewusst einfach gehalten:

1. Employee [Entität innerhalb der Datenbank]
2. EmployeeFirstnameDto [Einfaches DTO für die Darstellung des Vornamens]
3. EmployeeFullnameDto[Einfaches DTO für die Darstellung des gesamten Namens]
4. ConstructorExpressionsTest [JUnit-Test für die Ausführung]

Die Entität muss nach Erstellen noch als zu mappende Klasse in der persistence.xml angeführt werden.


Der Testfall führt nun unterschiedliche Aufgaben durch. Als erstes wird ein EntityManager erstellt, welcher für den Aufbau der Transaktionen und die Datenbankinteraktion vorhanden sein muss.

 
Im zweiten Schritt wird initial ein Employee erzeugt und sichergestellt, dass dieser auch in der Datenbank gespeichert worden ist.

Nun kommt der wichtige und spannende Teil. Das direkte Erstellen der DTOs aus der JPA-Query. Das Ergebnis der Query entspricht dem Typen, der übergeben wird. Dabei muss der zu erstellende Typ weder gemappt sein, noch sonstwie mit der Datenbank verknüpft werden.
Einzig und allein muss der entsprechende Konstruktur mit den übergebenen Attributen vorhanden sein.

Zugehöriger Konstruktor:

Das funktioniert natürlich auch für multiple Parameter.

Die Assertions stellen an dieser Stelle sicher, dass es sich auch wirklich um die entsprechenden Objekte handelt und nicht heimlich, still und leise die eigentliche Entität ausgelesen wird.

Wie auf der Konsole zu erkennen ist, handelt es sich auch wirklich um die entsprechenden DTOs.

Nützlich, wenn man sich das hin und her mit dem Konvertieren sparen möchte.