Java Persistence. Programowanie aplikacji bazodanowych w Hibernate. Wydanie II - ebook

• Mapowanie obiektowo-relacyjne i jego znaczenie
• Projekt aplikacji bazodanowej typu klient-serwer
• Korzystanie z frameworka Hibernate
• Specyfikacja Java Persistence
• Transakcyjne przetwarzanie danych, w tym również zagadnienia współbieżności
• Tworzenie i uruchamianie zapytań oraz przetwarzanie otrzymanych wyników

Hibernate i Java Persistence — najlepszy sposób na nowoczesną aplikację bazodanową!

Słowo wstępne do pierwszego wydania (17)

Przedmowa (19)

Podziękowania (21)

O książce (23)

O autorach (27)

CZĘŚĆ I. WPROWADZENIE W TEMATYKĘ ORM (29)

Rozdział 1. Utrwalanie obiektowo-relacyjne (31)

• 1.1. Co to jest utrwalanie? (32)
  • 1.1.1. Relacyjne bazy danych (33)
  • 1.1.2. Język SQL (34)
  • 1.1.3. Korzystanie z języka SQL w Javie (35)
• 1.2. Niedopasowanie paradygmatów (37)
  • 1.2.1. Problem ziarnistości (38)
  • 1.2.2. Problem podtypów (40)
  • 1.2.3. Problem tożsamości (41)
  • 1.2.4. Problemy związane z asocjacjami (43)
  • 1.2.5. Problem poruszania się po danych (44)
• 1.3. ORM i JPA (45)
• 1.4. Podsumowanie (47)

Rozdział 2. Zaczynamy projekt (49)

• 2.1. Wprowadzenie do frameworka Hibernate (49)
• 2.2. Aplikacja "Witaj, świecie" z JPA (50)
  • 2.2.1. Konfigurowanie jednostki utrwalania (51)
  • 2.2.2. Pisanie klasy utrwalania (53)
  • 2.2.3. Zapisywanie i ładowanie komunikatów (54)
• 2.3. Natywne mechanizmy konfiguracji frameworka Hibernate (57)
• 2.4. Podsumowanie (60)

Rozdział 3. Modele dziedziny i metadane (61)

• 3.1. Przykładowa aplikacja CaveatEmptor (62)
  • 3.1.1. Architektura warstwowa (62)
  • 3.1.2. Analiza dziedziny biznesowej (64)
  • 3.1.3. Model dziedziny aplikacji CaveatEmptor (65)
• 3.2. Implementacja modelu dziedziny (66)
  • 3.2.1. Rozwiązanie problemu wyciekania obszarów zainteresowania (67)
  • 3.2.2. Przezroczyste i zautomatyzowane utrwalanie (68)
  • 3.2.3. Pisanie klas zdolnych do utrwalania (69)
  • 3.2.4. Implementacja asocjacji POJO (73)
• 3.3. Metadane modelu dziedziny (77)
  • 3.3.1. Metadane bazujące na adnotacjach (78)
  • 3.3.2. Stosowanie reguł Bean Validation (80)
  • 3.3.3. Pobieranie metadanych z zewnętrznych plików XML (83)
  • 3.3.4. Dostęp do metadanych w fazie działania aplikacji (87)
• 3.4. Podsumowanie (90)

CZĘŚĆ II. STRATEGIE MAPOWANIA (91)

Rozdział 4. Mapowanie klas utrwalania (93)

• 4.1. Encje i typy wartości (93)
  • 4.1.1. Drobnoziarniste modele dziedziny (94)
  • 4.1.2. Definiowanie pojęć aplikacji (94)
  • 4.1.3. Odróżnianie encji od typów wartości (96)
• 4.2. Mapowanie encji z tożsamością (97)
  • 4.2.1. Tożsamość a równość w Javie (98)
  • 4.2.2. Pierwsza klasa encji i mapowanie (98)
  • 4.2.3. Wybieranie klucza głównego (100)
  • 4.2.4. Konfigurowanie generatorów kluczy (101)
  • 4.2.5. Strategie generatorów identyfikatorów (104)
• 4.3. Opcje mapowania encji (108)
  • 4.3.1. Zarządzanie nazwami (108)
  • 4.3.2. Dynamiczne generowanie SQL (111)
  • 4.3.3. Encje niezmienne (112)
  • 4.3.4. Mapowanie encji na podzapytanie (113)
• 4.4. Podsumowanie (114)

Rozdział 5. Mapowanie typów wartości (117)

• 5.1. Mapowanie prostych właściwości (118)
  • 5.1.1. Przesłanianie domyślnego zachowania dla właściwości o typach prostych (119)
  • 5.1.2. Personalizacja dostępu do właściwości (120)
  • 5.1.3. Używanie właściwości wyprowadzonych (122)
  • 5.1.4. Transformacje wartości kolumn (123)
  • 5.1.5. Wygenerowane i domyślne wartości właściwości (124)
  • 5.1.6. Właściwości opisujące czas (125)
  • 5.1.7. Mapowanie typów wyliczeniowych (126)
• 5.2. Mapowanie komponentów osadzanych (126)
  • 5.2.1. Schemat bazy danych (127)
  • 5.2.2. Przystosowanie klas do osadzania (127)
  • 5.2.3. Przesłanianie osadzonych atrybutów (131)
  • 5.2.4. Mapowanie zagnieżdżonych komponentów osadzanych (132)
• 5.3. Mapowanie typów Java i SQL za pomocą konwerterów (134)
  • 5.3.1. Typy wbudowane (134)
  • 5.3.2. Tworzenie własnych konwerterów JPA (140)
  • 5.3.3. Rozszerzanie frameworka Hibernate za pomocą typów użytkownika (147)
• 5.4. Podsumowanie (154)

Rozdział 6. Mapowanie dla dziedziczenia (155)

• 6.1. Jedna tabela na konkretną klasę. Niejawna obsługa polimorfizmu (156)
• 6.2. Jedna tabela na konkretną klasę oraz unie (158)
• 6.3. Jedna tabela na hierarchię klas (160)
• 6.4. Jedna tabela na podklasę oraz złączenia (164)
• 6.5. Mieszane strategie dziedziczenia (167)
• 6.6. Dziedziczenie klas osadzanych (169)
• 6.7. Wybór strategii (172)
• 6.8. Asocjacje polimorficzne (173)
  • 6.8.1. Polimorficzne asocjacje wiele-do-jednego (173)
  • 6.8.2. Polimorficzne kolekcje (176)
• 6.9. Podsumowanie (177)

Rozdział 7. Mapowanie kolekcji i asocjacje pomiędzy encjami (179)

• 7.1. Zbiory, kolekcje bag, listy i mapy typów wartości (180)
  • 7.1.1. Schemat bazy danych (180)
  • 7.1.2. Tworzenie i mapowanie właściwości będących kolekcjami (180)
  • 7.1.3. Wybór interfejsu kolekcji (182)
  • 7.1.4. Mapowanie zbioru (184)
  • 7.1.5. Mapowanie kolekcji bag identyfikatorów (185)
  • 7.1.6. Mapowanie list (186)
  • 7.1.7. Mapowanie mapy (187)
  • 7.1.8. Kolekcje posortowane i uporządkowane (188)
• 7.2. Kolekcje komponentów (191)
  • 7.2.1. Równość egzemplarzy komponentu (192)
  • 7.2.2. Kolekcja Set komponentów (194)
  • 7.2.3. Kolekcja bag komponentów (196)
  • 7.2.4. Mapa wartości komponentów (197)
  • 7.2.5. Komponenty jako klucze mapy (198)
  • 7.2.6. Kolekcje w komponencie osadzanym (199)
• 7.3. Mapowanie asocjacji encji (200)
  • 7.3.1. Najprostsza możliwa asocjacja (201)
  • 7.3.2. Definiowanie asocjacji dwukierunkowych (202)
  • 7.3.3. Kaskadowe zmiany stanu (204)
• 7.4. Podsumowanie (211)

Rozdział 8. Zaawansowane mapowanie asocjacji pomiędzy encjami (213)

• 8.1. Asocjacje jeden-do-jednego (214)
  • 8.1.1. Współdzielenie klucza głównego (214)
  • 8.1.2. Generator kluczy obcych i głównych (217)
  • 8.1.3. Wykorzystanie kolumny złączenia klucza obcego (220)
  • 8.1.4. Korzystanie z tabeli złączenia (221)
• 8.2. Asocjacje jeden-do-wielu (224)
  • 8.2.1. Kolekcje bag jeden-do-wielu (224)
  • 8.2.2. Jednokierunkowe i dwukierunkowe mapowania list (226)
  • 8.2.3. Opcjonalna asocjacja jeden-do-wielu z tabelą złączenia (228)
  • 8.2.4. Asocjacje jeden-do-wielu w klasach osadzanych (230)
• 8.3. Asocjacje wiele-do-wielu i asocjacje potrójne (232)
  • 8.3.1. Jednokierunkowe i dwukierunkowe asocjacje wiele-do-wielu (232)
  • 8.3.2. Asocjacja wiele-do-wielu z pośrednią encją (234)
  • 8.3.3. Asocjacje trójelementowe z komponentami (238)
• 8.4. Asocjacje pomiędzy encjami z wykorzystaniem kolekcji Map (241)
  • 8.4.1. Relacje jeden-do-wielu z kluczem w postaci właściwości (241)
  • 8.4.2. Relacje trójczłonowe klucz-wartość (243)
• 8.5. Podsumowanie (244)

Rozdział 9. Schematy złożone i odziedziczone (245)

• 9.1. Ulepszanie schematu bazy danych (246)
  • 9.1.1. Dodawanie pomocniczych obiektów bazy danych (247)
  • 9.1.2. Ograniczenia SQL (250)
  • 9.1.3. Tworzenie indeksów (257)
• 9.2. Obsługa kluczy odziedziczonych (258)
  • 9.2.1. Mapowanie naturalnych kluczy głównych (258)
  • 9.2.2. Mapowanie złożonych kluczy głównych (259)
  • 9.2.3. Klucze obce w złożonych kluczach głównych (261)
  • 9.2.4. Klucze obce w złożonych kluczach głównych (264)
  • 9.2.5. Klucze obce odwołujące się do pól niebędących kluczami głównymi (265)
• 9.3. Mapowanie właściwości do tabel pomocniczych (266)
• 9.4. Podsumowanie (268)

CZĘŚĆ III. TRANSAKCYJNE PRZETWARZANIE DANYCH (269)

Rozdział 10. Zarządzanie danymi (271)

• 10.1. Cykl życia utrwalania (272)
  • 10.1.1. Stany egzemplarza encji (273)
  • 10.1.2. Kontekst utrwalania (274)
• 10.2. Interfejs EntityManager (276)
  • 10.2.1. Kanoniczna jednostka pracy (276)
  • 10.2.2. Utrwalanie danych (278)
  • 10.2.3. Pobieranie i modyfikowanie trwałych danych (279)
  • 10.2.4. Pobieranie referencji (281)
  • 10.2.5. Przełączanie danych do stanu przejściowego (282)
  • 10.2.6. Odświeżanie danych (284)
  • 10.2.7. Replikowanie danych (284)
  • 10.2.8. Buforowanie w kontekście utrwalania (285)
  • 10.2.9. Synchronizowanie kontekstu utrwalania (287)
• 10.3. Praca z encjami w stanie odłączonym (288)
  • 10.3.1. Tożsamość odłączonych egzemplarzy (289)
  • 10.3.2. Implementacja metody równości (291)
  • 10.3.3. Odłączanie egzemplarzy encji (294)
  • 10.3.4. Scalanie egzemplarzy encji (295)
• 10.4. Podsumowanie (297)

Rozdział 11. Transakcje i współbieżność (299)

• 11.1. Podstawowe wiadomości o transakcjach (300)
  • 11.1.1. Cechy ACID (300)
  • 11.1.2. Transakcje bazodanowe i systemowe (301)
  • 11.1.3. Transakcje programowe z JTA (301)
  • 11.1.4. Obsługa wyjątków (303)
  • 11.1.5. Deklaratywne rozgraniczanie transakcji (306)
• 11.2. Zarządzanie współbieżnym dostępem (306)
  • 11.2.1. Współbieżność na poziomie bazy danych (307)
  • 11.2.2. Optymistyczne zarządzanie współbieżnością (312)
  • 11.2.3. Jawne pesymistyczne blokady (320)
  • 11.2.4. Unikanie zakleszczeń (324)
• 11.3. Dostęp do danych na zewnątrz transakcji (325)
  • 11.3.1. Czytanie danych w trybie autozatwierdzania (326)
  • 11.3.2. Kolejkowanie modyfikacji (328)
• 11.4. Podsumowanie (329)

Rozdział 12. Plany pobierania, strategie i profile (331)

• 12.1. Ładowanie leniwe i zachłanne (332)
  • 12.1.1. Obiekty proxy encji (333)
  • 12.1.2. Leniwe ładowanie trwałych kolekcji (337)
  • 12.1.3. Leniwe ładowanie z przechwytywaniem (339)
  • 12.1.4. Zachłanne ładowanie asocjacji i kolekcji (342)
• 12.2. Wybór strategii pobierania (344)
  • 12.2.1. Problem n+1 instrukcji SELECT (345)
  • 12.2.2. Problem iloczynu kartezjańskiego (346)
  • 12.2.3. Pobieranie danych partiami z wyprzedzeniem (349)
  • 12.2.4. Pobieranie kolekcji z wyprzedzeniem z wykorzystaniem podzapytań (351)
  • 12.2.5. Pobieranie zachłanne z wieloma instrukcjami SELECT (352)
  • 12.2.6. Dynamiczne pobieranie zachłanne (353)
• 12.3. Korzystanie z profili pobierania (355)
  • 12.3.1. Deklarowanie profili pobierania Hibernate (356)
  • 12.3.2. Korzystanie z grafów encji (357)
• 12.4. Podsumowanie (361)

Rozdział 13. Filtrowanie danych (363)

• 13.1. Kaskadowe przejścia stanu (364)
  • 13.1.1. Dostępne opcje kaskadowe (365)
  • 13.1.2. Przechodnie odłączanie i scalanie (366)
  • 13.1.3. Kaskadowe odświeżanie (368)
  • 13.1.4. Kaskadowe replikacje (370)
  • 13.1.5. Włączanie globalnej opcji przechodniego utrwalania (371)
• 13.2. Nasłuchiwanie i przechwytywanie zdarzeń (372)
  • 13.2.1. Obserwatory zdarzeń i wywołania zwrotne JPA (372)
  • 13.2.2. Implementacja interceptorów Hibernate (376)
  • 13.2.3. Rdzeń systemu obsługi zdarzeń (380)
• 13.3. Audyt i wersjonowanie z wykorzystaniem Hibernate Envers (382)
  • 13.3.1. Aktywacja rejestrowania audytu (382)
  • 13.3.2. Tworzenie śladu audytu (384)
  • 13.3.3. Szukanie wersji (385)
  • 13.3.4. Dostęp do historycznych danych (386)
• 13.4. Dynamiczne filtry danych (389)
  • 13.4.1. Definiowanie dynamicznych filtrów (390)
  • 13.4.2. Stosowanie filtra (390)
  • 13.4.3. Włączanie filtra (391)
  • 13.4.4. Filtrowanie dostępu do kolekcji (392)
• 13.5. Podsumowanie (393)

CZĘŚĆ IV. PISANIE ZAPYTAŃ (395)

Rozdział 14. Tworzenie i uruchamianie zapytań (397)

• 14.1. Tworzenie zapytań (398)
  • 14.1.1. Interfejsy zapytań JPA (398)
  • 14.1.2. Wyniki zapytania z określonym typem danych (401)
  • 14.1.3. Interfejsy zapytań frameworka Hibernate (402)
• 14.2. Przygotowywanie zapytań (403)
  • 14.2.1. Zabezpieczenie przed atakami wstrzykiwania SQL (403)
  • 14.2.2. Wiązanie parametrów nazwanych (404)
  • 14.2.3. Korzystanie z parametrów pozycyjnych (406)
  • 14.2.4. Stronicowanie dużych zbiorów wyników (406)
• 14.3. Uruchamianie zapytań (408)
  • 14.3.1. Wyszczególnianie wszystkich wyników (408)
  • 14.3.2. Pobieranie pojedynczego wyniku (408)
  • 14.3.3. Przewijanie z wykorzystaniem kursorów bazy danych (409)
  • 14.3.4. Iterowanie po wynikach (411)
• 14.4. Nazywanie i eksternalizacja zapytań (412)
  • 14.4.1. Wywoływanie zapytania przez nazwę (412)
  • 14.4.2. Definiowanie zapytań w metadanych XML (413)
  • 14.4.3. Definiowanie zapytań z adnotacjami (414)
  • 14.4.4. Programowe definiowanie nazwanych zapytań (415)
• 14.5. Podpowiedzi do zapytań (416)
  • 14.5.1. Ustawianie limitu czasu (417)
  • 14.5.2. Ustawianie trybu synchronizacji (417)
  • 14.5.3. Ustawianie trybu tylko do odczytu (418)
  • 14.5.4. Ustawianie rozmiaru pobierania (418)
  • 14.5.5. Ustawianie komentarza SQL (419)
  • 14.5.6. Podpowiedzi nazwanych zapytań (419)
• 14.6. Podsumowanie (421)

Rozdział 15. Języki zapytań (423)

• 15.1. Selekcja (424)
  • 15.1.1. Przypisywanie aliasów i rdzeni zapytań (425)
  • 15.1.2. Zapytania polimorficzne (426)
• 15.2. Ograniczenia (427)
  • 15.2.1. Wyrażenia porównań (428)
  • 15.2.2. Wyrażenia z kolekcjami (432)
  • 15.2.3. Wywoływanie funkcji (433)
  • 15.2.4. Sortowanie wyników zapytania (436)
• 15.3. Rzutowanie (437)
  • 15.3.1. Rzutowanie encji i wartości skalarnych (437)
  • 15.3.2. Dynamiczne tworzenie egzemplarzy (439)
  • 15.3.3. Niepowtarzalność wyników (440)
  • 15.3.4. Wywoływanie funkcji w projekcjach (441)
  • 15.3.5. Funkcje agregacji (443)
  • 15.3.6. Grupowanie (445)
• 15.4. Złączenia (446)
  • 15.4.1. Złączenia w SQL (447)
  • 15.4.2. Opcje złączenia w JPA (449)
  • 15.4.3. Niejawne złączenia asocjacyjne (449)
  • 15.4.4. Złączenia jawne (451)
  • 15.4.5. Dynamiczne pobieranie ze złączeniami (453)
  • 15.4.6. Złączenia teta (456)
  • 15.4.7. Porównywanie identyfikatorów (457)
• 15.5. Podzapytania (459)
  • 15.5.1. Zagnieżdżanie skorelowane i nieskorelowane (460)
  • 15.5.2. Kwantyfikacja (461)
• 15.6. Podsumowanie (462)

Rozdział 16. Zaawansowane opcje zapytań (465)

• 16.1. Transformacje wyników zapytań (466)
  • 16.1.1. Zwracanie listy list (466)
  • 16.1.2. Zwracanie listy map (467)
  • 16.1.3. Mapowanie aliasów na właściwości JavaBean (468)
  • 16.1.4. Pisanie własnej implementacji klasy ResultTransformer (469)
• 16.2. Filtrowanie kolekcji (470)
• 16.3. API Criteria frameworka Hibernate (473)
  • 16.3.1. Selekcja i porządkowanie (473)
  • 16.3.2. Ograniczanie (474)
  • 16.3.3. Rzutowanie i agregacja (475)
  • 16.3.4. Złączenia (477)
  • 16.3.5. Podzapytania (478)
  • 16.3.6. Zapytania przez przykład (479)
• 16.4. Podsumowanie (482)

Rozdział 17. Dostosowywanie SQL (483)

• 17.1. Korzystanie z trybu JDBC (484)
• 17.2. Mapowanie wyników zapytania SQL (486)
  • 17.2.1. Rzutowanie z zapytaniami SQL (487)
  • 17.2.2. Mapowanie na klasy encji (488)
  • 17.2.3. Dostosowywanie mapowania wyników (490)
  • 17.2.4. Eksternalizacja natywnych zapytań (502)
• 17.3. Dostosowywanie operacji CRUD (505)
  • 17.3.1. Własne mechanizmy ładujące (505)
  • 17.3.2. Personalizacja operacji tworzenia, aktualizowania i usuwania egzemplarzy encji (507)
  • 17.3.3. Personalizacja operacji na kolekcjach (509)
  • 17.3.4. Zachłanne pobieranie we własnych mechanizmach ładujących (511)
• 17.4. Wywoływanie procedur składowanych (513)
  • 17.4.1. Zwracanie zbioru wyników (515)
  • 17.4.2. Zwracanie wielu zbiorów wyników oraz liczników aktualizacji (516)
  • 17.4.3. Ustawianie parametrów wejściowych i wyjściowych (518)
  • 17.4.4. Zwracanie kursora (521)
• 17.5. Wykorzystywanie procedur składowanych do operacji CRUD (522)
  • 17.5.1. Spersonalizowany mechanizm ładujący z procedurą (523)
  • 17.5.2. Procedury dla operacji CUD (524)
• 17.6. Podsumowanie (526)

CZĘŚĆ V. BUDOWANIE APLIKACJI (527)

Rozdział 18. Projektowanie aplikacji klient-serwer (529)

• 18.1. Tworzenie warstwy utrwalania (530)
  • 18.1.1. Generyczny wzorzec obiektu dostępu do danych (532)
  • 18.1.2. Implementacja generycznego interfejsu (533)
  • 18.1.3. Implementacja obiektów DAO encji (536)
  • 18.1.4. Testowanie warstwy utrwalania (538)
• 18.2. Budowa serwera bezstanowego (540)
  • 18.2.1. Edycja przedmiotu aukcji (540)
  • 18.2.2. Składanie oferty (543)
  • 18.2.3. Analiza aplikacji bezstanowej (546)
• 18.3. Budowanie serwera stateful (548)
  • 18.3.1. Edycja przedmiotu aukcji (549)
  • 18.3.2. Analiza aplikacji stateful (554)
• 18.4. Podsumowanie (556)

Rozdział 19. Budowanie aplikacji webowych (557)

• 19.1. Integracja JPA z CDI (558)
  • 19.1.1. Tworzenie obiektu EntityManager (558)
  • 19.1.2. Łączenie obiektu EntityManager z transakcjami (560)
  • 19.1.3. Wstrzykiwanie obiektu EntityManager (560)
• 19.2. Stronicowanie i sortowanie danych (562)
  • 19.2.1. Stronicowanie na bazie przesunięć a stronicowanie przez przeszukiwanie (563)
  • 19.2.2. Stronicowanie w warstwie utrwalania (565)
  • 19.2.3. Odpytywanie strona po stronie (571)
• 19.3. Budowanie aplikacji JSF (572)
  • 19.3.1. Usługi o zasięgu żądania (572)
  • 19.3.2. Usługi o zasięgu konwersacji (576)
• 19.4. Serializacja danych modelu dziedziny (585)
  • 19.4.1. Pisanie usługi JAX-RS (585)
  • 19.4.2. Stosowanie mapowań JAXB (587)
  • 19.4.3. Serializacja obiektów proxy frameworka Hibernate (589)
• 19.5. Podsumowanie (593)

Rozdział 20. Skalowanie Hibernate (595)

• 20.1. Przetwarzanie masowe i wsadowe (596)
  • 20.1.1. Instrukcje masowe w JPQL i API kryteriów (596)
  • 20.1.2. Masowe instrukcje w SQL (601)
  • 20.1.3. Przetwarzanie wsadowe (602)
  • 20.1.4. Interfejs StatelessSession frameworka Hibernate (606)
• 20.2. Buforowanie danych (608)
  • 20.2.1. Architektura współdzielonej pamięci podręcznej frameworka Hibernate (609)
  • 20.2.2. Konfigurowanie współdzielonej pamięci podręcznej (614)
  • 20.2.3. Buforowanie encji i kolekcji (616)
  • 20.2.4. Testowanie współdzielonej pamięci podręcznej (619)
  • 20.2.5. Ustawianie trybów pamięci podręcznej (622)
  • 20.2.6. Zarządzanie współdzieloną pamięcią podręczną (623)
  • 20.2.7. Pamięć podręczna wyników zapytania (624)
• 20.3. Podsumowanie (627)

Bibliografia (629)

Skorowidz (631)