Module 8 The Java Persistence API

Transcription

1 Module 8 The Java Persistence API Objectives Describe the role of the Java Persistence API (JPA) in a Java EE application Describe the basics of Object Relational Mapping Describe the elements and environment of an entity Component Describe the life cycle and operational characteristics of entity components 220 Ω Omega Ω 1

2 Examining Java Persistence What is data persistence? What is the Java persistence specification? How does the Java Persistence API relate to Java EE application servers? What are the key features of the persistence model specified in the Java Persistence API? 221 Ω Omega Ω Static Relationship Mapping - Data Tier Elements 222 Ω Omega Ω 2

3 Static Relationship Mapping - Object Tier Elements 223 Ω Omega Ω Dynamic Relationship -Object/Data TierData Synchronization With entities, the data synchronization is maintained by the persistence provider. 224 Ω Omega Ω 3

4 The Java Persistence API The Java Persistence API: Replaces EJB 2.1 Entity Beans with non-ejb entity classes Is a standard API for specifying Object-to-Relational mapping information Can be used with or without a Java EE Application Server Container-Managed Persistence Application-Managed Persistence 225 Ω Omega Ω Object Relational Mapping Object Relational Mapping (ORM) software: Provides an object-oriented view of the database Examples include Oracle s Toplink and Hibernate 226 Ω Omega Ω 4

5 Normalized Data Mapping 227 Ω Omega Ω Use of an Entity Component Across a Set of Database Tables 228 Ω Omega Ω 5

6 Entity Class Requirements Entity classes are coded as standard Java classes with the following requirements: javax.persistence.entity annotation on the class or declared as an Entity in a deployment descriptor Must be a public class No-argument constructor with public or protected access Open to extension, in other word they are not final classes Implement Serializable if they are to be returned by remote session beans Top-level class, entity classes cannot be inner classes 229 Ω Omega Ω import java.io.serializable; import javax.persistence.*; Entity = "TABLE1") public class MyEntity implements = "ID") private int = "MSG") private String message; protected MyEntity() { public MyEntity(int id, String message) { this.id = id; this.message = message; public int getid() { return id; public String getmessage() { return message; public void setmessage(string message) { this.message = message; 230 Ω Omega Ω 6

7 Persistent Fields as Opposed to Persistent Properties Entity classes have their state synchronized with a database. The state of an entity class is obtained from either its variables (fields) or its accessor methods (properties). Fieldbased or property-based access: Determined by the placement of annotations Cannot have both field-based and property-based access 231 Ω Omega Ω Persistent Fields When using persistent fields, the persistence provider retrieves an object s state by reading its variables. Persistent fields cannot be public Should not be read by clients directly Unless annotated or modified with the transient keyword, all variables are persisted regardless of whether they have annotation. = "ID") private int = "MSG") private String message; public int getid() { return id; public String getmessage() { return message; public void setmessage(string message){ this.message=message; 232 Ω Omega Ω 7

8 Persistent Properties When using persistent properties, the persistence provider retrieves an object s state by calling its accessor methods. Methods must be public or protected Methods follow the JavaBeans naming convention Persistence annotations can only be on getter methods private int id; private = "ID") public int getid() { return id; public void setid(int id) { this.id = = "MSG") public String getmessage() { return message; public void setmessage(string message) {this.message=message; 233 Ω Omega Ω Persistence Data Types Persistence fields or properties can be of the following data types Java primitive types Java wrappers, such as java.lang.integer java.lang.string byte[] and Byte[] char[] and Character[] Any serializable types including but not limited to: java.util.date java.sql.date java.sql.timestamp 234 Ω Omega Ω 8

9 The Concept of a Primary Key An entity component distinguishes itself and the data it represents from other entities using a primary key. A primary key gives an entity instance its persistent identity. They are typically a string or an integer but can also be custom classes that correspond to several database table columns. Every entity class must have a primary key. Can be = = "ID", nullable = false) private int id; 235 Ω Omega Ω Entity Component Primary Key Association 236 Ω Omega Ω 9

10 Persistence Units A persistence unit is a collection of entity classes stored in a EJB-Jar, WAR, or JAR archive along with a persistence.xml file. A persistence unit: Defines what entity classes will be controlled by an entity manager Is limited to a single DataSource 237 Ω Omega Ω The persistence.xml file The persistence.xml file: Configures which classes make up a persistence unit Defines the base of a persistence unit Specifies the DataSource used <?xml version="1.0" encoding="utf-8"?> <persistence version="1.0 xmlns=" <persistence-unit name="brokertool-ejb" transaction-type="jta"> <jta-data-source>stockmarket</jta-data-source> <jar-file>brokerlibrary.jar</jar-file> <properties/> </persistence-unit> </persistence> 238 Ω Omega Ω 10

11 The Persistence Context A persistence context can be thought of as a working copy of a persistence unit. Several persistence contexts using the same persistence unit can be active at the same time. A persistence context: Typically lasts the duration of a transaction Limits entity instances to a single instance per persistent identity Has a management API, known as the entity manager 239 Ω Omega Ω The Entity Manager An Entity Manager provides methods to control events of a persistence context and the life cycle of entity instances in a persistence context. An Entity Manager: Provides operations, such as flush(), find(), and createquery(), to control a persistence context Replaces some of the functionality of home interfaces in EJB 2.1 Entity Beans Obtained using dependency injection in managed private EntityManager em; 240 Ω Omega Ω 11

12 Entity public class BrokerModelImpl implements BrokerModel private EntityManager em; public Stock getstock(string symbol) throws BrokerException{ Stock stock = em.find(stock.class, symbol); if (stock!= null) { return stock; else { throw new BrokerException("Stock : "+symbol+ " not found"); public void addstock(stock stock) throws BrokerException{ try { em.persist(stock); catch(entityexistsexception exe) { throw new BrokerException("Duplicate Stock : " Ω Omega Ω stock.getsymbol()); public void updatestock(stock stock) throws BrokerException { Stock s = em.find(stock.class, stock.getsymbol()); if (s == null) { throw new BrokerException("Stock : " + stock.getsymbol() " not found"); else { em.merge(stock); public void deletestock(stock stock) throws BrokerException { String id = stock.getsymbol(); stock = em.find(stock.class, id); if (stock == null) throw new BrokerException("Stock : " + stock.getsymbol() +" not found"); else em.remove(stock); 242 Ω Omega Ω 12

13 Entity Instance Life Cycle and Entity Manager Methods 243 Ω Omega Ω Entity Bean States Entity beans have a transitional life cycle. An entity can exist in one of four states: New The entity instance is newly created and not connected to a persistence context. Managed The entity instance is connected to a persistence context and has a unique entity identity. Only one managed instance of a identity can exist in a persistence context. Detached The entity instance is not connected to a persistence context. Removed The entity instance is scheduled for deletion. 244 Ω Omega Ω 13

14 Entity Manager Methods 245 Ω Omega Ω Entity Life Cycle Callback Annotations An entity instance can be notified before or after life- cycle changes using specially annotated methods in the entity class. @PreUpdate 246 Ω Omega Ω 14

15 Deploying Entity Classes To deploy entity classes, you must create a persistence unit. A persistence unit includes entity classes and a persistence.xml configuration file. The persistence unit exists inside of Java EE modules, such as EJB-JAR files and WAR files. Within these Java EE modules, you can have persistence units that include library jars. 247 Ω Omega Ω Creating a Persistence Unit Using Default Settings A persistence unit attempts to include all entity classes in the same EJB module as the persistence.xml file. 248 Ω Omega Ω 15

16 Examining a Persistence Unit Using Non- Default Settings A persistence unit can be made to include library jar files it would not normally include. 249 Ω Omega Ω A Native Query Example Native queries are easier to use because they do not require that you learn the Java Persistence query language. However, native queries should not be used extensively because they are non-portable. Query query = em.createnativequery("select * FROM Customer", Customer.class); List customers = query.getresultlist(); Query query = em.createnativequery("select * FROM SHARES WHERE SSN = '" + customerid + "'", CustomerShare.class); List shares = query.getresultlist(); 250 Ω Omega Ω 16