Jakarta Persistence

This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "Jakarta Persistence" – news · newspapers · books · scholar · JSTOR (June 2010) (Learn how and when to remove this message)

Jakarta Persistence, also known as JPA (abbreviated from formerly name Java Persistence API) is a Jakarta EE application programming interface specification that describes the management of relational data in enterprise Java applications.

Persistence in this context covers three areas:

• The API itself, defined in the jakarta.persistence package (javax.persistence for Jakarta EE 8 and below)
• The Jakarta Persistence Query Language (JPQL; formerly Java Persistence Query Language)
• Object/relational metadata

The reference implementation for JPA is EclipseLink.^[1]

The final release date of the JPA 1.0 specification was 11 May 2006 as part of Java Community Process JSR 220. The JPA 2.0 specification was released 10 December 2009 (the Java EE 6 platform requires JPA 2.0^[2]). The JPA 2.1 specification was released 22 April 2013 (the Java EE 7 platform requires JPA 2.1^[3]). The JPA 2.2 specification was released in the summer of 2017. The JPA 3.1 specification, the latest version, was released in the spring of 2022 as part of Jakarta EE 10.^[1]

A persistence entity is a lightweight Java class with its state typically persisted to a table in a relational database. Instances of such an entity correspond to individual rows in the table. Entities typically have relationships with other entities, and these relationships are expressed through object/relational mapping (ORM) metadata. This metadata may be specified directly in the entity class file by using annotations or in a separate XML descriptor file distributed with the application.

An example entity class with ORM metadata declared using annotations (import statements and setters/getters are omitted for simplicity).

@Entity public class Person {     @Id     private long id;     private String firstName;     private String lastName;     private int age; } 

The @Entity annotation declares that the class represents an entity. @Id declares the attribute which acts as the primary key of the entity. Additional annotations may be used to declare additional metadata (for example changing the default table name in the @Table annotation), or to create associations between entities.

The Jakarta Persistence Query Language (JPQL; formerly Java Persistence Query Language) makes queries against entities stored in a relational database. Queries resemble SQL queries in syntax but operate against entity objects rather than directly with database tables.

Prior to the introduction of EJB 3.0 specification, many enterprise Java developers used lightweight persistent objects provided by either persistence frameworks (such as Hibernate) or data access objects (DAO) instead of by using entity beans. This is because entity beans, in previous EJB specifications, called for much complicated code and imposed a heavy resource footprint, and they could be used only on Java EE application servers because of interconnections and dependencies in the source code between beans and DAO objects or persistence frameworks. Thus, many of the features originally presented in third-party persistence frameworks were incorporated into the Java Persistence API, and projects such as Hibernate and TopLink Essentials have become implementations of the Java Persistence API specification.

The EJB 3.0 specification (itself part of the Java EE 5 platform) included a definition of the Java Persistence API. However, developers do not need an EJB container or a Java EE application server to run applications that use this persistence API.^[4] Future versions of the Java Persistence API will be defined in a separate JSR and specification rather than in the EJB JSR/specification.

The Java Persistence API replaces the persistence solution of EJB 2.0 CMP (Container-Managed Persistence).

The Java Persistence API was developed in part to unify the Java Data Objects API and the EJB 2.0 Container Managed Persistence (CMP) API. Most products supporting each of the two APIs support the Java Persistence API.

The Java Persistence API specifies persistence only for relational database management systems by focusing on object-relational mapping (ORM). Some JPA providers support other database models, though this is outside the scope of JPA's design. The introduction section of the JPA specification states: "The technical objective of this work is to provide an object/relational mapping facility for the Java application developer using a Java domain model to manage a relational database."^[5]

The Java Data Objects specification supports ORM as well as persistence to other types of database models, for example, flat file databases and NoSQL databases, including document databases, graph databases any many other datastores.

The designers^[6] of the Java Persistence API aimed to provide for relational persistence, with many of the key areas taken from object-relational mapping tools such as Hibernate and TopLink. Java Persistence API improved on and replaced EJB 2.0, evidenced by its inclusion in EJB 3.0. The Service Data Objects (SDO) API (JSR 235) has a very different objective to that of the Java Persistence API and is considered ^[7][8] complementary. The SDO API is designed for service-oriented architectures, multiple data formats rather than only relational data and multiple programming languages. The Java Community Process manages the Java version of the SDO API; the C++ version of the SDO API is managed via OASIS.

Hibernate, founded by Gavin King, provides an open source object-relational mapping framework for Java. Versions 3.2 and later provide an implementation for the Java Persistence API.^[9][10] King represented JBoss on JSR 220,^[11] the JCP expert group charged with developing JPA. This led to ongoing controversy and speculation surrounding the relationship between JPA and Hibernate.^{[citation needed]} Sun Microsystems stated^[12] that ideas came from several frameworks, including Hibernate and Java Data Objects.

The Spring Data JPA is an implementation of the repository abstraction that is a key building block of domain-driven design based on the Java application framework Spring. It transparently supports all available JPA implementations and supports CRUD operations as well as the convenient execution of database queries.^{[13]: 47 [14]}

Development of a new version of JPA 2.0 was started in July 2007 in the Java Community Process as JSR 317. JPA 2.0 was approved as final on 10 December 2009. The focus of JPA 2.0 was to address features that were present in some of the popular ORM vendors but could not gain consensus approval for JPA 1.0.

Main features included were:

• Expanded object-relational mapping functionality
  • Support for collections of embedded objects, linked in the ORM with a many-to-one relationship
  • Ordered lists
  • Combinations of access types
• A criteria query API
• Standardization of SQL Hints
• Standardization of additional metadata to support DDL generation
• Support for validation
• Shared object cache support.

Vendors supporting JPA 2.0:

• Batoo JPA
• DataNucleus (formerly JPOX)
• EclipseLink (formerly Oracle TopLink)
• IBM, for WebSphere Application Server^[15]
• JBoss with Hibernate
• ObjectDB
• OpenJPA
• OrientDB
• Versant Corporation JPA (object database)^[16]

Development of JPA version 2.1 began in July 2011 as JSR 338. JPA 2.1 was approved as final on 22 May 2013.

Main features included were:

• Converters, which allow custom code conversions between database and object types
• Criteria update/delete to allow bulk updates and deletes through the Criteria API
• Entity graphs for partial or specified fetching or merging of objects.
• JPQL/Criteria enhancements such as arithmetic subqueries, generic database functions, join ON clause and the TREAT option.
• Schema generation
• Support for stored procedures

Vendors supporting JPA 2.1:

• DataNucleus
• EclipseLink
• Hibernate
• OpenJPA (from version 2.2.0)

Development of JPA 2.2, a maintenance release, began in 2017 under JSR 338. The maintenance review was approved on 19 June 2017.

Main features included were:

• The addition of @Repeatable to all relevant annotations
• Support for JPA annotations to be used in metaannotations
• Streaming for query results
• The ability for AttributeConverters to be CDI-injectable
• Support for Java 8 date and time types

Vendors supporting JPA 2.2:

• DataNucleus (from version 5.1)
• EclipseLink (from version 2.7)
• Hibernate (from version 5.3)
• OpenJPA (from version 3.0)

The JPA was renamed as Jakarta Persistence in 2019 and version 3.0 was released in 2020. This included the renaming of packages and properties from javax.persistence to jakarta.persistence.

Vendors supporting Jakarta Persistence 3.0:

• DataNucleus (from version 6.0)
• EclipseLink (from version 3.0)
• Hibernate (from version 5.5)
• OpenJPA (from version 4.0)

Version 3.1 was released in 2022.^[1] It is part of Jakarta EE 10, and thus requires at least Java 11 to run. It adds better UUID handling, various new JPQL functions for math and date/time handling, and other small changes.^[17]

Vendors supporting Jakarta Persistence 3.1:

• DataNucleus (from version 6.0)
• EclipseLink (from version 4.0)^[18]
• Hibernate (from version 6.0)^[19]
• OpenJPA (from version 4.0)

• .NET Persistence API (NPA)
• JDBC

• Deinum, Marten; Rubio, Daniel; Long, Josh; Mak, Gary (September 1, 2014). Spring Recipes: A Problem-Solution Approach (Second ed.). Apress. ISBN 978-1-4302-2499-0.

Wikibooks has a book on the topic of: Java Persistence

• Official website
• Documentation for the final version of the EJB3 spec (called JSR220)
• GlassFish's Persistence page Archived 2013-01-12 at archive.today
• JCP Persistence page

• Java EE 6 Persistence API Javadoc
• Java EE 6 Persistence API tutorial
• Java EE 7 Persistence API Javadoc
• Java EE 7 Persistence API tutorial
• Persistence in the Java EE 5 tutorial