BCD Session 05

Business Component Development Using EJB Technologies
Objectives
In this session, you will learn to:

Define Java persistence
Describe Java Persistence API (JPA)
Define entity classes
Define key concepts of Java Persistence API
Manage entity instance life-cycle states
Describe entity instance management
Deploy entity classes
Ver. 1.0
Slide 1 of 52

Examining Java Persistence
The Java persistence specification is the specification of the

Java API for the management of:
Persistence.
Object/relational mapping with Java EE and Java SE.
All Java EE application servers provide an implementation

of the Java Persistence API.
Examine the Java persistence model in the following two
stages:
The first stage presents a static view of persistence.
The second stage presents the dynamic view of persistence.
Ver. 1.0
Slide 2 of 52

Examining Java Persistence (Contd.)
The tasks to be performed by an application component

developer to use the Java Persistence API are:
Define entity classes
Package and deploy the entity classes
Provide application code to create and manage entity
instances
Ver. 1.0
Slide 3 of 52

Object Tier / Data Tier Static and Dynamic Mapping Example
The following figures show three tables in the database tier.

Auction Table
Auction ID
Seller
Item
StartAmount
Increment
Auction
Bidder
Amount
BidTime
Bid Table
BidID
Authorization
Item Table
ItemID
Ver. 1.0
Description
Image
Slide 4 of 52

Object Tier / Data Tier Static and Dynamic Mapping Example (Contd.)
The following figures show three entity classes in the object

tier.
Ver. 1.0
Slide 5 of 52

The following figure shows the dynamic relationship

consisting of data synchronization between the object and
data tiers.
Ver. 1.0
Slide 6 of 52

The following code shows the implementation of an entity

class:
1 @Entity
2 public class Item {
3
4 @Id
5 @GeneratedValue
6 private Integer itemID;
7 private String description;
8 private String image;
9
10
11 /** Creates a new instance of Item */
12 public Item() {
13 }
Ver. 1.0
Slide 7 of 52

14
15
16
17
18
19
20
21
22
23
24
25
26
Ver. 1.0
public Item(String description, String image){

setDescription(description);
setImage(image);
}
public Integer getItemID() {
return itemID;
}
public String getDescription() {
return description;
}
Slide 8 of 52

27
28 public void setDescription(String description)
{
29 this.description = description;
30 }
31
32 public String getImage(){
33 return image;
34 }
35
36 public void setImage(String image) {
37 this.image = image;
38 }
39 }
Ver. 1.0
Slide 9 of 52

Introducing Java Persistence API
Java Persistence API is the specification that deals with the

way relational data are mapped to java objects and how
these objects are stored in the relational databases.
Java persistence API can be commonly used within Java SE
and Java EE environments.
The Java Persistence specification defines the static and
dynamic relationships of the persistence model by defining
the entity component and entity manager object.
Ver. 1.0
Slide 10 of 52

Introducing Java Persistence API (Contd.)
The Java Persistence specifications:

Provide a standard Object-Relational (OR) mapping.
Are not tied to the Java EE container.
Can be tested and used in the J2SE environment.
Enable the use of different entity providers without affecting the
entity code.
Ver. 1.0
Slide 11 of 52

Persistent Fields
If the entity class uses persistent fields then persistence

provider accesses an objects state by reading its variables
directly.
Adhere to the following rules, while defining a persistent
field:
Persistent fields cannot be public.
Persistent field should not be directly read by the client
All fields are persisted regardless of whether they have

been annotated with @Column.
Fields annotated with @Transient or modified with transient
keyword are not persistent.
Ver. 1.0
Slide 12 of 52

Persistent Properties
If an entity class uses persistent properties, then

persistence provider retrieves an objects state by calling its
accessor methods.
For every persistent property of the entity, there is a getter
method getProperty and a setter method setProperty.
If the defined property is of type Boolean then isProperty
method is used instead of getProperty.
While defining a persistent, the methods must be public or
protected and must follow the JavaBeans naming
convention.
The persistence annotations can be applied only on getter
methods.
Ver. 1.0
Slide 13 of 52

Persistent Properties (Contd.)
The method signature for single-valued persistent properties

is:
Type getProperty()
void setProperty(Type type)
Ver. 1.0
Slide 14 of 52

The following code snippet displays the use of persistent

properties:
private int id;
private String message;
@Id @Column(name = "ID")
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
Ver. 1.0
Slide 15 of 52

@Column(name = "MSG")
public String getMessage()
{ return message; }
public void setMessage(String message)
{
this.message = message;
}
Ver. 1.0
Slide 16 of 52

Persistent Data Types
The data types that can be mapped, while using persistent

field or persistent properties are:
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.TimeStamp
Ver. 1.0
Slide 17 of 52

Defining Entity Classes: Essential Tasks
To define an entity class, you are required to:

Declare the entity class.
Verify and override the default mapping.
Ver. 1.0
Slide 18 of 52

Declare the Entity Class
The following steps shows a process to declare the entity

class:
1. Collect information required to declare the entity class.
2. Declare a public Java technology class.
3. If an entity instance is to be passed by value as a detached
object through a remote interface, then ensure the entity class
implements the Serializable interface.
4. Ensure the class does not define the finalize method.
5. Annotate the class with the Entity annotation.
6. Declare the attributes of the entity class.
7. You can optionally declare a set of public getter and setter
methods for every attribute declared.
Ver. 1.0
Slide 19 of 52

Declare the Entity Class (Contd.)
8. Annotate the primary key field or the getter method.

9. Declare a public or protected no-arg constructor that takes no
parameters.
Ver. 1.0
Slide 20 of 52

The following code shows an example of an entity class:

1 @Entity
2 public class Customer implements Serializable {
3 private Long custId;
4 private String name;
5
6 // No-arg constructor
7 public Customer() {}
8
9 @Id
10 public Long getCustId() {
11 return custId;
12 }
13
14 public void setCustId(Long id) {
15 custId = id;
Ver. 1.0
Slide 21 of 52

16
17
18
19
20
21
22
23
24
25
Ver. 1.0
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Slide 22 of 52

Verifying and Overriding the Default Mapping
The following annotations are used while verifying and

overriding the default mapping:
Table annotation
Column annotation
GeneratedValue annotation
Transient annotation
Basic and LOB annotations
Ver. 1.0
Slide 23 of 52

Key Concepts of Java Persistence API
Persistent unit:
Is a set of entity classes that are controlled by EntityManager
instance in an application.
Can be defined as a logical grouping of:
Mapping metadata
Database-related configuration data
Is defined in a special configuration file named as

persistence.xml, which is added to the META-INF directory of
an arbitrary archive, such as EJB-Jar, .WAR, .EAR, or JAR file.
Ver. 1.0
Slide 24 of 52

Key Concepts of Java Persistence API (Contd.)
The persistence.xml files:

Configures which classes make up a persistence unit.
Defines the base of a persistence unit by its location.
Specifies the DataSource used.
Ver. 1.0
Slide 25 of 52

The following code snippet shows an example of using the:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0"
xmlns="http://java.sun.com/xml/ns/persistence">
<persistence-unit name="introduction">
<description> This unit manages the introduction of
the bidder and their personnel details.
</description>
<jta-data-source>jdbc/BidderDB</jta-data-source>
<jar-file>BidderApp.jar</jar-file>
<class>com.bidder.bidderdetails</class></persistence
-unit>
</persistence>
Ver. 1.0
Slide 26 of 52

Entity Manager:
Is the service object that manages the entity lifecycle
instances.
Is the core object, which is used to create, retrieve, update,
and delete data from a database.
Is represented by the instance named
javax.persistence.EntityManager.
The two ways by which an EntityManager instance can be

used are:
Container-managed entity manager
Application-managed entity manager
Ver. 1.0
Slide 27 of 52

Persistence Identity:
Is a unique value used by the container in order to map the
entity instance to the corresponding table row in the database.
Persistence Context:
Is a set of entity instances, which are unique for every
persistence entity identity.
Can have either transaction scope or extended scope.
Ver. 1.0
Slide 28 of 52

Examining Managing Entity Instance Life-Cycle States
An entity manager is the service object that manages entity

life-cycle instances.
The four life-cycle states of an entity instance are:
New
Managed
Detached
Removed
Every entity manager is associated with a persistence

context.
A persistence context is a set of entity instances in which
there is a unique entity instance for any persistence identity.
The persistent identity is a unique value used by the
persistence provider to map the entity instance to the
corresponding table row in the database.
Ver. 1.0
Slide 29 of 52

Examining Managing Entity Instance Life-Cycle States (Contd.)
A persistence context can have the following lifetime

scopes.
Transaction scope
Extended scope
Ver. 1.0
Slide 30 of 52

Examining Managing Entity Instance Life-Cycle States (Contd.)
The following figure shows the possible states of an entity

instance.
Ver. 1.0
Slide 31 of 52

Entity Instance Management
When a reference to an entity manager has been obtained,

you use the methods of entity instance to read and write to
the database.
Ver. 1.0
Slide 32 of 52

Entity Manager Methods
The complete EntityManager API provides following

methods for the three kinds of operations:
Entity life-cycle management
Database synchronization operations
Entity lookup and queries
Some of the Entity Manager methods are:
Ver. 1.0
Methods
Description
flush
Forces the synchronization of the database with entities.
find
Finds an entity instance by executing a query by primary

key on the database
Contains
Returns true if the entity instance is in the persistence

context, implying that the entity instance is managed.
merge
Merges the state of the given entity into the current

persistence context
persist
Make an entity instance managed and persistent
remove
Remove the entity instance

Slide 33 of 52

Entity Life-Cycle Callback Annotations
Every persistent event corresponds to a callback method.

These methods are shared between the persistent classes
and there listeners.
The life-cycle callbacks are invoked by the persistence
provider and not by the EJB Container.
The Java Persistence API specification defines the following
life-cycle events for the entities:
PrePersist
PostPersist
PreRemove
PostRemove
PreUpdate
PostUpdate
PostLoad
Ver. 1.0
Slide 34 of 52

Versioning
The Java Persistence API specification highlights the

addition of version numbers to the entity data.
Versioning ability has to be manually enabled by the
developer.
The version number of an entity is also looked up when an
entity is retrieved from a database.
When an entity is modified and committed to the database,
the in-memory version number is compared with the version
number currently stored in the database.
If the version numbers match, the update is allowed and the
version number in the database is automatically
incremented.
If the version numbers did not match, an exception
javax.persistence.OptimisticLockException is thrown.
Ver. 1.0
Slide 35 of 52

Using Entities to Interact With the Database
You can use entity instances and the EntityManager API to

perform the following tasks:
Create a new entry in the database.
Locate and fetch an entry from the database.
Update an entry in the database.
Delete an existing entry in the database.
Ver. 1.0
Slide 36 of 52

Using Entities to Interact With the Database (Contd.)
The following code shows entity instance management

using transaction scoped persistence context:
1
2
3
4
5
6
@Stateful
public AppManagerBean implements AppManager {
@PersistenceContext
private EntityManager entityManager;
public Item createItemEntry(String description,

String image) {
7 Item item = new Item(description, image);
8 entityManager.persist(item);
9 return item;
10 }
11
Ver. 1.0
Slide 37 of 52

12 public Item findItem(Integer key) {
13 Item item = entityManager.find(Item.class, key);
14 return item;
15 }
16
17 public Item updateItemImage(Item item) {
18 // assume item has been updated prior to method
invocation
19 Item item1 = entityManager.merge(item);
20 return item1;
21 }
22
23 public Item updateItemImage(Integer key, String
newImage) {
24 Item item = entityManager.find(Item.class, key);
Ver. 1.0
Slide 38 of 52

25 item.setImage(newImage);
26 return item;
27 }
28
29 public Item updateItemImage(Item item, String
newImage) {
30 // item is detached intance; item1 is managed
instance
31 Item item1 = entityManager.merge(item);
32 item1.setImage(newImage);
33 return item1;
34 }
35
36 public Item updateItemImage(String newImage, Item
item) {
Ver. 1.0
Slide 39 of 52

37 item.setImage(newImage); // item is detatched
instance
38 Item item1 = entityManager.merge(item); // item1 is
managed
39 return item1;
40 }
41
42 public Item deleteItem(Integer key) {
43 Item item = findItem(key);
44 entityManager.remove(item);
45 return item;
46 }
47
48 public Item deleteItem(Item item) {
Ver. 1.0
Slide 40 of 52

49
50
51
52
53
Ver. 1.0
item = entityManager.find(Item.class, item.getId);

entityManager.remove(item); // managed instance
return item;
}
}
Slide 41 of 52

Deploying Entity Classes
To deploy entity classes, you are required to create a

persistence unit.
A persistence unit is a logical grouping of all the elements
required by the container to support the persistence
management of an application.
The required components of a persistence unit are:
All managed (entity) classes
Object relational mapping metadata
Entity manager factory and entity managers
Configuration information for the entity manager factory and
entity managers
A persistence.xml file
Ver. 1.0
Slide 42 of 52

Deploying Entity Classes (Contd.)
For deployment to a Java EE application server, the

components of the persistence unit must be placed in one of
the following locations:
In a EAR file
In a EJB-JAR file
In a WAR file
In an application client JAR file
Ver. 1.0
Slide 43 of 52

Creating a Persistence Unit Using Default Settings
The following figure shows persistence unit components in

default settings within an EJB-JAR.
Ver. 1.0
Slide 44 of 52

Creating a Persistence Unit Using Default Settings (Contd.)
To create a persistence unit within in an EJB-JAR file using

the default settings for various components of the
persistence unit, adhere to the following steps:
1. If not already expanded, expand the EJB-JAR archive.
2. Create subdirectories that reflect the full qualified names of
the managed classes you need to include in the persistence
unit.
3. Copy all the classes you need into the directories created in
Step 2.
4. Create a minimal persistence.xml file.
5. Copy the persistence.xml file into the META-INF directory off
the EJB-JAR root directory.
6. Create (archive) the EJB-JAR module.
Ver. 1.0
Slide 45 of 52

Creating a Persistence Unit Using Default Settings (Contd.)
The following code shows an example of the minimal

persistence XML file:
1 <persistence>
2 <persistence-unit name="OrderManagement"/>
3 <persistence>
Ver. 1.0
Slide 46 of 52

Examining a Persistence Unit Using Non Default Settings
The following code shows an example of a persistence XML

file denoting the use of non-default settings:
1 <persistence>
2 <persistence-unit name="OrderManagement5"
transaction-type=JTA>
3 <provider>com.acme.persistence</provider>
4 <jta-data-source>jdbc/MyPartDB</jta-data-source>
5 <mapping-file>product.xml</mapping-file>
6 <mapping-file>order.xml</mapping-file>
7 <exclude-unlisted-classes/>
8 <jar-file>product.jar</jar-file>
9 <jar-file>product-supplemental.jar</jar-file>
10 <class>com.acme.Order</class>
Ver. 1.0
Slide 47 of 52

Examining a Persistence Unit Using Non Default Settings (Contd.)
11
12
13
14
<class>com.acme.Customer</class>
<class>com.acme.Item</class>
<properties>
<property name="com.acme.persistence.sql-logging"
value="on"/>
15 </properties>
16 </persistence-unit>
Ver. 1.0
Slide 48 of 52

Summary
In this session, you learned that:

All Java EE application servers are required to provide an
implementation of the Java Persistence API.
The Java persistence model can be examined in the following
two stages:
The first stage presents a static view of persistence.
The second stage presents the dynamic view of persistence.
The Java Persistence specification

Provides a standard Object-Relational (OR) mapping.
Is not tied to the Java EE container.
Can be tested and used in the J2SE environment.
Enables to use different entity providers without affecting
the entity code.
Ver. 1.0
Slide 49 of 52

Summary (Contd.)
An entity is a persistence domain object that represents a table

in a relational database.
The persistent state of an entity is represented either through
persistent fields or persistent properties.
A persistence unit is defined in a special configuration file
named as persistence.xml, which controls the configuration of
a persistent unit.
An entity manager is the service object which is used to create,
retrieve, update, and delete data from a database.
Ver. 1.0
Slide 50 of 52

Summary (Contd.)
A persistence context is a set of entity instances. These entity

instances are unique for every persistence entity identity The
Java Persistence API specification defines the following
life-cycle annotations for the entities:
@PrePersist
@PostPersist
@PreRemove
@PostRemove
@PreUpdate
@PostUpdate
@PostLoad
The Java Persistence API specification highlights the version
numbers added to the entity data that helps to avoid
over-writing other data updates accidentally. The @Version
annotation is used to enable versioning.
Ver. 1.0
Slide 51 of 52

Summary (Contd.)
To define an entity class, you are required to:

Declare the entity class.
Verify and override the default mapping.
The four life-cycle states of an entity instance are:

New
Managed
Detached
Removed
A persistence context is a set of entity instances, which has a

unique entity instance for any persistence identity.
Ver. 1.0
Slide 52 of 52

BCD Session 05

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

BCD Session 05

Uploaded by

Copyright:

Available Formats

Business Component Development Using EJB Technologies

In this session, you will learn to:

Business Component Development Using EJB Technologies

The Java persistence specification is the specification of the

All Java EE application servers provide an implementation

Business Component Development Using EJB Technologies

The tasks to be performed by an application component

Business Component Development Using EJB Technologies

The following figures show three tables in the database tier.

Business Component Development Using EJB Technologies

The following figures show three entity classes in the object

Business Component Development Using EJB Technologies

The following figure shows the dynamic relationship

Business Component Development Using EJB Technologies

The following code shows the implementation of an entity

Business Component Development Using EJB Technologies

public Item(String description, String image){

Business Component Development Using EJB Technologies

Business Component Development Using EJB Technologies

Java Persistence API is the specification that deals with the

Business Component Development Using EJB Technologies

The Java Persistence specifications:

Business Component Development Using EJB Technologies

If the entity class uses persistent fields then persistence

All fields are persisted regardless of whether they have

Business Component Development Using EJB Technologies

If an entity class uses persistent properties, then

Business Component Development Using EJB Technologies

The method signature for single-valued persistent properties

Business Component Development Using EJB Technologies

The following code snippet displays the use of persistent

Business Component Development Using EJB Technologies

Business Component Development Using EJB Technologies

The data types that can be mapped, while using persistent

Business Component Development Using EJB Technologies

To define an entity class, you are required to:

Business Component Development Using EJB Technologies

The following steps shows a process to declare the entity

Business Component Development Using EJB Technologies

8. Annotate the primary key field or the getter method.

Business Component Development Using EJB Technologies

The following code shows an example of an entity class:

Business Component Development Using EJB Technologies

Business Component Development Using EJB Technologies

The following annotations are used while verifying and

Business Component Development Using EJB Technologies

Is defined in a special configuration file named as

Business Component Development Using EJB Technologies

The persistence.xml files:

Business Component Development Using EJB Technologies

The following code snippet shows an example of using the:

Business Component Development Using EJB Technologies

The two ways by which an EntityManager instance can be

Business Component Development Using EJB Technologies

Business Component Development Using EJB Technologies

An entity manager is the service object that manages entity

Every entity manager is associated with a persistence

Business Component Development Using EJB Technologies

A persistence context can have the following lifetime

Business Component Development Using EJB Technologies

The following figure shows the possible states of an entity

Business Component Development Using EJB Technologies

When a reference to an entity manager has been obtained,

Business Component Development Using EJB Technologies