Data persistence is the ability to maintain data between
application executions. Persistence is vital to enterprise applications
because of the required access to relational databases. Applications
that are developed for this environment must manage persistence themselves
or use 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 EJB 3.1 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 metadata 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.
Java EE containers that support
the EJB 3.x 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 an
EJB 3.x environment:
- Persistence unit
- Consists of the declarative metadata 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. An instance of an EntityManagerFactory represents a Persistence
Context.
- 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 metadata 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.x session beans
- EJB 3.x 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
- JavaServer 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 Guide. For
more information and examples on specific elements of persistence,
see the sections on the EntityManagerFactory, and the EntityManager
in the Apache OpenJPA User Guide.