06 lutego 2007

Java Persistence - Rozdział 3.2 Cykl rozwojowy instancji encji

0 komentarzy
Jestem przekonany! Głos społeczności jest dla mnie równie ważny jak mój własny ;-) Zatem przyzwyczajam się powoli do lifecycle == cykl życia/rozwojowy, chociaż stadia rozwojowe byłoby równie dobre...chyba.

Co nam przynosi rozdział 3.2 Cykl rozwojowy instancji encji (Entity Instance’s Life Cycle)? Duuużo dobrej wiedzy, której zawsze mi brakowało. Niby oczywiste, ale diabeł tkwi w szczegółach, a te szczegóły później pojawiają się, kiedy już właśnie wychodziliśmy do domu przez finalnym oddaniem projektu, albo w innych temu podobnych sytuacjach. Istotne jest, że czytając specyfikację JPA w zasadzie można poskromić i inne rozwiązania, niekoniecznie związane z JPA. Pierwszym rozwiązaniem, które przychodzi do głowy (a jest związane z JPA) to Hibernate, ale są i inne - np. Apache Cayenne. Tak, czy owak, cieszę się, że w końcu doczekałem się specyfikacji EJB3, która cieszy i jednocześnie uczy dobrych praktyk (np. konieczność użycia interfejsów do eksponowania metod biznesowych), a nie zniewala w kajdany hierarchii klas, itp. Jestem na stronie 53 specyfikacji (z 256 dostępnych), więc chwila uniesienia zawsze wskazana dla poprawienia samopoczucia. W takim tempie analizy specyfikacji nie doczekam się końca przez gwiazdką (a gdzie tu czas na inne przyjemności duchowe?!).

Rozdział 3.2 opisuje sposób zarządzania cyklem życia instancji encji przez EntityManager (głównodowodzący w armii o kryptonimie JPA).

Wyróżniamy 4 stadia rozwojowe encji (ach, to tutaj powinienem użyć tego wyrażenia!):
  • nowy (właśnie stworzony, ang. new) - brak trwałego bytu (identyfikatora) i powiązania z kontekstem utrwalania
  • zarządzany (ang. managed) - odwrotność encji w stanie 'nowa', tj. instancja posiada trwały identyfikator oraz jest związana z kontekstem utrwalania
  • odłączony (ang. detached) - instancja encji z trwałym identyfikatorem, ale niezwiązana z kontekstem utrwalania (literacko możnaby ten stan opisać jako 'uwolniony od karbów kontekstu utrwalania' ;-))
  • usunięty/zniszczony (ang. removed) - instancja z trwałym identyfikatorem, związana z kontekstem utrwalania, która oczekuje usunięcia z bazy danych (innymi słowy, jest to analogiczne do stadium 'zarządzany' za wyjątkiem oznaczenia instancji do trwałego skasowania)
Poszczególne podpunkty opisują dokładnie efekt operacji EntityManager na encje w poszczególnych stadiach. Użycie elementu cascade w adnotacjach służy do propagowania działania operacji EntityManager na encji i jej powiązane relacją encje. Mechanizm cascade najczęściej wykorzystywany jest w relacjach typu rodzic-dziecko (gdzie istnienie dziecka jest nieuzasadnione w przypadku usunięcia rodzica).

3.2.1 Utrwalanie instancji encji

Nowa encja (w sensie jej cyklu rozwojowego) staje się zarządzana (a tym samym i utrwalona) przez wykonanie metody persist na niej lub jako efekt utrwalania rodzica (efekt elementu cascade, dalej zwany efektem "kaskadowym").

Działanie operacji persist
  • Jeśli encja jest nowa, staje się zarządzaną. Encja będzie zapisana do bazy w przed lub w trakcie zatwierdzenia tranzakcji lub w wyniku operacji flush.
  • Jeśli encja już istnieje i stan odpowiada stanowi w bazie, metoda persist ignoruje polecenie zapisu encji. Jednakże, operacja jest wykonywana kaskadowo na encjach z nią związanych, jeśli relacja, od jej strony, oznaczona jest cascade=PERSIST lub cascade=ALL (lub odpowiednio zdefiniowana w deskryptorze).
  • Jeśli encja jest usunięta, stanie się zarządzana
  • Jeśli X jest odłączona, rzucony może być wyjątek EntityExistsException podczas wywołania persist, a EntityExistsException lub podtypy PersistenceException podczas operacji flush lub zatwierdzenia tranzakcji
  • Dla wszystkich encji Y będących w relacji z X, jeśli relacja do Y została udekorowana cascade=PERSIST lub cascade=ALL, operacja persist zostanie wykonana na Y (wydaje się jakby powtórzono punkt z encją w stanie zarządzania, jednakże tutaj jest ogólniej i dotyczy pozostałych stanów, np. usunięty)
3.2.2 Usunięcie

Encja zarządzana przechodzi w stan usunięty po wywołaniu operacji remove lub w efekcie wykonania "kaskadowego" remove na rodzicu.

Działanie operacji remove
  • Jeśli encja jest nowa, metoda remove ignoruje polecenie skasowania encji. Jednakże, operacja jest wykonywana kaskadowo na encjach z nią związanych, jeśli relacja, od jej strony, oznaczona jest z cascade=REMOVE lub cascade=ALL (lub odpowiednio zdefiniowana w deskryptorze).
  • Jeśli encja jest zarządzana, encja przechodzi w stan usunięty. Operacja jest wykonywana kaskadowo na encjach z nią związanych, jeśli relacja, od jej strony, oznaczona jest z cascade=REMOVE lub cascade=ALL.
  • Jeśli encja jest odłączona, pojawi się wyjątek IllegalArgumentException bądź zatwierdzenie tranzakcji zakończy się niepowodzeniem.
  • Jeśli encja jest usunięta, metoda remove ignoruje ją (wywołanie metody remove nie ma żadnego wpływu na stan encji)
  • Usunięta encja będzie usunięta z bazy danych podczas lub przed zatwierdzeniem tranzakcji lub jako wynik operacji flush.
Po skasowaniu encji, jej stan (poza ogólnym stanem, jeśliby traktować instancję encji jak zwykłą instancję) będzie odpowiadał stanowi w momencie wywołania operacji remove.

3.2.3 Synchronizacja z bazą danych

Stan trwałych encji jest synchronizowany z bazą danych podczas zatwierdzenia tranzakcji (nie można było napisać, że zapis stanu instancji następuje w trakcie zatwierdzenia tranzakcji? Czyżbym coś ignorował takim stwierdzeniem? Chyba tak, ponieważ zmiany mogą nadejść od strony bazy danych. Czytam dalej oczekując dalszych wyjaśnień). Synchronizacja obejmuje zapis do bazy danych zmian w trwałym stanie encji i ich relacji z innymi, jak opisano wcześniej (patrz: punkty o persist i remove).

Uaktualnienie stanu encji obejmuje ustawienie nowej wartości do trwałego pola lub właściwości (dla przypomnienia: właściwość to pole z metodami operującymi na nim - setter/getter) bądź zmiany wartości modyfikowalnego, trwałego pola lub właściwości.

Synchronizacja z bazą danych nie obejmuje odświeżenia encji zarządzanych chyba, że explicite wywołano operację refresh (i tutaj jest odpowiedź na moje pytanie wyżej, gdzie zastanawiałem się o możliwości napłynięcia modyfikacji z bazy danych - warto było czekać!).

Dwukierunkowe relacje będą utrwalane opierając się na konfiguracji po stronie początkowej (właściciela) relacji. W gestii programisty pozostaje utrzymywanie, trzymanych w pamięci, poprawnych wartości referencji encji po ich zmianie, po obu stronach relacji. W przypadku jednokierunkowej relacji jeden-do-jednego lub jeden-do-wielu, obowiązkiem programisty jest zapewnienie, że semantyka relacji jest zgodna (np. podczas braku ustawienia unikatowości w mapowaniu, a jej obecności w bazie danych).

Pojawia się uwaga, o zapewnieniu poprawnego uaktualniania strony inicjującej (początkowej) relacji podczas modyfikacji po stronie końcowej relacji, aby zmiany zostały utrwalone podczas synchronizacji (hmmm, a o czym jest tutaj mowa?!)

Dostawca JPA ma prawo utrwalać zmiany (wykonywać synchronizację) w dowolnych momentach w trakcie trwania tranzakcji. Operacja flush wymusza synchronizację, jednakże dotyczy to wyłącznie encji związanych z kontekstem utrwalania (a przez to nie dotyczy to nowych, które nie są z nim związane). Metoda setFlushMode w EntityManager oraz Query umożliwia kontrolę wykonania synchronizacji.

Wyróżniamy 2 ustawienia trybu flush (klasa javax.persistence.FlushModeType):
  • AUTO - (domyślna wartość) synchronizacja następuje podczas wykonywania zapytań, gwarantując ich poprawne działanie - operacje Query (więcej w nadchodzącej sekcji)
  • COMMIT - synchronizacja następuje wyłącznie podczas zatwierdzania tranzakcji (porównując z Javadoc klasy FlushModeType wydaje się być w rozbieżności względem specyfikacji, która stwierdza, że dostawca JPA ma prawo wykonać synchronizację również w innych momentach trwania tranzakcji. Piszę na grupę!).
Jeśli tranzakcja nie jest aktywna, dostawcy nie wolno synchronizować stanu z bazą.

Działanie operacji flush
  • Jeśli encja jest zarządzana, następuje synchronizacja jej stanu z bazą danych:
    • Wszyskie encje z nią związane przez relację, która oznaczona jest od jej strony jako cascade=PERSIST lub cascade=ALL są również synchronizowane
    • Jeśli jakakolwiek encja Y związana z synchronizowaną encją poprzez relację nie oznaczoną cascade=PERSIST lub cascade=ALL, wtedy:
      • Jeśli encja Y jest nowa lub usunięta, rzucony zostanie wyjątek IllegalStateException podczas flush (i automatycznie nastąpi wycofanie tranzakcji) lub zatwierdzenie tranzakcji nie powiedzie się
      • Jeśli encja Y jest odłączona, działanie flush jest zależne od strony początkowej relacji (która spowodowała zaangażowanie encji Y). Jeśli X jest właścicielem relacji, dowolne zmiany w relacji są synchronizowane z bazą, w przeciwnym przypadku, jeśli Y jest właścicielem relacji, zachowanie flush jest nieokreślone (!)
  • Jeśli encja jest usunięta, jest ona kasowana z bazy danych. Wartości elementu cascade są nieistotne.
3.2.4 Encje odłączone

Przejście encji do stanu odłączony może nastąpić w wyniku zajścia następujących sytuacji:
  • Zatwierdzenie tranzakcji w przypadku użycia tranzakcyjnego zarządcy encji zarządzanym przez kontener/serwer aplikacyjny (ang. transaction-scoped container-managed entity manager) - więcej w kolejnej sekcji
  • Wycofanie tranzakcji - więcej w kolejnej sekcji
  • Wyczyszczenie kontekstu utrwalania (prościej: w wyniku wywołania metody clear, która wszystkie związane encje przenosi w stan odłączenia)
  • Zamknięcie zarządcy encji (EntityManager)
  • Wykonanie serializacji encji (bezpośrednio) bądź (pośrednio) przekazując encję przez wartość, np. jako rezultat wywołania metody zdalnego interfejsu komponentu
Odłączone encje działają w tym stanie jakby były zwykłymi klasami (można przyjąć, że są pozbawione świadomości swojego trwałego bytu, a przez to nie będą synchronizowane z ich stanem w bazie danych).

Aplikacje mogą korzystać z dostępnego stanu odłączonych encji po zakończeniu działania kontekstu utrwalania (w zasadzie to nie ma już znaczenia, bo i tak nie są z nim związane). Dostępny stan to:
  • Dowolne pole i właściwość nie określona przez fetch=LAZY
  • Dowolne pole i właściwość, które były pobierane przez aplikację (które zdążyły się zainicjować)
Jeśli trwałe pole/właściwość jest asocjacją, dostępny stan związanej instancji może być poprawnie pobrany jeśli związana instancja jest dostępna (Co to ma być?! Mam po tym więcej pytań niż odpowiedzi!). Dostępnymi instancjami są:
  • Dowolna instancja encji pobrana korzystając z operacji find
  • Dowolna instancja encji pobrana poprzez zapytanie lub bezpośrednio pobrana w klauzuli FETCH JOIN
  • Dowolna instancja encji, której zmienne instancji przechowująca trwały stan, inny niż klucz główny, były odczytywane przez aplikację
  • Dowolna instanacja encji, do której można dotrzeć z innej dostępnej instancji encji poprzez relację oznaczoną fetch=EAGER
3.2.4.1 Uwspólnienie stanu odłączonej encji

Operacja merge pozwala na dystrybucję stanu z odłączonej encji do encji trwałych zarządzanych przez EntityManager (czyli nowe odpadają, nieprawdaż?)

Działanie operacji merge
  • Jeśli encja jest odłączona, stan jest kopiowany do encji poprzednio związanej z kontekstem utrwalania dla tego samego identyfikatora lub tworzona jest nowa encja zarządzana
  • Jeśli instancja encji jest nowa, tworzona jest kopia zarządzana encji (wraz ze skopiowanym stanem)
  • Jeśli encja jest skasowana, rzucony zostanie wyjątek IllegalArgumentException podczas merge lub zatwierdzenie tranzakcji nie powiedzie się.
  • Jeśli encja jest zarządzana, operacja merge jest ignorowana. Jednakże, operacja jest wykonywana kaskadowo na encjach z nią związanych, jeśli relacja, od jej strony, oznaczona jest z cascade=MERGE lub cascade=ALL (lub odpowiednio zdefiniowana w deskryptorze)
  • Dla wszystkich encji Y będących w relacji z X, jeśli relacja do Y została udekorowana cascade=MERGE lub cascade=ALL, operacja merge zostanie wykonana kaskadowo na Y tworząca dla niej kopię Y', która z kolei będzie związana z kopią X' (chyba, że encja X jest już zarządzana, co nie spowoduje stworzenia dla niej kopii)
  • Jeśli encja X' jest zarządzaną encją powstałą w wyniku merge na X, będącej w relacji nieoznaczonej jako cascade=MERGE lub cascade=ALL do innej encji Y, wtedy asocjacja X' prowadzi do kopii Y' (to było trudne, zobaczymy jak będzie w praktyce)
Dostawcy JPA nie wolno uwspólnić pól/właściwości oznaczonych przez LAZY, których wartości nie zostały pobrane. Zostaną one zignorowane.

Kolumny oznaczone przez Version, z których korzysta encja muszą być zweryfikowane przez dostawcę podczas uwspólniania i/lub podczas flush bądź zatwierdzania tranzakcji. Brak kolumn Version nie implikuje weryfikacji (pierwszy raz, kiedy pojawiła się wzmianka o tych kolumnach, więc oczekuję wyjaśnień w nadchodzących rozdziałach).

3.2.4.2 Odłączone encje i opóźnione pobieranie/ładowanie (ang. lazy loading)

Nie zapewnia się przenośności encji w przypadku ich serializacji i ponownego przyłączania (uwspólniania stanu) z kontekstem utrwalania, gdy pola/właściwości i/lub relacje są oznaczone jako opóźnione (ang. lazy).

Wymaga się, aby dostawca JPA wspierał możliwość serializacji i kolejnych deserializacji i uwspólniania stanu odłączonych encji (z polami/właściwościami opóźnionymi, których wartości nie zostały pobrane) w osobnych wirtualnych maszynach, gdzie pracuje to środowisko dostawcy (wydaje mi się, że należy to odczytywać jako stwierdzenie, że zapisanie stanu instancji na dysk - nie do bazy danych - a następnie ponowne skonstruowanie encji odłączonej w innej wirtualnej maszynie Javy u innego dostawcy JPA może zakończyć się niepowodzeniem).

Rozwiązaniem problemu przenośności jest zaniechanie korzystania z opóźnionego ładowania.

3.2.5 Zarządzane encje

Obowiązkiem aplikacji jest zapewnienie, że instancja encji jest zarządzana wyłącznie przez pojedyńczy kontekst utrwalania. Nie gwaratuje się poprawności działania encji zarządzanej przez kilka kontekstów utrwalania.

Metoda contains określa, czy instancja encji jest zarządzana przez dany kontekst utrwalania i zwróci wartość true, jeśli:
  • Instancja encji została pobrana z bazy danych i nie została skasowana lub odłączona
  • Instancja encji jest nowa, jednakże metoda persist została dla niej wywołana bezpośrednio bądź pośrednio poprzez "kaskadową" relację (to ma znaczenie w przypadku tranzakcji jeszcze nie zatwierdzonej, gdzie stan encji nie musi być jeszcze w bazie danych - nie musi być zsynchronizowany)
Metoda contains zwróci wartości false, jeśli:
  • Instancja encji jest odłączona
  • Wywołana została operacja remove bezpośrednio bądź pośrednio poprzez kaskadową relację
  • Jeśli instancja jest nowa, ale metoda persist nie została dla niej wywołana bezpośrednio bądź pośrednio poprzez kaskadową relację (podobnie jak przy wartości true w punkcie 2, z tym, że tutaj instancji nie ma ani w bazie ani w kontekście utrwalania)
I na zakończenie pojawia się uwaga o "widoczności" instancji encji dla metody contains w przypadku operacji persist oraz remove (kaskadowych bądź bezpośrednich), których faktyczny zapis do bazy danych może odbyć się dopiero na zakończenie tranzakcji.

Uff, dużo przydatnej wiedzy. Aż się prosi, aby przygotować kilka przykładowych aplikacji, które mogłyby pomóc w zrozumieniu tematu. No cóż, jak człowiek zarobiony i ma wyłącznie 2 ręce (i w dodatku, jak mawia moja żona, lewe ;-)) to tworzenie przykładów odkładamy na...zakończenie tranzakcji, tj. lektury specyfikacji.

Do zobaczenia na spotkaniu Warszawa JUG!

05 lutego 2007

Java Persistence - Rozdział 3 Entity Operations - pierwsze rozdanie

4 komentarzy
Zanim przejdę do relacji z lektury JPA słówko o tłumaczeniu lifecycle. Ja wybrałem stadia rozwojowe/życiowe, ale nie mogę się do niego przyzwyczaić. Może są bardziej trafne tłumaczenia? Poszukuję czegoś bardziej technicznego, czegoś co być może już jest w użyciu, ale mnie omija.

Poza tym, w międzyczasie, kiedy szukałem informacji o SCBCD 5.0 (310-091) , o którym mówi się, że będzie pod koniec lutego, natrafiłem na 2 ciekawe strony z materiałami. Warto na nie zajrzeć!
Pora zatem na relację z pierwszego podrozdziału rozdziału 3. Rozdział 3 opisuje użycie EntityManager API do zarządzania stadiami instancji encji i użycie Query API do pozyskiwania i wyszukiwania ich trwałego stanu.

3.1 EntityManager (zarządca encji)

Instancja EntityManager związana jest z kontekstem utrwalania (ang. persistent context). Kontekst utrwalania (trwałości) jest zbiorem instancji encji, w którym dla dowolnego trwałego bytu istnieje unikatowa instancja encji. W ramach kontekstu utrwalania następuje zarządzanie stadiami instancji encji. EntityManager API dostarcza metod do interakcji z kontekstem utrwalania - tworzenie i usuwanie trwałych instancji encji, odszukiwanie encji według ich klucza głównego i do zapytań po encjach.

Zbiór encji, które są zarządzane przez daną instancję EntityManager, jest określona przez jednostkę utrwalania (ang. persistence unit). Jednostka utrwalania definiuje zbiór wszystkich klas mapowanych do wspólnej bazy danych.

Interfejs EntityManager należy do pakietu javax.persistence i dostarcza następujące metody:
  • void persist(Object entity) - utwórz trwałą instancję zarządzaną (innymi słowy: zapisz encję do bazy danych i kontroluj jej stan)
  • <T> T merge(T entity) - zsynchronizuj stan encji z aktualnym kontekstem utrwalania
  • void remove(Object entity) - usuń instancję encji
  • <T> T find(Class<T> entityClass, Object primaryKey)- znajdź encję po wartości jej klucza głównego
  • <T> T getReference(Class<T> entityClass, Object primaryKey) - pobierz instancję, której stan może być pobrany z opóźnieniem
  • void flush() - zapisz (utrwal) stan kontekstu utrwalania do bazy danych
  • void setFlushMode(FlushModeType flushMode) - ustaw tryb zapisu stanu kontekstu utrwalania dla wszystkich encji w nim zawartym
  • FlushModeType getFlushMode() - pobierz tryb zapisu stanu kontekstu trwałości dla wszystkich encji w nim zawartym
  • void lock(Object entity, LockModeType lockMode) - ustaw tryb blokady dla encji zawartej w kontekście trwałości
  • void refresh(Object entity) - odśwież stan instancji encji danymi z bazy danych, nadpisując wprowadzone zmiany w encji
  • void clear() - wyczyść kontekst utrwalania, powodując, że wszystkie encje staną się odłączone (ang. detached). Zmiany w encjach, które nie zostały zapisane w bazie (operacja flush) nie będą w niej utrwalone
  • boolean contains(Object entity) - sprawdź, czy instancja encji należy do aktualnego kontekstu utrwalania
  • Query createQuery(String qlString) - stwórz instancję typu Query do wykonania zapytania w języku zapytań JPA (JPA-QL)
  • Query createNamedQuery(String name) - stwórz instancję typu Query do wykonania nazwanego zapytania (w JPA-QL bądź SQL)
  • Query createNativeQuery(String sqlString) - stwórz instancję typu Query do wykonania zapytania SQL, tj. UPDATE lub DELETE
  • Query createNativeQuery(String sqlString, Class resultClass) - stwórz instancję typu Query do wykonania zapytania SQL, tj. UPDATE lub DELETE z tą różnicą, że typem instancji w wyniku będzie resultClass
  • Query createNativeQuery(String sqlString, String resultSetMapping) - stwórz instancję typu Query do wykonania zapytania SQL, tj. UPDATE lub DELETE, gdzie resultSetMapping wskazuje nazwę mapowania wyniku
  • void joinTransaction() - instruuje EntityManager, aby przyłączył się do aktywnej tranzakcji JTA
  • Object getDelegate() - zwróć implementację EM specyficzną dla dostawcy JPA
  • void close() - zamknij instancję EntityManager
  • boolean isOpen() - sprawdź, czy EntityManager jest otwarty (gotów do pracy)
  • EntityTransaction getTransaction() - zwróć zarządcę tranzakcji, w celu rozpoczynania i zatwierdzania pośrednich tranzakcji
Metody persist, merge, remove i refresh muszą być wywoływane w kontekście aktywnej tranzakcji, jeśli EntityManager działa w trybie tranzakcyjnego kontekstu utrwalania. Brak tranzakcji powoduje wyjątek javax.persistence.TransactionRequiredException.

Metody find oraz getReference nie wymagają aktywnej tranzakcji. Jeśli EntityManager działa w trybie tranzakcyjnego kontekstu utrwalania, zwrócone encje będą odłączone (nie będą zarządzane). EntityManager działający w trybie rozszerzonego kontekstu tranzakcyjnego, zwróci encje zarządzane. Więcej informacji niebawem, w sekcji 3.3.

Instancje Query oraz EntityTransaction są poprawne (aktywne), jeśli związane z otwartą instancją EntityManager'a (tj. metoda isOpen zwróci true).

W przypadku wystąpienia błędów z zapytaniem JPA-QL bądź SQL (niepoprawnie zbudowane, wykonanie, bądź rzutowanie wyników na zadany typ) rzucane są wyjątki IllegalArgumentException bądź javax.persistence.PersistenceException, który zakłada się, że zawiera wyjątek specyficzny dla bazy danych.

Wyjątki niekontrolowane (ang. unchecked exceptions - RuntimeException i pochodne) rzucane przez EntityManager powodują wycofanie aktywnej tranzakcji.

Metody close, isOpen, joinTransaction i getTransaction służą do zarządzania stadiami zarządcy encji kontrolowanymi przez aplikację (ang. application-managed entity manager). Więcej w nadchodzącym rozdziale.

Sekcja 3.1.2 zawiera przykładowe użycie EntityManager'a, poprzez wstrzelenie zależności za pomocą @PersistenceContext, a następnie użycie metody find do odszukania encji Customer o podanym kluczu głównym. Encja Customer jest w relacji z Order (zapewne jeden do wielu, ale to nie było zaprezentowane w przykładzie).

Następny podrozdział 3.2 będzie o stadiach życiowych encji (3.2 Entity Instance’s Life Cycle) i pobieżne przejrzenie materiału wskazuje, że nie będzie lekko.

04 lutego 2007

Java Persistence - Rozdział 2 Entities zakończony

2 komentarzy
W końcu sekcja - 2.1.9 Dziedziczenie (Inheritance) - o tych wszystkich pojęciach wokół encji - dziedziczenie, polimorficzne asocjacje oraz polimorficzne zapytania, które w poprzednich rozdziałach były dla mnie kompletnie niezrozumiałe (poza nielicznymi wyjątkami). Dużo informacji, których miałem świadomość istnienia, ale nigdy nie zerałem się do ich analizy, a już tym bardziej czytania specyfikacji o nich (tak sobie myślę, że gdybym miał czytać o tym w dokumentacji Hibernate to do tej pory nie zebrałbym się, a tak Java EE pozwoliło mi zrozumieć kolejne "niejasne" sprawy ORM).

2.1.9 Dziedziczenie (ang. inheritance)

Encja może rozszerzać inną encję (jak również dowolną inną klasę, należy jedynie uważać na umieszczenie adnotacji @Entity). Encje wspierają dziedziczenie, polimorficzne asocjacje i polimorficzne zapytania.

Klasa encji może być klasą abstrakcyjną bądź konkretną (nieabstrakcyjną).

Jak wspomniałem wcześniej, a specyfikacja ponownie opisuje, klasa encji może rozszerzać dowolną klasę niebędącą encją i na odwrót - klasa niebędąca encją może rozszerzać encję (chociaż ten drugi przypadek jest o tyle nieistotny, że po prostu stwierdza fakt możliwości dziedziczenia klas, które posiadają adnotacje - adnotacje są metadanymi, które są wyłącznie istotne dla środowiska, które ich potrzebuje, np. serwer aplikacyjny).

Abstrakcyjne klasy jako encje

Klasa abstrakcyjna może być klasą encji. Analogicznie do pojęcia klasy abstrakcyjnej w Javie, klasy abstrakcyjnej encji (encji abstrakcyjnej) nie można bezpośrednio utworzyć. Poza tym ograniczeniem (niemożności tworzenia bezpośredniego encji), wszystkie inne cechy encji są dostępne (jednak wszystkie operacje z ich użyciem tak na prawdę są oparte o konretne podklasy). Deklaracja klasy abstrakcyjnej jako encji, czyli deklaracja encji abstrakcyjnej, to użycie @Entity lub definicja w deskryptorze.

Specyfikacja podaje przykład zastosowania abstrakcyjnej encji - klasa abstrakcyjna Employee oraz jej konretna podklasa - FullTimeEmployee czy PartTimeEmployee. W przykładzie pojawiają się adnotacje (@Version, @Inheritance, @DiscriminatorValue, @PrimaryKeyJoinColumn), które nie były jeszcze wyjaśnione, stąd spodziewam się obszerniejszych informacji o nich w rozdziałach następnych (już widzę, że rodział 9 - Metadata for Object/Relational Mapping może być dokładnie miejscem, w którym znajdę odpowiedzi).

Zmapowane nadklasy (ang. mapped superclasses)

Encja może dziedziczyć z nadklasy, która nie jest encją, choć dostarcza trwałego stanu i informacji o mapowaniu (jest bazą dla rozwoju innych bardziej zaawansowanych encji nie dostarczając kompletnej realizacji modelowanego bytu).

Zmapowane nadklasy nie mogą być odszukiwane i nie mogą być przekazane jako argument do EntityManager czy operacji Query. Zmapowana nadklasa nie może uczestniczyć w (trwałych, w sensie zapisu do bazy) relacjach.

Dowolna klasa - abstrakcyjna i konkretna (nieabstrakcyjna) - może być zmapowanymi nadklasami. Służy do tego adnotacja @MappedSuperclass lub element mapped-superclass w deskryptorze.

Zmapowana nadklasa nie posiada dedykowanej tabeli. Wszystkie informacje, specyficzne dla encji, są związane z encjami, które ją dziedziczną.

Zmapowana nadklasa może być mapowana z użyciem wszystkich adnotacji (bądź elementów deskryptora) jak typowa encja, jednakże mapowania będą dotyczyły wyłącznie encji pochodnych (dziedziczących ją). Jest to rezultat braku, dedykowanej dla niej tabeli. Dziedziczone mapowania dla encji pochodnych będą rozwiązywane na bazie jej tabel. Informacje mapujące można nadpisać korzystając z adnotacji @AttributeOverride i @AssociationOverride lub odpowiednich elementów w deskryptrze.

Zmapowana nadklasa jest równouprawniona względem domyślnych wartości mapowania (oczywiste, biorąc pod uwagę, że zmapowana nadklasa jest po prostu encją bez tabeli i cały mechanizm utrwalania dotyczy jej w równym stopniu jak typowych encji).

Jako przykład specyfikacja podaje, zmodyfikowany na potrzeby tematu, przykład poprzedni - z Employee, FullTimeEmployee oraz PartTimeEmployee. Przykład z @MappedSuperclass wydaje się być wizualnie prostszy do zrozumienia i nie wymagane jest użycie tylu adnotacji, co w poprzednim przykładzie z klasami abstrakcyjnymi).

Klasy niebądące encjami (nieencyjne klasy) w hierarchi dziedziczenia klas encji

Encja może dziedziczyć z klas nieencyjnych - konkretnych i abstrakcyjnych (z uwagą, że nie może to być klasa wbudowana encji - nie mylić z podobnym pojęciem w Javie! - bądź klasa będąca identyfikatorem encji).

Podobnie jak w programowaniu OO, stosowanie klas nieencyjnych jako nadklas, jest jedynie sposób uwspólnienia funkcjonalności na wiele podklas, które mogą być udekorowane @Entity (bądź zdefiniowane w deskryptorze) i przez to dostarczać dodatkowych informacji środowisku, a że jest to JPA, to w ogólnym rozumowaniu nie miałoby znaczenia. Tyle o ogólnym spojrzeniu z poziomu JVM. Specyfikacja JPA stwierdza, że stan klasy nieencyjnej nie jest trwały (nie podlega utrwalaniu/zapisowi). Dowolna informacja (czyli stan instancji) nadklasy nieencyjnej jest ulotna dla encji i nie podlega zarządzaniu przez EntityManager'a (i jeśli korzystamy z transakcyjnego kontekstu utrwalania, stan nadklasy nieencji może nie być zachowany między trakzakcjami). Adnotacje mapowania w nadklasie nieencyjnej są ignorowane.

Nieencyjne nadklasy nie mogą być argumentami dla EntityManager oraz Query.

Pamiętać należy, że encja jest klasą w Javie i można na niej wykonywać dowolne operacje (i tym samym korzystać z funkcjonalności nadklasy), z tą uwagą, że utrwalanie (cecha JPA) będzie ignorowało stan nadklasy oraz tworzenie nowej tranzakcji może być równoważne z zamazywaniem (ponownym inicjowaniem) właściwości/pól nadklasy.

Dla zobrazowania tematu specyfikacja dostarcza przykładu klasy nieencyjnej - Cart, która jest nadklasą dla encji - ShoppingCart. Przy każdorazowym dodaniu towaru do karty w encji następuje wywołanie metody nadklasy. Wywołanie metody incrementOperationCount(), która przechowuje informację w zmiennej instancji (stan ulotny) odpowiada ilości pozycji na karcie, której informacje mogę pozyskać bezpośrednio z niej (stan trwały), więc zastanawiam się, co, poza demonstracją mechanizmu nadklas nieencyjnych, chciano tym zamodelować. Może koleje rozdziały przyniosą więcej wiedzy i pozbędę się tych pytań?

I na koniec rozdziału 2 swoje miejsce miała sekcja dotycząca strategii mapowania hierarchii klas (ang. inheritance mapping strategies)

Pamiętam projekt, w którym przyszło mi pracować z osobą zachwyconą możliwościami Hibernate w upraszczaniu struktur bazodanowych. Pamiętam, że to, co stworzył była dla mnie kompletnie niezrozumiałe, tzn. rozumiałem co obsłużył takimi konstrukcjami, ale sam nie stworzyłbym tego w tym czasie. Tym bardziej, z zainteresowaniem przeczytałem sekcję 2.1.10 Inheritance Mapping Strategies zamykającą rozdział 2. To jest właśnie temat, który pamiętam do dziś z tamtego projektu, który próbowałem zrozumieć na bazie dokumentacji Hibernate. Teraz sądzę, że nie stanowiłoby to dla mnie problemu, ale wtedy to były czary mary! ;-)

2.1.10 Strategie mapowania hierarchii encji (ang. inheritance mapping strategies)

Mapowanie hierarchii klas jest wyznaczone przez metadane (dla mnie metadane kojarzą się od razu z adnotacjami, ale zakładam, że specyfikacja odnosi się również do deskryptorów).

Wyróżniamy 3 strategie mapowania klas do bazy relacyjnej (to jest bodajże pierwszy raz, kiedy użyto wyrażenia relacyjna baza danych - do tej pory korzystano z pojęcia baza danych, co mogłoby sugerować niezależność specyfikacji od typu bazy danych - relacyjna, obiektowa i...Lotus Notes):
  1. Dedykowana tabela dla hierarchii klasy
  2. Dedykowana tabela dla danej konkretnej klasy encji
  3. Połączone tabele dla konkretnej encji (ang. joined subclass strategy) - pola specyficzne dla podklasy są mapowane do osobnej tabeli niż pola wspólne dla nadklasy i sklejenie danych odbywa się poprzez join
Wsparcie dla strategii 2. jest opcjonalne.

Wsparcie dla kombinacji strategii wewnątrz pojedyńczej hierarchii encji jest opcjonalne.

Dedykowana tabela dla hierarchii klasy

Wszystkie klasy w hierarchii dziedziczenia są mapowane do pojedyńczej tabeli. Tabela posiada kolumnę - kolumna znakująca (ang. discriminator column) - będącą wyróżnikiem wskazującym przynależność wiersza do specyficznej podklasy.

Zaletą jest dobre wsparcie dla polimorficznych relacji oraz zapytań, które operują na hierarchii klas.

Wadą jest wymaganie odnośnie kolumn, które są specyficzne dla podklas, aby mogły przyjmować wartość NULL.

Dedykowana tabela dla danej konkretnej klasy encji

Każda klasa mapowana jest do własnej tabeli. Wszystkie właściwości klasy, włączając te odziedziczone, są mapowane do dedykowanej tabeli encji.

Wadą jest słabe wsparcie dla polimorficznych relacji oraz zazwyczaj wymaga UNION w SQL (lub oddzielnego zapytania SQL per podklasę) dla zapytań, które operują na hierarchii klas.

Połączone tabele dla konkretnej encji

Korzeń hierarchii klas jest reprezentowany jako pojedyńcza tabela. Każda podklasa posiada własną tabelę, która zawiera kolumny specyficzne dla podklasy (niedziedziczone z nadklas) oraz kolumnę z kluczem głównym, która jest kluczem obcym do klucza głównego tablicy nadklasy.

Zaletą jest wsparcie dla polimorficznych relacji.

Wadą jest konieczność użycia operacji łączących (join) w celu utworzenia instancji podklasy. Może to wpłynąć niekorzystnie na wydajność rozwiązania. Podobnie sytuacja przedstawia się względem zapytań, które operują na hierarchii klas.

Tym samym rodział 2 - Entities ogłaszam za zakończony! Tylko 24 strony, a szło mi jakbym czytał 200-stronicową lekturę szkolną. Nie ukrywam, że jakkolwiek Hibernate był w moim użyciu, to nigdy nie wgryzałem się w jego arkana, więc może stąd te opóźnienia. Kolejny rozdział opisuje EntityManager i Query API, i czekałem na niego z utęsknieniem. W końcu będzie można tworzyć przykładowe aplikacje!

03 lutego 2007

IV spotkanie Warszawskiej Grupy Użytkowników Technologii Java (Warszawa-JUG)

0 komentarzy

Warszawska Grupa Użytkowników Technologii Java (Warszawa JUG) zaprasza na IV spotkanie, które odbędzie się w nadchodzący wtorek 06.02.2007 o godzinie 18:00 w sali 5820 na Wydziale MiMUW przy ul. Banacha 2 w Warszawie.

Temat prezentacji: Ruby on Rails - (godzinna) demonstracja możliwości

Ruby on Rails (RoR) przez wielu uważany za fenomen ostatnich lat! Istnieje wiele środowisk do tworzenia aplikacji internetowych. Czy zanurzeni w technologie Java powiniśmy ignorować język Ruby? Może by tak dołożyć kolejne narzędzie i rozszerzyć nasz warsztat programistyczny? Prezentacja będzie próbą zainteresowania uczestników językiem Ruby wraz ze środowiskiem tworzenia aplikacji internetowych - Rails. Są ludzie którzy uważają że rok 2007 będzie należał do technologi Java EE 5 (w tym EJB3 i JSF 1.2), ale są również i tacy, którzy uważają, że to rok Ruby on Rails. Bez względu na przekonania, dobrze znać potencjalne technologie roku 2007.

Prezentacja prowadzona będzie przez Sebastiana Pietrowskiego, który samego siebie uważa za pragmatycznego programistę. Jest absolwentem MiMUW. Związany z Javą od wersji 1.1. Poszukiwacz świętego grala informatyki. Najistotniejsze, że jest pierwszym grupowiczem Warszawa JUG, który zdecydował się podjąć wyzwanie i poprowadzić spotkanie. Już to gwarantuje ciekawe spotkanie ;-)

Plan prezentacji obejmuje około 30-minutową prezentację wprowadzającą do Ruby, Ruby on Rails oraz porównanie z Javą, po czym nastąpi sprawdzenie wiadomości w praktyce, gdzie stworzymy internetowy pamiętnik - bloga (mówi się, że Sebie wystarczy jedynie 10 minut i pamiętnik będzie gotów).

Planowany czas prezentacji to 1 godzina z kolejnymi 30 minutami na dyskuję.

Na spotkaniu będziemy również gościć ekipę z www.warszawa.pl, która przedstawi architekturę serwisu oraz technologiczne wyzwania (iTV). Grupa z www.warszawa.pl planuje w ten sposób zainteresować grupowiczów do udziału w jego rozwoju.

Zapraszam w imieniu Warszawa-JUG!

Java Persistence - Chapter 2 Entities - kolejna część rozdziału

0 komentarzy
Dzisiaj kolejna relacja z lektury specyfikacji Java Persistence API. Wydaje się, że próba relacjonowania zabiera znacznie więcej czasu niż samo czytanie i zrozumienie materiału, jednakże pomaga w jego dalszym studiowaniu. Wydaje się, że potrzebne mi będzie narzędzie, którym będę graficznie reprezentował przeczytany materiał wraz z przykładami, jednakże jak do tej pory nie udało mi się niczego sensownego znaleźć. Pomysł polega na prezentacji kodu źródłowego komponentów encyjnych, diagramów tabel i klas i uatrakcyjnieniu ich krótkimi opisami/wyjaśnieniami. Na razie pierwsze próby spaliły na panewce. Nadal szukam...

Wracając do JPA i rozdziału 2 - Entities, pod lupę wziąłem definiowanie relacji między encjami oraz ich domyślne wartości (co znacząco upraszcza ich modelowanie).

Relacje między encjami

Wyróżniamy następujące relacje między encjami:
  • jeden do jednego (ang. one-to-one) - 1-1
  • jeden do wielu (ang. one-to-many) - 1-*
  • wiele do jednego (ang. many-to-one) - *-1
  • wiele do wielu (ang. many-to-many) - *-*
Relacje są polimorficzne (a to co takiego?! Do wyjaśnienia później - prawdopodobnie chodzi o możliwość referencji klas pochodnych w mapowaniu relacji).

Relacje są definiowane dekorując pole/właściwość encji źródłowej następującymi adnotacjami modelującymi relacje (ang. relationship modeling annotations):
  • @OneToOne
  • @OneToMany
  • @ManyToOne
  • @ManyToMany
Dla relacji, które nie definiują typu docelowego (tj. typy generyczne nie są w użyciu, które precyzowałyby typ docelowy), jest konieczne, aby zdefiniować encję końcową relacji.

Relacje mogą być jednokierunkowe (ang. unidirectional) lub dwukierunkowe (ang. bidirectional).

Dwukierunkowa relacja ma równocześnie stronę początkową (strona właściciela/wiodąca, ang. owning side) oraz stronę zwrotną (strona podległa/końcowa, ang. inverse side).

Jednokierunkowa relacja ma wyłącznie stronę początkową (właściciela).

Strona właściciela relacji wyznacza uaktualnienia do relacji w bazie danych (a co to ma być?!?! - więcej w nadchodzącym rozdziale).

Następujące reguły dotyczą relacji dwukierunkowych:
  • Strona zwrotna musi odnosić się do jej strony wiodącej używając elementu mappedBy adnotacji OneToOne, OneToMany, ManyToMany. mappedBy wskazuje na pole/właściwość encji, która jest właścicielem relacji.
  • Strona odpowiadająca many w dwukierunkowych relacjach many-to-one lub one-to-many musi być stroną wiodącą relacji, więc mappedBy nie może być zdefiniowane w adnotacji ManyToOne.
  • Dla dwukierunkowej relacji 1-1, strona wiodąca odpowiada kluczowi obcemu (ang. foreign key) po stronie zwrotnej
  • Dla dwukierunkowej relacji wiele-do-wielu dowolna strona może być wiodąca
Element cascade=REMOVE powinien być jedynie przypisany do OneToOne lub OneToMany (użycie z innymi powiązaniami powoduje, że encja staje się nieprzenośna).

Adnotacje kolumnowe i tablicowe (tj. dotyczące kolumn i tabel) nadpisują domyślną konfigurację mapowania encji (więcej później).

Dostawca mechanizmu utrwalania obsługuje mapowanie obiektowe do relacyjnego relacji, włączając ich ładowanie, zapis do bazy jak zdefiniowano w metadanych encji oraz integralność powiązań jak zapisano w bazie (przez nałożenie ograniczeń z kluczami obcymi). Mimo tego, to w gestii aplikacji leży odpowiedzialność za utrzymanie zgodności relacji podczas uruchomienia, np. zapewnienia, że obie strony dwukierunkowej relacji jeden do wielu są zgodne nawzajem, kiedy nastąpi uaktualnienie relacji podczas pracy.

Jeśli nie istnieją związane encje dla relacji wielo-encyjnych (wielo-wartościowych, w których jedna ze stron to many) zwrócona jest pusta kolekcja.

Domyślne wartości mapowania relacji

Sekcja opisuje wartości domyślne związane z adnotacjami modelującymi relacje - OneToOne, OneToMany, ManyToOne, ManyToMany oraz kiedy korzysta się z deskryptora.

Dwukierunkowe relacje OneToOne

Sytuacja dotyczy encji A i B, gdzie A powiązane jest z pojedyńczą instancją B i na odwrót oraz A jest stroną wiodącą.

Encja A jest mapowana do tabeli A, a encja B do tabeli B. Tabela A zawiera klucz obcy do tablicy B. Nazwa kolumny klucza obcego składa się z nazwy pola/właściwości relacji encji A (czyli 'A'), po której następuje '_' (podkreślnik) i doklejana jest nazwa kolumny klucza głównego w tablicy B. Typ kolumny klucza obcego w tabeli A odpowiada typowi klucza głównego w tabeli B i nałożone jest ograniczenie klucza unikatowego w tabeli A.

Następnie specyfikacja prezentuje przykład relacji między encjami Employee a Cubicle.

Na uwagę zasługuje wykorzystanie adnotacji @OneToOne oraz @OneToOne(mappedBy="assignedCubicle"). Opracowaniem przykładów zajmę się później w trakcie utrwalania wiedzy w mojej głowie ;-)

Dwukierunkowe relacje ManyToOne/OneToMany

Sytuacja dotyczy encji A i B, gdzie A powiązane jest z pojedyńczą instancją B, B powiązane jest ze zbiorem (kolekcją) encji A oraz encja A musi być stroną wiodącą relacji.

Encja A jest mapowana do tabeli A, a encja B do tabeli B. Tabela A zawiera klucz obcy do tablicy B. Nazwa kolumny klucza obcego składa się z nazwy pola/właściwości relacji encji A (czyli 'A'), po której następuje '_' (podkreślnik) i doklejana jest nazwa kolumny klucza głównego w tablicy B. Typ kolumny klucza obcego w tabeli A odpowiada typowi klucza głównego w tabeli B (w porównaniu z poprzednim przykładem relacji OneToOne nie nałożone jest ograniczenie klucza unikatowego w tabeli A)

Następnie specyfikacja prezentuje przykład relacji między encjami Employee a Department.

Jednokierunkowe relacje jednowartościowe (ang. single-valued)

Sytuacja dotyczy encji A i B, gdzie A powiązane jest z pojedyńczą instancją encji B, a B nie powiązane jest z encją A oraz A musi być stroną wiodącą relacji (dla przypomnienia, jednokierunkowa relacja ma jedynie stronę wiodącą).

Modelowanie jednokierunkowej pojedyńczej relacji może być zdefiniowane jako jednokierunkowe OneToOne lub jako jednokierunkowe ManyToOne.

Relacje jednokierunkowe OneToOne

W takim przypadku, modelując w/w sytuację, encja A jest mapowana do tabeli A, a encja B do tabeli B. Tabela A zawiera klucz obcy do tablicy B. Nazwa kolumny klucza obcego składa się z nazwy pola/właściwości relacji encji A (czyli 'A'), po której następuje '_' (podkreślnik) i doklejana jest nazwa kolumny klucza głównego w tablicy B. Typ kolumny klucza obcego w tabeli A odpowiada typowi klucza głównego w tabeli B i nałożone jest ograniczenie klucza unikatowego w tabeli A. Innymi słowy, jest to identyczna sytuacja do tej z dwukierunkowych relacji OneToOne.

Pojawia się przykład relacji Employee i TravelProfile, gdzie metoda getProfile jest udekorowana adnotacją @OneToOne.

Relacje jednokierunkowe ManyToOne

Modelując w/w sytuację, encja A jest mapowana do tabeli A, a encja B do tabeli B. Tabela A zawiera klucz obcy do tablicy B. Nazwa kolumny klucza obcego składa się z nazwy pola/właściwości relacji encji A (czyli 'A'), po której następuje '_' (podkreślnik) i doklejana jest nazwa kolumny klucza głównego w tablicy B. Typ kolumny klucza obcego w tabeli A odpowiada typowi klucza głównego w tabeli B (w porównaniu z poprzednim przykładem relacji OneToOne nie nałożone jest ograniczenie klucza unikatowego w tabeli A). Innymi słowy, jest to identyczna sytuacja do tej z dwukierunkowych relacji ManyToOne/OneToMany.

Pojawia się przykład relacji Employee i Address, gdzie Employee zawiera metodę getAddress() udekorowaną adnotacją @ManyToOne.

Relacje dwukierunkowe ManyToMany

Załóżmy istnienie encji A, która powiązana jest z kolekcją encji B, encja B powiązana jest z kolekcją encji A i encja A jest wiodącą stroną relacji.

Encja A jest mapowana do tabeli A, encja B do tabeli B. Tworzona jest tablica łącząca (powiązań), która nazwana jest A_B (nazwa encji wiodącej najpierw). Tablica ma dwie kolumny kluczy obcych. Pierwsza kolumna wskazuje na tabelę A o typie jak klucz główny tablicy A, z nazwą rozpoczynającą się od nazwy właściwości/pola encji B, dalej '_' (podkreślnik) i nazwy kolumny klucza głównego w tablicy A. Druga kolumna wskazuje na tabelę B o typie jak klucz główny tablicy B, z nazwą rozpoczynającą się od nazwy właściwości/pola encji A, dalej '_' (podkreślnik) i nazwy kolumny klucza głównego w tablicy B.

Pojawia się przykład relacji Project i Employee.

Jednokierunkowe relacje wielowartościowe (ang. multi-valued)

Załóżmy, że encja A jest powiązana z kolekcją encji B podczas, gdy encja B nie jest powiązana z encją A. Jednokierunkowa relacja posiada jedynie stronę wiodącą, w tym przypadku A.

Modelowanie jednokierunkowej wielowartościowej relacji może być zdefiniowane jako jednokierunkowe OneToMany lub jako jednokierunkowe ManyToMany.

Nie będę już opisywał domyślnych wartości tego typu mapowań, które są łatwe do wydedukowania na podstawie poprzednich przypadków.

Wydaje mi się, jakby lektura JPA nie była tak przyjemna jak EJB3 Simplified. Wydaje się być niezwykle szczegółowa, co z punktu widzenia czytelnika jest porządane, chociaż wymaga dużej dozy cierpliwości, aby przetrawić pojawiające się pojęcia i przypadki.

Jak już wspomniałem, dla uproszczenia przedstawienia tematu pomyślałem o przygotowaniu kilku diagramów, ale okazało się to niewykonalne dzisiaj. Sądziłem, że Eclipse Dali jest już gotów, aby podołać temu wyzwaniu, ale okazuje się, że wersja rozwojowa 1.0M4 nie nadaje się jeszcze do tego zadania. Na grupie dyskusyjnej (eclipse.technology.dali) doczytałem, że funkcjonalność opisana na stronie projektu jest już nieaktualna i plan zakłada, że wersja 1.0M5 będzie pełniejsza i obejmie opisaną funkcjonalność.
Szczęśliwie nie byłem pierwszym, który chciał podejść do tematu i udało mi się odszukać dobrą wizualizacją przedstawionych informacji na blogu Martina Adamka.

Już nie mogę doczekać się zakończenia rozdziału 2, po którym zaplanowałem stworzenie kilku przykładów do zobrazowania tematu.

02 lutego 2007

Java Persistence - Rozdział 2 Entities - kontynuacja lektury rozdziału

2 komentarzy
Poprzednią relację z rozdziału 2 - Entities - specyfikacji JPA zakończyłem na sekcji 2.1.1. Porcja kolejnych informacji wstępnych o encjach i ich mapowaniu.

Kolejna część rozdziału 2 rozpoczyna się prezentacją przykładowego komponentu encyjnego. Nie byłoby w nim nic nadzwyczajnego (POJO z annotacjami JPA), gdyby nie fakt, że klasa encji zawiera jedną metodę biznesową addPhone:

public void addPhone(PhoneNumber phone) {
this.getPhone().add(phone);
phone.addCustomer(this);
}

Zazwyczaj podobne metody posiadałem w innych klasach, nie będących encjami (np. sesyjnym komponentem) podczas, gdy encje były wyłącznie klasami z właściwościami (uważam za złą praktykę upublicznienie pól encji, czyli bezpośredni do nich dostęp). Faktycznie, możliwość umieszczenia metod w klasie encji, komponent nabiera rumieńców - staje się pełnoprawnym komponentem, a nie zwykłym DTO (ang. data transfer object - obiekt transferujący dane).

Tworzenie encji odbywa się identycznie jak instancji każdego innego typu w Javie - poprzez wywołanie dowolnego konstruktora za pomocą new. Instancja nie jest trwała doputy, dopóki nie wywołana zostanie metoda klasy EntityManager (innymi słowy, do momentu "zetknięcia" z EntityManager, klasa encji jest najzwyklejszą klasą w Javie i nie podlega jakieś magicznej obsłudze utrwalania, innej niż tej, której podlegają pozostałe byty w JVM).

Encja musi posiadać klucz unikatowy (ang. primary key). Klucz musi być zdefiniowany na encji, która jest początkiem hierarchii encji (pierwsza klasa udekorowana przez @Entity lub oznaczona jako encja przez deskryptor) lub na klasie nadrzędnej przywiązanej do hierarchii encji (ta część nie jest jeszcze dla mnie w pełni zrozumiała - oczekuję wyjaśnień w dalszej części specyfikacji).

Klucz unikatowy, prosty związany jest z pojedyńczą zmienną/właściwością instancji encji za pomocą adnotacji @Id.

Klucz unikatowy, złożony musi być związany z pojedyńczą zmienną/właściwością encji lub ich zbiorem. Konieczne jest zdefiniowanie dedykowanej klasy klucza i związanie z encją za pomocą adnotacji @EmbeddedId lub @IdClass (jak, co i kiedy w nadchodzących rozdziałach).

Klucze mogą składać się ze zmiennych/właściwości następujących typów:
  • dowolne typy proste i ich odpowiedniki opakowujące
  • java.lang.String
  • java.util.Date
  • java.sql.Date
Nie zalecane jest stosowanie kluczy opartych o typy zmienno-przecinkowe (float, double i ich odpowiedniki opakowujące).

Nie zalecane jest stosowanie typów w kluczach, innych niż wymienione, ze względu na możliwą nieprzenośność encji.

Zaleca się korzystanie z typów całkowito-liczbowych podczas korzystanie z generowanych kluczy unikatowych, ze względu na możliwą nieprzenośność encji.

Stosowanie java.util.Date jako klucza, wymaga stosowania typu DATE w mapowaniu (więcej informacji o mapowaniu w nadchodzących rozdziałach).

Dostęp do pól/właściwości klasy klucza unikatowego jest wyznaczony przez rodzaj dostępu encji z którą jest związany (sądziłem, że specyfikacja nie będzie już do tego wracała, więc teraz wyjaśniam). Rodzaj dostępu encji jest to sposób dotarcia do jej informacji (niezbędne do poprawnego działania środowiska JPA), albo bezpośrednio poprzez pole instancji (ang. field-based access) lub pośrednio, poprzez właściwości, czyli metody opakowujące - gettery i settery - (ang. property-based access).

Reguły tworzenia kluczy złożonych:
  • Klasa klucza musi być public z publicznym bezargumentowym konstruktorem (poza innymi)
  • Dostęp poprzez właściwość (do informacji encji) wymusza, aby właściwości (tj. metody opakowujące) były public lub protected
  • Klasa klucza musi być Serializable
  • Klasa klucza musi dostarczać metody equals oraz hashCode i muszą być zgodne z działaniem bazy, z którą jest związana
  • Klucz musi być klasą wbudowaną (o tym zaznaczono będzie później - ang. embeddable class) albo zmapowaną do wielu pól lub właściwości klasy
Jeśli klucz jest zmapowany do wielu pól i właściwości encji, nazwy i ich typy (między klasą klucza a klasą encji) muszą być takie same.

I ostatnia ważna informacja z sekcji o kluczach głównych (a wydawałoby się oczywista) opartych o typy modyfikowalne (ang. mutable types) to fakt, że wartość klucza głównego nie może się zmienić (czyli zmiana wartości pola/właściwości będącym kluczem lub jego składową). Niektóre implementacje JPA mogą rzucić wyjątek w takich sytuacjach, ale nie powinno się na to liczyć i encja może być nieprzenośna.

Klasy wbudowalne (ang. embeddable classes) - encja może składać się z klas reprezentujących jej stan. Instancje tych klas, w przeciwieństwie do instancji encji, nie posiadają identyfikatora trwałości. Powinny być udekorowane adnotacją @Embeddable lub zdefiniowane w deskryptorze oraz spełniać wymagania stawiane klasom encji.

Jeśli pole lub właściwość trwała, inna niż właściwość relacji, nie są udekorowane jedną z adnotacji mapujących (lub ich mapowania nie są opisane przez deskryptor) zachodzą następujące reguły:
  • Jeśli ich typem jest klasa udekorowana @Embeddable, są one mapowane jak, gdyby były one udekorowane @Embedded (więcej w kolejnych rozdziałach).
  • Jeśli ich typem jest jeden z następujących typów:
    • typy prymitywne lub ich typy opakowujące
    • java.lang.String
    • java.math.BigInteger
    • java.math.BigDecimal
    • java.util.Date
    • java.util.Calendar
    • java.sql.Date
    • java.sql.Time
    • java.sql.Timestamp
    • byte[], Byte[]
    • char[], Character[]
    • enumy
    • dowolny typ implementujący Serializable
są one mapowane jak, gdyby były one udekorowane adnotacją @Basic.

Jeśli żadna reguła nie zachodzi, pojawi się błąd.

Na dzisiaj wystarczy tej wiedzy.

01 lutego 2007

Java Persistence - Rozdział 2 Entities - rozpoczęcie rozdziału

0 komentarzy
Rozdział rozpoczyna się definicją podstawowego bytu specyfikacji JPA - encją (ang. entity). Tak zwięźle zdefiniowany w specyfikacji, że aż trudno przetłumaczyć to na polski (ze zrozumieniem było znacznie łatwiej) - lekki (w sensie zależności ze światem zewnętrznym) obiekt trwały reprezentujący/modelujący pewien byt (co w angielskim brzmi a lightweight persistent domain object - lipido ;-)). Można przyjąć, że jest to pojęcie architektoniczne, trochę górnolotne.

Realizacją encji w rękach programisty jest klasa encji (również znana jako komponent encyjny, ang. entity class).

Klasa encji określona jest przez udekorowanie adnotacją @Entity lub poprzez deskryptor instalacji (bardzo przydatne, jeśli chcielibyśmy skorzystać z istniejących klas bez ich modyfikacji - chociaż nie wyobrażam sobie tak istotnych transformacji bez jakichkolwiek kolizji. Dodatkowo możliwe jest tworzenie komponentów encyjnych bez wprowadzania zależności od implementacji adnotacji JPA).

Klasa encji musi posiadać bezargumentowy konstruktor o widoczności public bądź protected. Inne konstruktory również możliwe.

Klasa encji musi być klasą główną (ang. top-level class) w klasyfikacji języka Java. Bardzo zastanowiło mnie stwierdzenie, że enum oraz interfejsy nie powinny być encjami - wydaje się, że jest to technicznie możliwe, skoro zawarto takie zdanie w specyfikacji, ale czemu miałoby służyć skorzystanie z tego?!

Klasa encji nie może być final, jak i metody oraz trwałe zmienne instancji (czyli te, które podlegają zarządzaniu przez kontener).

Jeśli instancja będzie przekazywana przez wartość jako odłączony obiekt (ang. detached object), np. jako wynik metody interfejsu zdalnego, klasa musi implementować interfejs java.io.Serializable. Generalnie, dobrą praktyką jest tworzenie klasy encji implementującej interfejs Serializable (nawet, jeśli nie dojdzie do przekazywania klasy zdalnie).

Komponenty encyjne wspierają dziedziczenie, polimorficzne powiązania i zapytania (a cóż to takiego?!)

Klasy abstrakcyjne oraz konkretne (nieabstrakcyjne) mogą być klasami encyjnymi.

Klasa encji może rozszerzać klasę nieencyjną i na odwrót.

Stan trwały encji jest wyznaczony przez zmienne instancji bądź właściwości (czyli metody operujące na zmiennych instancji zgodne z wytycznymi specyfikacji JavaBeans). Zmienne instancji mogą być wyłącznie "dotykane" przez metody encji. Zabronione jest bezpośrednie korzystanie ze zmiennych instancji przez klientów encji. Stan encji dostępny jest jedynie poprzez metody zarządzające (settery/gettery) i/lub metody biznesowe. Zmienne instancji mogą być private, protected, package.

Stan komponentu pozyskiwany jest przez środowisko JPA poprzez właściwości (metody JavaBeans - setters/getters) bądź zmienne instancji. Udekorowanie adnotacją wyznacza dostęp poprzez właściwość bądź zmienną instancji.
Jeśli korzystamy z dostępu poprzez zmienne, środowisko JPA dostaje się do zmiennych trwałych bezpośrednio. Wszystkie zmienne nie-transient, które nie są udekorowane przez @Transient są trwałe (podlegają zapisowi). W przypadku dekorowania zmiennych, tam również znajdują się adnotacje mapujące.
Jeśli korzystamy z dostępu poprzez właściwości, środowisko JPA dostaje się do zmiennych trwałych poprzez metody setX oraz getX. Wszystkie właściwości nieudekorowane przez @Transient są trwałe. Metody muszą być public lub protected. Jedynie metody odczytujące właściwości (gettery) mogą być udekorowane. Zabronione jest udekorowanie metody modyfikującej właściwości (setter). W przypadku dekorowania właściwości wyłącznie metody odczytujące są udekorowane adnotacjami mapującymi.

Adnotacje mapujące (o nich niebawem) nie mogą być przypisane do pól i właściwości transient czy @Transient.

Istnieje duże ryzyko nieokreśloności działania środowiska, jeśli udekorujemy jednocześnie pola i właściwości, lub jeśli zadeklarowano inne wartości mapowania w deskryptorze instalacji. Innymi słowy należy zagwarantować, aby dekorowanie przypadło albo polom albo właściwościom i aby deskryptor był w zgodzie z adnotacjami.

Wymagane jest, aby klasa encji była zgodna z wytycznymi specyfikacji JavaBeans odnośnie nazewnictwa metod (setX dla modyfikacji zmiennej X, getX/isX dla odczytania jej wartości).

Pola trwałe będące kolekcjami obiektów mogą być jedynie typu java.util.Collection, java.util.Set, java.util.List, java.util.Map. Uwaga na kolejność elementów w List, która nie jest gwarantowana, chyba że korzysta się z OrderBy. Możliwe jest korzystanie z generycznych postaci kolekcji, np. Set<Exam>.

Jeśli korzysta się z możliwości dodania logiki aplikacji do metod właściwości (np. kontrola w metodzie setter podczas modyfikacji) należy uważać na brak kolejności ich wywoływania na instancji.

Wyjątki niekontrolowane rzucone przez metody dostępu (właściwości) powodują wycofanie aktywnej tranzakcji. Podczas zapisu/odczytu, rzucone wyjątki powodują wycofanie aktywnej tranzakcji i rzucenie wyjątku PersistenceException opakowującego właściwy wyjątek aplikacyjny.

Podklasy mogą przysłaniać/nadpisywać metody właściwości. Nie zaleca się nadpisywania adnotacji mapowania z nimi związanymi.

Pola/właściwości trwałe mogą być następujących typów:
  • wszystkie typy proste Java
  • java.lang.String
  • dowolne, istniejące i stworzone przez programistę, typy serializowalne (implementujące interfejs Serializable, włączając typy opakowujące, java.math.BigInteger, java.math.BigDecimal, java.util.Date, java.util.Calendar, java.sql.Date, java.sql.Time, java.sql.Timestamp, byte[], Byte[], char[], Character[])
  • enumy
  • inne klasy encyjne lub ich kolekcje
  • klasy wbudowane (ang. embeddable classes) - o nich później
Metadane (adnotacje bądź deskryptor instalacji) mapowania precyzują domyślne mapowanie, ładowanie/zapis i relacje (więcej o tym w rozdziale 9).

Kolejna relacja (dokończenie rozdziału) jutro^H^H^H^H^Hdzisiaj.