Java-Persistence mit Hibernate GERMAN

Bauer/King

Java Persistence mit Hibernate

Christian BauerGavin King

bersetzung: Jrgen Dubau, Freiburg/Elbe Titel der Originalausgabe: Java Persistence with Hibernate, 2007 Manning Pulications

Authorized translation of the English edition. This translation is published and sold by permission of Manning Publications, the owner of all rights to publish and sell the same.

Alle in diesem Buch enthaltenen Informationen, Verfahren und Darstellungen wurden nach bestem Wissen zusammengestellt und mit Sorgfalt getestet. Dennoch sind Fehler nicht ganz auszuschlieen. Aus diesem Grund sind die im vorliegenden Buch enthaltenen Informationen mit keiner Verpflich-tung oder Garantie irgendeiner Art verbunden. Autoren und Verlag bernehmen infolgedessen keine juristische Verantwortung und werden keine daraus folgende oder sonstige Haftung bernehmen, die auf irgendeine Art aus der Benutzung dieser Informationen oder Teilen davon entsteht. Ebenso bernehmen Autoren und Verlag keine Gewhr dafr, dass beschriebene Verfahren usw. frei von Schutzrechten Dritter sind. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Waren-bezeichnungen usw. in diesem Buch berechtigt deshalb auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wren und daher von jedermann benutzt werden drften.

Bibliografische Information der Deutschen Nationalbibliothek: Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet ber http://dnb.d-nb.de abrufbar.

Dieses Werk ist urheberrechtlich geschtzt. Alle Rechte, auch die der bersetzung, des Nachdruckes und der Vervielfltigung des Buches, oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche Genehmigung des Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder ein anderes Verfahren) auch nicht fr Zwecke der Unterrichtsgestaltung reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, ver-vielfltigt oder verbreitet werden.

Copyright fr die deutsche Ausgabe: 2007 Carl Hanser Verlag Mnchen Wien (www.hanser.de) Lektorat: Margarete Metzger Copy editing: Dr. Claudia Nlker, Bielefeld Herstellung: Irene Weilhart Umschlagdesign: Marc Mller-Bremer, Rebranding, Mnchen Umschlagrealisation: MCP Susanne Kraus GbR, Holzkirchen Datenbelichtung, Druck und Bindung: Ksel, Krugzell Ausstattung patentrechtlich geschtzt. Ksel FD 351, Patent-Nr. 0748702 Printed in Germany

ISBN 978-3-446-40941-5

V

Inhalt

Geleitwort zur zweiten Auflage .......................................................................................XIII

Geleitwort zur ersten Auflage ..........................................................................................XV

Vorwort zur zweiten Auflage..........................................................................................XVII

Vorwort zur ersten Auflage .............................................................................................XIX

Danksagung .....................................................................................................................XXI

ber dieses Buch...........................................................................................................XXIII

Teil 1: Erste Schritte mit Hibernate und EJB 3.0 ............................................................. 1

1 Objekt-relationale Persistenz.................................................................................. 31.1 Was ist Persistenz? .................................................................................................................. 5

1.1.1 Relationale Datenbanken ........................................................................................... 51.1.2 Die Grundlagen von SQL .......................................................................................... 61.1.3 SQL in Java nutzen.................................................................................................... 71.1.4 Persistenz in objektorientierten Applikationen .......................................................... 7

1.2 Die Unvereinbarkeit der Paradigmen ...................................................................................... 91.2.1 Das Problem der Granularitt .................................................................................. 111.2.2 Das Problem der Subtypen....................................................................................... 121.2.3 Das Problem der Identitt ........................................................................................ 141.2.4 Mit Assoziationen verbundene Probleme ................................................................ 151.2.5 Das Problem der Datennavigation ........................................................................... 171.2.6 Die Kosten der Unvereinbarkeit der Paradigmen..................................................... 18

1.3 Persistenzschichten und Alternativen .................................................................................... 191.3.1 Schichtarchitektur.................................................................................................... 191.3.2 Eine Persistenzschicht mit SQL/JDBC handcodieren.............................................. 201.3.3 Serialisierung........................................................................................................... 211.3.4 Objektorientierte Datenbanksysteme ....................................................................... 221.3.5 Andere Optionen...................................................................................................... 23

1.4 Objekt-relationales Mapping ................................................................................................. 231.4.1 Was ist ORM? ......................................................................................................... 24

Inhalt

VI

1.4.2 Generische ORM-Probleme......................................................................................261.4.3 Warum ORM? ..........................................................................................................271.4.4 Hibernate, EJB3 und JPA.........................................................................................29

1.5 Zusammenfassung..................................................................................................................34

2 Ein neues Projekt beginnen.................................................................................. 352.1 Ein Hibernate-Projekt beginnen .............................................................................................36

2.1.1 Auswahl eines Entwicklungsprozesses.....................................................................362.1.2 Das Projekt aufsetzen ...............................................................................................392.1.3 Konfiguration und Start von Hibernate.....................................................................452.1.4 Starten und Testen der Applikation ..........................................................................55

2.2 Ein neues Projekt mit Java Persistence...................................................................................622.2.1 Die Arbeit mit Hibernate Annotations......................................................................622.2.2 Die Arbeit mit Hibernate EntityManager .................................................................652.2.3 Die Komponenten von EJB ......................................................................................712.2.4 Wechsel zu Hibernate-Interfaces ..............................................................................77

2.3 Reverse Engineering einer Legacy-Datenbank.......................................................................792.3.1 Erstellen einer Datenbankkonfiguration ...................................................................802.3.2 Reverse Engineering anpassen..................................................................................812.3.3 Generieren von Java-Quellcode................................................................................82

2.4 Integration mit Java EE-Diensten...........................................................................................862.4.1 Integration mit JTA ..................................................................................................862.4.2 JNDI-gebundene SessionFactory..............................................................................902.4.3 Bereitstellung von JMX-Diensten ............................................................................92

2.5 Zusammenfassung..................................................................................................................93

3 Domain-Modelle und Metadaten........................................................................... 953.1 Die Applikation CaveatEmptor ..............................................................................................96

3.1.1 Analyse der Business-Domain..................................................................................963.1.2 Das Domain-Modell fr CaveatEmptor....................................................................97

3.2 Implementierung des Domain-Modells ................................................................................1003.2.1 Das Vermischen von Aufgabenbereichen...............................................................1003.2.2 Transparente und automatische Persistenz .............................................................1013.2.3 POJOs und persistente Entity-Klassen....................................................................1033.2.4 Implementierung von POJO-Assoziationen............................................................1053.2.5 Logik in Zugriffs-Methoden einfgen ....................................................................109

3.3 Objekt-relationale Mapping-Metadaten................................................................................1113.3.1 Metadaten in XML .................................................................................................1113.3.2 Auf Annotationen basierende Metadaten................................................................1133.3.3 Die Arbeit mit XDoclet ..........................................................................................1193.3.4 Umgang mit globalen Metadaten............................................................................1203.3.5 Die Manipulation von Metadaten zur Laufzeit .......................................................125

3.4 Alternative Entity-Reprsentation........................................................................................1273.4.1 Erstellung von dynamischen Applikationen ...........................................................1283.4.2 Daten in XML reprsentieren .................................................................................134

3.5 Zusammenfassung................................................................................................................137

Inhalt

VII

Teil 2: Konzepte und Strategien fr das Mapping....................................................... 139

4 Mapping von Persistenzklassen......................................................................... 1414.1 Entities- und Wert-Typen .................................................................................................... 141

4.1.1 Feingranulierte Domain-Modelle........................................................................... 1424.1.2 Konzeptdefinition .................................................................................................. 1424.1.3 Identifizierung von Entities und Wert-Typen ........................................................ 143

4.2 Entities mit Identitt mappen............................................................................................... 1454.2.1 Identitt und Gleichheit bei Java............................................................................ 1454.2.2 Umgang mit Datenbankidentitt ............................................................................ 1464.2.3 Primrschlssel fr Datenbanken........................................................................... 148

4.3 Optionen fr das Mapping von Klassen .............................................................................. 1534.3.1 Dynamische SQL-Generierung.............................................................................. 1534.3.2 Eine Entity unvernderlich machen ....................................................................... 1544.3.3 Bezeichnung von Entities fr Abfragen................................................................. 1554.3.4 Deklaration eines Paketnamens ............................................................................. 1564.3.5 Quoting von SQL-Identifikatoren.......................................................................... 1564.3.6 Implementierung von Namenskonventionen ......................................................... 157

4.4 Feingranulierte Modelle und Mappings............................................................................... 1594.4.1 Mapping von grundlegenden Eigenschaften .......................................................... 1594.4.2 Mapping von Komponenten .................................................................................. 165

4.5 Zusammenfassung ............................................................................................................... 170

5 Vererbung und selbst erstellte Typen................................................................ 1715.1 Mapping von Klassenvererbung.......................................................................................... 171

5.1.1 Tabelle pro konkrete Klasse mit implizitem Polymorphismus .............................. 1725.1.2 Tabelle pro konkrete Klasse mit Unions................................................................ 1755.1.3 Tabelle pro Klassenhierarchie................................................................................ 1775.1.4 Tabelle pro Subklasse ............................................................................................ 1815.1.5 Mischen von Vererbungsstrategien........................................................................ 1845.1.6 Wahl einer Strategie............................................................................................... 186

5.2 Das Typsystem von Hibernate............................................................................................. 1885.2.1 Wiederholung von Entity- und Wert-Typen .......................................................... 1885.2.2 Eingebaute Mapping-Typen................................................................................... 1905.2.3 Die Arbeit mit Mapping-Typen ............................................................................. 194

5.3 Erstellen eigener Mapping-Typen ....................................................................................... 1965.3.1 berlegungen zu eigenen Mapping-Typen............................................................ 1965.3.2 Die Extension Points.............................................................................................. 1975.3.3 ber eigene Mapping-Typen ................................................................................. 1985.3.4 Erstellen eines UserType ....................................................................................... 1995.3.5 Erstellen eines CompositeUserType ...................................................................... 2025.3.6 Parametrisierung eigener Typen ............................................................................ 2055.3.7 Mapping von Aufzhlungen .................................................................................. 207


Inhalt

VIII

6 Mapping von Collections und Entity-Assoziationen ........................................ 2136.1 Sets, Multimengen, Listen und Maps mit Wert-Typen.........................................................213

6.1.1 Wahl eines Collection-Interfaces............................................................................2146.1.2 Mapping eines Set ..................................................................................................2166.1.3 Mapping einer Identifikator-Multimenge ...............................................................2176.1.4 Mapping einer Liste................................................................................................2186.1.5 Mapping einer Map ................................................................................................2196.1.6 Sortierte und geordnete Collections........................................................................220

6.2 Collections von Komponenten .............................................................................................2226.2.1 Schreiben der Komponentenklasse .........................................................................2236.2.2 Mapping der Collection..........................................................................................2236.2.3 Aktivieren der bidirektionalen Navigation .............................................................2246.2.4 Vermeiden von not-null-Spalten.............................................................................224

6.3 Mapping von Collections mit Annotationen.........................................................................2266.3.1 Grundlegendes Mapping von Collections...............................................................2266.3.2 Sortierte und geordnete Collections........................................................................2286.3.3 Eine Collection von eingebetteten Objekten mappen .............................................228

6.4 Mapping einer Parent/Children-Beziehung ..........................................................................2306.4.1 Kardinalitt .............................................................................................................2316.4.2 Die einfachste mgliche Assoziation......................................................................2316.4.3 Die Assoziation bidirektional machen....................................................................2336.4.4 Kaskadierung des Objektzustands ..........................................................................236


7 Fortgeschrittene Mappings fr Entity-Assoziationen....................................... 2457.1 Entity-Assoziationen mit einem Wert ..................................................................................246

7.1.1 Gemeinsame Primrschlssel-Assoziationen .........................................................2477.1.2 one-to-one-Fremdschlssel-Assoziationen .............................................................2507.1.3 Mapping mit einer Join-Tabelle..............................................................................252

7.2 Mehrwertige Entity-Assoziationen.......................................................................................2567.2.1 one-to-many-Assoziationen....................................................................................2577.2.2 many-to-many-Assoziationen.................................................................................2637.2.3 Zustzliche Spalten bei Join-Tabellen ....................................................................2687.2.4 Mapping von Maps.................................................................................................273

7.3 Polymorphe Assoziationen...................................................................................................2767.3.1 Polymorphe many-to-one-Assoziationen................................................................2767.3.2 Polymorphe Collections .........................................................................................2787.3.3 Polymorphe Assoziationen mit Unions ..................................................................2797.3.4 Polymorphe Tabelle pro konkrete Klasse ...............................................................281


8 Legacy-Datenbanken und eigenes SQL ............................................................ 2858.1 Integration von Datenbanken aus Altsystemen ....................................................................286

8.1.1 Umgang mit Primrschlsseln ................................................................................2878.1.2 Beliebige Join-Bedingungen mit Formeln ..............................................................2978.1.3 Zusammenfhren beliebiger Tabellen ....................................................................3028.1.4 Die Arbeit mit Triggern ..........................................................................................305

Inhalt

IX

8.2 Anpassung von SQL............................................................................................................ 3098.2.1 Eigene CRUD-Anweisungen schreiben................................................................. 3108.2.2 Integration von Stored Procedures und Functions ................................................. 314

8.3 Verbesserung der Schema-DDL.......................................................................................... 3218.3.1 Eigene Namen und Datentypen in SQL ................................................................. 3218.3.2 Gewhrleistung von Datenkonsistenz .................................................................... 3238.3.3 Einfgen von Domain- und Spalten-Constraints.................................................... 3258.3.4 Constraints auf Tabellenebene............................................................................... 3268.3.5 Datenbank-Constraints........................................................................................... 3298.3.6 Erstellung von Indizes ........................................................................................... 3308.3.7 Einfgen zustzlicher DDL.................................................................................... 331


Teil 3: Dialogorientierte Objektverarbeitung ................................................................ 335

9 Die Arbeit mit Objekten ....................................................................................... 3379.1 Der Persistenz-Lebenszyklus............................................................................................... 338

9.1.1 Objekt-Zustnde .................................................................................................... 3389.1.2 Der Persistenzkontext ............................................................................................ 341

9.2 Objektidentitt und Objektgleichheit................................................................................... 3449.2.1 Die Konversationen ............................................................................................... 3459.2.2 Der Geltungsbereich der Objektidentitt................................................................ 3469.2.3 Die Identitt von detached Objekten...................................................................... 3479.2.4 Erweiterung eines Persistenzkontexts.................................................................... 353

9.3 Die Hibernate-Interfaces...................................................................................................... 3539.3.1 Speichern und Laden von Objekten ....................................................................... 3549.3.2 Die Arbeit mit detached Objekten ......................................................................... 3609.3.3 Management des Persistenzkontexts...................................................................... 365

9.4 Die Java Persistence API..................................................................................................... 3689.4.1 Speichern und Laden von Objekten ....................................................................... 3689.4.2 Die Arbeit mit detached Entity-Instanzen.............................................................. 373

9.5 Java Persistence in EBJ-Komponenten................................................................................ 3769.5.1 EntityManager injizieren ....................................................................................... 3779.5.2 Lookup eines EntityManagers ............................................................................... 3799.5.3 Zugriff auf eine EntityManagerFactory ................................................................. 379


10 Transaktionen und gleichzeitiger Datenzugriff................................................. 38310.1 Einfhrung in Transaktionen ............................................................................................... 383

10.1.1 Datenbank und Systemtransaktionen ..................................................................... 38510.1.2 Transaktionen in einer Hibernate-Applikation....................................................... 38710.1.3 Transaktionen mit Java Persistence ....................................................................... 397

10.2 Steuerung des zeitgleichen Zugriffs .................................................................................... 40010.2.1 Zeitgleicher Zugriff auf Datenbanklevel................................................................ 40110.2.2 Optimistische Steuerung des zeitgleichen Zugriffs................................................ 40610.2.3 Zustzliche Isolationsgarantien.............................................................................. 412

Inhalt

X

10.3 Nicht-transaktionaler Datenzugriff.......................................................................................41610.3.1 Entlarvte Mythen ber Autocommit .......................................................................41610.3.2 Die nicht-transaktionale Arbeit mit Hibernate........................................................41810.3.3 Optionale Transaktionen mit JTA...........................................................................419


11 Konversationen implementieren ........................................................................ 42311.1 Propagation der Hibernate-Session ......................................................................................424

11.1.1 Der Anwendungsfall fr die Session-Propagation..................................................42411.1.2 Thread-local-Propagation .......................................................................................42611.1.3 Propagation mit JTA...............................................................................................42711.1.4 Propagation mit EJBs .............................................................................................429

11.2 Konversationen mit Hibernate..............................................................................................43011.2.1 Die Garantien einer Konversation ..........................................................................43011.2.2 Konversationen mit detached Objekten ..................................................................43111.2.3 Erweitern einer Session fr eine Konversation.......................................................434

11.3 Konversationen mit JPA.......................................................................................................44011.3.1 Kontextpropagation in Java SE...............................................................................44111.3.2 Merging von detached Objekten in Konversationen...............................................44311.3.3 Erweiterung des Persistenzkontexts in Java SE......................................................444

11.4 Konversationen mit EJB 3.0.................................................................................................44811.4.1 Kontextpropagation mit EJBs.................................................................................44811.4.2 Erweiterter Persistenzkontext mit EJBs..................................................................451


12 Effiziente Bearbeitung von Objekten ................................................................. 45912.1 Transitive Persistenz ............................................................................................................460

12.1.1 Persistence by Reachability ....................................................................................46012.1.2 Kaskadierung auf Assoziationen anwenden ...........................................................46112.1.3 Die Arbeit mit dem transitiven Zustand..................................................................46512.1.4 Transitive Assoziationen mit JPA...........................................................................471

12.2 Bulk- und Batch-Operationen ..............................................................................................47312.2.1 Bulk-Anweisungen mit HQL und JPA QL.............................................................47312.2.2 Batch-Verarbeitung ................................................................................................47612.2.3 Die Arbeit mit einer stateless Session.....................................................................478

12.3 Datenfilterung und Interception ...........................................................................................48012.3.1 Dynamische Datenfilter..........................................................................................48112.3.2 Abfangen von Events in Hibernate.........................................................................48512.3.3 Das Core-Event-System .........................................................................................49112.3.4 Entity-Listener und Callbacks ................................................................................493


13 Fetching und Caching optimieren...................................................................... 49713.1 Definition des globalen Fetch-Plans.....................................................................................497

13.1.1 Optionen fr das Auslesen der Objekte ..................................................................49713.1.2 Der Fetch-Plan: Default und Lazy..........................................................................501

Inhalt

XI

13.1.3 Die Arbeit mit Proxies ........................................................................................... 50113.1.4 Deaktivieren der Proxy-Generierung..................................................................... 50413.1.5 Eager Loading von Assoziationen und Collections ............................................... 50513.1.6 Lazy Loading mit Interception............................................................................... 507

13.2 Wahl einer Fetching-Strategie ............................................................................................. 50913.2.1 Prefetching von Daten in Batches.......................................................................... 51013.2.2 Collections mit Subselects prefetchen ................................................................... 51313.2.3 Eager Fetching mit Joins........................................................................................ 51413.2.4 Optimieren des Fetchings fr Sekundrtabellen .................................................... 51613.2.5 Leitfaden zur Optimierung..................................................................................... 519

13.3 Grundlagen des Caching...................................................................................................... 52613.3.1 Geltungsbereiche und Strategien fr das Caching ................................................. 52713.3.2 Die Cache-Architektur von Hibernate ................................................................... 531

13.4 Caching in der Praxis........................................................................................................... 53513.4.1 Wahl einer Strategie fr die Concurrency-Steuerung ............................................ 53513.4.2 Die Arbeit mit Cache-Bereichen............................................................................ 53713.4.3 Einrichten eines lokalen Cache-Providers ............................................................. 53813.4.4 Einrichten eines replizierten Caches ...................................................................... 53913.4.5 Steuerung des Second-level-Caches ...................................................................... 543


14 Abfragen mit HQL und JPA QL........................................................................... 54714.1 Erstellen und Starten und Abfragen..................................................................................... 548

14.1.1 Vorbereiten einer Abfrage ..................................................................................... 54814.1.2 Ausfhren einer Abfrage ....................................................................................... 55714.1.3 Die Arbeit mit benannten Abfragen....................................................................... 561

14.2 HQL- und JPA QL-Abfragen .............................................................................................. 56414.2.1 Selektion ................................................................................................................ 56414.2.2 Restriktion ............................................................................................................. 56614.2.3 Projektion .............................................................................................................. 571

14.3 Joins, Reporting-Abfragen und Subselects.......................................................................... 57314.3.1 Zusammenfhren von Relationen und Assoziationen............................................ 57414.3.2 Reporting-Abfragen............................................................................................... 58414.3.3 Die Arbeit mit Subselects ............................................................................... 589


15 Fortgeschrittene Abfrageoptionen..................................................................... 59315.1 Abfragen mit Criteria und Example..................................................................................... 594

15.1.1 Grundlegende Abfragen mit Kriterien ................................................................... 59415.1.2 Joins und dynamisches Fetching............................................................................ 59915.1.3 Projektion und Berichtsabfragen............................................................................ 60415.1.4 Query by Example ................................................................................................. 607

15.2 Native SQL-Abfragen ......................................................................................................... 61015.2.1 AutomatischerUmgang mit dem Resultset............................................................. 61015.2.2 Auslesen skalarer Werte ........................................................................................ 61115.2.3 Natives SQL in Java Persistence............................................................................ 613

Inhalt

XII

15.3 Filtern von Collections .........................................................................................................61515.4 Caching der Abfrageergebnisse............................................................................................617

15.4.1 Aktivieren des Caches fr das Abfrageergebnis .....................................................61815.4.2 Funktionsweise des Abfrage-Caches ......................................................................61815.4.3 Wann sollte der Abfrage-Cache benutzt werden?...................................................61915.4.4 Cache-Lookups von natrlichen Identifikatoren.....................................................620


16 Erstellen und Testen von mehrschichtigen Applikationen.............................. 62316.1 Hibernate in einer Webapplikation.......................................................................................624

16.1.1 Der Use Case fr eine mehrschichtige Applikation................................................62416.1.2 Einen Controller schreiben .....................................................................................62416.1.3 Das Entwurfsmuster Open Session in View ...........................................................62616.1.4 Design von smarten Domain-Modellen ..................................................................630

16.2 Eine Persistenzschicht erstellen............................................................................................63216.2.1 Ein generisches Muster fr das Data Access Object...............................................63316.2.2 Das generische CRUD-Interface implementieren...................................................63516.2.3 Implementierung von Entity-DAOs........................................................................63716.2.4 Die Verwendung von Data Access Objects ............................................................638

16.3 Das Command-Muster .........................................................................................................64216.3.1 Die grundlegenden Interfaces .................................................................................64216.3.2 Ausfhrung von Command-Objekten.....................................................................64416.3.3 Varianten des Command-Musters ..........................................................................646

16.4 Das Design einer Applikation mit EJB 3.0...........................................................................64816.4.1 Mit stateful Beans eine Konversation implementieren ...........................................64816.4.2 DAOs mit EJBs schreiben ......................................................................................65016.4.3 Einsatz der Abhngigkeitsinjektion ........................................................................651

16.5 Testen ...................................................................................................................................65316.5.1 Die verschiedenen Testarten...................................................................................65316.5.2 Die Arbeit mit TestNG ...........................................................................................65416.5.3 Die Persistenzschicht testen....................................................................................65816.5.4 Ein paar berlegungen zu Performance-Benchmarks ............................................665


Anhang A: SQL-Grundbegriffe ...................................................................................... 669

Anhang B: Mapping-Schnellreferenz ............................................................................ 673

Quellenangaben.............................................................................................................. 675

Register ........................................................................................................................... 677

XIII

Geleitwort zur zweiten Auflage

Als Hibernate in Action vor zwei Jahren erschien, wurde es nicht nur sofort als magebli-ches Buch ber Hibernate akzeptiert, sondern auch als definitives Werk ber das objekt-relationale Mapping. In der Zwischenzeit hat sich die Persistenz-Landschaft durch das Release der Java Per-sistence API verndert, dem neuen Standard fr objekt-relationales Mapping fr Java EE und Java SE, das als Teil der Spezifikation von Enterprise JavaBeans 3.0 im Java Commu-nity Process entwickelt wurde. Bei der Entwicklung der Java Persistence API hat die EJB 3.0-Expertengruppe in hohem Mae von der Erfahrung mit den objekt-relationalen Mapping-Frameworks profitiert, die in der Java Community bereits in Benutzung sind. Als ein fhrendes Framework hat Hibernate einen besonders signifikanten Einfluss auf die technische Richtung bei Java Per-sistence gehabt. Das lag nicht nur daran, dass Gavin King und andere aus dem Hibernate-Team an der Entwicklung des EJB 3.0-Standards mitgearbeitet haben, sondern zum groen Teil auch am direkten und pragmatischen Ansatz, den Hibernate bezglich des objekt-relationalen Mappings und der Einfachheit, Klarheit und Leistungsfhigkeit seiner APIs genommen hat und dem Reiz, der sich daraus fr die Java Community ergab. Zustzlich zu ihrem Beitrag zu Java Persistence haben die Entwickler durch das in diesem Buch beschriebene Release (Hibernate 3) auch Hibernate betrchtlich weitergebracht. Da-zu gehren der Support fr Operationen mit groen Datenstzen, weitere und ausgefeiltere Mapping-Optionen (vor allem fr den Umgang von Datenbanken aus Altsystemen), Daten-filter, Strategien zum Managen von Konversationen und die Integration mit Seam, dem neuen Framework fr die Entwicklung von Webapplikationen mit JSF und EJB 3.0. Java Persistence mit Hibernate ist von daher um einiges mehr als blo die zweite Auflage von Hibernate in Action. Es bietet einen umfassenden berblick ber alle Mglichkeiten der Java Persistence API neben denen von Hibernate 3 sowie eine detaillierte Vergleichs-analyse beider APIs. Dieses Buch beschreibt, wie der Java Persistence Standard mit Hiber-nate implementiert wurde und wie man mit den Hibernate-Extensions fr Java Persistence arbeitet.

Geleitwort zur zweiten Auflage

XIV

Noch wichtiger ist, dass Christian Bauer und Gavin King bei ihrer Darstellung von Hiber-nate und Java Persistence die grundlegenden Prinzipien und Entscheidungen veranschauli-chen und erklren, die sowohl beim Design als auch der Nutzung eines objekt-relationalen Mapping-Frameworks bercksichtigt werden mssen. Durch ihre Ausfhrungen ber die dem ORM zugrunde liegenden Probleme bekommen die Leser ein fundiertes Verstndnis ber den effektiven Einsatz von ORM als Enterprise-Technologie. Java Persistence mit Hibernate richtet sich von daher an eine breit gefcherte Zielgruppe von Entwicklern: Neueinsteiger beim Thema objekt-relationales Mapping bis hin zu erfah-renen Entwicklern, die mehr ber die topaktuellen technologischen Innovationen in der Java-Community erfahren wollen und wissen mchten, was als Resultat dieser Arbeit ge-schehen ist und noch weiter auftauchen wird.

Linda DeMichielSpecification Lead Enterprise JavaBeans 3.0 und Java Persistence Sun Microsystems

XV

Geleitwort

Relationale Datenbanken stehen zweifellos im Zentrum moderner Unternehmen. Whrend moderne Programmiersprachen wie Java eine intuitive, objektorientierte An-sicht von Business-Entities auf Applikationsebene bieten, sind die diesen Entities zugrunde liegenden Unternehmensdaten von ihrem Wesen her relational. Gegenber den frheren navigationalen sowie den spteren OODB-Modellen besteht die grte Strke des relatio-nalen Modells berdies darin, dass es vom Design her von der programmatischen Manipu-lation und dem View auf Applikationsebene der Daten, mit denen es umgeht, intrinsisch keine Ahnung hat. In vielen Anlufen hat man an einem Brckenschlag zwischen relationalen und objekt-orientierten Technologien gearbeitet oder versucht, die eine durch die andere zu ersetzen, doch die Kluft zwischen beiden ist eine der harten Tatsachen des heutigen Enterprise Computings. Hibernate stellt sich durch seinen Ansatz des objekt-relationalen Mappings (ORM) dieser Herausforderung, eine Brcke zwischen relationalen Daten und Java-Objekten zu schaffen. Hibernate begegnet dieser Herausforderung auf sehr pragmatische, direkte und realistische Weise. Wie Christian Bauer und Gavin King in diesem Buch demonstrieren, muss man es zur effektiven Nutzung der ORM-Technologie verstehen und konfigurieren knnen, wie die Vermittlung zwischen relationalen Daten und Objekten ausgefhrt wird, wenn es sich nicht gerade um die allereinfachsten Enterprise-Umgebungen handelt. Das erfordert, dass sich der Entwickler sowohl mit der Applikation und deren Datenanforderungen als auch der Abfragesprache SQL, der relationalen Speicherstrukturen und dem Potenzial zur Optimie-rung, das die relationale Technologie bietet, auskennen muss. Hibernate bietet nicht nur eine komplett funktionsfhige Lsung, die diesen Anforderun-gen aus dem Stand entspricht, sondern weist auch eine flexible und konfigurierbare Archi-tektur auf. Hibernate wurde von seinen Entwicklern unter Bercksichtigung von Modulari-tt, Austauschbarkeit von Elementen, Erweiterbarkeit und Anpassungsmglichkeiten durch den Anwender designt. Als Folge davon ist Hibernate verdienterweise in den wenigen Jahren seit seiner Erstverffentlichung rasch zu einer der fhrenden ORM-Technologien fr Enterprise-Entwickler geworden.

Geleitwort

XVI

Dieses Buch bietet einen umfassenden berblick ber Hibernate. Es stellt vor, wie man mit den Mglichkeiten und Mechanismen zum Mapping von Typen fr das Modellieren von Assoziationen und Vererbung arbeitet, wie man Objekte mit der Hibernate-Abfrage-sprache effizient ausliest, wie man Hibernate zur Verwendung sowohl in gemanagten als auch nicht gemanagten Umgebungen konfiguriert und wie man die mitgelieferten Tools nutzt. Zustzlich kommentieren die Autoren im Verlauf des Buches die zugrunde liegen-den Probleme von ORM und die Entscheidungen fr das Design von Hibernate. Durch die-se Erkenntnisse bekommt der Leser ein weit reichendes Verstndnis der effektiven Nut-zung von ORM als Enterprise-Technologie. Hibernate in Action ist der definitive Leitfaden fr die Arbeit mit Hibernate und dem objekt-relationalen Mapping im heutigen Enterprise Computing.

Linda DeMichiel Lead Architect, Enterprise JavaBeans Sun Microsystems

XVII

Vorwort zur zweiten Auflage

Der Vorgnger dieses Buches, Hibernate in Action, begann mit einem Zitat von Anthony Berglas: Nur weil man Zweige auch mit der Nase ber den Boden schieben kann, heit das nicht, dass das der beste Weg ist, um Feuerholz zu sammeln. Seitdem hat sich das Hibernate-Projekt weiterentwickelt und die Strategien und Konzepte, mit denen Entwickler an der Verwaltung von Informationen arbeiten, sind ausgefeilter geworden. Doch die fun-damentalen Probleme sind weiterhin die gleichen: Jedes Unternehmen, mit dem wir tglich zusammenarbeiten, nutzt immer noch SQL-Datenbanken, und Java ist als erste Wahl fr die Entwicklung von Enterprise-Applikationen in dieser Branche tief verwurzelt. Doch die tabellarische Reprsentation der Daten in einem relationalen System unterschei-det sich immer noch fundamental von dem Netzwerk von Objekten in objektorientierten Java-Applikationen. Wir haben weiterhin mit der objekt-relationalen Unvereinbarkeit zu tun und mssen hufig die Erfahrung machen, dass Bedeutung und Kosten dieser Unver-einbarkeit unterschtzt werden. Andererseits stehen uns nun eine Reihe von Tools und Lsungen zur Verfgung, um dieses Problem anzugehen. Wir sind mit dem Sammeln von Feuerholz fertig, und das Feuerzeug haben wir durch einen Flammenwerfer ersetzt! Hibernate gibt es nun als drittes Major Release, und in diesem Buch beschreiben wir Hibernate 3.2. Verglichen mit lteren Hibernate-Versionen enthlt das neue Major Release doppelt so viele Features und dieses Buch ist beinahe doppelt so dick wie Hibernate in Action. Bei den meisten dieser Features geht es um solche, nach denen die Leser als Ent-wickler, die tglich mit Hibernate zu tun haben, gefragt haben. Wir haben so manches Mal gesagt, dass Hibernate die Lsung fr 90 Prozent aller Probleme ist, mit denen ein Ent-wickler von Java-Applikationen fertig werden muss, wenn er eine Datenbank-Applikation erstellt. Durch die neueste Hibernate-Version geht dieser Wert in Richtung 99 Prozent. Hibernate ist immer ausgereifter geworden, und die Anwendergruppe und die Community wachsen stndig. Vor diesem Hintergrund wurden die Java-Standards fr Datenmanage-ment und die Entwicklung von Datenbank-Applikationen von vielen Entwicklern als unzu-reichend erachtet. Wir haben Ihnen in Hibernate in Action sogar geraten, nicht mit EJB 2.x Entity Beans zu arbeiten.

Vorwort zur zweiten Auflage

XVIII

Und nun kommt EJB 3.0 und der neue Java Persistence Standard! Dieser neue Industrie-standard ist fr die Community der Java-Entwickler ein groer Schritt nach vorne. Damit werden ein leichtgewichtiges und vereinfachtes Programmiermodell und eine leistungs-fhige objekt-relationale Persistenz definiert. Viele der Schlsselkonzepte des neuen Stan-dards wurden im Hinblick auf Hibernate und andere erfolgreiche Lsungen fr die objekt-relationale Persistenz gestaltet. Die neueste Hibernate-Version implementiert den Java Per-sistence Standard. Somit knnen Sie Hibernate nun sowohl als Allzweckwaffe und auch wie jeden anderen Java Persistence Provider mit oder ohne andere EJB 3.0-Komponenten und Java EE 5.0-Dienste einsetzen. Durch diese tiefe Integration von Hibernate mit einem solch reichhalti-gen Programmiermodell knnen Sie bei Applikationen solche Funktionalitten designen und implementieren, die vorher von Hand schwierig zu schaffen waren. Wir haben dieses Buch geschrieben, damit Sie sowohl fr Hibernate als auch Java Per-sistence (und allen anderen relevanten EJB 3.0-Konzepten) einen vollstndigen und kor-rekten Leitfaden bekommen. Wir hoffen, dass Sie Freude daran haben, mit Hibernate zu arbeiten und dass diese Referenz-Bibel einen Stammplatz auf Ihrem Schreibtisch be-kommt.

XIX

Vorwort

Nur weil man Zweige auch mit der Nase ber den Boden schieben kann, heit das nicht, dass das der beste Weg ist, um Feuerholz zu sammeln.

Anthony Berglas

Heute arbeiten viele Software-Entwickler mit Enterprise Information Systems (EIS). Diese Art von Applikation erstellt, verwaltet und speichert strukturierte Informationen und ver-teilt diese zwischen vielen Anwendern, die sich an unterschiedlichen Standorten befinden. Zum Speichern von EIS-Daten gehrt der intensive Einsatz von auf SQL basierenden Da-tenbankmanagementsystemen (DBMS). Jedes Unternehmen, mit dem wir im Laufe unse-res Berufslebens zu tun hatten, arbeitet mit wenigstens einer SQL-Datenbank; die meisten Firmen sind in ihrem Business komplett von relationaler Datenbanktechnologie abhngig. In den vergangenen fnf Jahren hat die breite Akzeptanz der Programmiersprache Java in der Softwareentwicklung zur Vorherrschaft des objektorientierten Modells gefhrt. Die Ent-wickler sind von den Vorteilen der Objektorientierung nun begeistert. Doch der Groteil der Firmen hat sich ebenfalls langfristig an teure relationale Datenbanksysteme gebunden. Dabei geht es nicht nur um die tiefe Verwurzelung bestimmter Produkte von Datenbank-herstellern, sondern die funkelnagelneuen objektorientierten Webapplikationen mssen auch mit den vorhandenen Legacy-Daten arbeiten knnen. Allerdings unterscheidet sich die tabellarische Reprsentation der Daten in einem relatio-nalen System fundamental vom Netzwerk der Objekte in objektorientierten Java-Appli-kationen. Dieser Unterschied hat zur sogenannten objekt-relationalen Paradigmenunver-einbarkeit gefhrt.Traditionell werden die Bedeutung und die Kosten dieser Unvereinbarkeit unterschtzt, und die Tools fr die Behebung dieser Unvereinbarkeit sind nicht zufrieden stellend. Nun geben Java-Entwickler der relationalen Technologie die Schuld an dieser Unvereinbarkeit, whrend Daten-Profis sie der Objekt-Technologie anlasten. Mit dem Begriff objekt-relationales Mapping (ORM) werden die automatisierten Lsun-gen dieses Problems bezeichnet. Fr Entwickler, die des lstigen Data Access Codes mde

Vorwort

XX

sind, lautet die gute Nachricht, dass ORM nun ausgereift ist. Von den mit ORM-Middle-ware erstellten Applikationen kann man erwarten, dass sie kostengnstiger sind, eine bes-sere Performance haben und weniger herstellerspezifisch sind. Sie knnen besser mit nderungen am internen Objektschema oder dem zugrunde liegenden SQL-Schema um-gehen. Das Erstaunliche daran ist, dass all diese Vorteile fr Java-Entwickler nun kosten-frei zur Verfgung stehen. Gavin King begann Ende 2001 mit der Entwicklung von Hibernate, als er merkte, dass die damals beliebte Persistenzlsung CMP Entity Beans bei nicht-trivialen Applikationen mit komplexen Datenmodellen nicht skalieren konnte. Hibernate erblickte als unabhngiges, nicht-kommerzielles Open-Source-Projekt das Licht der Welt. Das Hibernate-Team (einschlielich der Autoren dieses Buches) hat ORM auf die harte Tour erlernen mssen das heit, durch den Kontakt zu den Anwendern und der Imple-mentierung dessen, was durch sie angefragt wurde. Als Resultat ist Hibernate eine prak-tische Lsung, betont die Produktivitt der Entwickler und beansprucht die technische Vorherrschaft. Hibernate ist von Zehntausenden von Anwendern in Tausenden von pro-duktiven Applikationen eingesetzt worden. Als dem Hibernate-Team zeitlich immer mehr abverlangt wurde, wurde beschlossen, dass es fr den zuknftigen Erfolg des Projekts (und die Bewahrung der geistigen Gesundheit von Gavin) ntig ist, dass sich professionelle Entwickler in Vollzeit mit Hibernate beschf-tigen. Hibernate gehrte seit Ende 2003 zu jboss.org und hat nun einen kommerziellen Aspekt: Sie knnen von JBoss Inc. kommerziellen Support und Training erwerben. Doch ein kommerzielles Training sollte nicht der einzige Weg bleiben, Hibernate zu erlernen. Es ist offensichtlich, dass viele, vielleicht sogar die meisten Java-Projekte vom Einsatz einer ORM-Lsung wie Hibernate profitieren obwohl das vor ein paar Jahren vielleicht noch nicht so offensichtlich war! Im dem Mae, wie die ORM-Technologie immer mehr zum Mainstream wird, reicht die Produkt-Dokumentation wie das kostenlose User Manual von Hibernate einfach nicht mehr aus. Wir haben erkannt, dass die Hibernate-Community und neue Hibernate-Anwender ein umfassendes Buch brauchen nicht nur, um die Ent-wicklung von Software mit Hibernate zu erlernen, sondern auch, um die objekt-relationale Unvereinbarkeit und die Beweggrnde hinter dem Design von Hibernate verstehen und einschtzen zu knnen. Das Buch, das Sie nun in Hnden halten, hat enorme Mhen beansprucht und uns ber ein Jahr lang den Lwenanteil unserer Freizeit gekostet. Es war auch Quelle vieler hitziger Debatten und Lernerfahrungen. Wir hoffen, dass dieses Buch eine ausgezeichnete Anlei-tung fr Hibernate ist (eine Hibernate-Bibel, wie ein Rezensent es genannt hat) und auch die erste umfassende Dokumentation der objekt-relationalen Unvereinbarkeit und ORM im Allgemeinen. Wir hoffen, dass Sie es hilfreich finden und dass Sie an der Arbeit mit Hibernate Freude haben.

XXI

Danksagungen

Dieses Buch wuchs von einer kleinen zweiten Auflage von Hibernate in Action zu einem Band mit beachtlichem Umfang. Wir htten das nicht geschafft, htten uns nicht viele Leute geholfen. Emmanuel Bernard hat als technischer Reviewer eine groartige Arbeit geleistet; wir danken ihm fr die vielen Stunden, die er damit zugebracht hat, unsere Code-Beispiele zu editieren. Wir danken auch unseren anderen Reviewern: Patrick Dennis, Jon Skeet, Awais Bajwa, Dan Dobrin, Deiveehan Nallazhagappan, Ryan Daigle, Stuart Caborn, Patrick Peak, TVS Murthy, Bill Fly, David Walend, Dave Dribin, Anjan Bacchu, Gary Udstrand und Srinivas Nallapati. Ein spezieller Dank geht an Linda DeMichiel, die wie schon fr die erste Auflage wieder ein Vorwort fr unser Buch geschrieben hat. Marjan Bace hat bei Manning, wo die englische Original-Ausgabe erschienen ist, wie-der ein groartiges Produktionsteam zusammengestellt. Sydney Jones editierte unser rohes Manuskript und verwandelte es in ein echtes Buch. Tiffany Taylor, Elizabeth Martin und Andy Carroll fanden all unsere Tippfehler und machten das Buch lesbar. Dottie Marsico war verantwortlich fr das Layout und sorgte dafr, dass das Buch toll aussieht. Mary Piergies koordinierte und organisierte den Produktionsprozess. Wir danken Euch allen fr die Zusammenarbeit.

ber dieses Buch

XXIII

ber dieses Buch

Wir haben uns drei Dinge vorgenommen, als wir dieses Buch geschrieben haben. Sie kn-nen es daher wie folgt nutzen: 1. Als Tutorial fr Hibernate, Java Persistence und EJB 3.0, das Sie durch die ersten

Schritte mit diesen Lsungen fhrt. 2. Als Anleitung fr alle grundlegenden und fortgeschrittenen Hibernate-Features fr

objekt-relationales Mapping (ORM), Objektverarbeitung, Abfragen (Querying), Per-formance-Optimierung und Applikationsdesign.

3. Als Referenz fr eine vollstndige und technisch genaue Definition der Funktionalit-ten von Hibernate und Java Persistence.

Normalerweise sind Bcher entweder Tutorials oder Referenzbcher. Von daher hat diese Erweiterung auch ihren Preis. Wenn Hibernate fr Sie neu ist, dann schlagen wir vor, dass Sie das Buch von vorne anfangen und die Tutorials in den Kapiteln 1 und 2 durcharbeiten. Wenn Sie schon mit lteren Versionen von Hibernate gearbeitet haben, sollten Sie die ersten beiden Kapitel kurz anlesen, um Ihr Gedchtnis aufzufrischen und einen berblick zu bekommen, und dann gleich zum Kapitel 3 springen. Wir werden Sie an entsprechender Stelle darauf hinweisen, wenn ein bestimmter Abschnitt oder ein Thema optional ist oder als Referenzmaterial dient, damit Sie diesen beim ersten Lesen guten Gewissens berspringen knnen.

Roadmap

Dieses Buch ist in drei Hauptteile gegliedert. In Teil 1 fhren wir in das grundlegende Problem der objekt/relationalen Persistenz ein, auch als object/relational paradigm mismatch bekannt, und erklren die Grundlagen des objekt-relationalen Mappings. Wir gehen mit Ihnen ein praktisches Tutorial durch, damit Sie Ihre ersten Schritte mit einem Hibernate-, Java Persistence- oder EJB 3.0-Projekt ma-chen knnen. Wir schauen uns das Java-Applikationsdesign fr Domnenmodelle an und die Optionen fr die Erstellung von Metadaten fr das objekt-relationale Mapping.

ber dieses Buch

XXIV

In Teil 2 liegt der Schwerpunkt auf dem Mapping von Java-Klassen und -Eigenschaften zu SQL-Tabellen und -Spalten. Wir untersuchen alle grundlegenden und fortgeschrittenen Mapping-Optionen in Hibernate und Java-Persistenz mit XML-Mapping-Dateien und Java Annotations. Wir zeigen Ihnen, wie Sie mit Vererbung, Collections und komplexen Klas-senzuordnungen umgehen. Zum Schluss besprechen wir die Integration mit Datenbank-schemata von Altsystemen und einige spezielle Mapping-Strategien, die besonders knifflig sind. Teil 3 beschftigt sich mit der Verarbeitung von Objekten und wie man mit Hibernate und Java Persistence Daten laden und speichern kann. Wir stellen die Programmierschnittstel-len vor und wie Sie Anwendungen mit Transaktionen und Conversations erstellen sowie Abfragen schreiben. Spter konzentrieren wir uns auf korrektes Design und Implementie-rung von mehrschichtigen Java-Applikationen. Wir besprechen die hufigsten Entwurfs-muster (Design-Patterns), die bei Hibernate verwendet werden, zum Beispiel die Data Access Object (DAO)- und EJB-Muster. Sie erfahren, wie Sie Ihre Hibernate-Applikation auf einfache Weise testen knnen und welche anderen Vorgehensweisen am besten sind, wenn Sie mit objekt-relationaler Mapping-Software arbeiten. Zum Schluss stellen wir Ihnen in einem online verfgbaren Kapitel das JBoss Seam Framework vor, das viele Konzepte aus Hibernate weiterfhrt und Sie in die Lage versetzt, auf einfache Weise Web-Applikationen unter Verwendung des Conversations-Musters zu erstellen. Dieses Kapitel knnen Sie unter http://downloads.hanser.de herunterladen. Wir versprechen Ihnen, dass Sie dieses Kapitel interessant finden werden, auch wenn Sie nicht beabsichtigen, Seam einzusetzen.

Fr wen ist dieses Buch gedacht?

Die Leser dieses Buches sollten ber Grundkenntnisse in objektorientierter Softwareent-wicklung verfgen und diese Kenntnisse praktisch genutzt haben. Um die Beispiele der Applikationen zu verstehen, sollten Sie mit der Programmiersprache Java und UML (Uni-fied Modeling Language) vertraut sein. Unsere Hauptzielgruppe besteht aus Java-Entwicklern, die mit SQL-basierten Datenbank-systemen arbeiten. Wir zeigen Ihnen, wie Sie durch den Einsatz von ORM die Produktivi-tt wesentlich erhhen knnen. Wenn Sie ein Datenbankentwickler sind, kann dieses Buch als Einfhrung in die objekt-orientierte Softwareentwicklung dienen. Als Datenbankadministrator werden Sie sich dafr interessieren, wie ORM sich auf die Performance auswirkt und wie Sie die Performance des SQL-Datenbank-Management-systems und der Persistenzschicht aufeinander abstimmen knnen, um vorgegebene Per-formanceziele zu erreichen. Weil bei den meisten Java-Applikationen der Datenzugriff der Flaschenhals ist, widmet dieses Buch den Performanceproblemen besondere Aufmerksam-keit. Viele DBAs haben verstndlicherweise eher ein schlechtes Gefhl bei der Vorstel-lung, die Performance einem Tool-generierten SQL-Code anzuvertrauen. Wir haben vor,

ber dieses Buch

XXV

diese Befrchtungen zu mildern und auch die Flle besonders zu erwhnen, bei denen Applikationen nicht mit einem von Tools verwalteten Datenzugriff arbeiten sollten. Mg-licherweise sind Sie erleichtert, wenn Sie hren, dass wir ORM nicht als beste Lsung fr jedes Problem betrachten.

Code-Konventionen

Dieses Buch bietet reichlich Beispiele, in denen alle Artefakte von Hibernate-Applika-tionen vorkommen: Java-Code, Hibernate-Konfigurationsdateien und XML-Mapping-Meta-datendateien. Quellcode in Listings oder Text erscheint in einer , um ihn vom normalen Text zu unterscheiden. Weiterhin werden auch die Namen von Java-Methoden, Komponentenparametern, Objekteigenschaften sowie XML-Elementen und -Attributen prsentiert. Java, HTML und XML knnen alle verbose (wortreich) sein. In vielen Fllen ist der Origi-nal-Quellcode (der online verfgbar ist) neu formatiert worden. Wir haben Zeilenumbr-che eingefgt und die Einrckungen umgearbeitet, um den verfgbaren Platz der Buchsei-ten auszunutzen. In seltenen Fllen hat auch das nicht gereicht und die Listings enthalten Markierungen zur Zeilenfortfhrung. Zustzlich sind aus den Listings auch oft Kommenta-re im Quellcode entfernt worden, wenn der Code im Text beschrieben wird. Anmerkungen zum Code begleiten einige der Quellcode-Listings und heben wichtige Konzepte besonders hervor. Gelegentlich verweisen nummerierte Gliederungspunkte auf Erklrungen, die nach dem Listing folgen.

Download des Quellcodes

Hibernate ist ein Open-Source-Projekt und wird unter der Lesser GNU Public License ver-ffentlicht. Anweisungen zum Download von Hibernate-Paketen (als Source oder Binary) finden Sie auf der Hibernate-Website www.hibernate.org. Der Quellcode fr alle Hello World- und CaveatEmptor-Beispiele dieses Buches ist bei http://caveatemptor.hibernate.org/ unter einer kostenlosen (BSD-hnlichen) Lizenz erhlt-lich. Auf dieser Website bekommen Sie auch den Code fr das CaveatEmptor-Beispiel in verschiedenen Varianten, beispielsweise mit dem Schwerpunkt auf natives Hibernate, auf Java Persistence und JBoss Seam. Sie knnen sich den Code fr die Beispiele dieses Bu-ches auch von der Website des Manning-Verlages herunterladen, bei dem die englische Ausgabe dieses Buches erschienen ist (www.manning.com/bauer2).

ber die Autoren

Christian Bauer ist Mitglied des Entwicklerteams von Hibernate. Er arbeitet als Trainer, Consultant und Produktmanager fr Hibernate, EJB 3.0 und JBoss Seam bei JBoss, einem Bereich von Red Hat. Gemeinsam mit Gavin King hat er Hibernate in Action verfasst.

ber dieses Buch

XXVI

Gavin King ist der Grnder der Hibernate- und JBoss Seam-Projekte und Mitglied der Expertengruppe fr EJB 3.0 (JSR 220). Er leitet berdies Web Beans JSR 299, die sich mit Standardisierung beschftigt und dabei Hibernate-Konzepte, JBoss Seam und EJB 3.0 ein-bezieht. Gavin arbeitet als Entwicklungsleiter bei JBoss, einer Sparte von Red Hat.

Author Online

Durch den Kauf von Java Persistence mit Hibernate sind Sie berechtigt, kostenlos auf ein privates, englischsprachiges Webforum bei Manning Publications (dem amerikanischen Originalverlag) zuzugreifen. Dort knnen Sie Kommentare ber das Buch abgeben, techni-sche Fragen stellen und sich Hilfe bei den Autoren und anderen Anwendern holen. Das Forum finden Sie auf www.manning.com/bauer2. Auf dieser Seite erhalten Sie Informati-onen, wie Sie nach der Registrierung ins Forum kommen, welche Art von Hilfe dort verfgbar ist sowie ber die Etikette des Forums. ber das vom Manning-Verlag bereitgestellte Forum finden Leser einen Platz, der infor-mative Gesprche der Leser untereinander und zwischen Lesern und Autoren ermglicht. Damit ist keine besondere Verpflichtung verbunden, in welchem Mae von Seiten der Autoren mit einer Mitarbeit zu rechnen ist, zumal deren Beitrag bei Author Online freiwil-lig (und unvergtet) bleibt. Wir schlagen vor, dass Sie versuchen, den Autoren ein paar anspruchsvolle Fragen zu stellen, auf dass ihr Interesse erhalten bleibe. Das Forum Author Online und die Archive der frheren Diskussionen werden auf der Website des Manning-Verlags so lange zugnglich sein, wie das Buch aufgelegt wird.

1

Teil 1 Erste Schritte mit Hibernate und EJB 3.0

In Teil 1 zeigen wir Ihnen, warum Objektpersistenz ein solch komplexes Thema ist und welche Lsungen Sie in der Praxis anwenden knnen. Kapitel 1 fhrt in das grundlegende Problem des objekt-relationalen Paradigmen-Bruchs ein und stellt verschiedene Lsungs-strategien vor, insbesondere das objekt-relationale Mapping (ORM). In Kapitel 2 fhren wir Sie schrittweise durch ein Tutorial mit Hibernate, Java Persistence und EJB 3.0. Darin implementieren und testen Sie ein Hello World-Beispiel in allen Variationen. Mit dieser Grundlage sind Sie bereit, in Kapitel 3 zu lernen, wie man komplexe Business-Domain-Modelle in Java designt und implementiert, und welche Optionen Ihnen fr Mapping-Metadaten zur Verfgung stehen. Nach dieser Lektre werden Sie verstehen, warum Sie das objekt-relationale Mapping bentigen und wie Hibernate, Java Persistence und EJB 3.0 in der Praxis funktionieren. Sie werden Ihr erstes kleines Projekt geschrieben haben und sich dann komplexere Probleme vornehmen. Sie werden auch verstehen, wie Business-Entities aus der realen Welt als Java-Domain-Model implementiert werden knnen und in welchem Format Sie es vorziehen, mit objekt-relationalen Mapping-Metadaten zu arbeiten.

3

1 Objekt-relationale Persistenz

Die Themen dieses Kapitels: Objektpersistenz mit SQL-Datenbanken Der objekt-relationale Paradigmen-Bruch Persistenzebenen in objektorientierten Applikationen Hintergrund des objekt-relationalen Mappings

Bei jedem Softwareprojekt, an dem wir gearbeitet haben, war die Verwaltung von persis-tenten Daten eine wesentliche Entscheidung. Persistente Daten sind fr Java-Applikationen keine neue oder ungewhnliche Anforderung, und von daher sollte man erwarten, dass man einfach nur unter hnlichen, gut etablierten Persistenzlsungen auswhlt. Denken Sie an Frameworks fr Web-Applikationen (Struts vs. WebWork), GUI-Komponenten-Frame-works (Swing vs. SWT) oder Template-Engines (JSP vs. Velocity). Alle diese konkurrie-renden Lsungen haben verschiedene Vor- und Nachteile, doch alle decken den gleichen Bereich ab und gehen im Allgemeinen hnlich vor. Leider ist das bei Persistenztechnologien nicht der Fall: Dort treffen wir auf hchst unterschiedliche Lsungen des gleichen Problems. Seit mehreren Jahren ist Persistenz ein hei diskutiertes Thema in der Java-Community. Viele Entwickler sind sich nicht einmal ber die Bandbreite des Problems einig. Ist Per-sistenz ein Problem, das bereits durch relationale Technologie und Extensions wie Stored Procedures gelst wurde, oder handelt es sich um ein viel umfassenderes Thema, dem man mit speziellen Modellen fr Java-Komponenten wie EJB Entity Beans begegnen msste? Sollten wir sogar die primitivsten CRUD-Operationen (Create, Read, Update, Delete) in SQL und JDBC per Hand kodieren oder sollte diese Arbeit automatisiert werden? Wie knnen wir eine Portabilitt erreichen, wenn jedes System zur Datenbankverwaltung mit einem eigenen SQL-Dialekt arbeitet? Sollten wir SQL ganz ber Bord werfen und eine an-dere Datenbanktechnologie ins Boot holen, zum Beispiel Objekt-Datenbanksysteme? Die Debatte darber hlt an, doch die Lsung namens objekt-relationales Mapping (ORM) hat eine breite Akzeptanz bekommen. Hibernate ist eine Open-Source-Implementierung von ORM.


4

Dabei handelt es sich um ein ambitioniertes Projekt, das sich zum Ziel genommen hat, das Problem des Managements von persistenten Daten in Java umfassend zu lsen. Es ber-nimmt die Interaktion der Applikation mit einer relationalen Datenbank und gibt dem Ent-wickler die Freiheit, sich ganz auf die eigentlichen Aufgaben konzentrieren zu knnen. Hibernate ist eine nicht-intrusive Lsung. Sie brauchen keine Unmenge von Hibernate-spezifischen Regeln und Entwurfsmustern zu befolgen, wenn Sie die Business-Logik und die Persistenzklassen schreiben. Somit integriert sich Hibernate reibungslos in die meisten neuen und vorhandenen Applikation und erfordert bei der restlichen Applikation keine umwlzenden nderungen. Dieses Buch beschftigt sich mit Hibernate. Hier geht es um grundlegende und fortge-schrittene Features und verschiedene Wege, wie Sie mit Hibernate neue Applikationen entwickeln knnen. Oftmals werden diese Empfehlungen nicht einmal nur speziell fr Hibernate sein. Manchmal sind es unsere Ideen, wie man etwas am besten macht, wenn man mit persistenten Daten arbeitet, und wir erlutern das dann im Kontext von Hibernate. In diesem Buch geht es auch um Java Persistence, einem neuen Standard fr Persistenz, der Bestandteil der ebenfalls aktualisierten EJB 3.0-Spezifikation ist. Hibernate implemen-tiert Java Persistence und untersttzt alle standardisierten Mappings, Abfragen und APIs. Bevor wir mit Hibernate anfangen knnen, sollten Sie allerdings die zentralen Probleme der Objektpersistenz und des objekt-relationalen Mappings verstanden haben. In diesem Kapitel wird erklrt, warum Tools wie Hibernate und Spezifikationen wie Java Persistence und EJB 3.0 notwendig sind. Zuerst definieren wir persistentes Daten-Management im Kontext von objektorientierten Applikationen und besprechen die Beziehung von SQL, JDBC und Java, den zugrunde lie-genden Technologien und Standards, auf die Hibernate aufbaut. Dann kmmern wir uns um das grundlegende Problem des Paradigmen-Bruchs bei der objekt-relationalen Persistenz (object/relational paradigm mismatch) und die allgemeinen Probleme, auf die man in der objektorientierten Softwareentwicklung mit relationalen Datenbanken trifft. Diese Probleme machen klar, wie sehr wir Tools und Muster brauchen, um den zeitlichen Aufwand fr den Persistenz-bezogenen Code der Applikationen zu minimieren. Nachdem wir uns alternative Tools und Persistenzmechanismen angeschaut haben, werden Sie sehen, dass ORM fr vie-le Szenarien die beste verfgbare Lsung ist. Durch unsere Errterung der Vor- und Nach-teile von ORM bekommen Sie umfassendes Hintergrundwissen, damit Sie die besten Ent-scheidungen bei der Auswahl einer Persistenzlsung fr Ihr eigenes Projekt treffen knnen. Wir schauen uns auch die verschiedenen Hibernate-Softwaremodule an und wie man sie so kombiniert, dass sie entweder nur mit Hibernate arbeiten oder mit Features, die konform zu Java Persistence und EJB 3.0 sind. Der beste Weg, Hibernate zu erlernen, ist nicht notwendigerweise linear. Wir knnen nachvollziehen, dass Sie vielleicht Hibernate sofort ausprobieren wollen. Wenn das Ihr Anliegen ist, dann schlagen Sie das zweite Kapitel auf, schauen sich das Hello World-Beispiel an und machen sich an ein eigenes Projekt. Unsere Empfehlung ist, dass Sie im Laufe der Zeit wieder hierher zurckkehren. So werden Sie gut vorbereitet sein und ber alle Hintergrundkonzepte verfgen, die Sie fr den Rest des Materials brauchen.

1.1 Was ist Persistenz?

5


Nahezu alle Applikationen erfordern persistente Daten. Persistenz ist eines der fundamen-talen Konzepte in der Entwicklung von Applikationen. Wenn ein Informationssystem seine Daten nach Abschalten des Stroms nicht bewahren knnte, wre es von wenig praktischem Nutzen. Wenn wir ber Persistenz bei Java sprechen, geht es normalerweise darum, Daten in einer relationalen Datenbank mit SQL zu speichern. Zum Anfang schauen wir uns kurz die Technologie an und wie sie bei Java eingesetzt wird. Mit diesen Informationen ge-wappnet fahren wir dann mit der Persistenz und ihrer Implementierung in objektorientier-ten Applikationen fort.

1.1.1 Relationale Datenbanken

Wie die meisten Entwickler werden Sie schon einmal mit einer relationalen Datenbank ge-arbeitet haben. Fr viele von uns gehrt das zu unserem tglich Brot. Relationale Techno-logie ist eine bekannte Gre, und das allein ist schon fr viele Organisationen Grund ge-nug, sich dafr zu entscheiden. Doch nur das zollt dieser Technologie nicht den gebhren-den Respekt. Relationale Datenbanken sind so allgemein verbreitet und tief verwurzelt, weil sie eben ein unglaublich flexibles und robustes Modell der Datenverwaltung bieten. Aufgrund der umfassenden und konsistenten theoretischen Grundlage des relationalen Da-tenmodells knnen relationale Datenbanken (neben anderen wnschenswerten Charakteris-tiken) die Integritt der Daten effektiv garantieren und schtzen. Manche gehen sogar soweit zu sagen, dass das relationale Konzept der Datenverwaltung, wie sie zuerst vor mehr als drei Jahrzehnten durch E.F. Codd vorgestellt wurde (Codd, 1970), die letzte groe Erfindung im Bereich des Computers ist . Weder sind Systeme zur relationalen Datenbankverwaltung ein spezielles Thema fr Java noch ist eine relationale Datenbank ausdrcklich fr eine bestimmte Applikation gedacht. Dieses wichtige Prinzip nennt man Datenunabhngigkeit. Anders gesagt und wir knnen diese wichtige Tatsache nicht genug betonen leben Daten lnger als jede Applikation.Relationale Technologien bieten eine Mglichkeit, Daten zwischen unterschiedlichen Applikationen auszutauschen oder zwischen verschiedenen Technologien, die gemeinsam Teile der gleiche Applikation bilden (zum Beispiel die transaktionale und die Report-Engine). Relationale Technologie ist ein gemeinsamer Nenner vieler hchst unterschied-licher Systeme und Technologieplattformen. Von daher ist das relationale Datenmodell oft die allgemeine unternehmensweite Reprsentation von Business Entities. Relationale Datenbankverwaltungssysteme haben auf SQL basierende APIs, von daher nennen wir die heutigen relationalen Datenbankprodukte SQL-Datenbankmanage-mentsysteme oder (wenn es um bestimmte Systeme geht) SQL-Datenbanken.Bevor wir detaillierter in die Praxis von SQL-Datenbanken einsteigen, muss noch ein wichtiges Thema angesprochen werden: Obwohl als relational vermarktet, ist ein Daten-banksystem, das nur eine SQL-Schnittstelle bietet, nicht wirklich relational und kommt in verschiedener Hinsicht dem ursprnglichen Konzept nicht einmal nahe. Naturgem hat


6

das zu Verwirrungen gefhrt. SQL-Praktiker werfen dem relationalen Datenmodell Schwchen bei der SQL-Sprache vor, und Experten fr relationales Datenmanagement be-schuldigen den SQL-Standard, eine schwache Umsetzung der relationalen Modelle und Ideale zu sein. Anwendungsentwickler stehen irgendwo dazwischen und haben die Last, etwas Funktionierendes abliefern zu mssen. Wir werden einige wichtige und signifikante Aspekte dieses Problems im Verlauf des Buches hervorheben, doch generell konzentrieren wir uns auf die praktischen Aspekte. Wenn Sie sich eingehender damit beschftigen wol-len, empfehlen wir Practical Issues in Database Management: A Reference for the Thin-king Practitioner von Fabian Pascal (Pascal, 2000).

1.1.2 Die Grundlagen von SQL

Um effektiv mit Hibernate arbeiten zu knnen, sind solide Kenntnisse des relationalen Modells und von SQL erforderlich. Sie mssen das relationale Modell und solche Themen wie Normalisierung (welche die Integritt Ihrer Daten garantiert) verinnerlicht haben und sollten Ihre SQL-Kenntnisse einsetzen knnen, um die Performance Ihrer Hibernate-Applikation zu optimieren. Hibernate automatisiert viele sich wiederholende Program-mieraufgaben, doch Ihr Wissen ber Persistenztechnologien darf bei Hibernate selbst nicht stehen bleiben, wenn Sie die Leistungsfhigkeit moderner SQL-Datenbanken voll ausnut-zen wollen. Denken Sie daran, dass das zugrunde liegende Ziel die robuste, effiziente Verwaltung persistenter Daten ist. Wir wollen uns nun einige der in diesem Buch verwendeten SQL-Begriffe in Erinnerung rufen. Sie verwenden SQL als Datendefinitionssprache (data definition language, DDL), um mit - und -Anweisungen ein Datenbankschema zu erstellen. Nach Erstel-lung von Tabellen (und Indizes, Sequenzen usw.) nutzen Sie SQL als Datenmanipulations-sprache (data manipulation language, DML), um Daten zu holen und zu manipulieren. Zu den Manipulationsoperationen gehren Einfgungen, Aktualisierungen und Lschungen.Sie kommen an die Daten, indem Sie Abfragen (Queries) mit Restriktionen, Projektionenund Join-Operationen (einschlielich des Kartesischen Produkts) durchfhren. Fr ein effizientes Berichtswesen nutzen Sie SQL, um Daten nach Bedarf zu gruppieren, zu sor-tieren oder zusammenzufassen. Sie knnen auch SQL-Anweisungen verschachteln; diese Technik nutzt Unterabfragen.Sie arbeiten wahrscheinlich schon jahrelang mit SQL und sind mit den grundlegenden Operationen und Anweisungen dieser Sprache vertraut. Doch wir wissen aus eigener Erfahrung, dass SQL manchmal schwer zu behalten ist und sich manche Begriffe in der Verwendung unterscheiden. Damit dieses Buch verstndlich ist, mssen wir mit den glei-chen Begriffen und Konzepten arbeiten. Von daher raten wir Ihnen, sich den Anhang A durchzulesen, wenn Ihnen Begriffe in diesem Buch neu oder unklar sind. Wenn Sie mehr wissen wollen, vor allem ber Performance-Aspekte und wie SQL ausge-fhrt wird, dann holen Sie sich das ausgezeichnete Buch SQL Tuning von Dan Tow (OReilly, 2004). Lesen Sie auch An Introduction to Database Systems von Chris Date (Addison-Wesley, 2003) zu Fragen der Theorie, der Konzepte und der Ideale von (relatio-


7

nalen) Datenbanksystemen. Letzteres ist eine ausgezeichnete Referenz (es ist wirklich dick) fr alle Fragen, die Sie mglicherweise ber Datenbanken und Datenmanagement haben. Obwohl die relationale Datenbank ein Teil des ORM ist, besteht der andere natrlich aus den Objekten in Ihrer Java-Applikation, die ber SQL in der Datenbank persistent gemacht und geladen werden sollen.

1.1.3 SQL in Java nutzen

Wenn Sie mit einer SQL-Datenbank in einer Java-Applikation arbeiten, gibt der Java-Code SQL-Anweisungen ber die JDBC(Java Database Connectivity)-API an die Datenbank weiter. Egal ob das SQL von Hand geschrieben und im Java-Code eingebettet wurde oder on the fly von Java-Code generiert wurde: Sie nutzen die JDBC-API dafr, Argumente zu binden, um Query-Parameter vorzubereiten, die Abfrage auszufhren, durch die Tabelle mit den Query-Resultaten zu scrollen, Werte aus dem Satz der Resultate zu holen usw. Das sind Datenzugriffsaufgaben auf niedriger Ebene als Applikationsentwickler sind wir mehr an dem Business-Problem interessiert, das einen solchen Datenzugriff erfordert. Wir mchten viel lieber Code schrieben, der Objekte (die Instanzen unserer Klassen) in der Da-tenbank sichert und von dort ausliest und uns damit diese niedere Plackerei erspart. Weil die mit dem Datenzugriff zusammenhngenden Aufgaben oft so nervttend sind, mssen wir fragen: Ist das relationale Datenmodell und (insbesondere) SQL die richtige Wahl fr Persistenz in objektorientierten Applikationen? Wir knnen diese Frage sofort beantworten: Aber sicher! Es gibt viele Grnde, warum SQL-Datenbanken die Computer-industrie dominieren relationale Datenbankmanagementsysteme sind die einzige gesi-cherte Technologie fr das Datenmanagement, und sie gehren beinahe immer zu den Anforderungen eines Java-Projekts. Allerdings haben die Entwickler in den vergangenen 15 Jahren von einem Paradigmen-Bruch gesprochen Dieser Bruch erklrt, warum bei jedem Unternehmensprojekt so viel Mhe fr Probleme aufgewendet wird, die mit der Persistenz zusammenhngen. Die Para-digmen, um die es hier geht, sind relationale Modellierung und Objektmodellierung oder vielleicht auch objektorientierte Programmierung und SQL. Wir beginnen die Untersuchung dieses Problems, indem wir fragen, was Persistenz im Kontext von objektorientierter Applikationsentwicklung bedeutet. Zuerst erweitern wir die simple Definition von Persistenz, die zu Beginn dieses Abschnitts eingefhrt wurde, zu einem umfassenderen, tieferen Verstndnis, was es heit, persistente Daten zu pflegen und zu nutzen.

1.1.4 Persistenz in objektorientierten Applikationen

In einer objektorientierten Applikation kann ein Objekt durch Persistenz den Prozess ber-leben, der es erstellt hat. Der Zustand des Objekts kann auf der Festplatte gespeichert wer-den, und ein Objekt mit dem gleichen Zustand kann irgendwann in der Zukunft wieder erstellt werden.


8

Das ist nicht nur auf einzelne Objekte begrenzt ganze Netzwerke von miteinander ver-bundenen Objekten knnen persistent gemacht und in einem neuen Prozess spter wieder erstellt werden. Die meisten Objekte sind nicht persistent, ein transientes Objekt hat eine begrenzte Lebenszeit, die an den Zyklus des Prozesses gebunden ist, von dem es instanzi-iert wurde. Nahezu alle Java-Applikation enthalten eine Mischung von persistenten und transienten Objekten. Von daher brauchen wir ein Subsystem, das die persistenten Daten verwaltet. Moderne relationale Datenbanken bieten eine strukturierte Reprsentation persistenter Da-ten, die das Manipulieren, Sortieren, Suchen und Gruppieren von Daten ermglicht. Sys-teme fr das Datenbankmanagement sind dafr verantwortlich, den gleichzeitigen Zugriff auf Daten und deren Integritt zu verwalten. Sie kmmern sich darum, wie Daten fr ver-schiedene Anwendern und Applikationen verfgbar gemacht werden. Sie garantieren die Integritt der Daten ber Integrittsregeln, die mit Constraints implementiert wurden. Ein Datenbankmanagementsystem bietet Sicherheit auf Datenebene. Wenn wir in diesem Buch ber Persistenz sprechen, denken wir an die folgenden Dinge:

Speicherung, Organisation und Beschaffung strukturierter Daten Gleichzeitiger Datenzugriff und Datenintegritt Gemeinsamer Datenzugriff

Insbesondere betrachten wir diese Probleme im Kontext einer objektorientierten Applika-tion, die mit einem Domain-Modell arbeitet. Eine Applikation mit einem Domain-Modell arbeitet nicht direkt mit der tabellarischen Reprsentation der Business Entities, sondern verfgt ber ein eigenes objektorientiertes Modell davon. Wenn die Datenbank eines Online-Auktionssystems zum Beispiel mit -und -Tabellen arbeitet, definiert die Java-Applikation die Klassen und .Anstatt dann direkt mit den Zeilen und Spalten eines SQL-Resultats zu arbeiten, interagiert die Business-Logik mit diesem objektorientierten Domain-Modell und dessen Laufzeit-Realisierung als Netzwerk von miteinander verknpften Objekten. Jede -Instanz hat einen Verweis auf ein Auktions-, und jedes kann ber eine Sammlung von Ver-weisen auf -Instanzen verfgen. Die Business-Logik wird nicht in der Datenbank (als SQL- Stored Procedure ) ausgefhrt, sondern in Java in der Applikationsschicht implemen-tiert. So kann die Business-Logik mit anspruchsvollen objektorientierten Konzepten wie Vererbung und Polymorphismus arbeiten. Wir knnen so zum Beispiel wohlbekannte Entwurfsmuster wie Strategy, Mediator und Composite (Gamma u.a., 1995) verwenden, die alle auf polymorphen Methodenaufrufen basieren. Doch Achtung: Nicht alle Java-Applikationen sind so designt noch sollten es sein. Einfa-che Applikationen kommen ohne ein Domain-Modell vielleicht deutlich besser zurecht. Komplexe Applikationen knnen vorhandene Stored Procedures wiederverwenden. SQL und die JDBC API sind perfekt einsetzbar fr den Umgang mit rein tabellarischen Daten, und der JDBC RowSet vereinfacht CRUD-Operationen sogar noch mehr. Die Arbeit mit einer tabellarischen Reprsentation persistenter Daten geht gradlinig vonstatten und ist gut nachvollziehbar.

1.2 Die Unvereinbarkeit der Paradigmen

9

Allerdings verbessert im Falle von Applikationen mit nicht-trivialer Business-Logik eine Vorgehensweise ber das Domain-Modell die Wiederverwendung und Wartungsfreund-lichkeit des Codes deutlich. In der Praxis sind beide Strategien blich und notwendig. Vie-le Applikationen mssen Prozeduren ausfhren, bei denen umfangreiche Datenstze nahe der Datenebene modifiziert werden mssen. Zur gleichen Zeit knnen andere Applikati-onsmodule von einem objektorientierten Domain-Modell profitieren, das regulre Online-Transaktionsprozesslogik auf der Applikationsschicht ausfhrt. Es ist ein effizienter Weg erforderlich, persistente Daten nher an den Applikationscode zu bringen. Wenn wir SQL und relationale Datenbanken erneut betrachten, erkennen wir schlielich die Unvereinbarkeit der beiden Paradigmen. SQL-Operationen wie Projektion und Join fhren immer zu einer tabellarischen Reprsentation der resultierenden Daten. (Das nennt man die transitive Hlle; das Resultat einer Operation mit Relationen ist immer eine Rela-tion.) Dies ist vllig verschieden vom Netzwerk der miteinander verknpften Objekte, mit denen die Business-Logik in einer Java-Applikation ausgefhrt wird. Es handelt sich um fundamental unterschiedliche Modelle, nicht einfach blo um verschiedene Visualisierun-gen des gleichen Modells. Mit dieser Erkenntnis beginnen Sie, die Probleme zu sehen manche leicht und andere nicht leicht zu verstehen , die von einer Applikation gelst werden mssen, bei der beideDatenreprsentationen kombiniert werden: das objektorientierte Domain-Modell und das persistente relationale Modell. Diese Unvereinbarkeit der beiden Paradigmen wollen wir uns genauer anschauen.

1.2 Die Unvereinbarkeit der Paradigmen

Die objekt-relationale Paradigmenunvertrglichkeit kann in verschiedene Abschnitte unter-teilt werden, die wir nacheinander anschauen werden. Beginnen wir mit einem einfachen, problemlosen Beispiel. Wenn wir uns daran weiterhangeln, werden Sie merken, wie diese Unvereinbarkeit auftaucht. Nehmen wir an, Sie wollen eine E-Commerce-Applikation entwerfen und implementieren. Bei dieser Applikation brauchen Sie eine Klasse, die Informationen ber einen Nutzer des Systems reprsentiert, und eine weitere, die Informationen ber die Abrechnungsdetails dieses Nutze

Java-Persistence mit Hibernate GERMAN

Documents

Transcript of Java-Persistence mit Hibernate GERMAN