Jakarta Data vs Spring Data: Two Repository Models, Two Query Styles
At first glance, the two look almost identical. You write an interface, you add a few method signatures, and the framework supplies the implementation. However, the similarity hides real differences in who owns the standard, when code is generated, and how much state a repository carries. This article compares the two, starting with the versions that matter today.
Which versions are current?
Before comparing anything, it helps to pin down what “current” means for each project.
| Project | Status on November 12, 2026 |
|---|---|
| Jakarta Data | Version 1.0 is the released specification and shipped in Jakarta EE 11 on June 26, 2025. Version 1.1 is listed as under development for Jakarta EE 12 on the specification page. In the spec repository, the newest release tag is 1.0.2 (August 20, 2026), and the newest milestone is 1.1.0-M4 (August 27, 2026). |
| Spring Data | The stable line is the 2026.0 release train, which uses Spring Data Commons 4.1.x, according to the reference documentation. In the Spring Data JPA repository, the newest tags are 4.1.2 and 4.2.0-RC1 (both October 22, 2026). The next train, 2026.1, is still in milestones in the docs I could see. |
Two caveats apply. First, release dates come from my own reading of each repository’s git tags, so confirm them on Maven Central before you pin a dependency. Second, Jakarta Data is a specification, so you also need a provider that implements it.
The repository model
Jakarta Data: a standard with several providers
Jakarta Data defines a persistence-agnostic API. You annotate an interface with @Repository, and a provider implements it for your data store. For relational databases, the portable core is the BasicRepository and CrudRepository types plus the @Insert, @Update and @Delete annotations (see the specification notes). Hibernate is one such provider. In Hibernate Data Repositories, an annotation processor generates the implementation at compile time, and the repository is backed by a StatelessSession, not by a persistence context. Consequently, there is no automatic dirty checking and no transparent lazy loading. A future version of the spec is expected to add stateful repositories, but that did not make version 1.0.
Spring Data: a framework with one module per store
Spring Data is not a specification. Instead, it is a family of modules for JPA, JDBC, MongoDB and more. You extend Repository, CrudRepository, ListCrudRepository or PagingAndSortingRepository, and Spring creates proxy instances at startup (see the Spring Data JPA reference). With Spring Data JPA, you keep the usual JPA persistence context, so entities stay managed inside a transaction. That is convenient, but it also means you inherit JPA’s lazy loading and flush behavior.
| Jakarta Data 1.0 | Spring Data | |
|---|---|---|
| Nature | Specification, multiple providers | Framework, one module per store |
| Implementation | Provider decides; Hibernate generates code at compile time | Proxy instances created by Spring |
| State | Stateless in Hibernate’s 1.0 implementation | JPA persistence context in Spring Data JPA |
| Base types | BasicRepository, CrudRepository | Repository, CrudRepository, ListCrudRepository, PagingAndSortingRepository |
Query styles side by side
Here the two overlap more than you might expect. Both support query by method name, and Hibernate’s documentation even mentions it as a facility for users migrating from Spring Data. First, a Spring Data repository (assuming a Book entity with author, publicationYear and title fields):
interface BookRepository extends ListCrudRepository<Book, String> {
List<Book> findByAuthorAndPublicationYearGreaterThanOrderByTitle(
String author, int year);
@Query("select b from Book b where b.title like ?1")
List<Book> titlesLike(String pattern);
}
Next, the Jakarta Data equivalent. It adds a third style, @Find, which matches method parameters to entity attributes by name. Note that this requires compiling with -parameters, unless you name each attribute with @By.
@Repository
interface Books extends BasicRepository<Book, String> {
List<Book> findByAuthorAndPublicationYearGreaterThanOrderByTitle(
String author, int year);
@Find
@OrderBy("title")
List<Book> byAuthor(String author);
@Query("where title like ?1")
List<Book> titlesLike(String pattern);
}
I checked these shapes against the Jakarta Data 1.0 API documentation, but I have not compiled them against a live provider, so run them once in your own project. Also, the specification warns that some keywords, such as And and Or, may not be supported by every provider.
| Jakarta Data | Spring Data | |
|---|---|---|
| By method name | Yes, in the spec | Yes, the classic style |
| Annotated query | @Query in JDQL or JPQL | @Query, including native queries |
| Parameter-based | @Find, @By, @OrderBy | Query by Example, Querydsl |
| Type safety | Static metamodel; Hibernate validates queries at compile time | Type-safe property paths arrived in the 2026.0 milestones |
| Paging | PageRequest, Page, CursoredPage | Pageable and Page |
Looking ahead, the in-progress specification documents describe JCQL, defined by the separate Jakarta Query specification, as the backward-compatible successor to JDQL. Meanwhile, Spring Data’s 2026.0 milestone announcement shows the other camp moving toward type-safe property references too. As a result, the two query models are converging.
What the repositories tell us
Numbers cannot decide this comparison, but they do show maturity. I read the commit and tag history of each project’s repository. Remember that Spring Data JPA ships several maintained lines at once, which inflates its tag count.


In short, Spring Data JPA has a long, steady release rhythm. Jakarta Data is much younger, with a burst of work around its 1.0 release and a second wave now building toward 1.1. Therefore, both projects are active, but only one has more than a decade of production feedback behind it.
Quick decision guide
- Pick Spring Data when your application already runs on Spring Boot and needs several stores.
- Pick Jakarta Data when you target a Jakarta EE 11 runtime and want a portable, standard API.
- Prefer Hibernate Data Repositories if compile-time query validation matters to you.
- Remember that Hibernate’s 1.0 repositories are stateless, so plan for explicit updates.
- Compile and run a small repository on your exact provider before committing.
What We Learned
Jakarta Data and Spring Data both remove repository boilerplate, but they differ in ownership and design. Jakarta Data 1.0 is a standard that arrived with Jakarta EE 11, with 1.1 under development, and its Hibernate implementation generates code at compile time over a stateless session. Spring Data is a mature framework whose stable 2026.0 train builds on proxies and the JPA persistence context. On the query side, both support query by method name and annotated queries, while Jakarta Data adds parameter-based @Find methods and Spring adds Query by Example and Querydsl. Both are also moving toward type-safe queries. Consequently, the right choice depends less on syntax and more on your runtime, your stores and how much state you want in your repositories.




