Data persistence, the ability to maintain data between
application executions, is vital to enterprise applications because
the required access to relational databases. Applications that are
developed for this environment must manage persistence themselves
or make use of third-party solutions to handle database updates and
retrievals with persistence. The Java Persistence
API (JPA) provides a mechanism for managing persistence and object-relational
mapping and functions for the EJB 3.0 and later specifications.
The JPA specification defines the object-relational mapping internally,
rather than relying on vendor-specific mapping implementations. JPA
is based on the Java programming model that applies
to Java EE environments, but JPA can function within
a Java SE environment for testing application
functions.
JPA represents a simplification of the persistence programming
model. The JPA specification explicitly defines the object-relational
mapping, rather than relying on vendor-specific mapping implementations.
JPA standardizes the important task of object-relational mapping by
using annotations or XML to map objects into one or more tables of
a database. To further simplify the persistence programming model:
- The EntityManager API can persist, update, retrieve, or remove
objects from a database
- The EntityManager API and object-relational mapping meta-data
handle most of the database operations without requiring you to write
JDBC or SQL code to maintain persistence
- JPA provides a query language, extending the independent EJB querying
language (also known as JPQL), that you can use to retrieve objects
without writing SQL queries specific to the database you are working
with.
JPA is designed to operate both inside and outside of a Java Enterprise Edition (Java EE)
container. When you run JPA inside a container, the applications can
use the container to manage the persistence context. If there is no
container to manage JPA, the application must handle the persistence
context management itself. Applications that are designed for container-managed
persistence do not require as much code implementation to handle persistence,
but these applications cannot be used outside of a container. Applications
that manage their own persistence can function in a container environment
or a Java SE environment.
Elements of a JPA Persistence Provider
Java EE containers that support the EJB 3.0 and later programming
model must support a JPA implementation, also called a persistence
provider. A JPA persistence provider uses the following elements to
allow for easier persistence management in this type of environment:
- Persistence unit: consists of the declarative meta-data
that describes the relationship of entity class objects to a relational
database. The EntityManagerFactory uses this data to create a persistence
context that can be accessed through the EntityManager.
- EntityManagerFactory: used to create an EntityManager for
database interactions. The application server containers typically
supply this function, but the EntityManagerFactory is required if
you are using JPA application-managed persistence.
- Persistence context: defines the set of active instances
that the application is manipulating currently. The persistence context
can be created manually or through injection.
- EntityManager: the resource manager that maintains the
active collection of entity objects that are being used by the application.
The EntityManager handles the database interaction and meta-data for
object-relational mappings. An instance of an EntityManager represents
a persistence context. An application in a container can obtain the
EntityManager through injection into the application or by looking
it up in the Java component name-space. If the
application manages its persistence, the EntityManager is obtained
from the EntityManagerFactory.
Attention: Injection of
the EntityManager is only supported for the following artifacts:
- EJB 3.0 session beans
- EJB 3.0 message-driven beans
- Servlets, Servlet Filters, and Listeners
- JSP tag handlers which implement interfaces javax.servlet. jsp.tagext.Tag
and javax.servlet.jsp.tagext.SimpleTag
- Java Server Faces (JSF) managed beans
- the main class of the application client.
- Entity objects: a simple Java class that represents a row
in a database table in its simplest form. Entities objects can be
concrete classes or abstract classes. They maintain states by using
properties or fields.
For more information about persistence, see the section on Java Persistence API Architecture and the section
on Persistence in the Apache OpenJPA User's Guide. For more information
and examples on specific elements of persistence, refer to the sections
on the EntityManagerFactory, and the EntityManager in the Apache OpenJPA
User's Guide.