Utrwalenie danych, tak aby zostały one zapisane i przechowane przez system informatyczny, jest jedną z podstawowych funkcji aplikacji. Prawie zawsze wymaga się trwałych danych. W przypadku Javy zazwyczaj utrwalenie danych odbywa się poprzez ich zapisanie w relacyjnej bazie danych z wykorzystaniem języka SQL. Relacyjne bazy danych stanowią niezwykle elastyczne i potężne narzędzie do zarządzania utrwalonymi danymi, jednak aby wykorzystać wszystkie zalety tego rozwiązania, trzeba zapewnić optymalne komunikowanie się aplikacji z bazą danych.

Niniejsza książka stanowi wyczerpujące źródło aktualnej wiedzy o frameworku Hibernate, najpopularniejszym narzędziu do utrwalania danych dla Javy, które zapewnia automatyczne i przezroczyste mapowanie obiektowo-relacyjne. Wyczerpująco opisano też standard Java Persistence 2.1 (JSR 338). Programowanie aplikacji w Hibernate wyjaśniono tu na licznych przykładach. Pokazano, jak korzystać z mapowania, zapytań, strategii pobierania, transakcji, konwersacji, buforowania i wielu innych funkcji. Nie zabrakło opisu najlepszych praktyk w projektowaniu baz danych oraz wskazówek dotyczących optymalizacji. Wszystkie przykłady zostały uaktualnione dla najnowszych wersji frameworka Hibernate i środowiska Java EE.

Najważniejsze zagadnienia omówione w książce:

• 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ą!

---

Christian Bauer jest szkoleniowcem i konsultantem. Bierze udział w rozwijaniu frameworka Hibernate. Autor kilku książek dotyczących programowania w Javie. Gavin King jest współzałożycielem projektu Hibernate oraz członkiem grupy ekspertów pracujących nad standardem Java Persistence (JSR 220). Przewodził również pracom nad standaryzacją CDI (JSR 299). Gary Gregory jest współautorem książek JUnit in Action oraz Spring Batch in Action. Jest także członkiem grup zarządzania projektami firmy Apache Software Foundation: Commons, HttpComponents, Logging Services i Xalan.

 

Osoby które kupowały "Java Persistence. Programowanie aplikacji bazodanowych w Hibernate. Wydanie II", wybierały także:

• Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII 193,23 zł, (59,90 zł -69%)
• Spring i Spring Boot. Kurs video. Testowanie aplikacji i bezpiecze 129,00 zł, (51,60 zł -60%)
• Metoda dziel i zwyci 89,00 zł, (35,60 zł -60%)
• JavaFX. Kurs video. Wzorce oraz typy generyczne 79,00 zł, (31,60 zł -60%)
• Platforma Xamarin. Kurs video. Poziom drugi. Zaawansowane techniki tworzenia aplikacji cross-platform 99,00 zł, (39,60 zł -60%)

• 
• 
• 
• 
• 

Spis treści

Java Persistence. Programowanie aplikacji bazodanowych w Hibernate. Wydanie II eBook -- spis treści

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)