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.

 

Osoby które kupowały "Java Data Objects", wybierały także:

• Metoda dziel i zwyci 89,00 zł, (26,70 zł -70%)
• Język C. Kurs video. Praktyczne wprowadzenie do programowania 99,00 zł, (29,70 zł -70%)
• 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 125,42 zł, (45,15 zł -64%)
• Maven. Kurs video. Automatyzacja tworzenia aplikacji w Javie 98,98 zł, (39,59 zł -60%)

• 
• 
• 
• 
• 

Spis treści

Java Data Objects -- spis treści

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)