Java Persistenz mit JPA und Hibernate. Michael Plöd - Senacor Technologies AG

Transkript

1 Java Persistenz mit JPA und Hibernate Michael Plöd - Senacor Technologies AG

2 Michael Plöd Partner bei Senacor Technologies AG Hibernate Erfahrung seit 2002

3 Ihr Hintergrund Erfahrung mit Java? Erfahrung mit Java Persistenz? Tägliche Projektarbeit? Einsatz von Hibernate im Projekt? Ihre Erwartungen an die Schulung?

4 Agenda Zeit Thema 08:00-09:00 Einleitung und theoretische Grundlagen 09:00-09:30 Hibernate im Überblick 09:45-10:30 Mapping von Klassen 10:30-11:15 Arbeiten mit Hibernate 11:15-11:45 Queries

5 Datenbank Java Anwendung <<TABLE>> FOTOS ID <PK> NAME... Foto <<TABLE>> FOTOS_IN_GALERIEN PIC_ID <PK><FK> GAL_ID <PK><FK> Object-Relational Impedance Mismatch 0..* 0..* Galerie <<TABLE>> GALERIEN ID <PK> TITEL...

6 Impedance Mismatch Identität Granularität Vererbung Datenbank Primärschlüssel Erstellung eigener Datentypen sehr proprietär Vererbung nur durch Datenmodell OO-Software Objekt-Identität Objekt-Gleichheit Identity vs Equality Eigene Typen können jederzeit erstellt werden Vererbung ist Bestandteil von OO-Software Navigation Assoziationen Navigation in jeder Richtung ohne Einschränkbarkeit möglich Navigation über Joins Join-Tabellen bei n:m Navigation wird explizit deklariert Gerichtete Navigation somit möglich To-One Relationen (Pointer) To-Many Relationen (Collections)

7 Java Persistenz Feature-Set Hibernate JDBC ist Java SE Standard JPA 2.0 ibatis und Spring JDBC Template sind JDBC Frameworks JPA 1.0 ibatis JPA 1, JPA 2 und Hibernate sind OR- Mapper JDBC-Template JDBC Code Menge / Komplexität

8 JDBC ist doch einfach

9 Einfacher Select mit JDBC List<User> users = new ArrayList<User>(); Class.forName( org.postgresql.driver ); Connection con = DriverManager.getConnection(url, username, password); Statement stmt = con.createstatement(); ResultSet rs = stmt.executequery( SELECT * FROM USERS ); while(rs.hasnext()) { User u = new User(); u.setname(rs.getstring(1)); users.add(u); } rs.close(); stmt.close(); con.close();

10 ! Exception Handling fehlt

11 Einfacher Select mit JDBC try { List<User> users = new ArrayList<User>(); Class.forName( org.postgresql.driver ); Connection con = DriverManager.getConnection(url, username, password); Statement stmt = con.createstatement(); ResultSet rs = stmt.executequery( SELECT * FROM USERS ); while(rs.hasnext()) { User u = new User(); u.setname(rs.getstring(1)); users.add(u); } rs.close(); stmt.close(); con.close(); } catch (SQLException e) { //Exception Handling }

12 Resource Leaks

13 Einfacher Select mit JDBC Connection con = null; Statement stmt = null; ResultSet rs = null; try { List<User> users = new ArrayList<User>(); Class.forName( org.postgresql.driver ); con = DriverManager.getConnection(url, username, password); stmt = con.createstatement(); rs = stmt.executequery( SELECT * FROM USERS ); while(rs.hasnext()) { User u = new User(); u.setname(rs.getstring(1)); users.add(u); } rs.close(); stmt.close(); con.close(); } catch (SQLException e) { //Exception Handling } finally { if(rs!= null) { try {rs.close();} catch (SQLException e) {...}; } if(stmt!= null) { try {stmt.close();} catch (SQLException e) {...}; } if(con!= null) { try {con.close();} catch (SQLException e) {...}; } }

14 JDBC Frameworks Eigenschaften Pro Contra Beispiele Adressieren Komplexität von JDBC Bieten wiederverwendbare Komponenten Einfache Typ Mappings (z.b. RowMapper) Einfach zu benutzen Wenige Fallstricke Auch für extrem komplexe Legacy Datenbanken geeignet Begrenztes Caching Beschränkte Typ Mappings Zahlreiche manuelle Aufrufe Spring JDBCTemplate ibatis

15 OR-Mapper Eigenschaften Pro Contra Adressieren Komplexität von JDBC Komplette Typ Mappings Ausgefeiltes Caching System Transaktionales Write-Behind Einfach zu benutzen Caching Code-Menge Manchmal komplex Schwächen bei schlecht entworfenen Legacy Datenbanken Beispiele Hibernate EclipseLink Open JPA

16 Aufbau eines OR- Mappers Configuration Factory 2nd Level Cache Persistence Context 1st Level Cache

17 Abbildung auf Datenbank Person Adresse Konto public class Person { private Adresse adresse; private Set<Konto> konten; } //... getter und setter XML Mapping Annotationen PERSONEN KONTEN

18 Aufbau von JPA Persistence EntityManager Factory 2nd Level Cache EntityManager 1st Level Cache

19 Aufbau von Hibernate Configuration SessionFactory 2nd Level Cache Session 1st Level Cache

20 Hibernate s Module ORM EntityManager Shards Search OGM Bean Validation Kern von Hibernate OR-Mapping Engine XML- und Annotation-Mappings JPA Implementierung auf Basis von Core und Annotations Unterstützung für verteilte Datenbestände Von Google Mächtige Volltext-Suche Basiert auf Lucene Hibernate für NoSQL Stores DDL Generierung Validierung DDL Generierung

21 Transaktionales Write-Behind begin commit Transaktion Session open saves: 1 saves: 1 updates: 1 close session.save(person) Logik session.update(konto) INSERT UPDATE DATENBANK

22 Agenda Zeit Thema 08:00-09:00 Einleitung und theoretische Grundlagen 09:00-09:30 JPA im Überblick 09:45-10:30 Mapping von Klassen 10:30-11:15 Arbeiten mit Hibernate 11:15-11:45 Queries

23 JPA im Überblick

24 Aufbau von JPA Persistence EntityManager Factory 2nd Level Cache EntityManager 1st Level Cache

25 Einfaches public class Person private long id; private String vorname; private String nachname; private long getid() { return id; } private void setid(long id) { this.id = id; } Person ID NUMBER <PK> VORNAME VARCHAR NACHNAME VARCHAR //... weitere getter und setter } //... equals und hashcode

26 Konfiguration META-INF/persistence.xml <persistence xmlns=" xmlns:xsi=" xsi:schemalocation=" version="2.0"> <persistence-unit name="test"> <class>com.senacor.schulung.hibernate.domain.person</class> <properties> <property name="javax.persistence.jdbc.driver" value="org.hsqldb.jdbcdriver" /> <property name="javax.persistence.jdbc.url" value="jdbc:hsqldb:hsql://localhost/testdb" /> <property name="javax.persistence.jdbc.user" value="sa" /> <property name="javax.persistence.jdbc.password" value="" /> <property name="hibernate.dialect" value="org.hibernate.dialect.hsqldialect"/> </properties> </persistence-unit> </persistence>

27 Initialisierung EntityManagerFactory Aus persistence.xml wird einmalig EntityManagerFactory erstellt EntityManagerFactory entitymanagerfactory = Persistence.createEntityManagerFactory( "test" );

28 Arbeiten mit JPA 1. EntityManager erstellen 2. Transaktion starten 3. Operationen durchführen 4. Transaktion committen 5. EntityManager schließen EntityManager e = emf.createentitymanager() User u = new User(); u.setname("testuser"); e.gettransaction().begin(); e.persist(u); e.gettransaction().commit(); e.close();

30 Einfache Mappings Domänenmodellierung Entitäten Attribute Primärschlüssel Value Objects Assoziationen

31 Identifikation von Entitäten und Value Objects Ein gutes Domänenmodell unterscheidet zwischen Entitäten und Value Objects Des Weiteren ist die Navigation im Modell klar gegliedert und folgt einheitlichen Richtlinien Fokus des Modells sollte primär Fachlichkeit sein

32 Entitäten konstante Identität eigenen besitzen eine und einen Lebenszyklus

33 Identität durch Attribute bestimmt Kein eigener Lebenszyklus Value Objects

34 Buchtip: Domain Driven Design von Eric Evans Addison Wesley Verlag ISBN:

35 Mapping von Entitäten Eine Entität muss gemappt werden Eine Entität muss einen annotierten Primärschlüssel haben Eine Entität muss einen No-Arg Constructor haben

36 Beispiel PERSONEN ) public class Person private long id; private String vorname; private String nachname; private long getid() { return id; } private void setid(long id) { this.id = id; } PERSONEN ID NUMBER <PK> VORNAME VARCHAR NACHNAME VARCHAR //... weitere getter und setter } //... equals und hashcode

37 Primärschlüssel- private long id; Default: manuell gesetzter Primärschlüssel

38 Generierungs Strategien Name Description increment Generiert long, int, short basierend auf Tabelle. Nicht in Cluster! identity Identity Columns in DB2, MySQL, MS SQL Server, Sybase, HSQL sequence Sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi, Interbase hilo HI/LO Algorithmus basierend auf Tabelle seqhil HI/LO Algorithmus basierend auf Sequence uuid 128-bit UUID Algorithmus, auf Netzwerk eingeschränkt guid GUID String in MS SQL Server und MySQL native Identity, Sequence oder hilo je nach Datenbank assigned ID wird von Applikation zugewiesen select Zieht ID, die durch Trigger vergeben wird foreign Zieht ID, die durch anderes Objekt vergeben wird sequence-identity Spezialisierte Sequence Generierung basierend auf JDBC 3

39 Primärschlüssel- ( name= SEQ, sequencename= seq_person ) public class strategy=generationtype.sequence, generator= SEQ ) private long id;

40 Primärschlüssel- ( name="tab_gen", table="generator_table", pkcolumnname = "key", valuecolumnname = "hi", pkcolumnvalue = "PERS", allocationsize = "20") public class strategy=generationtype.table, generator= TAB_GEN ) private long id;

41 Mapping von Attributen Platzierung von Annotationen auf Attribut oder Getter-Ebene möglich Platzierung entscheidet über Zugriff (via Reflection oder über Getter) Default: jedes nicht annotierte Attribut ist persistent Alle gängigen Typen werden unterstützt

42 Mapping von für Spaltenkonfiguration Sondermappings für Date und (B)LOB für nicht-persistente Attribute

43 @Entity public class Person PERS_ID ) private long id; PERS_VORNAME, nullable= false ) private String PERS_NACHNAME, nullable= false ) private PERS_GEBURTSTAG) private Date private short alter;... }

44 Mapping von Value Objects Beispiel: Person ist Entität mit konstanter ID, Adresse ist einfaches Objekt ohne konstante ID Person id : long vorname : String nachname : String Adresse strasse : String plz : String stadt : String

45 Mapping von Value Objects Notation Value Object ist in Java nicht vorgesehen Value Object ist einfaches Attribut von Entität Value Object hat keinen eigenen Lebenszyklus Lebenszyklus wird von Entität gesteuert

46 Value Object - public class Adresse ADR_STRASSE ) private String ADR_PLZ ) private String ADR_STADT ) private String stadt; }... getter und public class Person private long id; private String vorname; private String nachname; PERSON ID NUMBER <PK> VORNAME VARCHAR NACHNAME VARCHAR ADR_STRASSE VARCHAR ADR_PLZ VARCHAR ADR_STADT private Adresse anschrift }...

47 Value Object - public class strasse, column=@column(name= PERS_ADR_STRASSE plz, column=@column(name= PERS_ADR_PLZ stadt, column=@column(name= PERS_ADR_STADT )) }) private Adresse public class Adresse ADR_STRASSE ) private String ADR_PLZ ) private String ADR_STADT ) private String stadt; }... getter und setter }...

48 Mapping von Relationen JPA unterstützt folgende Relationen One-To-One One-To-Many Many-To-Many Unterscheidung zwischen uni- und bidirektionalen Relationen Unterstützung für List, Map, Value Objects

49 Relationen Teil 1 Unidirektionale Relation geht nur in eine Richtung und ist daher einfach und empfehlenswert JPA verwaltet bi-direktionale Relationen nicht von selbst (siehe fortgeschrittene Mappings) Best Practice: Aggregate

50 Aggregate gruppieren Entitäten <Entität> Selbstauskunft <Root <Entität> Entität> Kreditantrag <Root <Entität> Entität> Kunde <Entität> TilgungsDetail <Entität> Darlehen <Entität> Adresse

51 Many-To-One Person id : long vorname : String nachname : String Konto nummer : String blz : String PERSON ID NUMBER <PK> VORNAME VARCHAR NACHNAME VARCHAR KONTO_ID NUMBER <FK> KONTO ID NUMBER <PK> NUMMER NUMBER BLZ VARCHAR

52 public class Person private long id; private String vorname; private String private Konto konto public class Konto private long id; private Integer nummer; private String blz; }...

53 public class Person private long id; private String vorname; private PERS_KTO_ID, nullable=false) private Konto konto public class Konto private long id; private Integer nummer; private String blz; }...

54 One-To-Many Person id : long vorname : String nachname : String Konto nummer : String blz : String PERSON ID NUMBER <PK> VORNAME VARCHAR NACHNAME VARCHAR KONTO ID NUMBER <PK> NUMMER NUMBER BLZ VARCHAR PERSON_ID NUMBER <FK>

55 public class Person private long id; private String vorname; private String nachname; Ungeordnete private Set<Konto> konten = new HashSet<Konto>(); public class Konto private long id; private Integer nummer; private String blz; }...

56 public class Person private long id; private String vorname; private KTO_PERSON_ID ) private Set<Konto> konten = new HashSet<Konto> public class Konto private long id; private Integer nummer; private String blz; }...

57 One-To-Many mit public class Person private long id; private String vorname; private KTO_PERSON_ID KTO_ORDER ) private List<Konto> konten = new ArrayList<Konto>(); Spalte wird benötigt, die Reihenfolge persistiert }... KONTO ID NUMBER <PK> NUMMER NUMBER BLZ VARCHAR KTO_PERSON_ID NUMBER <FK> KTO_ORDER NUMBER

58 One-To-One Shared Primary Key Person id : long vorname : String nachname : String Konto nummer : String blz : String PERSON ID NUMBER <PK> VORNAME VARCHAR NACHNAME VARCHAR KONTO ID NUMBER <PK><FK> NUMMER NUMBER BLZ VARCHAR

59 One-To-One Shared Primary public class Person private private Konto konto... public class = name = "myforeigngenerator", strategy = "foreign", parameters = "property", value = "owner") ) private long id; private Person owner;... }

60 One-To-One Unique Foreign Key Person id : long vorname : String nachname : String Konto nummer : String blz : String PERSON ID NUMBER <PK> VORNAME VARCHAR NACHNAME VARCHAR KONTO_ID NUMBER <FK><UNIQUE> KONTO ID NUMBER <PK> NUMMER NUMBER BLZ VARCHAR

61 One-To-One Unique Foreign public class Person private long id; private String vorname; private String KONTO_ID, nullable=false) private Konto public class Konto private long id; private Integer nummer; private String blz; }...

62 Bidirektionale Relationen JPA verwaltet bi-direktionale Relationen nicht von selbst Im Code muss Konsistenz garantiert werden! Ein Ende ist invers, d.h. JPA ignoriert diesen Teil bei Verwaltung und Mapping verweist auf das nicht-inverse Ende Sonst: doppeltes Fremdschlüssel Mapping Tip: Bidirektionale Mappings nach Möglichkeit vermeiden

63 Many-To-One Bidirektional Person id : long vorname : String nachname : String Konto nummer : String blz : String PERSON ID NUMBER <PK> VORNAME VARCHAR NACHNAME VARCHAR KONTO_ID NUMBER <FK> KONTO ID NUMBER <PK> NUMMER NUMBER BLZ VARCHAR

64 Many-To-One / public class Person private long id; private String vorname; private String PERS_KTO_ID, nullable=false) private Konto konto... public class Konto private long id; private Integer nummer; private String konto ) private Set<Person> eigentuemer = new HashSet<Person>(); }...

65 Verwaltung von Bidirektionalen public class Konto private long id; private Integer nummer; private String konto ) private Set<Person> eigentuemer = new HashSet<Person>(); } public void addeigentuemer(person p) { if (p == null) { throw new IllegalArgumentException( p is null ); } if(p.getkonto()!= null) { p.getkonto().geteigentuemer().remove(p); } geteigentuemer().add(p); p.setkonto(this); }...

66 Many-To-Many Person id : long vorname : String nachname : String Team name : String PERSON PERS_TEAM TEAM ID NUMBER <PK> VORNAME VARCHAR NACHNAME VARCHAR PERS_ID NUMBER <FK> TEAM_ID NUMBER <FK> ID NUMBER <PK> NAME VARCHAR

67 public class Person private PERS_TEAM, joincolumns PERS_ID ), inversejoincolumns TEAM_ID ) ) private Set<Team> teams = new HashSet<Team>(); public class Team private long id; private String name; teams ) private Set<Person> personen = new HashSet<Person>();...

68 Lebenszyklus und transitive Persistenz Entitäten haben einen eigenständigen Lebenszyklus TransientObjectException bei folgendem Code ohne transitive Persistenz Konto k = new Konto(); Person p = new Person();... k.setperson(p); session.save(k);

69 Cascade konfiguriert transitive Persistenz JPA unterstützt folgende Cascades ALL PERSIST MERGE REMOVE REFRESH DETACH Hibernate hat andere Semantik!

70 public class Person private long id; private String vorname; private String private Konto konto }...

71 Sonderfall: Orphan Deletion Nur für Collections Löscht eine Entität wenn sie aus einer Collection entfernt wird Zwei Konfigurations / ManyToMany CascadeType.DELETE_ORPHAN)

73 Arbeiten mit JPA und Hibernate Lebenszyklus von Entitäten EntityManager / Session API

74 Lebenszyklus von Entitäten new() Transient gc save() / persist() saveorupdate() merge() Session.get().load().getReference().find() Persistent delete() remove() Removed gc Query.list().uniqueResult().iterate().scroll().getResultList().getSingleResult() evict() clear() close() Detached update() saveorupdate() merge() gc

75 Lebenszyklus von Entitäten Zustand Von Hibernate Verwaltet Datenbank ID transient nein nein persistent ja ja detached nein ja

76 Speichern Ein Objekt wird persistent session.save() gibt die generierte ID sofort zurück (return Serializable) em.persist() gibt keine ID zurück (return void)

77 Löschen em.remove() und session.delete() löschen eine Entity und setzen den Status removed remove() ist JPA API Löschen grosser Datenbestände über HQL hibernate.use_identifier_rollback = true setzt den ID Wert zurück (Status = transient )

78 Laden get() und load() laden persistente Entities find() und getreference() sind JPA API existiert existiert nicht Zugriff get() Entity null Entity / null find() Entity null Entity / null load() Proxy Proxy Entity / Exception getreference() Proxy Proxy Entity / Exception

79 Updates Default: alle Spalten sind im Update enthalten dynamic-update= true bewirkt dynamische SQL Generierung Eigene Dirty Checking Implementierung kann in Interceptor (finddirty())implementiert werden

80 Reattaching session.update() löst immer SQL update aus select-before-update konfiguriert dirty check mittels SELECT (ineffizient, aber bei on update Triggern interesssant) lock() löst kein update aus, sondern führt nur Reattach durch

81 Reattaching merge() verhindert NonUniqueObjectException Das übergebene Objekt ist nicht attached, sondern das zurückgegebene Kopiert alle Properties und Collections Transiente Objekte werden gespeichert

82 Reattaching Objekt mit gleicher ID bereits in Session merge Objekt in Session wird überschreiben saveorupdate NonUniqueObjectException Objekt ist Transient INSERT INSERT Zustand übergebenes Objekt Transient / Detached Persistent Zustand Rückgabe Objekt Persistent - (returns void) Bestandteil von JPA ja nein

84 Arbeiten mit Queries Query q = em.createquery( from Person p where p.nachname = :nachname ).setparameter( nachname, Müller ).setfirstresult(20).setmaxresults(10); List ergebnisse = q.getresultlist(); Query q = em.createquery( from Person p where p.username = :login ).setstring( login, meinlogin ) Person p = (Person)q.getSingleResult(); Criteria c = session.createcriteria(person.class); c.setfirstresult(20); c.setmaxresults(19); List ergebnisse = q.list();

85 name= findpersonbyusername, query= from Person p where p.username = :login ) public class @Column(name= PERS_ID ) private long PERS_USERNAME ) private String username; }... Query q = em.createnamedquery( findpersonbyusername ).setparameter( login, username); List ergebnisse = q.getresultlist();

86 JPA-QL Textuelle Abfrage Sprache Ähnlich zu SQL Geht gegen Objekte und nicht gegen Tabellen Voll Objektorientiert Starkte Verwandschaft zu HQL Query Objekt wird über EntityManager bezogen

87 Einfache JPQL Beispiele from Person Diese Abfragen from Person as p select p from Person as p machen alle das selbe select p from Person p SQL: SELECT * FROM PERSONEN

88 JPQL ist polymorph from Zahlungsart Zahlungsart from LastschriftEinzug from Kreditkarte Lastschrift Kreditkarte from java.lang.object from java.io.serializable

89 Einschränkungen mit where from Person where username = :login from Person p where p.adresse.strasse = :strasse from Person p where p. like %@senacor.% and p.adresse.stadt = Nürnberg and p.lastlogin < :vorgestern

90 Sortierung mit order by from Person p order by p.lastname asc from Person p order by p.lastname asc, p.firstname asc

91 Selektion select p.lastname, p.firstname from Person p Gibt Object Array zurück Rückgabewerte sind keine Entitäten!

92 Aggregation und Gruppierung select p.adresse.stadt, count(p) from Person p group by p.adresse.stadt select p.adresse.stadt, count(p) from Person p group by p.adresse.stadt having p.adresse.stadt like Bad %

93 Inner und Outer Join PERS_ID PERS_NAME... KTO_id... KTO_NR 1 Michael Michael Tina Tina Tina SELECT p.*, k.* FROM Person p INNER JOIN Konto k on p.id = k.pers_id PERS_ID PERS_NAME... KTO_id... KTO_NR 1 Michael Michael Tina Tina Tina Sepp null null 4 Melanie null null SELECT p.*, k.* FROM Person p LEFT OUTER JOIN Konto k on p.id = k.pers_id

94 Joins in JPQL Implizite Navigation from Person p where p.adresse.stadt = Regensburg Inner Join from Person p join p.konten k where k.balance > 0 Fetch Join from Person p left join fetch p.konten

95 QueryDSL

96 Einführung Typ-sicher durch Annotation Processor Unterstützung für SQL, Hibernate / JPA und MongoDB, JDO, Lucene Volle Code Completion Fluent-API

97 Maven <project> <build> <plugins>... <plugin> <groupid>com.mysema.maven</groupid> <artifactid>apt-maven-plugin</artifactid> <version>1.0.6</version> <executions> <execution> <goals> <goal>process</goal> </goals> <configuration> <outputdirectory>target/generated-sources/java</outputdirectory> <processor>com.mysema.query.apt.jpa.jpaannotationprocessor</processor> </configuration> </execution> </executions> </plugin>... </plugins> </build> </project>

98 Formulierung von Abfragen HibernateQuery query = new HibernateQuery(session); JPAQuery query = new JPAQuery(entityManager);

99 Einschränkungen mit Restrictions QPerson person = QPerson.person; Person p = query.from(person).where(person.username.eq( ploed )).uniqueresult(person); QPerson person = QPerson.person; List<Person> p = query.from(person).where(person.alter.between( 10, 14 ), person.lastname.like( P% )).list(person);

100 Sortierung mit orderby QPerson person = QPerson.person; List<Person> p = query.from(person).where(person.alter.between( 10, 14 ), person.lastname.like( P% )).orderby(person.lastname.asc()).list(person);

101 Gruppierung mit Projections QPerson person = QPerson.person; JPAQuery query = new JPAQuery(entityManager); List<Object[]> result = query.from(person).groupby(person.adresse.stadt).listdistinct(person.adresse.stadt, person.adresse.stadt.count();

102 Joins QPerson person = QPerson.person; JPAQuery query = new JPAQuery(entityManager); List<Person> l = query.from(person).innerjoin(person.fotos).orderby(person.username.asc()).distinct().list(person);