En webinar jpa v2final

Java Persistence API

Emil Nahlik (DC Bratislava)
Copyright © 2009 Accenture All Rights Reserved.

Centra Tools
Raise Hand Audio/Connectivity Tips
• Run the Audio Wizard
Yes / No • Choose Tools/Audio Wizard from the
menu at top of screen

Applause • Close all network based
applications
• Outlook, MSN/AOL, other websites,
Office Communicator, etc
Laugh
• Connect via an Accenture LAN or
high speed internet connection
• If using a wireless connection, ensure
Text Chat your signal is as strong as possible

• Monitor the Network Connectivity
Centra Volume Control Bar
• Contact Learning Product Support if
issues continue

Network Connectivity Bar

Asking Questions
Two Options:

1. Ask live questions during the designated Q&A sessions:
• Press Raise Hand icon to get faculty’s attention

• Once called upon, there are two options to speak:
- Click the Talk button or
- Press the Ctrl key
When done speaking, unselect the Talk button or
release the Ctrl Key.

2. Post questions at any time in the chat room.

Session structure
• Introduction
• Basic JPA Configuration
• Entity relationships
• Persistence operations and query language
• Transactions & optimistic/pessimistic locking
• Demo
•Q & A

Copyright © 2009 Accenture All Rights Reserved. 4

Introduction
Java Persistence API (JPA) is a data persistence mechanism,
that:

• is a part of JEE 5 (EJB3.0)
• works with Plain Old Java Objects (POJO)
• is DB-independent (configuration & JPA implementation)
• easy to use
• uses SQL-like language
• supports transactions and optimistic/pessimistic locking


Introduction

There is no need to run an application
server to use JPA. It can run as a stand
alone, you need just a JPA implementation
and properly configured XML file.


Basic JPA
Configuration
What does a typical JPA project consists of?

• JPA implementation
• Entities
• Entity manager
• Configuration file – persistence.xml


JPA Implementation
There are many JPA implementations:
• OpenJPA
• Hibernate
• TopLink
• CocoBase
• Castor
• JPOX
• etc.


Entities
Entity

• represents domain object stored in DB
• is a POJO class
• is annotated as @Entity
• must implement Serializable interface
• must have declared ID attribute


Entities
Example:

@Entity
public class Customer implements Serializable {
private static final long serialVersionUID = 1L;

@Id
private Integer id;
private String firstName;
private String lastName;
}


Entities
You can set ID (primary key) by your own

@Entity
public class Customer {
@Id
private int id = 0;
…
}

Somewhere in the code:
Customer cust = new Customer();
cust.setId(123);


Entities
Or you can use Sequence to generate ID (primary key)

• Sequence (in DB)
• Sequence genererator (in Entity)

@Entity
@Id
@SequenceGenerator(name=“Cust_Gen”,sequenceName=“Cust_Seq”)
@GeneratedValue(generator=“Cust_Gen”)
private int id;
…
}


Entity Manager
Entity Manager is responsible for managing
persistence and transactions.

• Create-Read-Update-Delete (CRUD) operations
• Java Persistence Query Language (JPQL)
• Access to transactions


Configuration file
There is persistence.xml configuration file that contains JPA
configuration. Inside this file, we define Persistence Unit and
configure:

• JPA provider class
• Data source
• Transaction type (JTA / non-JTA)
• List of entity classes that are persisted by Persistence Unit
• Additional parameters – e.g. Hibernate dialect


Configuration file
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns=http://java.sun.com/xml/ns/persistence>
<persistence-unit name=“MyPersistenceUnit" transaction-type="RESOURCE_LOCAL">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<non-jta-data-source>TEST_DB</non-jta-data-source>
<class>jpa.webinar.entities.Person</class>
<class>jpa.webinar.entities.Address</class>
<class>jpa.webinar.entities.PhoneNumber</class>


<properties>
<property name="hibernate.dialect“
value="org.hibernate.dialect.Oracle10gDialect"/>
<property name="hibernate.show_sql" value="true"/>
<property name="hibernate.format_sql" value="true"/>
</properties>
</persistence-unit>
</persistence>

Entities and
Relationships
There are many types of relationships:

• 1-to-1 – unidirectional (AB) / bidirectional (AB)
• 1-to-N – unidirectional / bidirectional
• N-to-1 – unidirectional / bidirectional
• M-to-N – always bidirectional


Entities and
Relationships
Unidirectional relationship Bidirectional relationship
1-to-1 (A  B) 1-to-N (A  B)

ClassA a = new ClassA(); ClassA a = new ClassA();
ClassB b = new ClassB(); ClassB b = new ClassB();
a.setB(b); a.addB(b);
b.setA(a);

For bidirectional relationships,
we always have to set both sides
of relationship!


Entities and
Relationships
Persistence-by-reachability

In JPA, when object is persisted, no related entities are
persisted automatically by default.

There are two options:
• Call persist method for each entity separately
• Use cascading to extend persistence reachability


Cascading
Persistence operation are applied to specified entities.
Similar to cascade deletes known from PL/SQL.

There are many types of cascades:
• PERSIST
• MERGE
• REMOVE
• REFRESH
• ALL ( = PERSIST + MERGE + REMOVE + REFRESH)


Cascading
Example:

@Entity

@OneToOne( cascade = CascadeType.ALL )
private IDCard idCard;

@OneToMany(mappedBy = “custId”,
cascade = { CascadeType.PERSIST, CascadeType.MERGE } )
private List<Order> orders;

// ...

}


One-to-One
relationship
a) Unidirectional

@OneToOne
@JoinColumn(name=“address_id”)


One-to-One relationship
(unidirectional)
@Entity
@Id
private Integer id;
@OneToOne
private Address address;
}

@Entity
public class Address implements Serializable {
@Id
private Integer id;
@Column(name=“street_name”)
private String street;
private String city;
}


One-to-One
relationship
b) Bidirectional

FK owner side (Customer):
@OneToOne

non-owner side (Address):
@OneToOne(mappedBy=“address”)


One-to-One relationship
(bidirectional)
@Entity
@Id
private Integer id;
@OneToOne
}

@Entity
@Id
private Integer id;
private String street_name;
private String street_num;
@OneToOne(mappedBy=“address”)
private Customer cust;
}


One-to-Many
relationship
• Can be unidirectional or bidirectional

• Several data types can be used for relationship representation:
– Collection
– Set
– List
– Map

• There are 2 ways how to define One-to-Many relationship:
– using Foreign key
– using Join table

One-to-Many
relationship
a) Using Foreign key (only Bidirectional)

FK non-owner side (Customer):
@OneToMany(mappedBy=“cust”)

FK owner side (Phone):
@ManyToOne
@JoinColumn(name=“cust_id”)


One-to-Many relationship
(foreign key)
@Entity
@Id
private Integer id;
private List<Phone> phones;
}

@Entity
public class Phone implements Serializable {
@Id
private Integer id;
private String prefix;
private String phoneNum;
@ManyToOne
@JoinColumn(name=“cust_id”)
}


One-to-Many
relationship
b) Using join table (unidirectional)

Collection owner (Customer):
@OneToMany
@JoinTable(name=“customer_phone” …)


(unidirectional)
@Entity
@Id
private Integer id;
@OneToMany
@JoinTable(name=“customer_phone”,
joinColumns = @JoinColumn(name=“cust_id”,
inverseJoinColumns = @JoinColumn(name=“phone_id”))
}

@Entity
@Id
private Integer id;
private String phonenum;
}


One-to-Many
relationship
c) Using join table (bidirectional)

Collection owner (Customer):
@JoinTable(name=“customer_phone” …)

FK owner side (Phone):
@ManyToOne


(bidirectional)
@Entity
@Id
private Integer id;
@JoinTable(name=“customer_phone”,
joinColumns = @JoinColumn(name=“cust_id”,
inverseJoinColumns = @JoinColumn(name=“phone_id”))
}

@Entity
@Id
private Integer id;
private String phonenum;
@ManyToOne
}


Many-to-One
relationship
Using Foreign key

FK owner side (Customer):
@ManyToOne


Many-to-One
relationship
@Entity
@Id
private Integer id;
@ManyToOne
}

@Entity
@Id
private Integer id;
private String street_name;
private String street_num;
}


Many-to-Many
relationship
Using join table

Employee:
@ManyToMany
@JoinTable(name=“employee_project” …)

FK owner side (Address):
@ManyToMany(mappedBy=“employees”)


Many-to-Many
relationship
@Entity
public class Employee implements Serializable {
@Id
private Integer id;
@ManyToMany
@JoinTable(name=“employee_project”,
joinColumns = @JoinColumn(name=“emp_id”,
inverseJoinColumns = @JoinColumn(name=“prj_id”))
private Collection<Project> projects;
}

@Entity
public class Project implements Serializable {
@Id
private Integer id;
private String name;
private String status;
@ManyToOne(mappedBy=“projects”)
private Collection<Employee> employees;
}


Persistence operations &
query language

All operations are managed by EntityManager

• is instantiated using EntityManager Factory
• based on persistence unit name (persistence.xml)

To instantiate EntityManager:
EntityManagerFactory emf =
Persistence.createEntityManagerFactory(“PersistenceUnit”);
EntityManager mng = emf.createEntityManager();


Entity Manager –
Entity lifecycle


Entity Manager –
CRUD operations
• Create: persist(Object obj) ~ INSERT
• Read: T find(Class<T> cls, Object id) ~ SELECT
• Update: T merge(T t) ~ UPDATE
• Delete: remove(Object obj) ~ DELETE


Entity Manager –
CRUD operations
persist(Object obj)
- persists object into DB (new records)

Example:
Customer cust = new Customer();
cust.setFirstName(“John”);
cust.setLastName(“Smith”);

entityManager.persist(cust);


Entity Manager –
CRUD operations
T find(Class<T> cls, Object id)
-finds record of given in DB
-returns instance of class cls or null

Example:
Integer customerId = 123;
Class cls = Customer.class;

Customer cust = entityManager.find(cls, customerId);


Entity Manager –
CRUD operations
T merge(T obj)
-to update existing record
-returns updated Entity

Example:

cust.setFirstName(“John jr”);
entityManager.merge(cust);


Entity Manager –
CRUD operations
remove(Object obj)
- removes object from DB

Example:

entityManager.remove(cust);


Entity Manager –
CRUD operations
refresh(Object obj)
- retrieves actual state of object from DB

Example:

...
entityManager.refresh(cust);


Entity Manager –
CRUD operations
Callbacks for Persistence operations:
• @PrePersist
• @PostPersist
• @PostLoad
• @PreUpdate
• @PostUpdate
• @PreRemove
• @PostRemove


Entity Manager –
CRUD operations
Callbacks for Persistence operations:

@Entity
@EntityListeners({CustomerListener.class})
@Id private Integer id;

@PreUpdate
private void something() {
System.out.println(“before update...”);
}
}

public class CustomerListener {
@PostUpdate
public void postUpdate(Customer cust) {
System.out.println(“after update...”);
}
}


Entity Manager
Queries

• Query language similar to SQL
• Query
• Named Query
• Native Query


Entity Manager –
Queries
Query – simple query (one-time use)

• parameters
• wildcards % and _ are supported

Example:
String jql = “SELECT c FROM Customer c WHERE c.firstName LIKE ?”;
Query query = entityManager.createQuery(jql);

query.setParameter(1, “J%”);
List<Customer> customers = query.getResultList();


Entity Manager –
Queries
Named Query – precompiled query
@Entity
@NamedQueries({
@NamedQuery(
name=“findByLastName”,
query=“SELECT c FROM Customer c WHERE c.lastName = :lstName”)
})
}

Query query = entityManager.createNamedQuery(“findByLastName”);
query.setParameter(“lstName”, “Smith”);


Entity Manager –
Queries
Native Query
@Entity
@Table(name=“CUSTOMER”
@NamedNativeQuery(name=“nativeQuery”,
query=“SELECT c.id FROM customer c WHERE c.lastName = ?)”,
resultClass = Customer.class)

}

Query query = entityManager.createNativeQuery(“nativeQ”);
query.setParameter(1, “Smith”);


Transactions
There are two ways to handle transactions:

• by application (SE)
• by JTA (EE)

<persistence-unit name=“MyUnit" transaction-type="RESOURCE_LOCAL">
or
<persistence-unit name=“MyUnit" transaction-type=“JTA">


Transactions
EntityManger methods:

• begin()
• commit()
• setRollbackOnly()
• rollback()
• isActive()


Transactions
Example:

Transaction t = mng.getTransaction();
try {
t.begin();
mng.persist(obj1);
mng.persist(obj2);
mng.commit();
}
catch (Exception e) {
mng.setRollbackOnly(true);
}
finally {
if (t.isRollbackOnly) t.rollback();
}


Locking
To avoid concurrency access, two types of
locking are available in JPA:

• Optimistic locking
• Pessimistic locking (JPA2.0)


Optimistic Locking
Checks if record has been updated by different
transaction (right before performing operation)

• lock() method
• lock modes:
– READ (OPTIMISTIC in JPA2.0)
– WRITE (OPTIMISTIC_FORCE_INCREMENT)


Optimistic Locking
Example:

@Entity
...
@Version
private Timestamp lastUpdateTimestamp;
}

try {
Customer cust = mng.find(Customer.class, 123);
mng.lock(cust, WRITE);  OPTIMISTIC_FORCE_INCREMENT in JPA2.0
// some update here...
mng.merge(cust);
transaction.commit();
}
catch (OptimisticLockException e) {
System.out.println(“Concurrent update detected!”);
}


Pessimistic Locking
Explicitly locks records in DB to avoid update by
different transaction. Available from JPA2.0.

• lock() method
• lock modes:
– PESSIMISTIC
– PESSIMISTIC_FORCE_INCREMENT


Pessimistic Locking
Example 1 – Lock after read:

...
Customer cust = mng.find(Customer.class, custId);
mng.lock(cust, PESSIMISTIC);
mng.merge(cust);
...

! Risk:
Since we first read and lock afterwards, an OptimisticException can occur
if another transaction updates record meanwhile.

Pessimistic Locking
Example 2 – Lock during read:

...
Customer cust =
mng.find(Customer.class, custId, PESSIMISTIC);
mng.merge(cust);
...

! Risks:
Records are locked longer. Risk of bottlenecks and deadlocks; bad
scalability.

Pessimistic Locking
Example 3 – Read, lock and refresh:

...
Customer cust = mng.find(Customer.class, custId);
mng.refresh(cust, PESSIMISTIC);
mng.merge(cust);
...

Advantage:
Lock is acquired only for time required for update.


Demo


Questions & Comments

Two options to ask a question or add your comments to the discussion:
 Use Raise Hand and then hold down the TALK icon or press the
Copyright © 2009
CTRL key; release when done
Accenture your question in the Chat Room
 Post All Rights

Reserved.

En webinar jpa v2final

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (6)

Semelhante a En webinar jpa v2final

Semelhante a En webinar jpa v2final (20)

Mais de alvaro alcocer sotil

Mais de alvaro alcocer sotil (20)

En webinar jpa v2final

Notas do Editor