.:$$:.

Książka "Java Data Objects":

• Demonstruje praktyczne techniki stosowane przez zawodowych programistów
• Zawiera poprawny, gruntownie przetestowany kod źródłowy programów oraz przykłady zaczerpnięte z praktyki
• Skoncentrowana jest na nowoczesnych technologiach, które muszą poznać programiści
• Zawiera rady profesjonalistów, które pozwolą czytelnikowi tworzyć najlepsze programy

Java Data Objects (JDO) przyspiesza tworzenie aplikacji w Javie dostarczając obiektowego mechanizmu trwałości i standardowych interfejsów umożliwiających korzystanie z baz danych. Książka ta jest wszechstronnym przewodnikiem po zagadnieniach trwałości JDO, przeznaczony dla zaawansowanego programisty.

Korzystając z realistycznych przykładów kodu autorzy przedstawiają sposoby tworzenia, pobierania, aktualizacji i usuwania obiektów trwałych, cykl życia obiektów i przejścia pomiędzy stanami, klasy i interfejsy JDO, zapytania, architekturę, problemy bezpieczeństwa i wiele innych zagadnień. Prezentują sposoby integracji JDO z EJB™, JTA, JCA i innymi technologiami J2EE™, omawiają też najlepsze sposoby wykorzystania JDO przez samodzielne aplikacje oraz komponenty J2EE™.

Jeśli chcesz poświęcić więcej czasu na rozwiązywanie zagadnień biznesowych, a mniej tracić na zajmowanie się problemem trwałości, to potrzebujesz właśnie JDO i jednej dobrej książki, która pomoże Ci efektywnie użyć JDO: "Java Data Objects".

• Omówienie specyfikacji JDO i podstawowych zagadnień związanych z trwałością obiektów
• Programowanie z użyciem JDO; najważniejsze klasy i obiekty
• Cykl życia obiektów
• Wyszukiwanie danych w JDO
• Przykładowa architektura i jej konstrukcja z użyciem JDO
• JDO a J2EE: JCA, EJB, transakcje, bezpieczeństwo
• Porównanie JDO z JDBC
• Przyszłość JDO i rozwój tej specyfikacji
• Studium przypadku

Uzupełnieniem są liczne dodatki omawiające między innymi: stany JDO, metadane, język JDOQL w notacji BNF i dostępne implementacje JDO.

• Praktyczne przykłady ilustrują możliwości użycia JDO przez istniejące aplikacje
• Tworzenia efektywniejszych systemów dzięki JDO
• Integracja JDO z J2EE krok po kroku
• Najlepsze sposoby wykorzystania JDO przez aplikacje biznesowe

Autorzy:
Sameer Tyagi jest architektem systemów biznesowych w firmie Sun Microsystems i pracuje w Java Center w Burlington w stanie Massachusets. Ma za sobą osiem lat doświadczeń zawodowych w dziedzinie informatyki i jest współautorem wielu książek związanych z technologiami Javy.

Keiron McCammon jest szefem działu technologii w firmie Versant Corporation. Pracuje w branży informatycznej już ponad dziesięć lat i zajmuje się głównie zastosowaniami technologii obiektowej w biznesie. Jest członkiem grupy eksperckiej JDO (JSR12) i często bierze udział w seminariach i konferencjach poświęconych tworzeniu aplikacji na platformach Java i J2EE przy wykorzystaniu JDO.

Michael Vorburger pracuje jako główny architekt oprogramowania w firmie Vertical zajmującej się tworzeniem oprogramowania. Jest aktywnym uczestnikiem listy dyskusyjnej poświęconej JDO.

Heiko Bobzin jest członkiem grupy eksperckiej JDO (JSR12). Prowadził prace związane z implementacją standardów JDO i ODMG 3.0 w firmie Poet Software, dostawcy obiektowych systemów baz danych.

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)