Java-Persistenz mit Hibernate (eBook)

Inhalt 5
Geleitwort zur zweiten Auflage 13
Geleitwort 15
Vorwort zur zweiten Auflage 17
Vorwort 19
Danksagungen 21
Über dieses Buch 23
Roadmap 23
Für wen ist dieses Buch gedacht? 24
Code-Konventionen 25
Download des Quellcodes 25
Über die Autoren 25
Author Online 26
Teil 1 Erste Schritte mit Hibernate und EJB 3.0 27
1 Objekt-relationale Persistenz 29
1.1 Was ist Persistenz? 31
1.1.1 Relationale Datenbanken 31
1.1.2 Die Grundlagen von SQL 32
1.1.3 SQL in Java nutzen 33
1.1.4 Persistenz in objektorientierten Applikationen 33
1.2 Die Unvereinbarkeit der Paradigmen 35
1.2.1 Das Problem der Granularität 37
1.2.2 Das Problem der Subtypen 38
1.2.3 Das Problem der Identität 40
1.2.4 Mit Assoziationen verbundene Probleme 41
1.2.5 Das Problem der Datennavigation 43
1.2.6 Die Kosten der Unvereinbarkeit der Paradigmen 44
1.3 Persistenzschichten und Alternativen 45
1.3.1 Schichtarchitektur 45
1.3.2 Eine Persistenzschicht mit SQL/JDBC handcodieren 46
1.3.3 Serialisierung 47
1.3.4 Objektorientierte Datenbanksysteme 48
1.3.5 Andere Optionen 49
1.4 Objekt-relationales Mapping 49
1.4.1 Was ist ORM? 50
1.4.2 Generische ORM-Probleme 52
1.4.3 Warum ORM? 53
1.4.4 Hibernate, EJB3 und JPA 55
1.5 Zusammenfassung 60
2 Ein neues Projekt beginnen 61
2.1 Ein Hibernate-Projekt beginnen 62
2.1.1 Auswahl eines Entwicklungsprozesses 62
2.1.2 Das Projekt aufsetzen 65
2.1.3 Konfiguration und Start von Hibernate 71
2.1.4 Starten und Testen der Applikation 81
2.2 Ein neues Projekt mit Java Persistence 88
2.2.1 Die Arbeit mit Hibernate Annotations 88
2.2.2 Die Arbeit mit Hibernate EntityManager 91
2.2.3 Die Komponenten von EJB 97
2.2.4 Wechsel zu Hibernate-Interfaces 103
2.3 Reverse Engineering einer Legacy-Datenbank 105
2.3.1 Erstellen einer Datenbankkonfiguration 106
2.3.2 Reverse Engineering anpassen 107
2.3.3 Generieren von Java-Quellcode 108
2.4 Integration mit Java EE-Diensten 112
2.4.1 Integration mit JTA 112
2.4.2 JNDI-gebundene SessionFactory 116
2.4.3 Bereitstellung von JMX-Diensten 118
2.5 Zusammenfassung 119
3 Domain-Modelle und Metadaten 121
3.1 Die Applikation CaveatEmptor 122
3.1.1 Analyse der Business-Domain 122
3.1.2 Das Domain-Modell für CaveatEmptor 123
3.2 Implementierung des Domain-Modells 126
3.2.1 Das Vermischen von Aufgabenbereichen 126
3.2.2 Transparente und automatische Persistenz 127
3.2.3 POJOs und persistente Entity-Klassen 129
3.2.4 Implementierung von POJO- Assoziationen 131
3.2.5 Logik in Zugriffs-Methoden einfügen 135
3.3 Objekt-relationale Mapping-Metadaten 137
3.3.1 Metadaten in XML 137
3.3.2 Auf Annotationen basierende Metadaten 139
3.3.3 Die Arbeit mit XDoclet 145
3.3.4 Umgang mit globalen Metadaten 146
3.3.5 Die Manipulation von Metadaten zur Laufzeit 151
3.4 Alternative Entity- Repräsentation 153
3.4.1 Erstellung von dynamischen Applikationen 154
3.4.2 Daten in XML repräsentieren 160
3.5 Zusammenfassung 163
Teil 2 Konzepte und Strategien für das Mapping 165
4 Mapping von Persistenzklassen 167
4.1 Entities- und Wert-Typen 167
4.1.1 Feingranulierte Domain-Modelle 168
4.1.2 Konzeptdefinition 168
4.1.3 Identifizierung von Entities und Wert-Typen 169
4.2 Entities mit Identität mappen 171
4.2.1 Identität und Gleichheit bei Java 171
4.2.2 Umgang mit Datenbankidentität 172
4.2.3 Primärschlüssel für Datenbanken 174
4.3 Optionen für das Mapping von Klassen 179
4.3.1 Dynamische SQL-Generierung 179
4.3.2 Eine Entity unveränderlich machen 180
4.3.3 Bezeichnung von Entities für Abfragen 181
4.3.4 Deklaration eines Paketnamens 182
4.3.5 Quoting von SQL-Identifikatoren 182
4.3.6 Implementierung von Namenskonventionen 183
4.4 Feingranulierte Modelle und Mappings 185
4.4.1 Mapping von grundlegenden Eigenschaften 185
4.4.2 Mapping von Komponenten 191
4.5 Zusammenfassung 196
5 Vererbung und selbst erstellte Typen 197
5.1 Mapping von Klassenvererbung 197
5.1.1 Tabelle pro konkrete Klasse mit implizitem Polymorphismus 198
5.1.2 Tabelle pro konkrete Klasse mit Unions 201
5.1.3 Tabelle pro Klassenhierarchie 203
5.1.4 Tabelle pro Subklasse 207
5.1.5 Mischen von Vererbungsstrategien 210
5.1.6 Wahl einer Strategie 212
5.2 Das Typsystem von Hibernate 214
5.2.1 Wiederholung von Entity- und Wert-Typen 214
5.2.2 Eingebaute Mapping-Typen 216
5.2.3 Die Arbeit mit Mapping-Typen 220
5.3 Erstellen eigener Mapping-Typen 222
5.3.1 Überlegungen zu eigenen Mapping-Typen 222
5.3.2 Die Extension Points 223
5.3.3 Über eigene Mapping-Typen 224
5.3.4 Erstellen eines UserType 225
5.3.5 Erstellen eines CompositeUserType 228
5.3.6 Parametrisierung eigener Typen 231
5.3.7 Mapping von Aufzählungen 233
5.4 Zusammenfassung 237
6 Mapping von Collections und Entity-Assoziationen 239
6.1 Sets, Multimengen, Listen und Maps mit Wert-Typen 239
6.1.1 Wahl eines Collection-Interfaces 240
6.1.2 Mapping eines Set 242
6.1.3 Mapping einer Identifikator-Multimenge 243
6.1.4 Mapping einer Liste 244
6.1.5 Mapping einer Map 245
6.1.6 Sortierte und geordnete Collections 246
6.2 Collections von Komponenten 248
6.2.1 Schreiben der Komponentenklasse 249
6.2.2 Mapping der Collection 249
6.2.3 Aktivieren der bidirektionalen Navigation 250
6.2.4 Vermeiden von not-null-Spalten 250
6.3 Mapping von Collections mit Annotationen 252
6.3.1 Grundlegendes Mapping von Collections 252
6.3.2 Sortierte und geordnete Collections 254
6.3.3 Eine Collection von eingebetteten Objekten mappen 254
6.4 Mapping einer Parent/Children-Beziehung 256
6.4.1 Kardinalität 257
6.4.2 Die einfachste mögliche Assoziation 257
6.4.3 Die Assoziation bidirektional machen 259
6.4.4 Kaskadierung des Objektzustands 262
6.5 Zusammenfassung 269
7 Fortgeschrittene Mappings für Entity-Assoziationen 271
7.1 Entity- Assoziationen mit einem Wert 272
7.1.1 Gemeinsame Primärschlüssel- Assoziationen 273
7.1.2 one-to-one-Fremdschlüssel- Assoziationen 276
7.1.3 Mapping mit einer Join-Tabelle 278
7.2 Mehrwertige Entity- Assoziationen 282
7.2.1 one-to-many- Assoziationen 283
7.2.2 many-to-many- Assoziationen 289
7.2.3 Zusätzliche Spalten bei Join-Tabellen 294
7.2.4 Mapping von Maps 299
7.3 Polymorphe Assoziationen 302
7.3.1 Polymorphe many-to-one- Assoziationen 302
7.3.2 Polymorphe Collections 304
7.3.3 Polymorphe Assoziationen mit Unions 305
7.3.4 Polymorphe Tabelle pro konkrete Klasse 307
7.4 Zusammenfassung 309
8 Legacy-Datenbanken und eigenes SQL 311
8.1 Integration von Datenbanken aus Altsystemen 312
8.1.1 Umgang mit Primärschlüsseln 313
8.1.2 Beliebige Join-Bedingungen mit Formeln 323
8.1.3 Zusammenführen beliebiger Tabellen 328
8.1.4 Die Arbeit mit Triggern 331
8.2 Anpassung von SQL 335
8.2.1 Eigene CRUD- Anweisungen schreiben 336
8.2.2 Integration von Stored Procedures und Functions 340
8.3 Verbesserung der Schema-DDL 347
8.3.1 Eigene Namen und Datentypen in SQL 347
8.3.2 Gewährleistung von Datenkonsistenz 349
8.3.3 Einfügen von Domain- und Spalten-Constraints 351
8.3.4 Constraints auf Tabellenebene 352
8.3.5 Datenbank-Constraints 355
8.3.6 Erstellung von Indizes 356
8.3.7 Einfügen zusätzlicher DDL 357
8.4 Zusammenfassung 359
Teil 3 Dialogorientierte Objektverarbeitung 361
9 Die Arbeit mit Objekten 363
9.1 Der Persistenz-Lebenszyklus 364
9.1.1 Objekt-Zustände 364
9.1.2 Der Persistenzkontext 367
9.2 Objektidentität und Objektgleichheit 370
9.2.1 Die Konversationen 371
9.2.2 Der Geltungsbereich der Objektidentität 372
9.2.3 Die Identität von detached Objekten 373
9.2.4 Erweiterung eines Persistenzkontexts 379
9.3 Die Hibernate-Interfaces 379
9.3.1 Speichern und Laden von Objekten 380
9.3.2 Die Arbeit mit detached Objekten 386
9.3.3 Management des Persistenzkontexts 391
9.4 Die Java Persistence API 394
9.4.1 Speichern und Laden von Objekten 394
9.4.2 Die Arbeit mit detached Entity-Instanzen 399
9.5 Java Persistence in EBJ-Komponenten 402
9.5.1 EntityManager injizieren 403
9.5.2 Lookup eines EntityManagers 405
9.5.3 Zugriff auf eine EntityManagerFactory 405
9.6 Zusammenfassung 407
10 Transaktionen und gleichzeitiger Datenzugriff 409
10.1 Einführung in Transaktionen 409
10.1.1 Datenbank und Systemtransaktionen 411
10.1.2 Transaktionen in einer Hibernate- Applikation 413
10.1.3 Transaktionen mit Java Persistence 423
10.2 Steuerung des zeitgleichen Zugriffs 426
10.2.1 Zeitgleicher Zugriff auf Datenbanklevel 427
10.2.2 Optimistische Steuerung des zeitgleichen Zugriffs 432
10.2.3 Zusätzliche Isolationsgarantien 438
10.3 Nicht-transaktionaler Datenzugriff 442
10.3.1 Entlarvte Mythen über Autocommit 442
10.3.2 Die nicht-transaktionale Arbeit mit Hibernate 444
10.3.3 Optionale Transaktionen mit JTA 445
10.4 Zusammenfassung 447
11 Konversationen implementieren 449
11.1 Propagation der Hibernate-Session 450
11.1.1 Der Anwendungsfall für die Session-Propagation 450
11.1.2 Thread-local-Propagation 452
11.1.3 Propagation mit JTA 453
11.1.4 Propagation mit EJBs 455
11.2 Konversationen mit Hibernate 456
11.2.1 Die Garantien einer Konversation 456
11.2.2 Konversationen mit detached Objekten 457
11.2.3 Erweitern einer Session für eine Konversation 460
11.3 Konversationen mit JPA 466
11.3.1 Kontextpropagation in Java SE 467
11.3.2 Merging von detached Objekten in Konversationen 469
11.3.3 Erweiterung des Persistenzkontexts in Java SE 470
11.4 Konversationen mit EJB 3.0 474
11.4.1 Kontextpropagation mit EJBs 474
11.4.2 Erweiterter Persistenzkontext mit EJBs 477
11.5 Zusammenfassung 482
12 Effiziente Bearbeitung von Objekten 485
12.1 Transitive Persistenz 486
12.1.1 Persistence by Reachability 486
12.1.2 Kaskadierung auf Assoziationen anwenden 487
12.1.3 Die Arbeit mit dem transitiven Zustand 491
12.1.4 Transitive Assoziationen mit JPA 497
12.2 Bulk- und Batch-Operationen 499
12.2.1 Bulk- Anweisungen mit HQL und JPA QL 499
12.2.2 Batch-Verarbeitung 502
12.2.3 Die Arbeit mit einer stateless Session 504
12.3 Datenfilterung und Interception 506
12.3.1 Dynamische Datenfilter 507
12.3.2 Abfangen von Events in Hibernate 511
12.3.3 Das Core-Event-System 517
12.3.4 Entity-Listener und Callbacks 519
12.4 Zusammenfassung 521
13 Fetching und Caching optimieren 523
13.1 Definition des globalen Fetch-Plans 523
13.1.1 Optionen für das Auslesen der Objekte 523
13.1.2 Der Fetch-Plan: Default und Lazy 527
13.1.3 Die Arbeit mit Proxies 527
13.1.4 Deaktivieren der Proxy-Generierung 530
13.1.5 Eager Loading von Assoziationen und Collections 531
13.1.6 Lazy Loading mit Interception 533
13.2 Wahl einer Fetching-Strategie 535
13.2.1 Prefetching von Daten in Batches 536
13.2.2 Collections mit Subselects prefetchen 539
13.2.3 Eager Fetching mit Joins 540
13.2.4 Optimieren des Fetchings für Sekundärtabellen 542
13.2.5 Leitfaden zur Optimierung 545
13.3 Grundlagen des Caching 552
13.3.1 Geltungsbereiche und Strategien für das Caching 553
13.3.2 Die Cache- Architektur von Hibernate 557
13.4 Caching in der Praxis 561
13.4.1 Wahl einer Strategie für die Concurrency-Steuerung 561
13.4.2 Die Arbeit mit Cache-Bereichen 563
13.4.3 Einrichten eines lokalen Cache-Providers 564
13.4.4 Einrichten eines replizierten Caches 565
13.4.5 Steuerung des Second-level-Caches 569
13.5 Zusammenfassung 571
14 Abfragen mit HQL und JPA QL 573
14.1 Erstellen und Starten und Abfragen 574
14.1.1 Vorbereiten einer Abfrage 574
14.1.2 Ausführen einer Abfrage 583
14.1.3 Die Arbeit mit benannten Abfragen 587
14.2 HQL- und JPA QL- Abfragen 590
14.2.1 Selektion 590
14.2.2 Restriktion 592
14.2.3 Projektion 597
14.3 Joins, Reporting-Abfragen und Subselects 599
14.3.1 Zusammenführen von Relationen und Assoziationen 600
14.3.2 Reporting- Abfragen 610
14.3.3 Die Arbeit mit Subselects 615
14.4 Zusammenfassung 617
15 Fortgeschrittene Abfrageoptionen 619
15.1 Abfragen mit Criteria und Example 620
15.1.1 Grundlegende Abfragen mit Kriterien 620
15.1.2 Joins und dynamisches Fetching 625
15.1.3 Projektion und Berichtsabfragen 630
15.1.4 Query by Example 633
15.2 Native SQL- Abfragen 636
15.2.1 AutomatischerUmgang mit dem Resultset 636
15.2.2 Auslesen skalarer Werte 637
15.2.3 Natives SQL in Java Persistence 639
15.3 Filtern von Collections 641
15.4 Caching der Abfrageergebnisse 643
15.4.1 Aktivieren des Caches für das Abfrageergebnis 644
15.4.2 Funktionsweise des Abfrage-Caches 644
15.4.3 Wann sollte der Abfrage-Cache benutzt werden? 645
15.4.4 Cache-Lookups von natürlichen Identifikatoren 646
15.5 Zusammenfassung 648
16.1 Hibernate in einer Webapplikation 650
16.1.1 Der Use Case für eine mehrschichtige Applikation 650
16.1.2 Einen Controller schreiben 650
16.1.3 Das Entwurfsmuster Open Session in View 652
16.1.4 Design von smarten Domain-Modellen 656
16.2 Eine Persistenzschicht erstellen 658
16.2.1 Ein generisches Muster für das Data Access Object 659
16.2.2 Das generische CRUD-Interface implementieren 661
16.2.3 Implementierung von Entity-DAOs 663
16.2.4 Die Verwendung von Data Access Objects 664
16.3 Das Command-Muster 668
16.3.1 Die grundlegenden Interfaces 668
16.3.2 Ausführung von Command-Objekten 670
16.3.3 Varianten des Command-Musters 672
16.4 Das Design einer Applikation mit EJB 3.0 674
16.4.1 Mit stateful Beans eine Konversation implementieren 674
16.4.2 DAOs mit EJBs schreiben 676
16.4.3 Einsatz der Abhängigkeitsinjektion 677
16.5 Testen 679
16.5.1 Die verschiedenen Testarten 679
16.5.2 Die Arbeit mit TestNG 680
16.5.3 Die Persistenzschicht testen 684
16.5.4 Ein paar Überlegungen zu Performance-Benchmarks 691
16.6 Zusammenfassung 693
Anhang A: SQL-Grundbegriffe 695
Anhang B: Mapping-Schnellreferenz 699
Quellenangaben 701
Register 703

8 Legacy-Datenbanken und eigenes SQL (S. 285-286)

Die Themen dieses Kapitels:

Integration von Legacy-Datenbanken und knifflige Mappings
Anpassung von SQL-Anweisungen
Verbesserung des SQL-Schemas mit eigener DDL

Bei vielen Beispielen in diesem Kapitel geht es um „schwierige" Mappings. Das erste Mal wenn Sie Probleme mit dem Erstellen eines Mappings bekommen, wird wahrscheinlich sein, wenn das Datenbankschema eines Legacy-, also eines Altsystems nicht verändert werden kann. Wir besprechen typische Probleme, auf die Sie bei einem solchen Szenario stoßen werden, und wie Sie Ihre Mapping-Metadaten anpassen können, statt Ihre Applikation oder das Datenbankschema zu verändern.

Wir zeigen Ihnen auch, wie Sie das von Hibernate automatisch generierte SQL überschreiben können. Dazu gehören SQL-Abfragen, DML-Operationen (Create, Update, Delete) und auch die automatische DDL-Generierung von Hibernate. Sie erfahren, wie Stored Procedures und benutzerdefinierte SQL-Funktionen gemappt werden und wie Sie die richtigen Integritätsregeln in Ihrem Datenbankschema anwenden. Dieser Abschnitt wird besonders dann nützlich sein, wenn Ihr Datenbankadministrator die vollständige Kontrolle braucht (oder wenn Sie selbst der DBA sind und Hibernate auf SQL-Ebene optimieren wollen). Wie Sie sehen, sind die Themen dieses Kapitels breit gestreut, Sie brauchen nicht alles am Stück zu lesen. Sie können einen Großteil dieses Kapitels als Referenzmaterial betrachten und darauf zurückgreifen, wenn ein bestimmtes Problem auftritt.

8.1 Integration von Datenbanken aus Altsystemen

In diesem Abschnitt decken wir hoffentlich alle die Eventualitäten ab, auf die Sie bei der Arbeit mit einer vorhandenen Altsystem-Datenbank oder (und das ist oft das Gleiche) einem eigenartigen bzw. kaputten Schema arbeiten müssen. Wenn Ihr Entwicklungsprozess Top-down ist, können Sie diesen Abschnitt jedoch überspringen. Darüber hinaus empfehlen wir Ihnen, dass Sie zuerst alle Kapitel über Klassen-, Collection- und Assoziations- Mappings lesen, bevor Sie versuchen, mit Reverse Engineering ein komplexes Legacy- Schema anzugehen.

Wir müssen Sie warnen: Wenn Ihre Applikation ein vorhandenes Legacy-Datenbankschema erbt, sollten Sie an diesem Schema normalerweise so wenig Änderungen wie möglich vornehmen. Jede Änderung daran könnte andere vorhandene Applikationen beeinträchtigen, die auf die Datenbank zugreifen. Möglicherweise müssen Sie auch eine kostspielige Migration vorhandener Daten in Betracht ziehen. Im Allgemeinen ist es nicht möglich, eine neue Applikation zu erstellen und keine Änderungen am vorhandenen Datenmodell zu machen – eine neue Applikation bedeutet normalerweise zusätzliche Business-Anforderungen, die naturgemäß eine Weiterentwicklung des Datenbankschemas nach sich zieht. Wir werden von daher zwei Arten von Problemen betrachten: solche, die mit den sich verändernden Business-Anforderungen zu tun haben (die im Allgemeinen nicht ohne Überarbeitung des Schemas gelöst werden können), und solche, die sich nur darauf beziehen, wie Sie das gleiche Business-Problem in Ihrer neuen Applikation repräsentieren wollen (gewöhnlich kann das ohne Änderungen am Datenbankschema gelöst werden, aber nicht immer).

Es sollte klar sein, dass die erste Art von Problemen schon erkennbar wird, wenn man sich nur das logische Datenmodell anschaut. Die zweite bezieht sich häufiger auf die Implementierung des logischen Datenmodells als physisches Datenbankschema. Wenn Sie diesen Beobachtung zustimmen, merken Sie, dass Schemaveränderungen bei folgenden Problemen erforderlich sind: Einfügen neuer Entities, Refakturierung vorhandener Entities, Einfügen neuer Attribute bei vorhandenen Entities und Überarbeitungen der Assoziationen zwischen Entities. Bei den ohne Schemaveränderungen lösbaren Problemen geht es gewöhnlich um unpraktische Tabellen- oder Spaltendefinitionen für eine bestimmte Entity. In diesem Abschnitt konzentrieren wir uns auf diese Art Probleme.

Wir gehen davon aus, dass Sie bereits ein Reverse Engineering des vorhandenen Schemas mit dem Hibernate Toolset probiert haben, wie wir es in Kapitel 2, Abschnitt 2.3 „Reverse Engineering einer Legacy-Datenbank", beschrieben haben. Die Konzepte und Lösungen, die in den folgenden Abschnitten vorgestellt werden, gehen davon aus, dass Sie ein grundlegendes objekt-relationales Mapping etabliert haben und zusätzliche Änderungen machen müssen, um es ans Laufen zu kriegen. Alternativ können Sie versuchen, das Mapping ohne Tools fürs Reverse Engineering komplett per Hand zu schreiben. Fangen wir mit dem offensichtlichsten Problem an: den Legacy-Primärschlüsseln.