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 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. If there is no container
to manage JPA, the application must handle the persistence 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, while larger, can function in a container environment
or a Java SE environment.
Elements of a JPA Persistence Provider
Java EE containers that support JPA must supply a persistence provider.
A JPA persistence provider uses the following elements to allow for easier
persistence management in an EJB 3.0 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.
Note: Injection of the EntityManager is only supported for the
following artifacts:
- EJB 3.0 session beans
- EJB 3.0 message-driven beans
- servlets, but injection is not supported in JSPs
- the main class of the application client.
- Entity objects: a simple Java class that represents a row in a
database table. 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.