1 Relacje 1. Modelowanie relacji. - siedem rodzajów relacji J2EE. - relacje jedno i wielokierunkowe, - relacje reprezentowane przez kolekcje.
2 Relacje Modelowanie pojęć biznesowych wymaga łączenia komponentów encyjnych w relacje. Specyfikacja JEE określa siedem rodzajów relacji: jeden-do-jednego (oneto-one), jeden-do-wielu (one-to-many), wiele-do-jednego (many-to-one) oraz wieledo-wielu (many-to-many). Relacja może mieć charakter jednokierunkowy (unidirectional) lub dwukierunkowy (bidirectional).
Jednokierunkowa relacja jeden-do-jednego CUSTOMER FIRST_NAME LAST_NAME ADDRES_ 1 1 ADDRESS STREET CITY ZIP @Entity public class Customer implements java.io.serializable { private Address address; @OneToOne(cascade={CascadeType.ALL) @JoinColumn(name="ADDRESS_") public Address getaddress( ) { return homeaddress; 3
4 Jednokierunkowa relacja jeden-do-jednego <entity-mappings> <entity class="com.titan.domain.customer" access="property"> <attributes> <id name="id"> <generated-value/> </id> <one-to-one name="address" targetentity="com.titan.domain.address" fetch="lazy" optional="true"> <cascade>all</cascade> <join-column name="address_"/> </one-to-one> </attributes> </entity> </entity-mappings>
5 Złączenie wg. klucza głównego @OneToOne @PrimaryKeyJoinColumn(cascade={CascadeType.ALL) public Address getaddress( ) { return homeaddress; Kontener automatycznie zmodyfikuje tabelę CUSTOMER: CREATE TABLE CUSTOMER( INT PRIMARY KEY NOT NULL, address_id INT, ) ALTER TABLE CUSTOMER ADD CONSTRAINT customerrefaddress FOREIGN KEY (address_id) REFERENCES ADDRESS (id);
6 Dwukierunkowa relacja jeden-do-jednego CUSTOMER FIRST_NAME LAST_NAME CREDIT_CARD_ 1 1 CREDIT_CARD NUMBER EXP_DATE Relacja dwukierunkowa polega na tym, ze jeden obiekt (encja) otrzymuje referencję do drugiego obiektu (encji) oraz drugi obiekt posiada referencję do pierwszego. Relacje dwukierunkowe są odwzorowane w relacyjnym modelu danych identycznie jak relacje jednokierunkowe.
@Entity public class Customer implements java.io.serializable { private CreditCard creditcard; @OneToOne(cascade={CascadeType.ALL) @JoinColumn(name="CREDIT_CARD_") public CreditCard getcreditcard( ) { return creditcard; 7 Dwukierunkowa relacja jeden-do-jednego @Entity public class CreditCard implements java.io.serializable { private Customer customer; // nazwa atrybutu w klasie Customer, którego dotyczy mapowanie @OneToOne(mappedBy="creditCard") public Customer getcustomer( ) { return this.customer; Klasa Customer nie ulega zmianie w porównaniu z relacją jednokierunkową
8 Dwukierunkowa relacja jeden-do-jednego Przykład programu wiążącego encje Customer oraz CreditCard: Customer cust = new Customer( ); CreditCard card = new CreditCard( ); cust.setcreditcard(card); card.setcustomer(cust); entitymanager.persist(cust); Ponieważ w adnotacji OneToOne encji Customer ustawiliśmy atrybut cascade={cascadetype.all odpowiedni wpis w tabeli CREDIT_CARD zostanie utworzony automatycznie.
Strona właścicielska i przeciwna Ustawione w powyższy sposób odwzorowanie określa, że obiekt Customer jest stroną właścicielską (owning side) natomiast CreditCard stroną przeciwną (inverse side). Poprawna zmiana właściciela karty kredytowej musi odbywać się następująco: Customer newcust = em.find(customer.class, newcustid); CreditCard card = oldcustomer.getcreditcard( ); oldcustomer.setcreditcard(null); newcust.setcreditcard(card); natomiast jej usunięcie jest realizowane przez: Customer cust = em.find(customer.class, id); em.remove(cust.getcreditcard( )); cust.setcreditcard(null); 9
10 Dwukierunkowa relacja jeden-do-jednego <entity-mappings> <entity class="com.titan.domain.customer" access="property"> </entity> <entity class="com.titan.domain.creditcard" access="property"> <attributes> <id name="id"> <generated-value/> </id> <one-to-one name="customer" target-entity="com.titan.domain.customer" mapped-by="creditcard"/> </attributes> </entity> </entity-mappings>
@Entity public class Customer implements java.io.serializable { private Collection<Phone> phonenumbers = new ArrayList<Phone>( ); @OneToMany(cascade={CascadeType.ALL) @JoinColumn(name="CUSTOMER_") public Collection<Phone> getphonenumbers( ) { return phonenumbers; 11 Jednokierunkowa relacja jeden-do-wielu CUSTOMER FIRST_NAME LAST_NAME 1 N PHONE NUMBER TYPE CUSTOMER_
12 Jednokierunkowa relacja jeden-do-wielu Obsługa encji jest analogiczna jak w przypadku jednokierunkowej relacji jeden-dojednego. Customer cust = entitymanager.find(customer.class, pk); Phone phone = new Phone("123-456-7890"); // dodanie telefonu cust.getphones( ).add(phone); // usunięcie telefonu cust.getphones( ).remove(phone); entitymanager.remove(phone);
13 Jednokierunkowa relacja jeden-do-wielu <entity-mappings> <entity class="com.titan.domain.customer" access="property"> <attributes> <id name="id"> <generated-value/> </id> <one-to-many name="phones" targetentity="com.titan.domain.phone"> <cascade-all/> <join-column name="customer_"/> </one-to-many> </attributes> </entity> </entity-mappings>
@Entity public class Customer implements java.io.serializable { private Collection<Phone> phones; @OneToMany(cascade={CascadeType.ALL) @JoinTable(name="CUSTOMER_PHONE"), joincolumns={@joincolumn(name="customer_"), inversejoincolumns={@joincolumn(name="phone_")) public Collection<Phone> getphonenumbers( ) { return phones; 14 Relacja z wykorzystaniem tabeli złączenia CUSTOMER FIRST_NAME LAST_NAME CUSTOMER_PHONE 1 N N 1 CUSTOMER_ PHONE_ PHONE NUMBER TYPE
15 Relacja z wykorzystaniem tabeli złączenia <entity-mappings> <entity class="com.titan.domain.customer" access="property"> <attributes> <id name="id"> <generated-value/> </id> <one-to-many name="phones" targetentity="com.titan.domain.phone"> <cascade-all/> <join-table name="customer_phone"> <join-column name="customer_"/> <inverse-join-column name="phone_"/> </join-table> </one-to-many> </attributes> </entity> </entity-mappings>
16 Jednokierunkowa relacja wiele-do-jednego CRUISE NAME SHIP_ N 1 SHIP NAME @Entity public class Cruise implements java.io.serializable { private Ship ship; @ManyToOne @JoinColumn(name="SHIP_") public Ship getship( ) { return ship;
17 Jednokierunkowa relacja wiele-do-jednego <entity-mappings> <entity class="com.titan.domain.cruise" access="property"> <attributes> <id name="id"> <generated-value/> </id> <many-to-one name="ship" target-entity="com.titan.domain.ship" fetch="eager"> <join-column name="ship_"/> </many-to-one> </attributes> </entity> </entity-mappings>
18 Dwukierunkowa relacja jeden-do-wielu CRUISE NAME SHIP_ 1 N RESERVATION AMOUNT_PA CRUISE_ Analogicznie jak w poprzednim wypadku relacja dwukierunkowa jest wykorzystywana gdy obie encje muszą wiedzieć o sobie nawzajem. W modelu programistycznym odpowiednie adnotacje są dodane do definicji obu klas. Zgodnie ze specyfikacją JPA stroną właścicielską jest komponent naprzeciwko encji z licznością równą jeden. W naszym przypadku to Reservation.
@Entity public class Cruise implements java.io.serializable { private Collection<Reservation> reservations = new ArrayList<Reservation>( ); @OneToMany(mappedBy="cruise") public Collection<Reservation> getreservations( ) { return reservations; 19 Dwukierunkowa relacja jeden-do-wielu @Entity public class Reservation implements java.io.serializable { private Cruise cruise; @ManyToOne @JoinColumn(name="CRUISE_") public Cruise getcruise( ) { return cruise;
Dwukierunkowa relacja jeden-do-wielu <entity-mappings> <entity class="com.titan.domain.cruise" access="property"> <attributes> <id name="id"><generated-value/></id> <one-to-many name="ship" target-entity="com.titan.domain.reservation" fetch="lazy" mapped-by="cruise"> </one-to-many> </attributes> </entity> <entity class="com.titan.domain.reservation" access="property"> <attributes> <id name="id"><generated-value/></id> <many-to-one name="cruise" target-entity="com.titan.domain.cruise" fetch="eager"> <join-column name="cruise_"/> </many-to-one> </attributes> </entity> </entity-mappings> 20
21 Dwukierunkowa relacja wiele-do-wielu CUSTOMER FIRST_NAME LAST_NAME CUSTOMER_RESERVATION CUSTOMER_ RESERVATION_ RESERVATION AMOUNT_PA Relacja wiele-do-wielu w relacyjnym modelu danych odwzorowana z wykorzystaniem tabeli złączenia
@Entity public class Customer implements java.io.serializable { private Collection<Reservation> reservations = new ArrayList<Reservation>( ); @ManyToMany(mappedBy="customers") public Collection<Reservation> getreservations( ) { return reservations; 22 Dwukierunkowa relacja wiele-do-wielu @Entity public class Reservation implements java.io.serializable { private Set<Customer> customers = new HashSet<Customer>( ); @ManyToMany @JoinTable(name="RESERVATION_CUSTOMER"), joincolumns={@joincolumn(name="reservation_"), inversejoincolumns={@joincolumn(name="customer_")) public Set<Customer> getcustomers( ) { return customers;
Dwukierunkowa relacja wiele-do-wielu <entity-mappings> <entity class="com.titan.domain.reservation" access="property"> <attributes><id name="id"><generated-value/></id> <many-to-many name="customers" target-entity="com.titan.domain.customer" fetch="lazy"> <join-table name="reservation_customer"> <join-column name="reservation_"/> <inverse-join-column name="customer_"/> </join-table> </many-to-many> </attributes> </entity> <entity class="com.titan.domain.customer" access="property"> <attributes><id name="id"><generated-value/></id> <many-to-many name="cruise" target-entity="com.titan.domain.reservation" fetch="lazy" mapped-by="customers"> </many-to-many> </attributes> </entity> </entity-mappings> 23
24 Jednokierunkowa relacja wiele-do-wielu CABIN NAME DECK CABIN_RESERVATION CABIN_ RESERVATION_ RESERVATION AMOUNT_PA @Entity public class Reservation implements java.io.serializable { @ManyToMany @JoinTable(name="CABIN_RESERVATION", joincolumns={@joincolumn(name="reservation_"), inversejoincolumns={@joincolumn(name="cabin_")) public Set<Cabin> getcabins( ) { return cabins;
25 Jednokierunkowa relacja wiele-do-wielu <entity-mappings> <entity class="com.titan.domain.reservation" access="property"> <attributes> <id name="id"> <generated-value/> </id> <many-to-many name="cabins" target-entity="com.titan.domain.cabin" fetch="lazy"> <join-table name="cabin_reservation"> <join-column name="reservation_"/> <inverse-join-column name="cabin_"/> </join-table> </many-to-many> </attributes> </entity> </entity-mappings>
26 Relacje reprezentowane przez kolekcje JPA umożliwia stosowanie następujących kolekcji do reprezentowania relacji jedendo-wielu i wiele-do-wielu: java.util.collection, java.util.set, java.util.list i java.util.map. private List<Customer> customers = new ArrayList<Customer>( ); @ManyToMany @OrderBy("lastName ASC") @JoinTable(name="RESERVATION_CUSTOMER"), joincolumns={@joincolumn(name="reservation_"), inversejoincolumns={@joincolumn(name="customer_")) public List<Customer> getcustomers( ) { return customers;
<many-to-many name="customers" target-entity="com.titan.domain.customer" fetch="lazy"> <order-by>lastname ASC</order-by> <join-table name="reservation_customer"> <join-column name="reservation_"/> <inverse-join-column name="customer_"/> </join-table> </many-to-many> 27 Relacje reprezentowane przez kolekcje JPA umożliwia stosowanie następujących kolekcji do reprezentowania relacji jedendo-wielu i wiele-do-wielu: java.util.collection, java.util.set, java.util.list i java.util.map. @ManyToMany @OrderBy("lastName ASC") @JoinTable(name="RESERVATION_CUSTOMER"), joincolumns={@joincolumn(name="reservation_"), inversejoincolumns={@joincolumn(name="customer_")) public List<Customer> getcustomers( ) { return customers;
28 java.util.map @OneToMany(cascade={CascadeType.ALL) @JoinColumn(name="CUSTOMER_") @MapKey(name="number") public Map<String, Phone> getphonenumbers( ) { return phonenumbers; <one-to-many name="phonenumbers" target-entity="com.titan.domain.phone" fetch="lazy"> <cascade-all/> <map-key name="number"/> <join-column name="customer_"/> </one-to-many>
29 Podsumowanie JEE w ramach odwzorowania relacyjno-obiektowego umożliwia korzystanie z siedmiu typów relacji. Odwzorowanie jest określone poprzez mechanizm adnotacji lub konfigurację zapisaną w pliku persistance.xml. Aby modelować relacje obejmujące wiele obiektów możemy korzystać z czterech podstawowych typów kolekcji.