Java Persistence API
The Java Persistence API (JPA) is
a Java application programming interface specification that
describes the management of relational data in applications using Java Platform,
Standard Edition and Java Platform, Enterprise Edition.
The Java Persistence API provides a POJO persistence model for
object-relational mapping (ORM).
ORM is a programming ability to covert data from object type to
relational type and vice versa. The main feature of ORM is mapping or binding
an object to its data in the database.
Following architecture explains the flow of storing objects into
any relational database.
Understanding the above architecture:
Module 1: In this module
there will be Object data under POJO classes and business logic under service
interfaces and classes will be implemented. It is the main business component
layer, which has business logic operations and attributes.
For example let us take any table ‘Payment’ from any database:
Payment POJO class contain attributes such as Id, CompanyId, Status,
Payment type etc.
And methods like setter and getter methods of those attributes
and Payment DAO/Service classes contains service methods such as create Payment,
find Payment etc.
Module 2: In this module we
will be creating the bindings for data mapping using the Java persistence
framework.
This module will be holding the persistence.xml (replicating the
ORM config file ORM.xml), JPA loader, JPA provider and Object grid.
1. JPA Provider: Any vendor
product providing the Java Persistence flavor like Eclipselink, Hibernate,
Toplink.
2. Object mapping file: This will be
persistence.xml in case of Eclipselink based implementation or it could be any
ORM.xml file depending on the vendor we have selected.
3. JPA Loader: This acts like a
cache memory which holds relational grid data and works as if a copy of
database to interact with Service classes for data in POJOs for our
implementation.
4. Object Grid: It is a temporary
location holding data before all queries hit the database it is first effected
on the data in the object grid. Only after it is committed, it effects the main
database.
Module 3: This is the last
phase where object – data mapping actually comes into action and deals with the
database for Select / Insert / Update / Delete data.
Only when the business component commit the data, it is stored
into the database physically. Until then the modified data is stored in a cache
memory as a grid format. Same is the process for obtaining data.
There are following areas which can be covered in Java
Persistence
·
The Java Persistence API
·
The query language
·
The Java Persistence Criteria API
·
Object/relational mapping metadata
Where to use JPA?
To reduce the burden of writing codes for relational object
management, a programmer follows the ‘JPA Provider’ framework. It brings
following benefits along with its ORM framework / implementation:
·
Idiomatic persistence: It enables you to write the persistence
classes using object oriented classes.
·
High Performance: It has many fetching techniques and hopeful
locking techniques.
·
Reliable: It is highly stable and eminent. Used by many
industrial programmers.
Entities
An entity is a lightweight persistence domain object. Typically
an entity represents a table in a relational database, and each entity instance
corresponds to a row in that table.
An entity class must follow these requirements.
·
The class must be annotated with the javax.persistence.Entity
annotation.
·
The class must have a public or protected, no-argument
constructor. The class may have other constructors.
·
The class must not be declared final. No methods or persistent
instance variables must be declared final.
·
Entities may extend both entity and
non-entity classes, and non-entity classes may extend entity classes.
·
The persistent state of an entity can
be accessed through either the entity’s instance variables or properties. The
fields or properties must be of the following Java language types:
§ Java primitive types
§ java.lang.String
§ Other serializable types, including:
§ Wrappers of Java primitive types
§ java.math.BigInteger
§ java.math.BigDecimal
§ java.util.Date
§ java.util.Calendar
§ java.sql.Date
§ java.sql.Time
§ java.sql.TimeStamp
§ User-defined serializable types
§ byte[]
§ Byte[]
§ char[]
§ Character[]
·
If the entity class uses persistent
fields, the Persistence runtime accesses entity-class instance variables
directly. All fields not annotated javax.persistence.Transient or not marked as
Java transient will be persisted to the data store.
·
Primary Keys in Entities
Each entity has a unique object identifier. A customer
entity, for example, might be identified by a customer number. The unique
identifier, or primary key, enables clients to locate a particular entity
instance. Every entity must have a primary key. An entity may have either a
simple or a composite primary key.
Simple primary keys use the javax.persistence.Id
annotation to denote the primary key property or field.
