Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00624 008678 10481208 na godz. na dobę w sumie
Java Data Objects - książka
Java Data Objects - książka
Autor: , , , Liczba stron: 456
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-392-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

Użyj Java Data Objects --
przełomowej technologii trwałości obiektów na platformie Java

Książka 'Java Data Objects':

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'.

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

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.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI Java Data Objects KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Autorzy: Sameer Tyagi, Keiron McCammon, Michael Vorburger, Heiko Bobzin T³umaczenie: Jaromir Senczyk ISBN: 83-7361-392-7 Tytu³ orygina³u: Core Java Data Objects Format: B5, stron: 456 Przyk³ady na ftp: 107 kB 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. Spis treści O Autorach...................................................h...................................................h............... ..............................13 Przedmowa ...................................................h...................................................h................ ...........................15 Wstęp...................................................h...................................................h.................... ................................ 23 Część I Wprowadzenie 25 Rozdział 1. Przegląd specyfikacji JDO...................................................h................................................... 27 1.1. Powstanie specyfikacji JDO...................................................n.................................. 27 1.2. Obiektowy model dziedziny ...................................................n.................................. 27 1.3. Trwałość ortogonalna ...................................................n.......................................... 30 1.3.1. Obiekty trwałe i obiekty ulotne ...................................................n..................... 33 1.4. Środowiska zarządzane i niezarządzane ...................................................n................ 36 1.4.1. Środowiska niezarządzane...................................................n........................... 36 1.4.2. Środowiska zarządzane ...................................................n............................... 36 1.5. Role i obowiązki...................................................n.................................................. 37 1.5.1. Specyfikacje JDO ...................................................n........................................ 38 1.5.2. Obowiązki programisty ...................................................n................................ 38 1.5.3. Obowiązki producenta ...................................................n................................. 40 1.6. Podsumowanie ...................................................n...................................................n 41 Rozdział 2. Podstawowe zagadnienia dotyczące trwałości obiektów .................................................. 43 2.1. Trwałość i aplikacje...................................................n............................................. 43 2.2. Serializacja binarna JDK ...................................................n...................................... 44 2.2.1. Interfejs programowy serializacji............n...................................................n....... 44 2.2.2. Zarządzanie wersjami i serializacja...................................................n............... 46 2.2.3. Kiedy stosować serializację? ...................................................n....................... 47 2.2.4. Kiedy unikać stosowania serializacji? ...................................................n........... 48 2.3. Odwzorowania obiektowo-relacyjne ...................................................n....................... 48 2.3.1. Klasy i tablice...................................................n............................................. 49 2.3.2. Odwzorowania typów String, Date i innych...................................................n..... 50 2.3.3. Odwzorowanie dziedziczenia ...................................................n........................ 51 4 Java Data Objects 2.3.4. Bezpieczeństwo...................................................n.......................................... 53 2.3.5. Translacja języka zapytań ...................................................n............................ 54 2.3.6. Spójność referencyjna, usuwanie obiektów i inne zagadnienia ........................... 54 2.3.7. Trwałość transparentna i odwzorowania O/R...................................................n. 54 2.3.8. Identyfikacja...................................................n............................................... 55 2.4. Tworzenie własnej warstwy odwzorowania O/R ...................................................n...... 56 2.4.1. Buforowanie ...................................................n............................................... 56 2.4.2. Transakcyjny dostęp do bazy i obiekty transakcyjne .......................................... 57 2.4.3. Blokowanie ...................................................n................................................ 58 2.4.4. Tablice, zbiory, listy i mapy ...................................................n.......................... 58 2.4.5. Efektywność ...................................................n............................................... 59 2.4.6. Tworzyć samodzielnie czy kupować?...................................................n............. 59 2.5. Wnioski...................................................n...................................................n........... 60 Część II Szczegóły 63 Rozdział 3. Rozpoczynamy programowanie z użyciem JDO ...................................................h............... 65 3.1. Jak działa JDO? ...................................................n.................................................. 66 3.2. Podstawy JDO...................................................n...................................................n.. 69 3.3. Definiowanie klasy ...................................................n.............................................. 70 3.3.1. Metadane JDO................................n...................................................n............ 71 3.3.2. Odwzorowanie klasy do bazy danych...................................................n............. 72 3.4. Połączenie do bazy danych ...................................................n.................................. 72 3.5. Tworzenie obiektu ...................................................n............................................... 74 3.6. Wczytywanie obiektu ...................................................n........................................... 76 3.6.1. Wczytywanie przez nawigację ...................................................n....................... 76 3.6.2. Wczytywanie za pomocą interfejsu Extent ...................................................n..... 77 3.6.3. Wczytywanie przez zapytanie...................................................n........................ 78 3.7. Aktualizacja obiektu ...................................................n............................................ 79 3.8. Usuwanie obiektu ...................................................n............................................... 80 3.9. Model obiektowy JDO ...................................................n.......................................... 82 3.9.1. Typy podstawowe...................................................n........................................ 82 3.9.2. Referencje ...................................................n................................................. 83 3.9.3. Klasy kolekcji ...................................................n............................................. 87 3.9.4. Tablice...................................................n...................................................n.... 89 3.9.5. Dziedziczenie ...................................................n............................................. 90 3.9.6. Modyfikatory..................................n...................................................n............. 91 3.9.7. Ograniczenia JDO...................................................n........................................ 92 3.10. Obsługa wyjątków ...................................................n............................................. 92 3.11. Tożsamość obiektów ...................................................n......................................... 93 3.12. Typy tożsamości obiektów ...................................................n................................. 94 3.12.1. Tożsamość na poziomie bazy danych ...................................................n......... 95 3.12.2. Tożsamość na poziomie aplikacji ...................................................n............... 95 3.12.3. Tożsamość nietrwała ...................................................n................................ 98 3.13. Cykl życia obiektu ...................................................n............................................. 98 3.14. Sterowanie współbieżnością ...................................................n.............................. 99 3.14.1. Transakcje ACID ...................................................n..................................... 100 3.14.2. Transakcje optymistyczne...................................................n........................ 100 3.15. Podsumowanie ...................................................n............................................... 101 Spis treści 5 Rozdział 4. Cykl życia obiektów...................................................h............................................................103 4.1. Cykl życia obiektu trwałego ...................................................n................................ 103 4.1.1. Utrwalanie obiektu...................................................n.................................... 104 4.1.2. Odtwarzanie obiektów z bazy danych ...................................................n.......... 105 4.1.3. Uproszczony cykl życia obiektu...................................................n................... 107 4.2. Informacja o stanie obiektu ...................................................n............................... 108 4.3. Operacje powodujące zmianę stanu...................................................n.................... 109 4.3.1. PersistenceManager.makePersistent ...................................................n......... 110 4.3.2. PersistenceManager.deletePersistent ...................................................n........ 110 4.3.3. PersistenceManager.makeTransient...................................................n........... 110 4.3.4. Transaction.commit ...................................................n.................................. 110 4.3.5. Transaction.rollback...................................................n.................................. 110 4.3.6. PersistenceManager.refresh...................................................n...................... 110 4.3.7. PersistenceManager.evict ...................................................n......................... 111 4.3.8. Odczyt pól wewnątrz transakcji...................................................n................... 111 4.3.9. Zapis pól wewnątrz transakcji ...................................................n.................... 111 4.3.10. PersistenceManager.retrieve ...................................................n................... 111 4.4. Wywołania zwrotne...................................................n............................................ 111 4.4.1. Zastosowania metody jdoPostLoad ...................................................n............ 112 4.4.2. Zastosowania metody jdoPreStore ...................................................n............. 113 4.4.3. Zastosowania metody jdoPreDelete...................................................n............ 114 4.4.4. Zastosowania metody jdoPreClear...................................................n.............. 115 4.5. Stany opcjonalne ...................................................n.............................................. 115 4.5.1. Ulotne instancje transakcyjne ...................................................n.................... 116 4.5.2. Zastosowania ulotnych instancji transakcyjnych ............................................. 117 4.5.3. Instancje nietransakcyjne ...................................................n.......................... 117 4.5.4. Transakcje optymistyczne...................................................n.......................... 119 4.6. Przykłady...................................................n...................................................n....... 120 4.7. Podsumowanie ...................................................n................................................. 124 Rozdział 5. Programowanie w JDO ...................................................h......................................................125 5.1. Koncepcje JDO ...................................................n................................................. 125 5.1.1. Zdolność do trwałości ...................................................n............................... 126 5.1.2. Metadane JDO.................................n...................................................n......... 126 5.1.3. Domyślna grupa pobierania ...................................................n....................... 128 5.1.4. Trwałość poprzez osiągalność...................................................n.................... 128 5.1.5. Obiekty klas pierwszej i drugiej kategorii...................................................n..... 129 5.1.6. Tożsamość obiektów...................................................n................................. 130 5.1.7. Cykl życia obiektu ...................................................n..................................... 130 5.1.8. Transakcje ...................................................n............................................... 131 5.2. Interfejsy i klasy JDO ...................................................n......................................... 135 5.3. Podstawowe interfejsy JDO ...................................................n................................ 138 5.3.1. javax.jdo.PersistenceManagerFactory ...................................................n......... 138 5.3.2. PersistenceManager ...................................................n................................. 148 5.3.3. Extent...................................................n...................................................n... 165 5.3.4. Query...................................................n...................................................n.... 167 5.3.5. Transaction ...................................................n.............................................. 174 5.3.6. InstanceCallbacks ...................................................n.................................... 180 5.4. Klasy wyjątków ...................................................n................................................. 182 5.4.1. JDOException ...................................................n........................................... 183 5.4.2. JDOFatalException ...................................................n.................................... 183 6 Java Data Objects 5.4.3. JDOFatalUserException ...................................................n............................. 183 5.4.4. JDOFatalInternalException ...................................................n......................... 184 5.4.5. JDOFatalDataStoreException ...................................................n..................... 184 5.4.6. JDOOptimisticVerificationException ...................................................n............ 184 5.4.7. JDOCanRetryException ...................................................n.............................. 184 5.4.8. JDOUnsupportedOptionException ...................................................n............... 184 5.4.9. JDOUserException ...................................................n.................................... 185 5.4.10. JDODataStoreException ...................................................n.......................... 185 5.4.11. JDOObjectNotFoundException ...................................................n.................. 185 5.5. Dodatkowe interfejsy...................................................n......................................... 185 5.5.1. Klasa JDOHelper ...................................................n...................................... 185 5.5.2. Klasa I18NHelper ...................................................n..................................... 187 5.6. SPI ...................................................n...................................................n............... 187 5.6.1. PersistenceCapable ...................................................n.................................. 188 5.6.2. JDOPermission ...................................................n......................................... 188 5.6.3. JDOImplHelper ...................................................n......................................... 188 5.6.4. StateManager ...................................................n.......................................... 189 5.7. Podsumowanie ...................................................n................................................. 189 Rozdział 6. Wyszukiwanie danych...................................................h.........................................................191 6.1. Wyszukiwanie obiektu na podstawie tożsamości ...................................................n... 191 6.2. Wyszukiwanie zbioru obiektów za pomocą ekstensji................................................ 193 6.3. Wyszukiwanie obiektów za pomocą zapytań ...................................................n........ 194 6.3.1. Zapytania dla ekstensji ...................................................n............................. 197 6.4. JDOQL ...................................................n...................................................n.......... 197 6.4.1. Specyfikacja filtrów ...................................................n................................... 199 6.5. Zapytania, filtry i parametry opcjonalne...................................................n............... 204 6.5.1. Deklaracje parametrów ...................................................n............................. 204 6.5.2. Deklaracje poleceń importu ...................................................n....................... 206 6.5.3. Deklaracje zmiennych ...................................................n............................... 206 6.5.4. Uporządkowanie wyników zapytania...................................................n............ 207 6.5.5. Przestrzenie nazw w zapytaniach...................................................n................ 208 6.6. Więcej o interfejsie Query ...................................................n.................................. 208 6.6.1. Tworzenie zapytań ...................................................n.................................... 209 6.6.2. Zapytania i buforowanie ...................................................n............................ 209 6.6.3. Zapytania skompilowane ...................................................n........................... 210 6.6.4. Szablony zapytań ...................................................n...................................... 210 6.6.5. Wybór innego języka zapytań......................n...................................................n 212 6.7. Podsumowanie ...................................................n................................................. 212 Rozdział 7. Scenariusze i architektury ................h...................................................h...................... .........213 7.1. JDO i JDBC ...................................................n...................................................n.... 213 7.2. Rodzaje baz danych ...................................................n.......................................... 214 7.2.1. JDO i relacyjne bazy danych ...................................................n....................... 215 7.2.2. JDO i obiektowe bazy danych ...................................................n..................... 216 7.2.3. Porównania baz danych ...................................................n............................. 216 7.3. J2EE, RMI i CORBA ...................................................n........................................... 217 7.4. Środowiska zarządzane i niezarządzane ...................................................n.............. 218 7.4.1. Zarządzanie połączeniami...................................................n.......................... 219 7.4.2. Zarządzanie transakcjami ...................................................n.......................... 220 Spis treści 7 7.5. Aplikacje wielowątkowe ...................................................n..................................... 221 7.5.1. Programowanie wielowątkowe...................................................n.................... 221 7.5.2. Uproszczone programowanie wielowątkowe ...................................................n 222 7.6. Podsumowanie ...................................................n................................................. 222 Część III J2EE 223 Rozdział 8. JDO i JCA ...................................................h...................................................h.... .....................225 8.1. Wprowadzenie do JCA ...................................................n....................................... 225 8.2. JDO i JCA ...................................................n...................................................n...... 227 8.3. Wykorzystanie JDO i JCA...................................................n.................................... 227 8.3.1. Konfiguracja ...................................................n............................................. 228 8.3.2. Zarządzanie połączeniami...................................................n.......................... 228 8.3.3. Zarządzanie transakcjami ...................................................n.......................... 230 8.3.4. Bezpieczeństwo...................................................n........................................ 234 8.5. Wykorzystanie JDO bez JCA...................................................n................................ 234 8.6. Podsumowanie ...................................................n................................................. 235 Rozdział 9. JDO i Enterprise JavaBeans ...................................................h.............................................237 9.1. Wprowadzenie ...................................................n.................................................. 237 9.2. Komponenty sesyjne i JDO............................................n........................................ 239 9.2.1. Zarządzanie transakcjami ...................................................n.......................... 240 9.2.2. Przykład komponentu sesyjnego, który nie ma stannu i używa transakcji zarządzanych przez kontener ...................................................n.......................... 243 9.2.3. Przykład komponentu sesyjnego, który ma stan i użynwa transakcji zarządzanych przez kontener ...................................................n.......................... 245 9.2.4. Architektura zorientowana na usługi (SOA) ...................................................n.. 247 9.3. Komponenty sterowane komunikatami i JDO ...................................................n....... 257 9.3.1. Przykład kodu ...................................................n........................................... 258 9.4. Komponenty Entity i JDO ...................................................n................................... 259 9.4.1. Trwałość zarządzana przez komponent i JDO.................................................. 261 9.5. Kiedy używać EJB? ...................................................n............................................ 261 9.5.1. Skalowalne aplikacje JDO i łączenie w klastry ................................................ 265 9.5.2. Rozwiązania z transmisją w obu kierunkach ...................................................n 266 9.6. Podsumowanie ...................................................n................................................. 268 Rozdział 10. Bezpieczeństwo ...................................................h................................................................271 10.1. Poziomy bezpieczeństwa ...................................................n................................. 271 10.1.1. Bezpieczeństwo na poziomie pól i klas ...................................................n..... 271 10.1.2. Bezpieczeństwo na poziomie bazy danych...................................................n. 272 10.1.3. Bezpieczeństwo na poziomie aplikacji ...................................................n...... 273 10.2. Implementacja interfejsu PersistenceCapable ...................................................n... 273 10.2.1. Referencyjne narzędzie rozszerzania kodu...................................................n. 275 10.2.2. Zasady działania...................................................n..................................... 277 10.2.3. Śledzenie dostępu do pola ...................................................n...................... 279 10.2.4. Dostęp do metadanych ...................................................n........................... 282 10.2.5. Plik zasad bezpieczeństwa ...................................................n...................... 283 10.2.6. Problemy z bezpieczeństwem...................................................n................... 283 8 Java Data Objects 10.3. Bezpieczeństwo aplikacji ...................................................n................................. 284 10.3.1. Bezpieczeństwo połączeń ...................................................n........................ 284 10.3.2. Środowiska zarządzane ...................................................n........................... 285 10.3.3. Autoryzacja na poziomie aplikacji ...................................................n............. 285 10.4. Podsumowanie ...................................................n............................................... 286 Rozdział 11. Transakcje ...................................................h...................................................h.. ...................287 11.1. Koncepcje transakcji ...................................................n....................................... 287 11.1.1. Uczestnicy transakcji ...................................................n.............................. 288 11.1.2. Transakcje lokalne...................................................n.................................. 289 11.1.3. Transakcje rozproszone...................................................n........................... 289 11.1.4. Zatwierdzanie dwufazowe ...................................................n........................ 289 11.2. Transakcje i Java ...................................................n............................................ 292 11.2.1. Transakcje JDBC.............................n...................................................n........ 292 11.2.2. JTA i JTS ...................................................n................................................ 292 11.3. Transakcje w JDO ...................................................n........................................... 295 11.3.1. Konflikty podczas zatwierdzania transakcji optymistycznych........................... 301 11.3.2. Obiekty transakcyjne i nietransakcyjne ...................................................n..... 302 11.3.3. Zachowywanie i odtwarzanie wartości...................................................n....... 305 11.3.4. JDO i transakcje serwera aplikacji J2EE ...................................................n.... 306 11.3.5. Interfejs Transaction i synchronizacja za pomocą zwrotnych wywołań metod ... 314 11.4. Podsumowanie ...................................................n............................................... 314 Część IV Wnioski 315 Rozdział 12. JDO i JDBC...................................................h...................................................h.. .....................317 12.1. JDBC 2.0 i 3.0...................................................n................................................ 317 12.1.1. Podstawy JDBC ...................................................n...................................... 318 12.1.2. Historia JDBC ...................................................n......................................... 319 12.1.3. Nowe możliwości JDBC 3.0.......................n.................................................. 320 12.1.4. Rozszerzenia interfejsu JDBC...................................................n................... 321 12.2. Przykład: przechowywanie obiektów w relacyjnej bazie danych za pomocą JDBC ...... 322 12.3. Porównanie JDBC i JDO ...................................................n................................... 325 12.3.1. Porównanie możliwości JDBC i JDO ...................................................n.......... 328 12.3.2. Nieporozumienia związane z JDBC i JDO ...................................................n... 328 12.3.3. Kiedy używać JDBC ...................................................n................................. 333 12.3.4. Kiedy używać razem JDO i JDBC? ...................................................n............. 339 12.4. Podsumowanie ...................................................n............................................... 339 Rozdział 13. Wskazówki, triki i najlepsze rozwiązania...................................................h......................341 13.1. Modelowanie danych...................................................n....................................... 341 13.1.1. Wprowadzenie ...................................................n........................................ 341 13.1.2. Klasy obudowujące i typy podstawowe...................................................n...... 342 13.1.3. Referencje obiektów trwałych...................................................n................... 343 13.1.4. Pola o typie kolekcji ...................................................n................................ 343 13.1.5. Modelowanie związków odwrotnych ...................................................n.......... 346 13.1.6. Hierarchie dziedziczenia ...................................................n.......................... 348 13.1.7. Klasy świadome trwałości ...................................................n....................... 348 13.2. JDO i serwlety...................................................n................................................. 349 13.3. Wyodrębnienie klas należących do modelu dziedziny............................................. 352 Spis treści 9 13.4. Wykorzystanie XML-a jako formatu wymiany danych .............................................. 353 13.4.1. Wprowadzenie ...................................................n........................................ 354 13.4.2. Alternatywy...................................................n............................................. 355 13.4.3. Dostępne technologie ...................................................n............................. 355 13.4.4. Przykład ...................................................n................................................. 358 13.5. Kontrola poprawności danych...................................................n........................... 359 13.5.1. Wykorzystanie metody jdoPrestore interfejsu InstanceCallback ...................... 361 13.5.2. Wykorzystanie metody beforeCompletion() interfejsu Synchronization............. 362 13.6. Podsumowanie ...................................................n............................................... 365 Rozdział 14. Perspektywy...................................................h...................................................h. ................367 14.1. Zaawansowana semantyka transakcji ...................................................n............... 367 14.1.1. Zagnieżdżanie transakcji ...................................................n......................... 368 14.1.2. Punkty odwoływania transakcji ...................................................n................. 368 14.1.3. Jawne blokowanie...................................................n................................... 369 14.2. Optymalizacja wydajności ...................................................n................................ 369 14.3. Zarządzanie związkami ...................................................n.................................... 369 14.3.1. Związki dwukierunkowe ...................................................n........................... 370 14.3.2. Usuwanie kaskadowe................................................n................................. 370 14.3.3. Odzyskiwanie zasobów zajmowanych przez obiekty trwałe ............................. 371 14.4. Rozszerzenia zapytań ...................................................n...................................... 371 14.4.1. Łańcuchy ...................................................n............................................... 371 14.4.2. Operacje agregacji ...................................................n.................................. 371 14.4.3. Projekcje...................................................n................................................ 372 14.5. Odwzorowania obiektów..............................................n........................................ 372 14.6. Wzorzec wyliczenia ...................................................n.......................................... 372 14.7. Podsumowanie ...................................................n............................................... 373 Rozdział 15. Studium przypadku. Biblioteka JDO...................................................h................................375 15.1. Pliki, pakiety i model obiektowy...................................................n........................ 375 15.2. Pakiet model ...................................................n.................................................. 376 15.2.1. Klasa Publication...................................................n.................................... 376 15.2.2. Klasa Book ...................................................n............................................ 378 15.2.3. Klasa CD ...................................................n............................................... 378 15.2.4. Klasa Copy...................................................n............................................. 380 15.2.5. Klasa User ...................................................n............................................. 381 15.2.6. Klasy Right i Rights...................................................n................................. 383 15.3. Pakiet usecase...................................................n............................................... 385 15.3.1. Klasa AbstractUserCase........................n...................................................n.. 385 15.3.2. Przypadek AddBook ...................................................n................................ 388 15.4. Klasa BookOperation ...................................................n...................................... 390 15.4.1. Przypadek ListBooks ...................................................n............................... 392 15.4.2. Przypadek DetailedBook...................................................n.......................... 395 15.4.3. Przypadek EditBook ...................................................n................................ 396 15.4.4. Przypadek DeleteBook ...................................................n............................ 398 15.4.5. Klasa BorrowReturn ...................................................n................................ 399 15.4.6. Przypadek Borrow ...................................................n................................... 400 15.4.7. Przypadek Return...................................................n.................................... 400 15.5. Uruchamianie ...................................................n................................................. 400 15.5.1. Metadane XML ...................................................n....................................... 401 15.5.2. Uruchomienie z poziomu wiersza poleceń ...................................................n. 401 15.5.3. Uruchamianie serwletów ...................................................n......................... 402 10 Java Data Objects Dodatki 403 Dodatek A Stany JDO ...................................................h...................................................h...... ...................405 Dodatek B Metadane XML...................................................h...................................................h... ...............409 Dodatek C Język JDOQL w notacji BNF ...................................................h.................................................419 Dodatek D PersistenceManagerFactory — informator ...................................................h...................425 Dodatek E Implementacje JDO...................................................h..............................................................429 Skorowidz ...................................................h...................................................h................ ...........................441 Cykl życia obiektów W rozdziale tym omówimy cykl życia obiektów oraz przedstawimy powody, dla których zna- jomość zmian stanu obiektów JDO może być istotna dla programisty aplikacji. Dlaczego znajomość cyklu życia obiektu i zmian stanu jest tak ważna? Wyobraźmy sobie, jak działa maszyna wirtualna JVM, gdy aplikacja wywołuje operator PGY. Wiemy, że przy- dzielany jest odpowiedni obszar pamięci i zwracana jest jego referencja, ale w rzeczywisto- ści działanie maszyny wirtualnej jest bardziej skomplikowane. Najpierw może się okazać, że maszyna JVM musi załadować kod bajtowy z pewnego zasobu i przetłumaczyć go na in- strukcje macierzystego procesora. Wykonywana jest statyczna inicjacja, ładowane są klasy bazowe i wywoływane konstruktory. Jeszcze bardziej skomplikowany może być przebieg usuwania obiektu, w który zaangażowany będzie mechanizm odzyskiwania nieużytków, me- chanizm słabych referencji, kolejki i zwrotne wywołania metod HKPCNKG. Dlatego też ma- szyna wirtualna JVM musi dysponować dobrze zdefiniowanym modelem cyklu życia obiek- tów. Podobnym modelem cyklu dysponuje również implementacja JDO dla obiektów trwa- łych — rozpoczynają one życie jako zwykłe, ulotne obiekty języka Java, następnie uzyskują trwałość, mogą zostać usunięte bądź z powrotem przejść do stanu ulotnego i tak dalej. Zna- jomość cyklu życia obiektów trwałych w ogóle nie jest konieczna, zwłaszcza szczegółowa. Jeśli jednak aplikacja używa wywołań zwrotnych, to zalecane jest myślenie w kategoriach efektów ubocznych związanych ze stanami obiektów trweałych i ich zmianami. Najpierw omówione zostaną obowiązkowe i opcjonalne stany obiektów trwałych, metody umożliwiające określenie stanu obiektu oraz metody, których skutkiem jest zmiana stanu. Zmiany stanu obiektów trwałych zilustrowane zostaną fragmentami kodu źródłowego w ję- zyku Java wyświetlającymi dodatkowo informacje o stanie tych obiektów. Cześć poświęcona wywołaniom zwrotnym wyjaśni sposób i warunki ich użycia. Na końcu przedstawione zosta- ną te stany i operacje, które są w JDO opcjonalne. 4.1. Cykl życia obiektu trwałego JDO definiuje siedem stanów obowiązkowych i trzy staney opcjonalne. Stany VTCPUKGPV, RGTUKU VGPVPGY, RGTUKUVGPVPGYFGNGVGF, JQNNQY, RGTUKUVGPVENGCP, RGTUKUVGPVFKTV[ i RGTUKUVGPV 104 Część II n Szczegóły FGNGVGF są obowiązkowe. Stany VTCPUKGPVFKTV[, VTCPUKGPVENGCP i RGTUKUVGPVPQPVTCPUC EVKQPCN są opcjonalne i zostaną omówione w dalszej części rozdziału. Niektóre ze zmian stanu obiektu są bezpośrednio wywoływane przez aplikację — na przy- kład na skutek utrwalenia obiektu. Również rozpoczęcie lub zakończenie transakcji może wywołać zmianę stanu obiektu, czyli zachodzi ona na skutek wywołania przez aplikację jed- nej z metod DGIKP , EQOOKV lub TQNNDCEM klasy 6TCPUCEVKQP. Zauważmy, że w środo- wiskach zarządzanych zmiany stanu mogą być również wywoływane przez zewnętrzny kon- troler transakcji. Instancja języka Java rozpoczyna cykl życia JDO na skutek wywołania me- tody OCMG2GTUKUVGPV lub załadowania istniejącego obiektu trwałego z bazy edanych. Rozdział rozpoczniemy od omówienia dwóch typowych sekwencji utrwalania obiektów i odtwarzania ich na podstawie informacji zapisanych w bazie danych. Zilustrujemy je krót- kim przykładem kodu oraz pokażemy sposób użycia klasy , 1*GNRGT w celu uzyskania in- formacji o zmianach stanów zachodzących podczas wykoenywania wspomnianych sekwencji. 4.1.1. Utrwalanie obiektu Operacje prowadzące do utrwalenia obiektu mogą przebiegać w sposób przedstawiony na diagramie stanów (rysunek 4.1). Rysunek 4.1. Utrwalanie instancji ulotnych 4.1.1.1. Stan ulotny (transient) Instancje klasy zdolnej do trwałości zachowują się po ich utworzeniu za pomocą operatora PGY w taki sam sposób jak instancje każdej innej klasy języka Java. Modyfikacje pól tych in- stancji nie są śledzone, co w praktyce oznacza taką samą efektywność dostępu jak w przypa- dku instancji klas, które nie są zdolne do trwałości. Na instancje ulotne nie mają wpływu wywołania metod związanych z transakcjami czyli DGIKP , EQOOKV i TQNNDCEM z wyjąt- kiem sytuacji, w których instancje te są osiągalne zae pośrednictwem obiektów trwałych. 4.1.1.2. Stan persistent-new Wywołanie metody 2GTUKUVGPEG/CPCIGTOCMG2GTUKUVGPV przypisuje instancji nowy identy- fikator, a jej stan zmienia się z VTCPUKGPV na RGTUKUVGPVPGY. Obiekt w stanie RGTUKUVGPV PGY zachowuje się tak samo jak obiekt w stanie VTCPUKGPV, ale zapisywany jest w bazie da- nych podczas zatwierdzania transakcji lub gdy stan obiektu musi zostać zsynchronizowany ze stanem w wewnętrznych buforach JDO. Obiekt znajdujący się w stanie RGTUKUVGPVPGY Rozdział 4. n Cykl życia obiektów 105 jest już kontrolowany przez implementację JDO. Obiekty mogą przejść do stanu RGTUKUVGPV PGY również wtedy, gdy osiągalne są za pośrednictwem innych obiektów trwałych. Proces ten przebiega tak długo, aż wszystkie instancje osiągalne z danego obiektu znajdą się w stanie VTCPUKGPV lub RGTUKUVGPVPGY. Pomiędzy wywołaniem metody OCMG2GTUKUVGPV a zatwier- dzeniem transakcji referencje mogą ulec zmianie, a osiągalne instancje stać się niedostępne. Takie tymczasowo trwałe obiekty znajdują się również ew stanie RGTUKUVGPVPGY. Jednak ich stan może ulec zmianie podczas zatwierdzania transakcji, gdy okaże się, że tymczasowo trwałe obiekty nie są już osiągalne. 4.1.1.3. Stan pusty (hollow) Po pomyślnym zakończeniu transakcji stan obiektu zmienia się z RGTUKUVGPVPGY na JQNNQY. Obiekt w stanie pustym jest referencją, która może reprezentować pewne dane znajdujące się w bazie danych, ale które nie zostały jeszcze załadowane do pamięci lub są nieaktualne. Zwykle inni klienci bazy danych lub inne aplikacje JDO posiadają swobodny dostęp oraz możliwość modyfikacji danych w bazie, których referencją jest pusty obiekt. Gdy aplikacja będzie próbowała użyć obiektu w stanie pustym, to obowiązkiem implementacji jest ponowne załadowanie danych do pamięci. Scenariusz ten zostanie szczegółowo wyjaśniony nieco da- lej. Po zatwierdzeniu transakcji zawartość obiektów znajdujących się w stanie pustym zostaje usunięta w celu zwolnienia pamięci. Jeśli wśród tych danych znajdowały się referencje obie- któw, to mechanizmowi odzyskiwania nieużytków nie wolno zwolnić grafu obiektów. Stan pusty nie może zostać stwierdzony przez aplikację. Nie jest dostępna odpowiednia w tym celu metoda klasy , 1*GNRGT, a próba dostępu do pól takiego obiektu może spowo- dować zmianę jego stanu i nie jest wtedy możliwe okreeślenie poprzedniego stanu obiektu. 4.1.1.4. Stan persistent-new-deleted Gdy obiekt znajdujący się w stanie RGTUKUVGPVPGY zostaje usunięty przez wywołanie metody 2GTUKUVGPEG/CPCIGTFGNGVG2GTUKUVGPV , to jego stan zmienia się na RGTUKUVGPVPGYFGNGVGF. Przywrócenie takiego obiektu nie jest możliwe i stan RGTUKUVGPVPGYFGNGVGF jest osta- teczny do momentu zakończenia transakcji. Próba dostępu do pól obiektu znajdującego się w stanie RGTUKUVGPVPGYFGNGVGF spowoduje zgłoszenie wyjątku , 17UGT ZEGRVKQP. Nie dotyczy to jedynie pól wchodzących w skład klucza głównego. Po zakończeniu transakcji (poprzez wywołanie metody EQOOKV lub TQNNDCEM ) usunięta instancja przechodzi do stanu VTCPUKGPV. 4.1.2. Odtwarzanie obiektów z bazy danych Przejdziemy teraz do omówienia zmian stanów instancji, które zostają początkowo załado- wane z bazy danych. Diagram zmian stanów dla takich instancji przedstawiony został na rysunku 4.2 106 Część II n Szczegóły Rysunek 4.2. Odtwarzanie instancji z bazy danych 4.1.2.1. Stan pusty (hollow) Jak już wspomnieliśmy wcześniej, obiekty utworzone w celu reprezentacji referencji danych zapisanych w bazie danych, które nie zawierają jeszcze danych, znajdują się również w sta- nie pustym. Próba dostępu do ich pól powoduje załadowanie danych z bazy. Obiekty znaj- dujące się w stanie pustym tworzone są za pomocą wywołań metod takich jak ZVGPV KVGTCVQT PGZV , 2GTUKUVGPEG/CPCIGTIGV1DLGEV$[+F lub wykonania zapytania. Zwy- kle trwałe pola obiektów z stanie pustym inicjowane są za pomocą wartości domyślnych (0 lub PWNN), ale ponieważ obiekty takie tworzone są za pomocą konstruktorów nieposiadają- cych argumentów, to konstruktory te mogą nadawać tymże polom również inne wartości początkowe. Na tym może właśnie polegać jedyna różnica pomiędzy obiektami w stanie pu- stym, które brały wcześniej udział w transakcji (omówionymi w poprzednim punkcie), a obiektami w stanie pustym utworzonymi przez implementację JDO. 4.1.2.2. Stan persistent-clean Po nadaniu polom obiektu wartości pobranych z bazy danych obiekt taki przechodzi ze sta- nu JQNNQY do stanu RGTUKUVGPVENGCP, ale tylko wtedy, gdy jego dane nie zostały zmodyfi- kowane przez bieżącą transakcję. Stan te nosi taką nazwę (ang. clean — czysty), ponieważ dane obiektu w pamięci są spójne z odpowiadającymi im danymi w bazie. Chociaż pobraniem danych obiektu zajmuje się implementacja JDO, to referencje do innych obiektów rozwiązy- wane są przez instancję klasy 2GTUKUVGPEG/CPCIGT. Referencje te mogą wskazywać obiekty, które znajdują się już w pamięci. W przeciwnym razie 2GTUKUVGPEG/CPCIGT tworzy nowe obiekty w stanie pustym. Zasoby obiektów znajdujących się w stanie RGTUKUVGPVENGCP mogą zostać zwolnione przez mechanizm odzyskiwania nieużytków, jeśli w kodzie aplikacji nie istnieją już referencje do tych obiektów. Jeśli obiekty zostały rzeczywiście zwolnione przez ten mechanizm, to obowiązkiem klasy 2GTUKUVGPEG/CPCIGT jest buforowanie ich referencji i utworzenie nowych obiektów w stanie pustym, gdy oekaże się, że są one potrzebne. Rozdział 4. n Cykl życia obiektów 107 4.1.2.3. Stan persistent-dirty Obiekt przechodzi ze stanu JQNNQY lub RGTUKUVGPVENGCP do stanu RGTUKUVGPVFKTV[, gdy zmodyfikowane zostaje co najmniej jedno jego pole. Stan ten nosi taką nazwę (ang. dirty — brudny), ponieważ dane obiektu w pamięci przestają być spójne z danymi znajdującymi się w bazie. Nawet jeśli uzyskana w wyniku modyfikacji wartość pola jest taka sama jak poprzednia, to obiekt i tak przechodzi do stanu RGTUKUVGPVFKTV[. Co więcej, instancja nie powraca do stanu JQNNQY lub RGTUKUVGPVENGCP, gdy przywrócone zostaną poprzednie warto- ści pól. Gdy obiektowi znajdującemu się w stanie RGTUKUVGPVENGCP lub RGTUKUVGPVFKTV[ zostanie przypisana ulotna instancja, to obiekt takei nie przechodzi do stanu RGTUKUVGPVPGY. 4.1.2.4. Stan persistent-deleted Na skutek wywołania metody 2GTUKUVGPV/CPCIGTFGNGVG2GTUKUVGPV stan obiektu trwałe- go zmienia się na RGTUKUVGPVFGNGVGF. Opuszczenie tego stanu czyli przywrócenie usuniętej instancji trwałej możliwe jest jedynie poprzez przerwanie transakcji. Pomyślne zatwierdze- nie transakcji powoduje przejście obiektu ze stanu RGTUKUVGPVFGNGVGF do stanu VTCPUKGPV. Obiekt nie może zostać ponownie utrwalony z tą samą tożsamością tak długo jak znajduje się w stanie RGTUKUVGPVFGNGVGF. 4.1.3. Uproszczony cykl życia obiektu Diagram zamieszczony na rysunku 4.3 przedstawia uproszczony cykl życia obiektu. Obszar obwiedziony prostokątem Odczyt zawiera stany, w których odczyt (dostęp) obiektu nie po- woduje zmiany ich stanu. Prostokąt Zapis zawiera stany, w których modyfikacja obiektu nie powoduje zmiany ich stanu. Rysunek 4.3. Cykl życia obiektu — stany obowiązkowe 108 Część II n Szczegóły 4.2. Informacja o stanie obiektu Wymienionych wcześniej siedem stanów: VTCPUKGPV, RGTUKUVGPVPGY, RGTUKUVGPVPGYFGNG VGF, JQNNQY, RGTUKUVGPVENGCP, RGTUKUVGPVFKTV[ i RGTUKUVGPVFGNGVGF jest obowiązkowych dla wszystkich implementacji JDO. Jednak implementacje JDO nie udostępniają żadnego interfejsu programowego, który umożliwiałby uzyskanie informacji o stanach, w których znajdują się obiekty JDO. Dokładny stan obiektu znany jest jedynie implementacji JDO, a niektóre stany mogą nawet nie być implementowane przez pewnych producentów. Stany obiektów JDO są zdefiniowane bowiem w sposób behawioralny. Mimo to istnieją pewne metody, które pozwalają sprawdzić atrybuty trwałości dla danego obiektu i na ich podsta- wie wnioskować o stanie obiektu. Metody te należą do klasy , 1*GNRGT: DQQNGCPKU GNGVGF 1DLGEVQ DQQNGCPKU KTV[ 1DLGEVQ DQQNGCPKU0GY 1DLGEVQ DQQNGCPKU2GTUKUVGPV 1DLGEVQ DQQNGCPKU6TCPUCEVKQPCN 1DLGEVQ Nie istnieje natomiast metoda, która pozwalałaby ustalić, czy obiekt znajduje się w stanie pustym. Sposób ładowania zawartości takiego obiektu zależy bowiem od konkretnej imple- mentacji. W dalszej części rozdziału przedstawimy jednak inny sposób, który pozwala uzy- skać informację o tym, czy obiekt znajduje się w stanie pustym. Przedstawiona poniżej kla- sa wyświetla znaczniki instancji, posługując się klaseą , 1*GNRGT: RWDNKEENCUU ZCORNG ] RWDNKEUVCVKEXQKFRTKPV+PHQ 5VTKPIOUI1DLGEVQDL ] 5VTKPI$WHHGTDWHPGY5VTKPI$WHHGT OUI  KH , 1*GNRGTKU2GTUKUVGPV QDL DWHCRRGPF RGTUKUVGPV  KH , 1*GNRGTKU0GY QDL DWHCRRGPF PGY  KH , 1*GNRGTKU KTV[ QDL DWHCRRGPF FKTV[  KH , 1*GNRGTKU GNGVGF QDL DWHCRRGPF FGNGVGF  KH , 1*GNRGTKU6TCPUCEVKQPCN QDL DWHCRRGPF VTCPUCEVKQPCN  5[UVGOQWVRTKPVNP DWHVQ5VTKPI  _ _ Poniższy fragment kodu ilustruje omówione dotąd stanye i metody: RWDNKEUVCVKEXQKFOCKP 5VTKPICTIU=? ] 2GTUKUVGPEG/CPCIGTROROHIGV2GTUKUVGPEG/CPCIGT  ROEWTTGPV6TCPUCEVKQP DGIKP  $QQMDQQMPGY$QQM  Rozdział 4. n Cykl życia obiektów 109 RTKPV+PHQ PQYCKPUVCPELCMNCU[$QQMDQQM  ROOCMG2GTUKUVGPV DQQM  RTKPV+PHQ VTYCđCKPUVCPELCMNCU[$QQMDQQM  ROFGNGVG2GTUKUVGPV DQQM  RTKPV+PHQ WUWPKúVCKPUVCPELCMNCU[$QQMDQQM  ROEWTTGPV6TCPUCEVKQP TQNNDCEM  RTKPV+PHQ QFYQđCPKGVTCPUCMELKDQQM  ROEWTTGPV6TCPUCEVKQP DGIKP  ROOCMG2GTUKUVGPV DQQM  ROEWTTGPV6TCPUCEVKQP EQOOKV RTKPV+PHQ CVYKGTFGPKGVTCPUCMELKDQQM  ROEWTTGPV6TCPUCEVKQP DGIKP  5VTKPIVKVNGDQQMVKVNG RTKPV+PHQ QFE[VRQNCDQQM  DQQMVKVNGPQYC DQQMVKVNG RTKPV+PHQ OQF[HKMCELCRQNCDQQM  ROFGNGVG2GTUKUVGPV DQQM  RTKPV+PHQ WUWPKúVCKPUVCPELCMNCU[$QQMDQQM  ROEWTTGPV6TCPUCEVKQP EQOOKV  RTKPV+PHQ CVYKGTFGPKGVTCPUCMELKDQQM  _ Wykonanie powyższego kodu spowoduje wyświetlenie naestępującego tekstu: PQYCKPUVCPELCMNCU[$QQMFKTV[ VTYCđCKPUVCPELCMNCU[$QQMRGTUKUVGPVPGYFKTV[ WUWPKúVCKPUVCPELCMNCU[$QQMRGTUKUVGPVPGYFKTV[FG NGVGF QFYQđCPKGVTCPUCMELKFKTV[ CVYKGTFGPKGVTCPUCMELKRGTUKUVGPV QFE[VRQNCRGTUKUVGPV OQF[HKMCELCRQNCRGTUKUVGPVFKTV[ WUWPKúVCKPUVCPELCMNCU[$QQMRGTUKUVGPVFKTV[FGNGVG F CVYKGTFGPKGVTCPUCMELKFKTV[ 4.3. Operacje powodujące zmianę stanu W poprzednim podrozdziale przestawiliśmy podstawowe stany obiektów oraz operacje ta- kie jak odczyt pola lub usunięcie obiektu trwałego z bazy, które w oczywisty sposób zmie- niają stan obiektów. W tym podrozdziale przyjrzymy się bliżej metodom zmieniającym stan obiektów i wyjaśnimy ich działanie bardziej szczegółowo. Niektóre z tych metod zmieniają stan obiektów na skutek bezpośredniego ich wywołania, inne wpływają pośrednio na stan wielu obiektów. 110 Część II n Szczegóły 4.3.1. PersistenceManager.makePersistent Metoda OCMG2GTUKUVGPV klasy 2GTUKUVGPEG/CPCIGT powoduje przejście ulotnych obiektów do stanu RGTUKUVGPVPGY. Podczas wykonania tej metody przeglądany jest graf obiektu w celu znalezienia innych obiektów znajdujących się jeszcze w stanie VTCPUKGPV. Również te obiekty mogą niejawnie przejść do stanu RGTUKUVGPVPGY. 4.3.2. PersistenceManager.deletePersistent Wywołanie metody FGNGVG2GTUKUVGPV powoduje przejście obiektu ze stanu RGTUKUVGPVENGCP, RGTUKUVGPVFKTV[ lub JQNNQY do stanu RGTUKUVGPVFGNGVGF, natomiast obiekty znajdujące się dotychczas w stanie RGTUKUVGPVPGY przechodzą do stanu RGTUKUVGPVPGYFGNGVGF. Ope- racja ta nie ma wpływu na inne osiągalne obiekty. 4.3.3. PersistenceManager.makeTransient Obiekt może przejść do stanu VTCPUKGPV pod warunkiem, że jego obecnym stanem jest RGT UKUVGPVENGCP lub JQNNQY. Na skutek wywołania metody OCMG6TCPUKGPV obiekt taki zostaje wyjęty spod kontroli instancji klasy 2GTUKUVGPEG/CPCIGT i traci swoją tożsamość. Metoda ta nie wywiera wpływu na inne obiekty osiągalne za pośrednictwem obiektu, który był jej pa- rametrem wywołania. 4.3.4. Transaction.commit Instancje należące do bieżącej transakcji są przetwarzane przez JDO podczas jej zatwierdza- nia, instancje znajdujące się w stanie JQNNQY nie zmieniają swojego stanu, natomiast instan- cje znajdujące się w stanie PGY, ENGCP lub FKTV[ przechodzą do stanu JQNNQY. Wszystkie in- ne instancje stają się ulotne. Po zatwierdzeniu instancji obiekty znajdujące się w stanie pustym oraz zwykłe, ulotne obiekty języka Java pozostają pod kontrolą instancji klasy 2GTUKUVGP EG/CPCIGT. 4.3.5. Transaction.rollback Na skutek odwołania transakcji obiekty znajdujące się w stanie ENGCP, FKTV[ lub FGNGVGF przechodzą do stanu JQNNQY. Pozostałe obiekty stają się ulotne. Obiekty, które znajdowały się w stanie JQNNQY lub VTCPUKGPV powracają do swojego poprzedniego stanu. 4.3.6. PersistenceManager.refresh Wywołanie metody TGHTGUJ powoduje ponowne załadowanie danych obiektu z bazy na sku- tek czego wszelkie modyfikacje obiektu zostają utracone. Metoda ta przeprowadza obiekty ze stanu RGTUKUVGPVFKTV[ do stanu RGTUKUVGPVENGCP. Rozdział 4. n Cykl życia obiektów 111 4.3.7. PersistenceManager.evict Metoda ta umożliwia zaoszczędzenie pamięci przez implementację buforowania stosowaną w klasie 2GTUKUVGPEG/CPCIGT. Na skutek jej użycia obiekty przechodzą ze stanu RGTUKUVGPV ENGCP do stanu JQNNQY. Wartości pól obiektów są przy tym usuwane, aby umożliwić mechani- zmowi odzysku nieużytków zwolnienie podobiektów. 4.3.8. Odczyt pól wewnątrz transakcji Po wczytaniu danych z bazy obiekty przechodzą ze stanu JQNNQY do stanu RGTUKUVGPVENGCP. Gdy stosowany jest pesymistyczny algorytm zarządzania współbieżnością, to obiekt może zostać zablokowany dla zapobieżenia równoczesnej moedyfikacji. 4.3.9. Zapis pól wewnątrz transakcji Gdy podczas wykonywania transakcji zmodyfikowane zostaje pole obiektu znajdującego się pod kontrolą instancji klasy 2GTUKUVGPEG/CPCIGT, to implementacja JDO musi zapamię- tać, że należy później zaktualizować dane tego obiektu w bazie. Obiekt przechodzi wtedy ze stanu RGTUKUVGPVENGCP lub JQNNQY do stanu RGTUKUVGPVFKTV[. Jeśli stosowany jest pe- symistyczny algorytm zarządzania współbieżnością, to implementacja JDO może zabloko- wać dostęp do obiektu innym klientom tej samej bazy danych. Modyfikacja wartości pól obiektów znajdujących się w stanie VTCPUKGPV, RGTUKUVGPVFKTV[ lub RGTUKUVGPVPGY pozo- staje bez wpływu na stan takich obiektów. Gdy polu obiektu przypisywany jest inny obiekt, to zmodyfikowany obiekt przechodzi do stanu RGTUKUVGPVFKTV[, a obiekt przypisany nie zmienia swojego stanu. 4.3.10. PersistenceManager.retrieve Wywołanie metody 2GTUKUVGPEG/CPCIGTTGVTKGXG ma ten sam skutek, co odczyt pola obie- ktu podczas bieżącej transakcji. 4.4. Wywołania zwrotne Implementując metody wywoływane zwrotnie aplikacja może przejąć obsługę części omó- wionych wydarzeń występujących w cyklu życia obiektu. Istnieją w zasadzie trzy sytuacje, w których programista aplikacji może zaimplementować w ten sposób specjalne zachowa- nie obiektów trwałych: n odczyt lub zapis wartości pól, które nie są trwałe leub nie powinny być przetwarzane przez domyślny algorytm JDO, n usuwanie obiektów składowych, n usuwanie zbędnych referencji. 112 Część II n Szczegóły Metody wywoływane zwrotnie umieszczone zostały w osobnym interfejsie, którego obsłu- ga przypomina sposób obsługi interfejsu etykietowego LCXCKQ5GTKCNKCDNG. Jeśli klasa zdolna do trwałości implementuje interfejs +PUVCPEG CNNDCEMU, to jest to sygnałem dla im- plementacji JDO, że należy użyć wywołań zwrotnych. W przeciwnym razie nie są one wy- korzystywane. 4.4.1. Zastosowania metody jdoPostLoad Metoda LFQ2QUV.QCF wywoływana jest za każdym razem, gdy obiekt trwały zostaje załado- wany z bazy danych czyli, gdy jego stan zmienia się z JQNNQY na RGTUKUVGPVENGCP. Dokład- niej rzecz ujmując, metoda ta jest wywoływana w momencie, gdy dane obiektu stają się spój- ne z danymi zapisanymi w bazie danych. Interfejs InstanceCallbacks Jeśli klasa implementuje interfejs +PUVCPEG CNNDCEMU, to metody LFQ2QUV.QCF, LFQ 2TG5VQTG, LFQ2TG NGCT i LFQ2TG GNGVG są automatycznie wywoływane przez imple- mentację JDO, gdy pola instancji są odczytywane, modyfikowane, zerowane lub obiekty są usuwane. W przeciwieństwie do interfejsu 5GTKCNKCDNG klasa odpowiedzialna jest za wywołanie metod interfejsu +PUVCPEG CNNDCEMU swojej klasy bazowej. Metody inter- fejsu +PUVCPEG CNNDCEMU zadeklarowane są jako metody o dostępie publicznym i dla- tego należy zwrócić uwagę, by nie wywoływać ich w innycmh sytuacjach. Implementując metodę LFQ2QUV.QCF, możemy zaoszczędzić na kodzie sprawdzającym po- czątkowe przypisanie wartości ulotnych, ponieważ JDO definiuje, że metoda ta wywoły- wana jest dokładnie raz. Klasa może więc zaimplementować metodę LFQ2QUV.QCF, aby przypisać wartości początkowe polom ulotnym, zwłaszcza gdy zależą one od wartości pól trwałych. Możliwość taka jest szczególnie przydatna, gdy ustalenie tych wartości wymaga skomplikowanych obliczeń, które nie powinny być wykeonywane wielokrotnie. Inne zastosowanie może polegać na rejestrowaniu przez obiekty aplikacji załadowania obiektów trwałych z bazy danych. Na przykład w celu odroczenia inicjacji kolekcji do momentu rzeczywistego jej użycia, co pozwala zaoszczędzić pamięć i zwiększyć efektyw- ność działania programu: RWDNKEENCUU$QQM KORNGOGPVULCXCZLFQ+PUVCPEG CNNDCEMU ] VTCPUKGPV/CRO[/CRPCTCKGPKGLGUVCKPKELQYCPC RWDNKE$QQM 5VTKPIVKVNG ]Wľ[YCP[RTGCRNKMCELú  _ RTKXCVG$QQM ]Wľ[YCP[RTG, 1 _ RWDNKEXQKFLFQ2QUV.QCF ] O[/CRPGY*CUJ/CR KPKELQYCPCRQFECUđCFQYCPKC _ Rozdział 4. n Cykl życia obiektów 113 RQQUVCđGOGVQF[Y[YQđ[YCPGYTQVPKG RWDNKEXQKFLFQ2TG5VQTG ] _ RWDNKEXQKFLFQ2TG GNGVG ] _ RWDNKEXQKFLFQ2TG NGCT ] _ _ 4.4.2. Zastosowania metody jdoPreStore Metoda ta wywoływana jest przed zapisaniem pól do bazy danych. Jedno z zastosowań tej metody polega na aktualizacji wartości pól trwałych na podstawie pól, które nie są trwałe przed zakończeniem transakcji. Metoda może być również wykorzystana w celu sprawdze- nia, czy wartości pól trwałych są spójne lub spełniają ograniczenia. W przypadku, gdy war- tość pola narusza zdefiniowane ograniczenia, aplikacja może uniemożliwić ich zapisanie w bazie danych, zgłaszając wyjątek. Jednak obiekty biznesowe powinny udostępniać meto- dy walidacji umożliwiające sprawdzenie zgodności z nałożonymi ograniczeniami. Metody te powinny być wywoływane przez aplikację przed zapiesaniem danych w bazie. Powiązanie tego rodzaju walidacji ze szkieletem trwałości nie jest dobrą praktyką. Metody LFQ2TG5VQTG należy raczej używać w celu wykrycia błędnych wartośeci pojawiających się w programie. Poniżej przedstawiamy sposób aktualizacji pola będącego tablicą bajtów za pomocą strumie- nia serializowanych obiektów, które nie są trwałe: RWDNKEENCUU$QQM KORNGOGPVU+PUVCPEG CNNDCEMU ] VTCPUKGPV QNQTO[ QNQTRQNGPKGLGUVVTYCđG RTKXCVGD[VG=?CTTC[QDUđWIKYCPCRTGYKúMUQħèKORNGOG PVCELK, 1 RWDNKEXQKFLFQ2QUV.QCF ] 1DLGEV+PRWV5VTGCO
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:


Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: