hibernate w akcji pełna wersja.pdf
(
18297 KB
)
Pobierz
710571326 UNPDF
Hibernate w akcji
Autorzy: Christian Bauer, Gavin King
T³umaczenie: Rafa³ Joñca
ISBN: 83-246-0527-4
Tytu³ orygina³
u:
Hibernate in Action
Format: B5, stron: 410
Wydawnictwo Helion
ul. Koœciuszki 1c
44-100 Gliwice
tel. 032 230 98 63
e-mail: helion@helion.pl
Szukasz rozwi¹zania problemów zwi¹zanych z korzystaniem z relacyjnych baz danych
w po³¹czeniu z programowaniem obiektowym? Chcesz poprawiæ wydajnoœæ i jakoœæ
aplikacji bazodanowych? A mo¿e rozwi¹zania, które stosowa³eœ dotychczas, okazuj¹
siê niewystarczaj¹ce przy du¿ych projektach? Siêgnij po Hibernate, czyli rewolucyjne
narzêdzie stanowi¹ce warstwê poœrednicz¹c¹ pomiêdzy aplikacj¹ i baz¹ danych,
umo¿liwiaj¹ce utrwalanie i odczyt obiektów Javy w bazie. Hibernate eliminuje koniecznoœæ
rêcznego tworzenia kodu odwzorowuj¹cego obiekty na model relacyjny i odwrotnie,
a tak¿e znacz¹co poprawia wydajnoœæ i stabilnoœæ aplikacji. Nie bez znaczenia równie¿
jest fakt, i¿ Hibernate dostêpne jest na licencji open-source.
Ksi¹¿ka „Hibernate w akcji”, napisana przez twórców tego narzêdzia. To wyczerpuj¹cy
podrêcznik dla programistów, którzy planuj¹ zastosowaæ je w swoich projektach.
Czytaj¹c j¹, dowiesz siê, na czym polega odwzorowanie obiektowo-relacyjne i w jaki
sposób implementuje je Hibernate. Poznasz zasady tworzenia i stosowania obiektów
trwa³ych, zarz¹dzania transakcjami i buforowania danych. Znajdziesz tak¿e informacje
o optymalizowaniu wydajnoœci aplikacji stosuj¹cych Hibernate oraz procesie
projektowania takich aplikacji.
W ksi¹¿ce poruszono m.in.:
Odwzorowania obiektowo-relacyjne
Konfiguracja i uruchomienie Hibernate
Odwzorowywanie danych w klasach
Stosowanie obiektów trwa³ych
Transakcje i buforowanie
Wydajne pobieranie obiektów z bazy
Projektowanie aplikacji wykorzystuj¹cych Hibernate
Narzêdzia wspomagaj¹ce dzia³anie Hibernate
Poznaj Hibernate i przekonaj siê, jak dziêki niemu usprawnisz swoj¹ pracê
Spis treści
Przedmowa
9
Wstęp
11
Podziękowania
13
O książce i autorach
15
O Hibernate 3 i EJB 3
19
1. Trwałość dzięki odwzorowaniu obiektowo-relacyjnemu 21
1.1. Czym jest trwałość? .............................................................................................................. 23
1.1.1. Relacyjne bazy danych ............................................................................................. 23
1.1.2. Język SQL ................................................................................................................. 24
1.1.3. Korzystanie z SQL w Javie ....................................................................................... 24
1.1.4. Trwałość w aplikacjach obiektowych ....................................................................... 25
1.2. Niedopasowanie paradygmatów ......................................................................................... 27
1.2.1. Problem szczegółowości ........................................................................................... 28
1.2.2. Problem podtypów .................................................................................................... 29
1.2.3. Problem identyczności ............................................................................................. 30
1.2.4. Problemy dotyczące asocjacji ................................................................................... 32
1.2.5. Problem nawigacji po grafie obiektów ..................................................................... 33
1.2.6. Koszt niedopasowania ............................................................................................... 34
1.3. Warstwy trwałości i alternatywy ........................................................................................ 35
1.3.1. Architektura warstwowa ........................................................................................... 35
1.3.2. Ręczne tworzenie warstwy trwałości za pomocą SQL i JDBC .............................. 37
1.3.3. Wykorzystanie serializacji ........................................................................................ 38
1.3.4. A może ziarenka encyjne EJB? ................................................................................ 39
4
Spis treści
1.3.5. Obiektowe systemy bazodanowe ............................................................................. 40
1.3.6. Inne rozwiązania ....................................................................................................... 41
1.4. Odwzorowanie obiektowo-relacyjne .................................................................................. 41
1.4.1. Czym jest ORM? ....................................................................................................... 42
1.4.2. Ogólne problemy ORM ............................................................................................ 44
1.4.3. Dlaczego ORM? ........................................................................................................ 45
1.5. Podsumowanie ...................................................................................................................... 47
2. Wprowadzenie i integracja Hibernate 49
2.1. „Witaj świecie” w stylu Hibernate ...................................................................................... 50
2.2. Podstawy architektury Hibernate ...................................................................................... 55
2.2.1. Interfejsy podstawowe .............................................................................................. 56
2.2.2. Interfejsy wywołań zwrotnych ................................................................................. 58
2.2.3. Typy ........................................................................................................................... 58
2.2.4. Interfejsy rozszerzeń ................................................................................................ 59
2.3. Konfiguracja podstawowa .................................................................................................... 59
2.3.1. Tworzenie obiektu SessionFactory .......................................................................... 60
2.3.2. Konfiguracja w środowisku niezarządzanym .......................................................... 62
2.3.3. Konfiguracja w środowisku zarządzanym ................................................................ 66
2.4. Zaawansowane ustawienia konfiguracyjne ........................................................................ 68
2.4.1. Konfiguracja bazująca na pliku XML ...................................................................... 69
2.4.2. Obiekt SessionFactory dowiązany do JNDI ........................................................... 70
2.4.3. Dzienniki ................................................................................................................... 71
2.4.4. Java Management Extensions .................................................................................. 73
2.5. Podsumowanie ...................................................................................................................... 75
3. Odwzorowanie klas trwałości danych 77
3.1. Aplikacja CaveatEmptor ..................................................................................................... 78
3.1.1. Analiza dziedziny biznesowej .................................................................................. 79
3.1.2. Model dziedzinowy CaveatEmptor ......................................................................... 79
3.2. Implementacja modelu dziedzinowego .............................................................................. 82
3.2.1. Kwestia przesiąkania zadań ...................................................................................... 82
3.2.2. Trwałość automatyczna i przezroczysta ................................................................... 83
3.2.3. Tworzenie klas POJO ............................................................................................... 84
3.2.4. Implementacja asocjacji POJO ................................................................................. 86
3.2.5. Dodanie logiki do metod dostępowych ................................................................... 90
3.3. Definicja metadanych odwzorowujących .......................................................................... 92
3.3.1. Metadane w pliku XML ........................................................................................... 92
3.3.2. Podstawowe odwzorowania właściwości i klas ........................................................ 95
3.3.3. Programowanie zorientowane na atrybuty ............................................................ 101
3.3.4. Modyfikacja metadanych w trakcie działania aplikacji ......................................... 102
3.4. Identyczność obiektów ....................................................................................................... 104
3.4.1. Identyczność a równość .......................................................................................... 104
3.4.2. Tożsamość bazodanowa w Hibernate .................................................................... 104
3.4.3. Wybór kluczy głównych ......................................................................................... 106
3.5. Szczegółowe modele obiektów .......................................................................................... 108
3.5.1. Encje i typy wartości .............................................................................................. 109
3.5.2. Stosowanie komponentów ...................................................................................... 109
3.6. Odwzorowanie dziedziczenia klas .................................................................................... 113
3.6.1. Tabela na klasę konkretną ...................................................................................... 113
3.6.2. Tabela na każdą hierarchię klas ............................................................................. 115
Spis treści
5
3.6.3. Tabela na każdą podklasę ....................................................................................... 117
3.6.4. Wybór strategii ........................................................................................................ 120
3.7. Asocjacje .............................................................................................................................. 121
3.7.1. Asocjacje zarządzane? ............................................................................................. 121
3.7.2. Krotność .................................................................................................................. 122
3.7.3. Najprostsza możliwa asocjacja ............................................................................... 122
3.7.4. Tworzenie asocjacji dwukierunkowej .................................................................... 123
3.7.5. Związek rodzic-potomek ........................................................................................ 126
3.8. Podsumowanie .................................................................................................................... 127
4. Stosowanie obiektów trwałych 129
4.1. Cykl życia obiektu trwałego .............................................................................................. 130
4.1.1. Obiekty ulotne ........................................................................................................ 131
4.1.2. Obiekty trwałe ......................................................................................................... 132
4.1.3. Obiekt odłączony .................................................................................................... 133
4.1.4. Zasięg identyczności obiektów ............................................................................... 134
4.1.5. Poza zasięgiem identyczności ................................................................................ 135
4.1.6. Implementacja equals() i hashCode() .................................................................... 136
4.2. Zarządca trwałości .............................................................................................................. 140
4.2.1. Czynienie obiektu trwałym .................................................................................... 140
4.2.2. Aktualizacja stanu trwałego obiektu odłączonego ................................................. 141
4.2.3. Pobranie obiektu trwałego ..................................................................................... 142
4.2.4. Aktualizacja obiektu trwałego ................................................................................ 143
4.2.5. Zmiana obiektu trwałego na ulotny ....................................................................... 143
4.2.6. Zmiana obiektu odłączonego na ulotny ................................................................. 144
4.3. Trwałość przechodnia w Hibernate ................................................................................. 144
4.3.1. Przechodniość przez osiągalność ........................................................................... 145
4.3.2. Trwałość kaskadowa w Hibernate ......................................................................... 146
4.3.3. Zarządzanie kategoriami przedmiotów .................................................................. 147
4.3.4. Rozróżnienie obiektów ulotnych i odłączonych .................................................... 151
4.4. Pobieranie obiektów ........................................................................................................... 152
4.4.1. Pobieranie obiektów na podstawie identyfikatora ................................................ 153
4.4.2. Wprowadzenie do HQL ......................................................................................... 154
4.4.3. Zapytania przez określenie kryteriów .................................................................... 155
4.4.4. Zapytanie przez przykład ....................................................................................... 155
4.4.5. Strategie sprowadzania danych .............................................................................. 156
4.4.6. Wybór strategii sprowadzania w odwzorowaniach ............................................... 158
4.4.7. Optymalizacja pobierania obiektów ....................................................................... 163
4.5. Podsumowanie .................................................................................................................... 164
5. Transakcje, współbieżność i buforowanie 167
5.1. Transakcje bazodanowe .....................................................................................................169
5.1.1. Transakcje JDBC i JTA .......................................................................................... 170
5.1.2. Interfejs Transaction ............................................................................................... 171
5.1.3. Opróżnianie sesji ..................................................................................................... 173
5.1.4. Poziomy izolacji ...................................................................................................... 174
5.1.5. Wybór poziomu izolacji .......................................................................................... 176
5.1.6. Ustawianie poziomu izolacji ................................................................................... 177
5.1.7. Blokada pesymistyczna ........................................................................................... 177
5.2. Transakcje aplikacyjne ...................................................................................................... 180
5.2.1. Wersjonowanie zarządzane .................................................................................... 181
6
Spis treści
5.2.2. Szczegółowość sesji ................................................................................................ 184
5.2.3. Inne sposoby implementacji blokady optymistycznej .......................................... 185
5.3. Buforowanie — teoria i praktyka ..................................................................................... 186
5.3.1. Strategie i zasięgi buforowania ............................................................................... 187
5.3.2. Architektura buforów Hibernate ............................................................................ 190
5.3.3. Buforowanie w praktyce ......................................................................................... 195
5.4. Podsumowanie .................................................................................................................... 204
6. Zaawansowane zagadnienia odwzorowań 205
6.1. System typów Hibernate ....................................................................................................206
6.1.1. Wbudowane typy odwzorowań .............................................................................. 207
6.1.2. Zastosowania typów odwzorowań .......................................................................... 210
6.2. Odwzorowywanie kolekcji typów wartości ...................................................................... 220
6.2.1. Zbiory, pojemniki, listy i odwzorowania ................................................................ 220
6.3. Odwzorowanie asocjacji encyjnych .................................................................................. 228
6.3.1. Asocjacja jeden-do-jednego .................................................................................... 229
6.3.2. Asocjacje wiele-do-wielu ........................................................................................ 232
6.4. Odwzorowanie asocjacji polimorficznych ....................................................................... 241
6.4.1. Polimorficzna asocjacja wiele-do-jednego ............................................................. 241
6.4.2. Kolekcje polimorficzne ........................................................................................... 243
6.4.3. Asocjacje polimorficzne i jedna tabela na klasę konkretną ................................... 244
6.5. Podsumowanie .................................................................................................................... 246
7. Wydajne pobieranie obiektów 247
7.1. Wykonywanie zapytań ....................................................................................................... 249
7.1.1. Interfejsy zapytań ................................................................................................... 249
7.1.2. Dowiązywanie parametrów .................................................................................... 251
7.1.3. Zapytania nazwane .................................................................................................. 254
7.2. Proste zapytania dotyczące obiektów ............................................................................... 255
7.2.1. Najprostsze zapytanie ............................................................................................. 256
7.2.2. Zastosowanie aliasów .............................................................................................. 256
7.2.3. Zapytania polimorficzne ......................................................................................... 257
7.2.4. Ograniczenia ........................................................................................................... 257
7.2.5. Operatory porównań ............................................................................................... 258
7.2.6. Dopasowywanie tekstów ........................................................................................ 260
7.2.7. Operatory logiczne .................................................................................................. 261
7.2.8. Kolejność wyników zapytań ................................................................................... 262
7.3. Złączanie asocjacji .............................................................................................................. 262
7.3.1. Złączenia w Hibernate ............................................................................................ 264
7.3.2. Pobieranie asocjacji ................................................................................................ 265
7.3.3. Aliasy i złączenia ..................................................................................................... 266
7.3.4. Złączenia niejawne .................................................................................................. 270
7.3.5. Złączenia w stylu theta ........................................................................................... 271
7.3.6. Porównywanie identyfikatorów .............................................................................. 272
7.4. Tworzenie zapytań raportujących .................................................................................... 273
7.4.1. Projekcja .................................................................................................................. 274
7.4.2. Agregacja ................................................................................................................. 276
7.4.3. Grupowanie ............................................................................................................. 277
7.4.4. Ograniczanie grup klauzulą having ........................................................................ 278
7.4.5. Poprawa wydajności zapytań raportujących .......................................................... 279
Plik z chomika:
szafran87
Inne pliki z tego folderu:
Joep P. M. Schrijvers poradnik korporacyjnego szczura ebook.pdf
(5896 KB)
Ernest Adams projektowanie gier. podstawy. wydanie ii pełna wersja.pdf
(18126 KB)
sam wypalam cd scan.pdf
(13281 KB)
usb.-uniwersalny-interfejs-szeregowy full version.pdf
(10289 KB)
ebook(17).pdf
(77493 KB)
Inne foldery tego chomika:
Zgłoś jeśli
naruszono regulamin