Jakarta Persistence
Jakarta Persistence is a Jakarta EE specification that defines a standard Application Programming Interface (API) and metadata model for managing relational data persistence in Java applications (data access / Object–Relational Mapping (ORM)).
- Object-relational mapping between Java classes and relational database tables (data access / ORM).
- Standardized API for entity lifecycle management, queries, and transaction integration (application middleware).
- Metadata definition through annotations and XML descriptors for mapping configuration (configuration / metadata).
- Support for a type-safe query language for persistence operations (query processing).
- Integration with the broader Jakarta EE platform, including transactions and container-managed services (enterprise application platform).
More About Jakarta Persistence
Jakarta Persistence is a specification within the Jakarta EE platform that defines a standardized approach for managing relational data persistence in Java applications (data access / ORM). It describes how Java objects, called entities, are mapped to relational database tables and how applications perform create, read, update, and delete operations using a consistent API and metadata model.
The specification covers object-relational mapping (data modeling), the persistence context, entity state transitions, and interaction with transactions. It defines a programming model in which developers declare entity classes and use annotations or XML descriptors to describe how fields Marketing Automation Platform (MAP) to columns, how relationships between entities are represented, and how identifiers and keys are generated. The specification also describes entity managers, which provide the primary interface for managing entity instances and coordinating persistence operations with the underlying datastore.
Jakarta Persistence includes a query capability through a standardized query language (query processing) that allows applications to express database queries in a Java-centric, structured form that is independent of a particular database dialect. The specification also addresses object lifecycle within persistence contexts, including managed and detached entities, flushing, cascading operations, and lazy or eager loading of related data.
In enterprise environments, Jakarta Persistence is used as part of Jakarta EE application servers and compatible runtimes (enterprise application platform). It integrates with Jakarta Transactions for demarcating transactional boundaries and with other Jakarta EE services such as dependency injection and contexts. This integration allows application components, such as Jakarta Enterprise Beans or Jakarta RESTful Web Services resources, to access persistent data through a uniform persistence layer managed by the container.
The specification is maintained under the Eclipse Foundation as part of the Jakarta EE family, which provides governance, open development processes, and compatibility testing. While Jakarta Persistence defines the APIs, behavior, and metadata, it is implemented by compatible persistence providers that pass the relevant Technology Compatibility Kits. This separation between specification and implementation allows enterprises to select providers that comply with Jakarta Persistence while keeping application code aligned with a vendor-neutral programming model.
From a taxonomy perspective, Jakarta Persistence fits into categories such as object-relational mapping frameworks, Java enterprise data access, and standardized persistence APIs. It is used in multi-tier enterprise applications that require structured access to relational databases under the Jakarta EE programming model.