Skip to main content

Jakarta Data

Jakarta Data is a Jakarta EE specification that defines a unified, repository-based programming model for data access across different persistence technologies (data access framework).

  • Repository-based abstraction for CRUD operations and queries over domain entities (data access framework).
  • Uniform Application Programming Interface (API) for working with different underlying data stores such as relational or NoSQL databases (data access abstraction).
  • Annotation-driven configuration of repositories, query methods, and mapping metadata (metadata and configuration model).
  • Integration with other Jakarta EE specifications like Jakarta Persistence and Jakarta NoSQL for storage-specific behavior (enterprise Java platform integration).
  • Pluggable provider architecture to support multiple implementations within Jakarta EE runtimes (extensibility framework).

More About Jakarta Data

Jakarta Data is a specification under the Eclipse Foundation’s Jakarta EE umbrella that addresses the problem of fragmented data access patterns in enterprise Java applications (enterprise Java platform). It defines a cohesive, repository-oriented programming model that allows developers to access data from heterogeneous persistence technologies through a consistent API (data access framework). The goal is to decouple domain-level data access code from the details of specific storage technologies while remaining aligned with Jakarta EE conventions and deployment models.

At the core of Jakarta Data is the repository abstraction (data access framework). Developers define repository interfaces for domain entities, and the underlying provider generates implementations that handle create, read, update, delete, and query operations. The specification standardizes method signatures, query derivation rules, and support for pagination and sorting where applicable (query and CRUD abstraction). This pattern reduces boilerplate and enables applications to switch or combine back-end stores with fewer changes to business logic.

Jakarta Data integrates with storage-focused Jakarta EE specifications to provide storage-specific semantics through a uniform façade (enterprise integration). For example, implementations may delegate to Jakarta Persistence for relational database access or to Jakarta NoSQL for non-relational data stores, while the application continues to interact with Jakarta Data repositories (data access abstraction). The specification defines how these integrations behave from the perspective of the Jakarta EE programming model, including context management and interaction with CDI and other platform components.

The configuration and mapping model in Jakarta Data relies on annotations and convention-based defaults (metadata and configuration model). Developers can annotate repositories and domain types to customize query mapping, parameter binding, and result handling. The annotation-driven approach aligns with the broader Jakarta EE ecosystem, where declarative metadata is common for persistence, messaging, and Representational State Transfer (REST) endpoints. This enables consistent configuration practices across application layers.

From an enterprise usage perspective, Jakarta Data targets applications running on Jakarta EE compatible runtimes that need to work with multiple data sources or migrate between technologies over time (enterprise application architecture). Operations teams and architects can treat Jakarta Data as a standardized layer for data access that supports portability across compliant implementations. Because it is a Jakarta EE specification, it follows the platform’s compatibility and governance rules under the Eclipse Foundation, which supports vendor-neutral standardization and a TCK-based compatibility process (open specification governance).

In a technical taxonomy, Jakarta Data fits in the category of enterprise Java data access frameworks, providing a specification-level contract rather than a single product (data access standard). It complements Jakarta Persistence and Jakarta NoSQL by providing a higher-level repository model that can sit on top of those technologies or other storage providers. This positioning makes Jakarta Data relevant to architects planning layered data access architectures and to vendors implementing Jakarta EE compatible servers and libraries.