3. Java Persistence API
Basics
Multiplicity in Entity Relationships
CM Database Schema
Many-to-One Mappings
Exercise: Read a Payment
CM Database Schema
Payment Entity (1 of 2)
Payment Entity (2 of 2)
DAO & Service Interfaces
PaymentDaoImpl Class
Main Class
Exercise: Read a Payment
Exercise: Group Payments
PaymentDaoImp Class
Main Class
Exercise: Group Payments
One-to-Many Mappings
Exercise: Read a Merchant’s Payments
CM Database Schema
Merchant Entity
Main Class (1 of 2)
Main Class (2 of 2)
Exercise: Read a Merchant’s Payments
Many-to-Many Mappings
@JoinTable Annotation
Exercise: Read Customer’s Merchants
Customer Entity (1 of 2)
Customer Entity (2 of 2)
Main Class
Exercise: Read Customer’s Merchants
Lazy Relationships
One-to-One Mappings
Embedded Objects (1 of 2)
Embedded Objects (2 of 2)
Embedded Type
Address Embedded Type
Using an Embedded Object
Reuse of Embedded Type
Database Schema Generation
eclipselink.ddl-generation Values
Schema Generation Practice
Schema Generation Practice
287.00K
Category: programmingprogramming

3. Java Persistence API. 4. Entity Relationships

1. 3. Java Persistence API

4. Entity Relationships

2. Basics

• A foreign key can be one or more
columns that reference a unique key,
usually the primary key, in another table
• A foreign key and the primary parent key it
references must have the same number
and type of fields
• Foreign keys represents relationships
from a column or columns in one table to a
column or columns in another table
09.01.2017 2:09
Victor Mozharsky
2

3. Multiplicity in Entity Relationships

• Multiplicities are of the following types:
– Many-to-one: Multiple instances of an entity
can be related to a single instance of the
other entity
– One-to-one: Each entity instance is related to
a single instance of another entity
– One-to-many: An entity instance can be
related to multiple instances of the other
entities
– Many-to-many: The entity instances can be
related to multiple instances of each other.
09.01.2017 2:09
Victor Mozharsky
3

4. CM Database Schema

09.01.2017 2:09
Victor Mozharsky
4

5. Many-to-One Mappings

• A many-to-one mapping is defined by
annotating the attribute in the source entity
(the attribute that refers to the target entity)
with the @ManyToOne annotation
• A @JoinColumn(name=Fkname) annotation
discribes a foreing key of a relationship
09.01.2017 2:09
Victor Mozharsky
5

6. Exercise: Read a Payment

• Create a project for read payment data by
payment id with a merchant name instead
of merchant id
09.01.2017 2:09
Victor Mozharsky
6

7. CM Database Schema

09.01.2017 2:09
Victor Mozharsky
7

8. Payment Entity (1 of 2)

@Entity
public class Payment {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private int id;
private double charge;
private double total;
private String goods;
private java.sql.Date dt;
@ManyToOne
@JoinColumn(name="merchantId")
private Merchant merchant;
09.01.2017 2:09
Victor Mozharsky
8

9. Payment Entity (2 of 2)

public Merchant getMerchant(){ return merchant; }
public void setMerchant(Merchant value){
merchant = value;
}
. . . . . . . .. . . . . . . .
public String getStringForPrint() {
String txt = "id = " + id + "; date = ";
SimpleDateFormat dtFrm = new SimpleDateFormat("dd.MM.yyyy");
txt += dtFrm.format(dt) + "; merchant = " + merchant.getName();
txt += "; total = " + total + "; charge = " + charge;
return txt;
}
09.01.2017 2:09
Victor Mozharsky
9

10. DAO & Service Interfaces

DAO & Service Interfaces
public interface PaymentDao {
public List<Payment> findByMerchantId(int id);
public double getPaymentSum();
public Payment findById(int id);
}
public interface PaymentService {
public List<Payment> findByMerchantId(int id);
public double getPaymentSum();
public Payment findById(int id);
}
09.01.2017 2:09
Victor Mozharsky
10

11. PaymentDaoImpl Class

public Payment findById(int id){
return em.find(Payment.class, id);
}
09.01.2017 2:09
Victor Mozharsky
11

12. Main Class

@SuppressWarnings("resource")
public static void main(String[] args) {
ApplicationContext context = new
ClassPathXmlApplicationContext("beans.xml");
PaymentService paymentService =
context.getBean(PaymentService.class);
Payment p = paymentService.findById(2);
System.out.println(p.toString());
}
09.01.2017 2:09
Victor Mozharsky
12

13. Exercise: Read a Payment

• See P351ReadPayment project for the full
text
09.01.2017 2:09
Victor Mozharsky
13

14. Exercise: Group Payments

• Modify P237Grouping project using
entities from the previous project
09.01.2017 2:09
Victor Mozharsky
14

15. PaymentDaoImp Class

public List<Result> getTotalReport(){
String txt = "SELECT new com.bionic.edu.Result
(p.merchant.name, count(p), SUM(p.chargePayed))";
txt += "FROM Payment p GROUP BY p.merchant.name";
TypedQuery<Result> query = em.createQuery(txt,
Result.class);
return query.getResultList();
}
09.01.2017 2:09
Victor Mozharsky
15

16. Main Class

@SuppressWarnings("resource")
public static void main(String[] args) {
ApplicationContext context = new
ClassPathXmlApplicationContext("beans.xml");
PaymentService paymentService =
context.getBean(PaymentService.class);
List<Result> list = paymentService.getTotalReport();
for(Result r: list)
System.out.format("%1$25s %2$3d %3$8.2f \n",
r.getName(), r.getCount(), r.getSum());
}
09.01.2017 2:09
Victor Mozharsky
16

17. Exercise: Group Payments

• See P352GroupPayment project for the
full text
09.01.2017 2:09
Victor Mozharsky
17

18. One-to-Many Mappings

• An entity instance can be related to multiple
instances of the other entities
• One-to-many relationships use the @OneToMany
annotation on the corresponding persistent
property or field
• The mappedBy element is needed to refer to the
attribute annotated by ManyToOne in the
corresponding entity:
@OneToMany(mappedBy=“attribute”)
• A one-to-many association needs to map the
collection of entities
09.01.2017 2:09
Victor Mozharsky
18

19. Exercise: Read a Merchant’s Payments

• Create a project for read payment data
that correspond to a merchant given by its
id
09.01.2017 2:09
Victor Mozharsky
19

20. CM Database Schema

09.01.2017 2:09
Victor Mozharsky
20

21. Merchant Entity

@Entity
public class Merchant {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private int id;
private String name;
private double charge;
private int period;
private double total;
@OneToMany(mappedBy="merchant")
private Collection<Payment> payments;
09.01.2017 2:09
Victor Mozharsky
21

22. Main Class (1 of 2)

@SuppressWarnings("resource")
public static void main(String[] args) {
ApplicationContext context = new
ClassPathXmlApplicationContext("beans.xml");
MerchantService merchantService =
context.getBean(MerchantService.class);
List<Merchant> list =
merchantService.getSortedByNeedToPay();
for(Merchant m: list){
System.out.println("=======================");
System.out.println(m.getName());
09.01.2017 2:09
Victor Mozharsky
22

23. Main Class (2 of 2)

System.out.println(" ");
Collection<Payment> payments = m.getPayments();
for (Payment p : payments) {
System.out.println(p.toString());
}
}
}
09.01.2017 2:09
Victor Mozharsky
23

24. Exercise: Read a Merchant’s Payments

• See P353MerchantPayments project for
the full text
09.01.2017 2:09
Victor Mozharsky
24

25. Many-to-Many Mappings

• The entity instances can be related to
multiple instances of each other
• Many-to-many relationships use the
@ManyToMany annotation on the
corresponding persistent property or field
• We must use a third table to associate the
two entity types (join table)
09.01.2017 2:09
Victor Mozharsky
25

26. @JoinTable Annotation

@JoinTable(name=“table name”,
[email protected](name=“c1Id”),
inverseJoinColumns=
@JoinColumn(name=“c2Id”))
09.01.2017 2:09
Victor Mozharsky
26

27. Exercise: Read Customer’s Merchants

• Create a project to read data about
merchants whose goods were bought by a
given customer
09.01.2017 2:09
Victor Mozharsky
27

28. Customer Entity (1 of 2)

@Entity
public class Customer {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private int id;
private java.sql.Date maturity;
private String ccType;
private String ccNo;
private String eMail;
private String address;
private String name;
09.01.2017 2:09
Victor Mozharsky
28

29. Customer Entity (2 of 2)

@ManyToMany
@JoinTable(name="Payment",
[email protected](name="customerId"),
[email protected](name="merchantId"
))
private Collection<Merchant> merchants;
09.01.2017 2:09
Victor Mozharsky
29

30. Main Class

@SuppressWarnings("resource")
public static void main(String[] args) {
ApplicationContext context = new
ClassPathXmlApplicationContext("beans.xml");
CustomerService customerService =
context.getBean(CustomerService.class);
Customer customer = customerService.findById(1);
if (customer != null){
System.out.println(customer.toString());
Collection<Merchant> merchants = customer.getMerchants();
for (Merchant m : merchants) {
System.out.println(m.getName());}}}
09.01.2017 2:09
Victor Mozharsky
30

31. Exercise: Read Customer’s Merchants

• See P354CustAndMerch project for the full
text
09.01.2017 2:09
Victor Mozharsky
31

32. Lazy Relationships

• The fetch mode can be specified on any of
the four relationship mapping types:
@ManyToOne(fetch=FetchType.LAZY)
• Lazy loading can essential enhance
performance
09.01.2017 2:09
Victor Mozharsky
32

33. One-to-One Mappings

• Each entity instance is related to a single
instance of another entity
• One-to-one relationships use the
@OneToOne annotation on the
corresponding persistent property or field
• Example of One-To-One mapping:
Employee and ParkingSpace entities
09.01.2017 2:09
Victor Mozharsky
33

34. Embedded Objects (1 of 2)

• An embedded object is one that is dependent
on an entity for its identity
• It has no identity of its own, but is merely part
of the entity state
• The state of the embedded object is stored
with the rest of the entity state in the
database row, with no distinction between
the state in the Java entity and that in its
embedded object
09.01.2017 2:09
Victor Mozharsky
34

35. Embedded Objects (2 of 2)

• We can share the same embedded object
type with other entities that also have the
same internal representation
• Example: the home address of the
employee (contains Street, City, State,
ZipCode fields)
09.01.2017 2:09
Victor Mozharsky
35

36. Embedded Type

• An embedded type is marked as such by
adding the @Embeddable annotation to
the class definition
• Its fields and properties will be persistable
as part of an entity
• We might also want to define the access
type of the embeddable object so it is
accessed the same way regardless of
which entity it is embedded in
09.01.2017 2:09
Victor Mozharsky
36

37. Address Embedded Type

@Embeddable
@Access(AccessType.FIELD)
public class Address {
private String street;
private String city;
private String state;
private String zipCode;
// ...
}
09.01.2017 2:09
Victor Mozharsky
37

38. Using an Embedded Object

@Entity
public class Employee {
@Id
private int id;
private String name;
private long salary;
@Embedded
private Address address;
// ...
}09.01.2017 2:09
Victor Mozharsky
38

39. Reuse of Embedded Type

• An Address class could be reused in both
Employee and Company entities
09.01.2017 2:09
Victor Mozharsky
39

40. Database Schema Generation

• Automatically generation the tables and
database schema for a persistence unit
can be done through the "eclipselink.ddlgeneration" persistence unit property
• The tables and constraints will be
generated for all of the classes defined in
that persistence unit.
09.01.2017 2:09
Victor Mozharsky
40

41. eclipselink.ddl-generation Values

• create-tables – if the table already exists
then it will not be dropped or replaced, the
existing table will be used
• drop-and-create-tables - will first drop the
existing table, and then create the new
table. Note that this will lose all of the data
in the tables when they are dropped!!
09.01.2017 2:09
Victor Mozharsky
41

42. Schema Generation Practice

• One of the complaints around schema
generation is that you can’t specify
everything that you need to be able to
finely tune the schema.
• There are too many differences between
databases and too many different settings
to try to put in options for every database
type.
09.01.2017 2:09
Victor Mozharsky
42

43. Schema Generation Practice

• If every database-tuning option were
exposed through JPA then we would end
up duplicating the features of Data
Definition Language (DDL) in an API
• The final schema will typically be tuned by
a database administrator or someone with
the appropriate level of database
experience.
09.01.2017 2:09
Victor Mozharsky
43
English     Русский Rules