Skip to content

Spring Data 2025.1 Release Notes

Jump to bottom Edit New page
Chris Bono edited this page Jun 10, 2025 · 46 revisions

General Themes

  • Upgrade to Spring Framework 7

  • Upgrade to Jakarta EE 11 (JPA 3.2, Servlet 6.1)

  • Upgrade to Kotlin 2.1

  • Strong use of JPQL in JPA

  • Removal of ListenableFuture support

Participating Modules

Details

New and Noteworthy

Spring Data Commons - 4.0

Removal of ListenableFuture support ⚠️ Breaking Change

With Spring Framework removing support for ListenableFuture, we’re removing support for ListenableFuture as well. Please use CompletableFuture when using @Async query methods.

Removal of deprecated API ⚠️ Breaking Change

PersistenceConstructor Migration

  • Removal of @PersistenceConstructor in favor of @PersistenceCreator

  • Removal of Parameter.hasSpelExpression() in favor of hasValueExpression().

  • Removal of PersistentEntity.getPersistenceConstructor() in favor of PersistentEntity.getInstanceCreatorMetadata() and isConstructorArgument(…) in favor of isCreatorArgument(…).

  • Removal of PreferredConstructor.isConstructorParameter(…) isCreatorParameter(…).

  • Removal of MappingInstantiationException.getConstructor(…) in favor of getEntityCreator().

SpEL to Value Expression Migration

  • Removal of DefaultSpELExpressionEvaluator and SpELExpressionEvaluator in favor of ValueExpressionEvaluator.

  • Removal of SpELExpressionParameterValueProvider in favor of ValueExpressionParameterValueProvider.

  • Removal of ValueExpressionParameterValueProvider.potentiallyConvertSpelValue(…) in favor of potentiallyConvertExpressionValue(…).

  • Removed ExtensionAwareQueryMethodEvaluationContextProvider, QueryMethodEvaluationContextProvider and their reactive variants in favor of Value Expression support. QueryMethodValueEvaluationContextAccessor.createEvaluationContextProvider(beanFactory) can help to create default instances.

  • Removed SpelEvaluator and SpelQueryContext in favor of ValueExpressionQueryRewriter

QueryMethod Parameters Revision

  • Removed QueryMethod.createParameters(Method method, TypeInformation<?> domainType) in favor of createParameters(ParametersSource parametersSource)

  • Removal of Parameter(MethodParameter parameter) and Parameters(Method method, Function<MethodParameter, T> parameterFactory).

ClassUtils and ReflectionUtils Revision

  • Removal of CastUtils without replacement. Apply casting where necessary.

  • Removal of org.springframework.data.repository.util.ClassUtils. Several methods went into org.springframework.data.util.ClassUtils and ReflectionUtils.

Begin deprecation of projection support for non-annotated method parameters

Begin the process of stopping support for proxying web handler method params that are not explicitly annotated with @ProjectedPayload (either at the type or parameter level) by logging a warning for each qualifying parameter that this style is deprecated and that we will drop support for this a future release.

Other Changes

  • Removal of PersistentPropertyPath.getRequiredLeafProperty() in favor of getLeafProperty().

  • QPageRequest constructors are private now, use of factory methods.

  • Removal of AnnotationRepositoryConfigurationSource constructor

  • Removal of RepositoryFactorySupport.getTargetRepositoryViaReflection(…), use instantiateClass(…) instead.

  • Removed PagedResourcesAssembler.getMethodParameter(…) without replacement

  • Removed org.springframework.data.repository.util.ReactiveWrappers in favor of the variant in the org.springframework.data.util package.

  • ClassTypeInformation was made package-protected. Obtain instances of TypeInformation using the appropriate factory methods on TypeInformation.

  • Removal of the org.springframework.data.type.classreading package in favor of Spring’s AnnotationMetadata.

Ahead Of Time Compilation

The spring.aot.repositories.enabled flag advises the commons infrastructure to not only contribute runtime hints and reflection configuration when participating in the AOT phase, but also generated repository query method code fragments for supporting modules.

Spring Data JPA - 4.0

Upgrade to JPA 3.2

Spring Data JPA 4.0 upgrades its baseline to JPA 3.2, requiring Hibernate 7.0 and respective Eclipselink 5.0 runtime versions. With the upgrade, we refined our implementations to use Query.getSingleResultOrNull() for single-result query methods, resulting in the avoidance of NoResultException. Further changes include support of union, intersect, except, cast, left, right, and replace functions, and support for the || string concatenation operator.

Nulls Precedence

Upgrading to JPA 3.2 allows consistent support for nulls precedence in Sort expressions as the Criteria Query API allows declaration of nulls precedence. Previously, we only supported nulls precedence in JPQL queries.

Replace derived CriteriaQuery with String-based queries

15 years ago, Spring Data JPA started to see first light. Back then, it used String-based queries and eventually moved to JPA’s CriteriaQuery API to avoid string concatenation when building queries. It has been quite a ride with the Criteria API being powerful yet restricted as Hibernate was capable of way more functionality than exposed through the Criteria API (e.g. Nulls Precedence when sorting).

A couple of years into Criteria API, we started noticing a huge performance penalty using Criteria API. JPA providers have to evaluate the entire query on each query creation, whereas Hibernate is able to cache queries much better when using String-based JPQL queries.

We finally decided to explore a JPQL-based approach to derived queries and we found a 3.5x improvement in running such queries. While the factor 3.5x applies to in-memory databases, a typical application can still benefit from a roughly 25% improvement in query throughput by leveraging Hibernate’s query caching.

Using a different API that has proven over 15 years bears quite some risk in breaking applications that otherwise ran fine. We would appreciate your feedback on cases that behave differently than the previous version.

Refined Specification API

We revised our Specification API to reflect its usage better. Over time, we introduced specification support for delete queries, which uses a different query type hierarchy (CriteriaDelete), and that wasn’t an ideal fit for existing interfaces accepting CriteriaQuery.

We introduced DeleteSpecification and UpdateSpecification to enable seamless usage of delete respective update queries. Along with that change, we also introduced PredicateSpecification to define reusable specification functions that return Predicate regardless of the query context in which they are used.

Related to a refined Specification API, we extended the fluent findBy(…) API to return a Slice without running a count query. Also, paginated queries optionally accept a count specification if the count query should be provided (i.e., an optimized query).

Light-weight JpaSort.unsafe(…) parsing for Specifications

A selected set of expressions can now be used with JpaSort.unsafe(…) together with Specifications. The newly introduced parser for ORDER BY expressions translates ORDER BY items to JPA’s Criteria API Expressions as much as possible. ORDER BY parsing can translate simple path expressions, function calls, and CASE clauses. Any more complex ordering items should be provided directly to CriteriaQuery.

Revision of DeclaredQuery and Introduction of QueryEnhancerSelector ⚠️ Breaking Change

With this release, we widely revised DeclaredQuery and QueryEnhancer. Since introducing JSqlParser with Spring Data 3.0, we have constantly extended capabilities to introspect and rewrite queries. At some point, we were asked to force JSqlParser (or disable JSqlParser usage) but that turned out to be impossible given its design. We had to revise our arrangement entirely to decouple the individual parsing and analysis stages a declared query goes through.

Additionally, parts of DeclaredQuery and QueryEnhancer have been public API without intending to do so. With this major revision, we decoupled DeclaredQuery from its sole StringQuery implementation that would parse and introspect queries without a way to provide a strategy to select the intended QueryEnhancer.

QueryEnhancer is now slimmed down to essential methods that are necessary for Query Introspection and Rewriting. QueryEnhancerSelector allows the implementation of QueryEnhancer selection (Regex, JSqlParser, JPQL). You can even provide your own QueryEnhancer implementation.

With that change, the spring.data.jpa.query.native.parser option is gone and no longer available. You can configure QueryEnhancerSelector through @EnableJpaRepositories:

@Configuration
@EnableJpaRepositories(queryEnhancerSelector = MyQueryEnhancerSelector.class)
class ApplicationConfig {
  // …
}

Spring Data Relational - 4.0

Spring Data JDBC - 4.0

Removal of DbActionExecutionException ⚠️ Breaking Change

DbActionExecutionException gets removed without replacement. Exceptions from NamedParameterJdbcTemplate now get thrown directly, without the extra wrapper.

Spring Data MongoDB - 5.0

Removal of JMX support

JMX support has been deprecated in version 4.5 and removed in 5.0. We recommend switching to Spring Boot Actuator Endpoints and exposing those over JMX if needed.

Result Transformation

The newly introduced QueryResultConverter allows to contextually post-process results, providing access to both the raw Document as well as the already mapped object, which can be useful when there is a need to apply additional transformations.

List<Optional<Jedi>> result = template.query(Person.class)
    .as(Jedi.class)
    .matching(query(where("firstname").is("luke")))
    .map((document, reader) -> Optional.of(reader.get()))
    .all();

Spring Data Neo4j - 8.0

Spring Data Elasticsearch - 6.0

Spring Data Couchbase - 6.0

Spring Data for Apache Cassandra - 5.0

Removal of ListenableFuture support ⚠️ Breaking Change

With Spring Framework removing support for ListenableFuture, we’re removing support for ListenableFuture as well. Packages org.springframework.data.cassandra.core.cql.legacy and o.s.d.c.core.legacy are removed. Use asynchronous template API implementations and their utilities from o.s.d.c.core.cql respective o.s.d.c.core returning CompletableFuture.

Result Transformation

The new QueryResultConverter is useful when there is a need to apply additional contextual transformations as it provides access to both the Row as well as the already mapped object as outlined below.

List<Optional<Jedi>> results = template.query(Person.class)
    .as(Jedi.class)
    .map((row, reader) -> Optional.of(reader.get())
    .all();

Spring Data Redis - 4.0

Removal of MicrometerTracingAdapter ⚠️ Breaking Change

We’ve removed MicrometerTracingAdapter in favor of Lettuce’s built-in Micrometer support through MicrometerTracing.

Spring Data KeyValue - 4.0

Spring Data REST - 5.0

Spring Data LDAP - 4.0

Release Dates

  • M1 - January 2025

  • M2 - April 2025

  • M3 - May 2025

  • M4 - July 2025

  • RC1 - Sept 2025

  • RC2 - Oct 2025

  • GA - Nov 2025

  • OSS Support until: May 2025

  • End of Life: Sept 2026

Add a custom footer

Pages

Clone this wiki locally