Java Data Objects Sameer Tyagi, Keiron McCammon, Michael Vorburger, Heiko Bobzin

Dostępność produktu

Produkt nie został jeszcze oceniony pod kątem ułatwień dostępu lub nie podano żadnych informacji o ułatwieniach dostępu lub są one niewystarczające. Prawdopodobnie Wydawca/Dostawca jeszcze nie umożliwił dokonania walidacji produktu lub nie przekazał odpowiednich informacji na temat jego dostępności.

Spis treści książki

O Autorach (13)


Przedmowa (15)


Wstęp (23)


Część I Wprowadzenie (25)


Rozdział 1. Przegląd specyfikacji JDO (27)


• 1.1. Powstanie specyfikacji JDO (27)
  
• 1.2. Obiektowy model dziedziny (27)
  
• 1.3. Trwałość ortogonalna (30)
  
  • 1.3.1. Obiekty trwałe i obiekty ulotne (33)
• 1.4. Środowiska zarządzane i niezarządzane (36)
  
  • 1.4.1. Środowiska niezarządzane (36)
  • 1.4.2. Środowiska zarządzane (36)
• 1.5. Role i obowiązki (37)
  
  • 1.5.1. Specyfikacje JDO (38)
  • 1.5.2. Obowiązki programisty (38)
  • 1.5.3. Obowiązki producenta (40)
• 1.6. Podsumowanie (41)

Rozdział 2. Podstawowe zagadnienia dotyczące trwałości obiektów (43)


• 2.1. Trwałość i aplikacje (43)
  
• 2.2. Serializacja binarna JDK (44)
  
  • 2.2.1. Interfejs programowy serializacji (44)
  • 2.2.2. Zarządzanie wersjami i serializacja (46)
  • 2.2.3. Kiedy stosować serializację? (47)
  • 2.2.4. Kiedy unikać stosowania serializacji? (48)
• 2.3. Odwzorowania obiektowo-relacyjne (48)
  
  • 2.3.1. Klasy i tablice (49)
  • 2.3.2. Odwzorowania typów String, Date i innych (50)
  • 2.3.3. Odwzorowanie dziedziczenia (51)
  • 2.3.4. Bezpieczeństwo (53)
  • 2.3.5. Translacja języka zapytań (54)
  • 2.3.6. Spójność referencyjna, usuwanie obiektów i inne zagadnienia (54)
  • 2.3.7. Trwałość transparentna i odwzorowania O/R (54)
  • 2.3.8. Identyfikacja (55)
• 2.4. Tworzenie własnej warstwy odwzorowania O/R (56)
  
  • 2.4.1. Buforowanie (56)
  • 2.4.2. Transakcyjny dostęp do bazy i obiekty transakcyjne (57)
  • 2.4.3. Blokowanie (58)
  • 2.4.4. Tablice, zbiory, listy i mapy (58)
  • 2.4.5. Efektywność (59)
  • 2.4.6. Tworzyć samodzielnie czy kupować? (59)
• 2.5. Wnioski (60)

Część II Szczegóły (63)


Rozdział 3. Rozpoczynamy programowanie z użyciem JDO (65)


• 3.1. Jak działa JDO? (66)
  
• 3.2. Podstawy JDO (69)
  
• 3.3. Definiowanie klasy (70)
  
  • 3.3.1. Metadane JDO (71)
  • 3.3.2. Odwzorowanie klasy do bazy danych (72)
• 3.4. Połączenie do bazy danych (72)
  
• 3.5. Tworzenie obiektu (74)
  
• 3.6. Wczytywanie obiektu (76)
  
  • 3.6.1. Wczytywanie przez nawigację (76)
  • 3.6.2. Wczytywanie za pomocą interfejsu Extent (77)
  • 3.6.3. Wczytywanie przez zapytanie (78)
• 3.7. Aktualizacja obiektu (79)
  
• 3.8. Usuwanie obiektu (80)
  
• 3.9. Model obiektowy JDO (82)
  
  • 3.9.1. Typy podstawowe (82)
  • 3.9.2. Referencje (83)
  • 3.9.3. Klasy kolekcji (87)
  • 3.9.4. Tablice (89)
  • 3.9.5. Dziedziczenie (90)
  • 3.9.6. Modyfikatory (91)
  • 3.9.7. Ograniczenia JDO (92)
• 3.10. Obsługa wyjątków (92)
  
• 3.11. Tożsamość obiektów (93)
  
• 3.12. Typy tożsamości obiektów (94)
  
  • 3.12.1. Tożsamość na poziomie bazy danych (95)
  • 3.12.2. Tożsamość na poziomie aplikacji (95)
  • 3.12.3. Tożsamość nietrwała (98)
• 3.13. Cykl życia obiektu (98)
  
• 3.14. Sterowanie współbieżnością (99)
  
  • 3.14.1. Transakcje ACID (100)
  • 3.14.2. Transakcje optymistyczne (100)
• 3.15. Podsumowanie (101)

Rozdział 4. Cykl życia obiektów (103)


• 4.1. Cykl życia obiektu trwałego (103)
  
  • 4.1.1. Utrwalanie obiektu (104)
  • 4.1.2. Odtwarzanie obiektów z bazy danych (105)
  • 4.1.3. Uproszczony cykl życia obiektu (107)
• 4.2. Informacja o stanie obiektu (108)
  
• 4.3. Operacje powodujące zmianę stanu (109)
  
  • 4.3.1. PersistenceManager.makePersistent (110)
  • 4.3.2. PersistenceManager.deletePersistent (110)
  • 4.3.3. PersistenceManager.makeTransient (110)
  • 4.3.4. Transaction.commit (110)
  • 4.3.5. Transaction.rollback (110)
  • 4.3.6. PersistenceManager.refresh (110)
  • 4.3.7. PersistenceManager.evict (111)
  • 4.3.8. Odczyt pól wewnątrz transakcji (111)
  • 4.3.9. Zapis pól wewnątrz transakcji (111)
  • 4.3.10. PersistenceManager.retrieve (111)
• 4.4. Wywołania zwrotne (111)
  
  • 4.4.1. Zastosowania metody jdoPostLoad (112)
  • 4.4.2. Zastosowania metody jdoPreStore (113)
  • 4.4.3. Zastosowania metody jdoPreDelete (114)
  • 4.4.4. Zastosowania metody jdoPreClear (115)
• 4.5. Stany opcjonalne (115)
  
  • 4.5.1. Ulotne instancje transakcyjne (116)
  • 4.5.2. Zastosowania ulotnych instancji transakcyjnych (117)
  • 4.5.3. Instancje nietransakcyjne (117)
  • 4.5.4. Transakcje optymistyczne (119)
• 4.6. Przykłady (120)
  
• 4.7. Podsumowanie (124)

Rozdział 5. Programowanie w JDO (125)


• 5.1. Koncepcje JDO (125)
  
  • 5.1.1. Zdolność do trwałości (126)
  • 5.1.2. Metadane JDO (126)
  • 5.1.3. Domyślna grupa pobierania (128)
  • 5.1.4. Trwałość poprzez osiągalność (128)
  • 5.1.5. Obiekty klas pierwszej i drugiej kategorii (129)
  • 5.1.6. Tożsamość obiektów (130)
  • 5.1.7. Cykl życia obiektu (130)
  • 5.1.8. Transakcje (131)
• 5.2. Interfejsy i klasy JDO (135)
  
• 5.3. Podstawowe interfejsy JDO (138)
  
  • 5.3.1. javax.jdo.PersistenceManagerFactory (138)
  • 5.3.2. PersistenceManager (148)
  • 5.3.3. Extent (165)
  • 5.3.4. Query (167)
  • 5.3.5. Transaction (174)
  • 5.3.6. InstanceCallbacks (180)
• 5.4. Klasy wyjątków (182)
  
  • 5.4.1. JDOException (183)
  • 5.4.2. JDOFatalException (183)
  • 5.4.3. JDOFatalUserException (183)
  • 5.4.4. JDOFatalInternalException (184)
  • 5.4.5. JDOFatalDataStoreException (184)
  • 5.4.6. JDOOptimisticVerificationException (184)
  • 5.4.7. JDOCanRetryException (184)
  • 5.4.8. JDOUnsupportedOptionException (184)
  • 5.4.9. JDOUserException (185)
  • 5.4.10. JDODataStoreException (185)
  • 5.4.11. JDOObjectNotFoundException (185)
• 5.5. Dodatkowe interfejsy (185)
  
  • 5.5.1. Klasa JDOHelper (185)
  • 5.5.2. Klasa I18NHelper (187)
• 5.6. SPI (187)
  
  • 5.6.1. PersistenceCapable (188)
  • 5.6.2. JDOPermission (188)
  • 5.6.3. JDOImplHelper (188)
  • 5.6.4. StateManager (189)
• 5.7. Podsumowanie (189)

Rozdział 6. Wyszukiwanie danych (191)


• 6.1. Wyszukiwanie obiektu na podstawie tożsamości (191)
  
• 6.2. Wyszukiwanie zbioru obiektów za pomocą ekstensji (193)
  
• 6.3. Wyszukiwanie obiektów za pomocą zapytań (194)
  
  • 6.3.1. Zapytania dla ekstensji (197)
• 6.4. JDOQL (197)
  
  • 6.4.1. Specyfikacja filtrów (199)
• 6.5. Zapytania, filtry i parametry opcjonalne (204)
  
  • 6.5.1. Deklaracje parametrów (204)
  • 6.5.2. Deklaracje poleceń importu (206)
  • 6.5.3. Deklaracje zmiennych (206)
  • 6.5.4. Uporządkowanie wyników zapytania (207)
  • 6.5.5. Przestrzenie nazw w zapytaniach (208)
• 6.6. Więcej o interfejsie Query (208)
  
  • 6.6.1. Tworzenie zapytań (209)
  • 6.6.2. Zapytania i buforowanie (209)
  • 6.6.3. Zapytania skompilowane (210)
  • 6.6.4. Szablony zapytań (210)
  • 6.6.5. Wybór innego języka zapytań (212)
• 6.7. Podsumowanie (212)

Rozdział 7. Scenariusze i architektury (213)


• 7.1. JDO i JDBC (213)
  
• 7.2. Rodzaje baz danych (214)
  
  • 7.2.1. JDO i relacyjne bazy danych (215)
  • 7.2.2. JDO i obiektowe bazy danych (216)
  • 7.2.3. Porównania baz danych (216)
• 7.3. J2EE, RMI i CORBA (217)
  
• 7.4. Środowiska zarządzane i niezarządzane (218)
  
  • 7.4.1. Zarządzanie połączeniami (219)
  • 7.4.2. Zarządzanie transakcjami (220)
• 7.5. Aplikacje wielowątkowe (221)
  
  • 7.5.1. Programowanie wielowątkowe (221)
  • 7.5.2. Uproszczone programowanie wielowątkowe (222)
• 7.6. Podsumowanie (222)

Część III J2EE (223)


Rozdział 8. JDO i JCA (225)


• 8.1. Wprowadzenie do JCA (225)
  
• 8.2. JDO i JCA (227)
  
• 8.3. Wykorzystanie JDO i JCA (227)
  
  • 8.3.1. Konfiguracja (228)
  • 8.3.2. Zarządzanie połączeniami (228)
  • 8.3.3. Zarządzanie transakcjami (230)
  • 8.3.4. Bezpieczeństwo (234)
• 8.5. Wykorzystanie JDO bez JCA (234)
  
• 8.6. Podsumowanie (235)

Rozdział 9. JDO i Enterprise JavaBeans (237)


• 9.1. Wprowadzenie (237)
  
• 9.2. Komponenty sesyjne i JDO (239)
  
  • 9.2.1. Zarządzanie transakcjami (240)
  • 9.2.2. Przykład komponentu sesyjnego, który nie ma stanu i używa transakcji zarządzanych przez kontener (243)
  • 9.2.3. Przykład komponentu sesyjnego, który ma stan i używa transakcji zarządzanych przez kontener (245)
  • 9.2.4. Architektura zorientowana na usługi (SOA) (247)
• 9.3. Komponenty sterowane komunikatami i JDO (257)
  
  • 9.3.1. Przykład kodu (258)
• 9.4. Komponenty Entity i JDO (259)
  
  • 9.4.1. Trwałość zarządzana przez komponent i JDO (261)
• 9.5. Kiedy używać EJB? (261)
  
  • 9.5.1. Skalowalne aplikacje JDO i łączenie w klastry (265)
  • 9.5.2. Rozwiązania z transmisją w obu kierunkach (266)
• 9.6. Podsumowanie (268)

Rozdział 10. Bezpieczeństwo (271)


• 10.1. Poziomy bezpieczeństwa (271)
  
  • 10.1.1. Bezpieczeństwo na poziomie pól i klas (271)
  • 10.1.2. Bezpieczeństwo na poziomie bazy danych (272)
  • 10.1.3. Bezpieczeństwo na poziomie aplikacji (273)
• 10.2. Implementacja interfejsu PersistenceCapable (273)
  
  • 10.2.1. Referencyjne narzędzie rozszerzania kodu (275)
  • 10.2.2. Zasady działania (277)
  • 10.2.3. Śledzenie dostępu do pola (279)
  • 10.2.4. Dostęp do metadanych (282)
  • 10.2.5. Plik zasad bezpieczeństwa (283)
  • 10.2.6. Problemy z bezpieczeństwem (283)
• 10.3. Bezpieczeństwo aplikacji (284)
  
  • 10.3.1. Bezpieczeństwo połączeń (284)
  • 10.3.2. Środowiska zarządzane (285)
  • 10.3.3. Autoryzacja na poziomie aplikacji (285)
• 10.4. Podsumowanie (286)

Rozdział 11. Transakcje (287)


• 11.1. Koncepcje transakcji (287)
  
  • 11.1.1. Uczestnicy transakcji (288)
  • 11.1.2. Transakcje lokalne (289)
  • 11.1.3. Transakcje rozproszone (289)
  • 11.1.4. Zatwierdzanie dwufazowe (289)
• 11.2. Transakcje i Java (292)
  
  • 11.2.1. Transakcje JDBC (292)
  • 11.2.2. JTA i JTS (292)
• 11.3. Transakcje w JDO (295)
  
  • 11.3.1. Konflikty podczas zatwierdzania transakcji optymistycznych (301)
  • 11.3.2. Obiekty transakcyjne i nietransakcyjne (302)
  • 11.3.3. Zachowywanie i odtwarzanie wartości (305)
  • 11.3.4. JDO i transakcje serwera aplikacji J2EE (306)
  • 11.3.5. Interfejs Transaction i synchronizacja za pomocą zwrotnych wywołań metod (314)
• 11.4. Podsumowanie (314)

Część IV Wnioski (315)


Rozdział 12. JDO i JDBC (317)


• 12.1. JDBC 2.0 i 3.0 (317)
  
  • 12.1.1. Podstawy JDBC (318)
  • 12.1.2. Historia JDBC (319)
  • 12.1.3. Nowe możliwości JDBC 3.0 (320)
  • 12.1.4. Rozszerzenia interfejsu JDBC (321)
• 12.2. Przykład: przechowywanie obiektów w relacyjnej bazie danych za pomocą JDBC (322)
  
• 12.3. Porównanie JDBC i JDO (325)
  
  • 12.3.1. Porównanie możliwości JDBC i JDO (328)
  • 12.3.2. Nieporozumienia związane z JDBC i JDO (328)
  • 12.3.3. Kiedy używać JDBC (333)
  • 12.3.4. Kiedy używać razem JDO i JDBC? (339)
• 12.4. Podsumowanie (339)

Rozdział 13. Wskazówki, triki i najlepsze rozwiązania (341)


• 13.1. Modelowanie danych (341)
  
  • 13.1.1. Wprowadzenie (341)
  • 13.1.2. Klasy obudowujące i typy podstawowe (342)
  • 13.1.3. Referencje obiektów trwałych (343)
  • 13.1.4. Pola o typie kolekcji (343)
  • 13.1.5. Modelowanie związków odwrotnych (346)
  • 13.1.6. Hierarchie dziedziczenia (348)
  • 13.1.7. Klasy świadome trwałości (348)
• 13.2. JDO i serwlety (349)
  
• 13.3. Wyodrębnienie klas należących do modelu dziedziny (352)
  
• 13.4. Wykorzystanie XML-a jako formatu wymiany danych (353)
  
  • 13.4.1. Wprowadzenie (354)
  • 13.4.2. Alternatywy (355)
  • 13.4.3. Dostępne technologie (355)
  • 13.4.4. Przykład (358)
• 13.5. Kontrola poprawności danych (359)
  
  • 13.5.1. Wykorzystanie metody jdoPrestore interfejsu InstanceCallback (361)
  • 13.5.2. Wykorzystanie metody beforeCompletion() interfejsu Synchronization (362)
• 13.6. Podsumowanie (365)

Rozdział 14. Perspektywy (367)


• 14.1. Zaawansowana semantyka transakcji (367)
  
  • 14.1.1. Zagnieżdżanie transakcji (368)
  • 14.1.2. Punkty odwoływania transakcji (368)
  • 14.1.3. Jawne blokowanie (369)
• 14.2. Optymalizacja wydajności (369)
  
• 14.3. Zarządzanie związkami (369)
  
  • 14.3.1. Związki dwukierunkowe (370)
  • 14.3.2. Usuwanie kaskadowe (370)
  • 14.3.3. Odzyskiwanie zasobów zajmowanych przez obiekty trwałe (371)
• 14.4. Rozszerzenia zapytań (371)
  
  • 14.4.1. Łańcuchy (371)
  • 14.4.2. Operacje agregacji (371)
  • 14.4.3. Projekcje (372)
• 14.5. Odwzorowania obiektów (372)
  
• 14.6. Wzorzec wyliczenia (372)
  
• 14.7. Podsumowanie (373)

Rozdział 15. Studium przypadku. Biblioteka JDO (375)


• 15.1. Pliki, pakiety i model obiektowy (375)
  
• 15.2. Pakiet model (376)
  
  • 15.2.1. Klasa Publication (376)
  • 15.2.2. Klasa Book (378)
  • 15.2.3. Klasa CD (378)
  • 15.2.4. Klasa Copy (380)
  • 15.2.5. Klasa User (381)
  • 15.2.6. Klasy Right i Rights (383)
• 15.3. Pakiet usecase (385)
  
  • 15.3.1. Klasa AbstractUserCase (385)
  • 15.3.2. Przypadek AddBook (388)
• 15.4. Klasa BookOperation (390)
  
  • 15.4.1. Przypadek ListBooks (392)
  • 15.4.2. Przypadek DetailedBook (395)
  • 15.4.3. Przypadek EditBook (396)
  • 15.4.4. Przypadek DeleteBook (398)
  • 15.4.5. Klasa BorrowReturn (399)
  • 15.4.6. Przypadek Borrow (400)
  • 15.4.7. Przypadek Return (400)
• 15.5. Uruchamianie (400)
  
  • 15.5.1. Metadane XML (401)
  • 15.5.2. Uruchomienie z poziomu wiersza poleceń (401)
  • 15.5.3. Uruchamianie serwletów (402)

Dodatki (403)


Dodatek A Stany JDO (405)


Dodatek B Metadane XML (409)


Dodatek C Język JDOQL w notacji BNF (419)


Dodatek D PersistenceManagerFactory - informator (425)


Dodatek E Implementacje JDO (429)


Skorowidz (441)

pokaż cały spis treści

ukryj recenzje