Datenbanken Objektrelationales Mapping Spezifikation

Transkript

1 Datenbanken Objektrelationales Mapping Spezifikation Ziel: Automatische Abbildung von Java-Klassen auf relationale Datenbanktabellen Damit verbunden: Vereinfachung der Applikationsprogrammierung Insbesondere: Datenmanipulationen ohne komplexe SQL-Statements Spezifikation: Java EE 5 application server + Reference Implementation (Glassfish) Java Persistence API (JPA) + Reference Implementation (Toplink Essentials) Java Persistence API (JPA) + Reference Implementation (Eclipselink) Download: Prof. Dr. Günter Brackly 1

2 D A T E N B A N K n Person persnr name Adresse adrnr plz Hobbies DBPersonen 1 J n n n hnr hobby Ausbildungen anr von Beruf bnr begonnen persnr private Collection <DBAdresse> adressen; DBAdressen Prof. Dr. Günter Brackly 2 adrnr private DBPersonen person; DBHobbies hnr private DBPersonen person; usw. P A - A N W E N D U N G

3 Vorgehensweise bei der Benutzung des JPA: 1. Java J2EE 5 oder höher installieren; 2. Eine Realisation der JPA-Spezifikation installieren (Eclipselink, Toplink,..); 3. Normale Applikationsklassen schreiben (POJOs: Plane Old Java Objects); 4. Diejenigen Klassen, die den Tabellen in der Datenbank entsprechen, annotieren (das ist das OR-Mapping); 5. Eine Datei Persistence.xml erzeugen, in der i) die Klassen aufgeführt sind, die persistente Objekte haben dürfen; ii) die Verbindungsinformationen stehen; Dadurch wird eine Persistence-Unit erzeugt für s Speichern in der Applikation. Prof. Dr. Günter Brackly 3

4 Vorgehensweise bei der Benutzung des JPA: 6. Mit der Persistence-Unit kann eine EntityManagerFactory erzeugt werden, die in der Applikation die Persistenz regelt: EntityManagerFactory emf = Persistence.createEntityManagerFactory( ); 7. Über die EntityManagerFactory erzeugt man einen EntityManager, der die Datenbank-Kommunikation behandelt: EntityManager em = emf.createentitymanager(); Prof. Dr. Günter Brackly 4

5 Vorgehensweise bei der Benutzung des JPA: 8. Ein EntityManager (em) kann: - Transaktionen instanziieren: EntityTransaction etrans = em.gettransaction(); Transaktionen müssen explizit gestartet und geschlossen werden: etrans.begin(); DB-Kommunikation etrans.commit(); bzw. etrans.rollback(); - Querys der JPQL ausführen: em.createquery( ); - Objekte (Datensätze) über den annotierten PK finden: em.find(..); - Objekte in annotierten Tabellen speichern: em.persist(objekt); - Objekte (Datensätze) aus der Datenbank löschen: em.remove(objekt); Prof. Dr. Günter Brackly 5

6 Beispiel 1: (name="adresse") public class DBAdresse (name="adrnr") private int adrnr; private String plz; private String ort; private String str; private (name="persnr") private DBPersonen person; }... Prof. Dr. Günter Brackly 6

7 Beispiel 2: import java.util.*; public class DBPersonen { (name="persnr") private int persnr; private String name; private String (mappedby="person", cascade=cascadetype.persist) private Collection <DBAdresse> (mappedby="person", cascade=cascadetype.persist) private Collection<DBBeruf> (mappedby="person", cascade=cascadetype.persist) private Collection <DBHobbies>hobbies; Prof. Dr. Günter Brackly 7

8 Entities annotieren Ganz normale Java-Anwendungsklassen (POJOs) schreiben; Diejenigen Klassen, die Tabellen in der Datenbank entsprechen, als public class DBPersonen { } Nur die Klassen, die annotiert sind, können Objekte speichern! Entities, d.h. potenziell speicherbare Objekte sollten nur innerhalb einer Transaktion erzeugt, aktualisiert oder gelöscht werden! Prof. Dr. Günter Brackly 8

9 Entities annotieren Primärschlüssel-Attribut und seine Werte-Erzeugung (name="persseq", sequencename="persnr_seq", private int persnr; Durch diese Annotation des Primary Key der Tabelle wird zusätzlich zum OID des Objekts auch der PK als Persistence Identifier für das Entity-Objekt bereit gestellt. Dann kann die Methode find() des EntityManagers über diesen Persistence Identifier die Datensätze aus den Tabellen sammeln und als Objekte (Entities) der Applikation zur Verfügung stellen. Prof. Dr. Günter Brackly 9

10 Entities annotieren Alle Entities müssen java.util.date statt java.sql.date verwenden. Alle dauerhaft zu speichernden Attribute vom Type java.util.date müssen als Temporal annotiert private java.util.date gebdat; Diese Annotation definiert dann in der Realisation (eclipselink) eine Abbildung von util.date auf sql.date und umgekehrt. Prof. Dr. Günter Brackly 10

11 Beziehungen annotieren Es können 1:1, 1:n, n:1 oder n:m Beziehungen annotiert werden. Bei den ersten drei dieser Beziehungstypen muss unterschieden werden zwischen einer unidirektionalen bzw. einer bidirektionalen Beziehung: - unidirektional: nur von einem der beteiligten Entities wird die Beziehung aufgebaut. - bidirektional: von beiden beteiligten Entities wird die Beziehung zum jeweils anderen Entity aufgebaut. Bidirektionale Beziehungen sind eigentlich zwei unidirektionale Beziehungen, jeweils vom anderen Entity aus, und werden auch genau so als zwei unidirektionale Beziehungen zwischen diesen Entities annotiert! Prof. Dr. Günter Brackly 11

12 Beziehungen annotieren Bestimmend für die Modellierung einer Beziehung zwischen Entities ist ihre Modellierung in der Datenbank! Das Entity, dessen Tabelle den Foreign Key enthält, ist der Besitzer der Entity Beziehung. In diesem Entity wird eine joincolumn annotiert, eben der FK. Beispiel: (die n:1 Beziehung zwischen Adressen Adresse") persnr ) private DBPerson person; Dies ist eine unidirektionale Annotation einer n:1 Beziehung. Prof. Dr. Günter Brackly 12

13 Beziehungen annotieren Soll die Beziehung bidirektional modelliert werden, muss auch beim DBPersonen-Entity eine OneToMany Annotation erfolgen, und zwar als Inverse zur ersten Beziehung! In der Datenbank hat die Tabelle Person aber keinen FK! Deshalb kann beim Entity keine joincolumn Annotation verwendet werden. Statt dessen wird eine inverse Beziehung über die Annotation mappedby beschrieben, die Bezug nimmt auf das Beziehungsattribut person im Besitzer-Entity DBAdresse: Beispiel: (die 1: n Beziehung zwischen Personen und class person ) private Collection<DBAdresse> adressen; Prof. Dr. Günter Brackly 13

14 Beziehungen annotieren unidirektionale 1:1 - Beziehung zwischen zwei Entities class (name="persnr") private DBPersonen person; bidirektionale 1:1 - Beziehung zwischen zwei Entities annotieren: Zusätzlich zur obigen class DBPersonen ="person") private DBBankaccount bank; Prof. Dr. Günter Brackly 14

15 Beziehungen annotieren unidirektionale n:1 - Beziehung zwischen zwei Entities class (name="persnr") private DBPersonen person; bidirektionale 1:n - Beziehung zwischen zwei Entities annotieren: Zusätzlich zur obigen class DBPersonen (mappedby="person", cascade=cascadetype.persist) private Collection <DBAdresse> adressen; Prof. Dr. Günter Brackly 15

16 Beziehungen annotieren n:m - Beziehung (nur bidirektional) zwischen zwei Entities class DBVerein private Collection <DBPersonen> class DBPersonen (mappedby="mitglieder") private Collection <DBVerein> vereine; Prof. Dr. Günter Brackly 16

17 Beziehungen annotieren n:m - Beziehung (nur bidirektional) zwischen zwei Entities class DBVerein private Collection <DBPersonen> class DBPersonen (mappedby="mitglieder") private Collection <DBVerein> vereine; Keines der beiden Entities besitzt ein join-attribut zum jeweils anderen Entity, d.h. diese ManyToMany - Beziehung kann nur implementiert werden mit einer zusätzlichen weiteren Join-Tabelle! Da beide Entities gleichberechtigt sind in dieser n:m Beziehung, ist es egal bei welchem Entity diese Join-Table annotiert wird! Prof. Dr. Günter Brackly 17

18 Beziehungen annotieren n:m - Beziehung mit Beziehungstabelle zwischen zwei Entities class DBVerein private joincolumns=@joincolumn(name="vnr"), inversejoincolumns=@joincolumn(name="persnr") ) private Collection <DBPersonen> class DBPersonen (mappedby="mitglieder") private Collection <DBVerein> vereine; Prof. Dr. Günter Brackly 18

19 Beziehungen annotieren Problem: n:m - Beziehung mit eigenen Attributen, bzw. mehr als 2-stellige Beziehungen : Diese Art von Beziehung kann nicht über eine JoinTable annotiert werden, sondern muss als eigene assoziative Entity-Klasse modelliert werden. Beispiel: Die n:m Beziehung Halten = ({Dozent, Veranstaltung}, {semester}) n : m Die zugehörige Beziehungstabelle hat als Schlüssel {doznr, vnr, semester}, also alle Attribute. Diese Beziehungstabelle muss als eigenes Entity modelliert werden. Problem: Jede Entityklasse muss einen Persistence-Identifier ID haben, der nur aus einem Attribut bestehen darf! Hier ist der Schlüssel aber 3-elementig!! Prof. Dr. Günter Brackly 19

20 Beziehungen annotieren Folgerung: Zusätzlich zu der Beziehungs-Entity-Klasse Halten muss eine weitere Klasse HaltenPK modelliert werden, die als Attribute die Attribute des Primärschlüssels der Tabelle Halten hat. Die Entity-Klasse Halten bekommt dann als Persistence-Identifier ein Objekt vom Typ public class HaltenPK implements Serializable { private static final long serialversionuid = 1L; private int doznr; private int vnr; private String semester; } Prof. Dr. Günter Brackly 20

21 Beziehungen public class Halten implements Serializable { private static final long serialversionuid = private HaltenPK id; //bi-directional many-to-one association insertable=false, updatable=false) private Dozent dozent; //bi-directional many-to-one association insertable=false, updatable=false) private Veranstaltung veranstaltung;.. } Prof. Dr. Günter Brackly 21

22 Beziehungen annotieren Die PK-Klassen dürfen keine set-methoden haben, da die PK-Objekte nicht verändert werden dürfen. Zur Erzeugung eines PK-Objekts muss also ein Konstruktor vorhanden sein, der alle Attribute umfasst! In der zu einer PK-Klasse gehörenden Beziehungsklasse muss bei der Annotation der Beziehung der referenzierten Objekte darauf geachtet werden, dass die JoinColumn als nicht einfügbar und nicht aktualisierbar gesetzt ist (das geschieht ja über insertable=false, updatable=false) private Dozent dozent; Prof. Dr. Günter Brackly 22

23 Persistenz Alle als Entity annotierten Klassen, die auch in der persistence.xml Datei eingetragen sind, können persistente Objekte bekommen! Objekte zu solchen Klassen werden persistent, indem sie innerhalb einer Transaktion gespeichert werden: EntityTransaction tx = em.gettransaction(); tx.begin(); em.persist(person); tx.commit(); (em ist hier ein Objekt vom Typ EntityManager, eine Klasse, die im Zusammenhang mit der Persistenz benutzt wird. Siehe Folien 10 ff) Hat man ein solches Masterobjekt entsprechend annotiert, können durch em.persist(person) automatisch auch die abhängigen Tabellen mit den Werten aus den Collection-Attributen (adressen, hobbies, etc.) gefüllt werden! (Kaskadierendes (mappedby="person",cascade=cascadetype.persist) ) Prof. Dr. Günter Brackly 23

24 Persistenz Zur Persistenz wird ein Datenbanksystem und eine Persistenz-Implementierung (Eclipselink, Toplink, Hibernate, etc.) benötigt. Die notwendigen Informationen über das zugrunde liegende Datenbanksystem erhält das Anwendungsprogramm aus einer so genannten Persistence-Unit. In der Deklaration der Persistence-Unit in der Datei persistence.xml bekommt diese einen Namen, mit dem sie im Programm verwendet werden kann. Die Zuordnung des Programms zur Persistence-Unit geschieht über eine so genannte EntityManagerFactory: EntityManagerFactory emf = Persistence.createEntityManagerFactory("PersonenDB"); (Hier wird dem Programm eine Persistence-Unit mit Namen PersonenDB zugeordnet!) Prof. Dr. Günter Brackly 24

25 Persistenz Toplink Die Persistence-Unit wird in der Datei persistence.xml deklariert : <?xml version="1.0" encoding="utf-8"?> <persistence xmlns=" version="1.0"> <persistence-unit name ="PersonenDB"> <provider>oracle.toplink.essentials.ejb.cmp3.entitymanagerfactoryprovider</provider> <class>orelmap.dbpersonen</class> <class>orelmap.dbberuf</class> <class>orelmap.dbausbildungen</class> <class>orelmap.dbhobbies</class> <class>orelmap.dbadresse</class> <properties> <property name="toplink.jdbc.driver" value="oracle.jdbc.driver.oracledriver"/> <property name="toplink.jdbc.user" value= dau"/> <property name="toplink.jdbc.password" value= dau"/> <property name="toplink.jdbc.url" value="jdbc:oracle:thin:@localhost:1521:gbir"/> </properties> </persistence-unit> </persistence> Prof. Dr. Günter Brackly 25

26 Persistenz Eclipselink Die Persistence-Unit wird in der Datei persistence.xml deklariert : <?xml version="1.0" encoding="utf-8"?> <persistence xmlns=" version="1.0"> <persistence-unit name ="PersonenDB"> <provider>org.eclipse.persistence.jpa.persistenceprovider</provider> <class>orelmap.dbpersonen</class> <class>orelmap.dbberuf</class> <class>orelmap.dbausbildungen</class> <class>orelmap.dbhobbies</class> <class>orelmap.dbadresse</class> <properties> <property name="eclipselink.jdbc.driver" value="oracle.jdbc.driver.oracledriver"/> <property name="eclipselink.jdbc.user" value= dau"/> <property name="eclipselink.jdbc.password" value= dau"/> <property name="eclipselink.jdbc.url" value="jdbc:oracle:thin:@localhost:1521:gbir"/> </properties> </persistence-unit> </persistence> Prof. Dr. Günter Brackly 26

27 Persistenz Hat man eine Persistence-Unit in einer persistence.xml-datei erstellt und über eine EntityManagerFactory dem Anwendungsprogramm bekannt gemacht, kann man sie in einem EntityManager benutzen, um innerhalb von Transaktionen Objekte persistent zu machen: EntityManagerFactory emf = Persistence.createEntityManagerFactory("PersonenDB"); EntityManager em = emf.createentitymanager(); EntityTransaction tx = em.gettransaction(); tx.begin(); em.persist(pers); tx.commit(); Ein EntityManager dient also zur Synchronisation der Anwendungsobjekte mit der Datenbank! Prof. Dr. Günter Brackly 27

28 Persistenz JPA bietet mehrere Möglichkeiten der Erzeugung und Verwendung von EntityManagern und Persistence Contexts an: Container-Managed EntityManager Verfügbar nur in Java EE Application-Managed EntityManager Verfügbar für Java EE und SE Wir verwenden Application-Managed EntityManager und damit auch Application Managed Persistence Context: Konsequenz: EntityManager müssen über eine EntityManagerFactory erzeugt werden; ihr Lebenszyklus muss von der Applikation verwaltet werden: EntityManager em = emf.createentitymanager(); em.close(); Prof. Dr. Günter Brackly 28

29 Persistenz Ein EntityManager verwaltet alle in der Applikation instanziierten Entities mit einem Bezug zur Datenbank. Diese Menge der Entity-Instanzen bildet den sogenannten Persistence Context. Dazu hat das Interface EntityManager unter anderem die folgenen Methoden: persist() remove() find() refresh() createquery() gettransaction() clear() Speichern eines Objektes in der Datenbank; Entfernen eines Objekts aus der Datenbank; Finden eines Objekts aus der Datenbank über den PK; Aktualisieren eines Objekts aus der Datenbank im Programm; Erzeugen einer Query Instanz bzgl. JPQL; Implementieren des EntityTransaction Interface Auflösen der Entity-Instanzen des Persistence Context Prof. Dr. Günter Brackly 29

30 Persistenz Bei allen Beziehungen ist auch kaskadierendes Speichern und Löschen von Entities und abhängigen Entities möglich. Dies muss entsprechend bei der Entity Annotierung vermerkt class DBPersonen (mappedby="person", cascade={ CascadeType.PERSIST, CascadeType.REMOVE } ) private Collection <DBAdresse> adressen; Voraussetzung für das erfolgreiche Speichern bzw. Löschen ist dann lediglich, dass die abhängigen Entities dem Master-Entity zugeordnet sind vor dem Aufruf von persist() bzw. remove(). Wichtig: bei bidirektionalen Beziehungen muss auf beiden Seiten das Kaskadieren annotiert werden!! Prof. Dr. Günter Brackly 30

31 Persistenz / Transaktionen JPA bietet auch zwei Möglichkeiten der Verwaltung des Persistence Contexts in Transaktionen: Java Transaction API Resource-Local Transactions Transaktionen des Java EE Servers Native Transaktionen des JDBC-Treibers Application-Managed EntityManager können mit beiden Transaktionskonzepten arbeiten Wir verwenden hier das Konzept der Resource-Local Transactions Konsequenz: Transaktionen müssen von der Applikation kontrolliert und verwaltet werden! Prof. Dr. Günter Brackly 31

32 Persistenz / Transaktionen Resource-local Transactions: Implementieren: EntityTransaction trans = em.gettransaction(); Das Interface EntityTransaction stellt entsprechend dem JDBC Connection Interface unter anderen folgende Methoden zur explizitenverwaltung der Transaktionen zur Verfügung: - public void begin(); - public void commit(); - public void rollback() Prof. Dr. Günter Brackly 32

33 Persistenz / Transaktionen Synchronisation mit der Datenbank: Datensätze von Tabellen werden als Entity-Instanzen im Persistence Context von einem EntityManager verwaltet. Alle Veränderungen (Neuanlegen, Aktualisieren, Löschen) werden zunächst in der Applikation an Entity-Instanzen im Persistence Context vorgenommen. Diese Änderungen werden vom EntityManager über einen flush des Persistence Context in die Datenbank geschrieben und dauerhaft gespeichert, wenn die Entity-Transaktion committed. Die einzige andere Möglichkeit, einen solchen flush in Gang zu setzen ist der explizite Aufruf der flush() Methode des EntityManagers in der Applikation! Bei einem flush überprüft der EntityManager den Persistence Context auf neue, veränderte oder zu löschende Entities und schreibt die Änderungen über SQL- Statements des Persistence-Providers (Eclipselink, Toplink) in die Datenbank. Prof. Dr. Günter Brackly 33

34 Persistenz / Transaktionen Synchronisation mit der Datenbank: EntityTransactions werden also im Persistence Context des EntityManagers (EM) gestartet und beendet. Erst beim Ende der EntityTransaction wird auch in der Datenbank eine Transaktion gestartet! Nach dem erfolgreichen Ende einer Transaktion verbleiben die Entities im Persistence Context als vom EM verwaltete Entities. Dort kann ihr Zustand über die refresh()-methode des EM aus der Datenbank aktualisiert werden. Das refresh() eines Entities wird immer dann notwendig, wenn zu vermuten ist, dass von einem anderen Client mit einem anderen EM das Objekt in der Datenbank (also der Datensatz) zwischenzeitlich geändert wurde!! Prof. Dr. Günter Brackly 34

35 Persistenz / Transaktionen Synchronisation mit der Datenbank: Wird eine Transaktion erfolglos beendet (rollback), verlieren alle zugehörigen Entites ihren Status als vom EM verwaltete Entities und damit ihren Zusammenhang zur Datenbank! Es sind sogenannte detached Entities! Detached Entities können wieder in die Verwaltung (den Persistence Context) des EM aufgenommen werden durch die merge()-methode des EM. Dann können sie auch wieder mit der Datenbank synchronisiert werden (refresh() ) : etx.begin(); person = em.merge(person); em.refresh(person); etx.commit(); Prof. Dr. Günter Brackly 35

36 Persistenz / Transaktionen Synchronisation mit der Datenbank: der Persistence Context eines EntityManagers (EM) wird mit dem Schließen des EM gelöscht. Ein Application managed EM kann in seinem Persistence Context beliebig viele Transaktionen (hintereinander) verarbeiten. Ein solcher Persistence Context kann geleert werden durch die clear()-methode des EM. Dies kann notwendig werden, da im Laufe des Bestehens des Persistence Context immer mehr verwaltete Entities durch erfolgreiche Transaktionen hineinkommen, die aber irgendwann nicht mehr gebraucht werden! Prof. Dr. Günter Brackly 36

37 Persistenz Synchronisation mit der Datenbank: Es kann über die Annotation der Entity-Klassen das gesamte Datenbankdesign von JPA erzeugt werden! Dies muss explizit aufgerufen werden durch neue properties in der persistence.xml Datei: <property name="toplink.ddl-generation" value="create-tables"/> <property name="eclipselink.ddl-generation" value="create-tables"/> Mit dieser Angabe werden alle Tabellen, Sequences, PK- und FK-Constraints, etc. in der Datenbank erzeugt. Für die Generation gibt es noch andere values: z. B. drop-and-create, mit der Konsequenz, dass bestehende Tabellen gelöscht und neu erzeugt werden! Man kann sich auch nur die SQL-Skripts erzeugen lassen, oder beides. Weitere nützliche Hinweise findet man unter: Prof. Dr. Günter Brackly 37

38 Eclipse Zur Entwicklung von Anwendungsprogrammen mit JPA unter Eclipse ist folgendes zu beachten: Das Projekt muss mit einer JRE größer gleich 1.5 arbeiten und als JPA- Projekt erzeugt worden sein; Das Projekt muss im JavaBuildPath die externen JARs toplink-essentials.jar bzw. eclipselink.jar toplink-essentials-agent.jar und die Datenbank-JDBC-jars angegeben haben; javax.persistence_ jar Um das JPA zu benutzen, muss in den Klassen das Package javax.persistence.* importiert werden; Das Projekt muss im JPA-Ordner die Datei persistence.xml haben; Prof. Dr. Günter Brackly 38

39 Datenbank JPA-Anwendung Person Adresse Hobbies Ausbildungen ojdbc4.jar JDBC- Treiber persistence.xml Persistence- Unit Anwendungsprogramm EntityManager EntityManager Factory Beruf Datenbank-Entity-Klassen DBPersonen DBAdressen DBAusbildungen DBHobbies DBBeruf Prof. Dr. Günter Brackly 39

40 Ergebnis und Fazit: OR-Mapping mit JPA und Eclipselink vereinfacht die Anwendungsprogrammierung von Datenbankanwendungen enorm! Nach der Deklaration einer Persistence-Unit und der Annotation der Datenbankklassen können Anwendungsobjekte ohne insert-, update- oder delete-statements in der Datenbank gespeichert bzw. verändert bzw. gelöscht werden! Mit der find() Methode des EntityManagers können Objekte, identifiziert über den PK, aus der Datenbank selektiert werden. Komplexere Abfragen müssen allerdings weiterhin über select-statements bzw. JPQL explizit formuliert werden! POJO Persistence: Objekte können durch Annotation persistent werden, ohne die Objekte selbst zu ändern. Prof. Dr. Günter Brackly 40

41 Ergebnis und Fazit: Queries der JPQL beziehen sich auf Klassen und Attribute, nicht auf das zugrunde liegende Datenbankschema, d.h. der Programmierer braucht eigentlich keine Kenntnis dieses Schemas! Über die Persistence-Units können effizient und flexibel alle marktüblichen Datenbanksysteme angebunden werden. Das betrifft dann natürlich auch die Migration von einem DB-System zu einem anderen. Der Implementierungsaufwand für Projekte reduziert sich, da durch die Annotation alle Tabellen und andere Datenbankobjekte automatisch erzeugt werden. Hat man Sequences annotiert und die zugehörige Werte-Erzeugung für die PKs, müssen alle Trigger, die bisher für den automatischen Aufruf der Sequences verantwortlich waren, deaktiviert werden! (alter trigger <name> disable; ). Prof. Dr. Günter Brackly 41

42 Ergebnis und Fazit: Was man nicht machen sollte, ist die Erzeugung neuer zusätzlicher Tabellen über JPA! Diese neuen Tabellen werden zwar korrekt erzeugt, aber es werden keine neuen FK-Attribute oder FK-Constraints in bestehenden Tabellen erzeugt und zu dieser neuen Tabelle aufgebaut, auch wenn entsprechende bidirektionale Beziehungen annotiert sind!! Annotiert man Entity-Klassen mit bereits bestehenden Tabellen, müssen im Datenbankdesign alle FK-Attribute und die zugehörigen PK- und FK-Constraints deklariert sein, damit kaskadierendes Speichern und Löschen möglich ist! Prof. Dr. Günter Brackly 42

43 Insert-Methode mit JDBC und Oracle (Teil 1): public static int insertperson(connection con, DBPersonen pers) { String stmt = "insert into person(name, vorname, gebdat, geschlecht, einnahmen, bonus) values (?,?,?,?,?,?)"; try { PreparedStatement ps = con.preparestatement(stmt); ps.setstring(1,pers.getname()); ps.setstring(2,pers.getvorname()); ps.setdate(3,pers.getgebdat()); ps.setstring(4,pers.getgeschlecht()); ps.setfloat(5,pers.geteinnahmen()); ps.setstring(6,pers.getbonus()); ps.executeupdate(); ps.close(); String stmt1 = "insert into adresse(plz, ort, str, typ, persnr) values (?,?,?,?, persnr_seq.currval)"; PreparedStatement ps1 = con.preparestatement(stmt1); ps1.setstring(1,((dbadresse) pers.getadressen().get(0)).getplz()); ps1.setstring(2,((dbadresse) pers.getadressen().get(0)).getort()); ps1.setstring(3,((dbadresse) pers.getadressen().get(0)).getstr()); ps1.setstring(4,((dbadresse) pers.getadressen().get(0)).gettyp()); ps1.executeupdate(); ps1.close(); String stmt2 = "insert into hobbies(hobby, persnr) values (?, persnr_seq.currval)"; PreparedStatement ps2 = con.preparestatement(stmt2); ps2.setstring(1,((dbhobbies) pers.gethobbies().get(0)).gethobby()); ps2.executeupdate(); ps2.close(); Prof. Dr. Günter Brackly 43

44 Insert-Methode mit JDBC und Oracle (Teil 2): String stmt3 = "insert into ausbildungen(von, bis, beschreibung, abschluss, datum, persnr) values (?,?,?,?,?, persnr_seq.currval)"; PreparedStatement ps3 = con.preparestatement(stmt3); ps3.setdate(1,((dbausbildungen) pers.getausbildungen().get(0)).getvon()); ps3.setdate(2,((dbausbildungen) pers.getausbildungen().get(0)).getbis()); ps3.setstring(3,((dbausbildungen) pers.getausbildungen().get(0)).getbeschreibung()); ps3.setstring(4,((dbausbildungen) pers.getausbildungen().get(0)).getabschluss()); ps3.setdate(5,((dbausbildungen) pers.getausbildungen().get(0)).getdatum()); ps3.executeupdate(); ps3.close(); String stmt4 = "insert into beruf(begonnen, beendet, beschreibung, gehalt, persnr) values (?,?,?,?, persnr_seq.currval)"; PreparedStatement ps4 = con.preparestatement(stmt4); ps4.setdate(1,((dbberuf) pers.getberufsphasen().get(0)).getbegonnen()); ps4.setdate(2,((dbberuf) pers.getberufsphasen().get(0)).getbeendet()); ps4.setstring(3,((dbberuf) pers.getberufsphasen().get(0)).getbeschreibung()); ps4.setfloat(4,((dbberuf) pers.getberufsphasen().get(0)).getgehalt()); ps4.executeupdate(); ps4.close(); PreparedStatement ps5 = con.preparestatement("select persnr_seq.currval from dual"); ResultSet rs = ps5.executequery(); rs.next(); int persnr = rs.getint(1); rs.close(); con.commit(); return persnr; } catch(exception e) { System.out.println(e); return -1; } } Prof. Dr. Günter Brackly 44

45 Insert-Methode mit JPA und Oracle: public static int insertperson(entitymanager em, DBPersonen pers) { try { EntityTransaction tx = em.gettransaction(); tx.begin(); em.persist(pers); tx.commit(); return pers.getpersnr(); } catch(exception e) { System.out.println(e); tx.rollback(); return -1; } } Prof. Dr. Günter Brackly 45

46 JPQL: JPQL select Statement ist analog zu SQL aufgebaut mit den gleichen Klauseln: select Klausel from Klausel where Klausel group by Klausel having Klausel order by - Klausel Wichtigster Unterschied: Die Queries beziehen sich auf Entities, nicht auf Datensätze, d.h. JPQL Statements werden für Applikationsobjekte formuliert und vom EntityManager bzw. JPA-Provider in SQL-Statements für die Datenbank umgesetzt! Auch hier ist es also so, dass der Anwendungsprogrammierer keine Kenntnis vom Datenbankdesign haben muss! Prof. Dr. Günter Brackly 46

47 JPQL: Beispiel 1: String query = " select p from DBPersonen p join p.adressen a where a.ort = 'Zweibrücken' "; EntityTransaction tx = em.gettransaction(); tx.begin(); Query q = em.createquery(query); List erg = q.getresultlist(); tx.commit(); Die Ergebnisliste erg enthält Entities vom Typ DBPersonen, die im Programm weiter verwendet werden können. Prof. Dr. Günter Brackly 47

48 JPQL: Beispiel 2: String query = " select p.name, p.vorname, a.ort from DBPersonen p join p.adressen a where a.typ = 'P' "; EntityTransaction tx = em.gettransaction(); tx.begin(); Query q = em.createquery(query); List erg = q.getresultlist(); tx.commit(); for ( Iterator i = erg.iterator(); i.hasnext(); ) { Object[] werte = (Object[]) i.next(); System.out.println(werte[0]+" "+werte[1]+" "+werte[2]); } Die Ergebnisliste erg enthält jetzt pro Datensatz ein Array von Attribut- Werten Prof. Dr. Günter Brackly 48

49 JPQL: In JPQL sind fast alle Standard SQL Operatoren und Ausdrücke erlaubt: Select-Klausel: Als Ausdrücke erlaubt sind: - Objekte: select p from DBPersonen p; - Objektattributwerte: select p.name from DBPersonen p; - Referenzobjekte: select p.adressen.get(0) from DBPersonen p; - Objekt-Arrays: select p.persnr, p.name from DBPersonen p; Eine Besonderheit der Select-Klausel ist die Verwendung von Konstruktor- Ausdrücken zur Erzeugung (Zusammenstellung) neuer Objekte, quasi als View: select NEW frauen.dbpersonen(p.persnr, p.name, p.gebdat) from DBPersonen p where p.geschlecht = 'W'; Ergebnis sind neue Instanzen vom Typ frauen.dbpersonen, vorausgesetzt, dass ein entsprechender Konstruktor in DBPersonen existiert! Diese können dann im Programm über den vollen Typnamen zugegriffen werden. Prof. Dr. Günter Brackly 49

50 JPQL: From-Klausel: Zulässig sind alle mengenwertigen Konstrukte, kombiniert über INNER, LEFT OUTER, RIGHT OUTER oder FULL OUTER JOINs: - select a.ort from DBPersonen p JOIN p.adressen a; - select p.name from DBPersonen p JOIN p.adressen a JOIN p.ausbildungen au where au.abschluss = 'Abitur' and a.plz = '66482'; - select a.ort from DBPersonen p, DBAdresse a where p = a.person; - select p, ba from DBPersonen p LEFT OUTER JOIN p.bank ba; Voraussetzung ist hier eine 1:1 Beziehung zwischen DBPersonen und DBBank; Hat eine Person noch keine Bank eingetragen, ist das BankObjekt NULL. Prof. Dr. Günter Brackly 50

51 JPQL: Where-Klausel: - Zulässig sind alle bedingten Ausdrücke, verbunden durch Boolesche Operatoren AND, OR, NOT; - Es können die aus SQL bekannten Operatoren verwendet werden: BETWEEN LIKE IN EXISTS - Es können beliebig Subqueries gebildet werden. - Bzgl. Collections gibt es den speziellen Operator IS [NOT] EMPTY - Es gibt build-in Funktionen wie abs(number), current_date, etc Prof. Dr. Günter Brackly 51

52 JPQL: Where-Klausel: - Beispiele: select p from DBPersonen p where p.gebdat BETWEEN ' ' AND ' ' select p from DBPersonen p where p.name LIKE 'M er%' select p from DBPersonen p where p.hobbies IS EMPTY; select p from DBPersonen p where p.gebdat = (select max(pers.gebdat) from DBPersonen pers) select p from DBPersonen p where NOT EXISTS (select au from p.ausbildungen au where au.abschluss = 'Abitur') Prof. Dr. Günter Brackly 52

53 JPQL: Group by- und Having-Klausel: Wie im Standard SQL gibt es in JPQL die 5 Aggregatfunktionen: max(), min(), avg(), sum(), count() bzgl. derer gruppiert werden kann. - Beispiele: select count(a) from DBPersonen p join p.adresssen a select p.name, count(a), max(b.gehalt) from DBPersonen p join p.adresssen a join p.berufsphasen b GROUP BY p.name select p.name, count(a) from DBPersonen p join p.adresssen a GROUP BY p.name HAVING count(a) > 2 Prof. Dr. Günter Brackly 53

54 JPQL: Order by Klausel: Wie im Standard SQL können Abfrageergebnisse sortiert werden, absteigend (DESC) oder aufsteigend (ASC) - Beispiel: select p.persnr, p.name, p.vorname, p.gschlecht from DBPersonen p order by p.geschlecht, p.name DESC Unterschied zum Standard SQL: Es kann nur nach den Attributen sortiert werden, die in der select-klausel angegeben sind! Prof. Dr. Günter Brackly 54

55 JPQL: Update Statement : Wie im Standard SQL können bestehende Entities aktualisiert werden: update DBPersonen p set p.gebdat = ' ', p.geschlecht = 'M' where p.persnr = 7; Das Update-Statement wird direkt in ein SQL-Statement umgesetzt und an die Datenbank geschickt, ohne die betroffenen Datensätze zunächst als Entities in der Applikation zu instanziieren! Das ist notwendig, falls massenhaft Datensätze aktualisiert werden sollen! Prof. Dr. Günter Brackly 55

56 JPQL: Delete - Statement: Wie im Standard SQL können bestehende Entities gelöscht werden: delete from DBBeruf b where b.person is null Unterschied zwischen em.remove() und (JPQL) delete: Mit em.remove() können nur Objekte gelöscht werden, die sich im Persistence Context des EntityManagers befinden, also in der Applikation als Entities instanziiert sind!! Auch das delete-statement wird direkt in ein SQL-Statement umgesetzt und an die Datenbank geschickt, ohne die betroffenen Datensätze zunächst als Entities in der Applikation zu instanziieren! Prof. Dr. Günter Brackly 56