Add Ahead of Time Repository support.

We now provide AOT support to generate repository implementations during build-time for JDBC repository query methods.

Supported Features

Derived query methods, @query and named query methods
* @Modifying methods returning void, int, and long
* Pagination, Slice, Stream, and Optional return types
* DTO and Interface Projections
* Value Expressions

Excluded methods
* CrudRepository, Querydsl, Query by Example, and other base interface methods as their implementation is provided by the base class respective fragments
* Methods whose implementation would be overly complex
* Methods accepting ScrollPosition (e.g. Keyset pagination)

Author: mp911de

spring-data-jdbc/pom.xml

@@ -167,6 +167,18 @@
 
 		<!-- Test dependencies -->
 
+		<dependency>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-test</artifactId>
+			<scope>test</scope>
+		</dependency>
+
+		<dependency>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-core-test</artifactId>
+			<scope>test</scope>
+		</dependency>
+
 		<dependency>
 			<groupId>org.awaitility</groupId>
 			<artifactId>awaitility</artifactId>
@@ -194,6 +206,19 @@
 			<scope>test</scope>
 		</dependency>
 
+		<dependency>
+			<groupId>net.javacrumbs.json-unit</groupId>
+			<artifactId>json-unit-assertj</artifactId>
+			<version>4.1.0</version>
+			<scope>test</scope>
+		</dependency>
+
+		<dependency>
+			<groupId>com.fasterxml.jackson.core</groupId>
+			<artifactId>jackson-databind</artifactId>
+			<scope>test</scope>
+		</dependency>
+
 		<dependency>
 			<groupId>com.tngtech.archunit</groupId>
 			<artifactId>archunit</artifactId>

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateOperations.java

@@ -28,6 +28,7 @@
 import org.springframework.data.jdbc.core.convert.DataAccessStrategy;
 import org.springframework.data.jdbc.core.convert.JdbcConverter;
 import org.springframework.data.relational.core.query.Query;
+import org.springframework.jdbc.core.RowMapper;
 
 /**
  * Specifies operations one can perform on a database, based on an <em>Domain Type</em>.
@@ -342,4 +343,16 @@ public interface JdbcAggregateOperations {
 	 */
 	DataAccessStrategy getDataAccessStrategy();
 
+	/**
+	 * Return a {@link RowMapper} that can map rows of a {@link java.sql.ResultSet} to instances of the specified
+	 * {@link Class type}. The row mapper supports entity callbacks and lifecycle events if enabled and configured on the
+	 * underlying template instance.
+	 *
+	 * @param type type of the entity to map.
+	 * @return a row mapper for the given type.
+	 * @param <T>
+	 * @since 4.0
+	 */
+	<T> RowMapper<? extends T> getRowMapper(Class<T> type);
+
 }

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateTemplate.java

@@ -15,6 +15,8 @@
  */
 package org.springframework.data.jdbc.core;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -37,7 +39,9 @@
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.jdbc.core.convert.DataAccessStrategy;
+import org.springframework.data.jdbc.core.convert.EntityRowMapper;
 import org.springframework.data.jdbc.core.convert.JdbcConverter;
+import org.springframework.data.jdbc.core.convert.QueryMappingConfiguration;
 import org.springframework.data.mapping.IdentifierAccessor;
 import org.springframework.data.mapping.callback.EntityCallbacks;
 import org.springframework.data.relational.core.EntityLifecycleEventDelegate;
@@ -56,6 +60,7 @@
 import org.springframework.data.relational.core.mapping.event.*;
 import org.springframework.data.relational.core.query.Query;
 import org.springframework.data.support.PageableExecutionUtils;
+import org.springframework.jdbc.core.RowMapper;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
@@ -83,6 +88,7 @@ public class JdbcAggregateTemplate implements JdbcAggregateOperations, Applicati
 	private final JdbcConverter converter;
 
 	private @Nullable EntityCallbacks entityCallbacks;
+	private QueryMappingConfiguration queryMappingConfiguration = QueryMappingConfiguration.EMPTY;
 
 	/**
 	 * Creates a new {@link JdbcAggregateTemplate} given {@link RelationalMappingContext} and {@link DataAccessStrategy}.
@@ -186,6 +192,23 @@ public void setEntityLifecycleEventsEnabled(boolean enabled) {
 		this.eventDelegate.setEventsEnabled(enabled);
 	}
 
+	/**
+	 * Return a {@link RowMapper} to map results for {@link Class type}.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @return a row mapper to map results for {@link Class type}.
+	 * @param <T> return type.
+	 * @since 4.0
+	 */
+	@Override
+	@SuppressWarnings("unchecked")
+	public <T> RowMapper<? extends T> getRowMapper(Class<T> type) {
+
+		RelationalPersistentEntity<?> entity = context.getRequiredPersistentEntity(type);
+
+		return new LifecycleEntityRowMapper<T>((RelationalPersistentEntity<T>) entity);
+	}
+
 	@Override
 	public <T> T save(T instance) {
 
@@ -741,4 +764,29 @@ private interface AggregateChangeCreator<T> {
 		RootAggregateChange<T> createAggregateChange(T instance);
 	}
 
+	class LifecycleEntityRowMapper<T> extends EntityRowMapper<T> {
+
+		public LifecycleEntityRowMapper(RelationalPersistentEntity<T> entity) {
+			super(entity, converter);
+		}
+
+		@Override
+		public T mapRow(ResultSet resultSet, int rowNumber) throws SQLException {
+
+			T object = super.mapRow(resultSet, rowNumber);
+
+			if (object != null) {
+
+				eventDelegate.publishEvent(() -> new AfterConvertEvent<>(object));
+
+				if (entityCallbacks != null) {
+					return entityCallbacks.callback(AfterConvertCallback.class, object);
+				}
+			}
+
+			return object;
+		}
+
+	}
+
 }

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/EntityRowMapper.java

@@ -41,13 +41,6 @@ public class EntityRowMapper<T> implements RowMapper<T> {
 	private final JdbcConverter converter;
 	private final Identifier identifier;
 
-	private EntityRowMapper(TypeInformation<T> typeInformation, JdbcConverter converter, Identifier identifier) {
-
-		this.typeInformation = typeInformation;
-		this.converter = converter;
-		this.identifier = identifier;
-	}
-
 	@SuppressWarnings("unchecked")
 	public EntityRowMapper(AggregatePath path, JdbcConverter converter, Identifier identifier) {
 		this(((RelationalPersistentEntity<T>) path.getRequiredLeafEntity()).getTypeInformation(), converter, identifier);
@@ -57,6 +50,13 @@ public EntityRowMapper(RelationalPersistentEntity<T> entity, JdbcConverter conve
 		this(entity.getTypeInformation(), converter, Identifier.empty());
 	}
 
+	private EntityRowMapper(TypeInformation<T> typeInformation, JdbcConverter converter, Identifier identifier) {
+
+		this.typeInformation = typeInformation;
+		this.converter = converter;
+		this.identifier = identifier;
+	}
+
 	@Override
 	public T mapRow(ResultSet resultSet, int rowNumber) throws SQLException {
 

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/QueryMappingConfiguration.java

@@ -28,10 +28,14 @@
  */
 public interface QueryMappingConfiguration {
 
-	@Nullable
-	default <T extends @Nullable Object> RowMapper<? extends T> getRowMapper(Class<T> type) {
-		return null;
-	}
+	/**
+	 * Returns the {@link RowMapper} to be used for the given type or {@literal null} if no specific mapper is configured.
+	 *
+	 * @param type
+	 * @return
+	 * @param <T extends @Nullable Object>
+	 */
+	<T> @Nullable RowMapper<? extends T> getRowMapper(Class<T> type);
 
 	/**
 	 * An immutable empty instance that will return {@literal null} for all arguments.

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/aot/AotQueries.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.jdbc.repository.aot;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.jspecify.annotations.Nullable;
+
+import org.springframework.data.repository.aot.generate.QueryMetadata;
+
+/**
+ * Value object capturing queries used for repository query methods.
+ *
+ * @author Mark Paluch
+ * @since 4.0
+ */
+record AotQueries(AotQuery result, @Nullable AotQuery count) {
+
+	/**
+	 * Factory method to create an {@link AotQueries} instance with a single query.
+	 *
+	 * @param query
+	 * @return
+	 */
+	public static AotQueries create(AotQuery query) {
+		return new AotQueries(query, null);
+	}
+
+	/**
+	 * Factory method to create an {@link AotQueries} instance with an entity- and a count query.
+	 *
+	 * @param query
+	 * @param count
+	 * @return
+	 */
+	public static AotQueries create(AotQuery query, AotQuery count) {
+		return new AotQueries(query, count);
+	}
+
+	public QueryMetadata toMetadata() {
+		return new AotQueryMetadata();
+	}
+
+	/**
+	 * String and Named Query-based {@link QueryMetadata}.
+	 */
+	private class AotQueryMetadata implements QueryMetadata {
+
+		@Override
+		public Map<String, Object> serialize() {
+
+			Map<String, Object> serialized = new LinkedHashMap<>();
+
+			if (result() instanceof StringAotQuery sq) {
+				serialized.put("query", sq.getQueryString());
+			}
+
+			if (result() instanceof StringAotQuery.NamedStringAotQuery nsq) {
+				serialized.put("name", nsq.getQueryName());
+			}
+
+			if (count() instanceof StringAotQuery sq) {
+				serialized.put("count-query", sq.getQueryString());
+			}
+
+			if (count() instanceof StringAotQuery.NamedStringAotQuery nsq) {
+				serialized.put("count-name", nsq.getQueryName());
+			}
+
+			return serialized;
+		}
+
+	}
+
+}

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/aot/AotQuery.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.jdbc.repository.aot;
+
+import java.util.List;
+
+import org.springframework.data.domain.Limit;
+import org.springframework.data.jdbc.repository.query.ParameterBinding;
+
+/**
+ * AOT query value object along with its parameter bindings.
+ *
+ * @author Mark Paluch
+ * @since 4.0
+ */
+abstract class AotQuery {
+
+	private final List<ParameterBinding> parameterBindings;
+
+	AotQuery(List<ParameterBinding> parameterBindings) {
+		this.parameterBindings = parameterBindings;
+	}
+
+	/**
+	 * @return the list of parameter bindings.
+	 */
+	public List<ParameterBinding> getParameterBindings() {
+		return parameterBindings;
+	}
+
+	/**
+	 * @return the preliminary query limit.
+	 */
+	public Limit getLimit() {
+		return Limit.unlimited();
+	}
+
+	/**
+	 * @return whether the query is limited (e.g. {@code findTop10By}).
+	 */
+	public boolean isLimited() {
+		return getLimit().isLimited();
+	}
+
+	/**
+	 * @return whether the query a delete query.
+	 */
+	public boolean isDelete() {
+		return false;
+	}
+
+	/**
+	 * @return whether the query is a count query.
+	 */
+	public boolean isCount() {
+		return false;
+	}
+
+	/**
+	 * @return whether the query is an exists query.
+	 */
+	public boolean isExists() {
+		return false;
+	}
+
+	/**
+	 * @return {@literal true} if the query uses value expressions.
+	 */
+	public boolean hasExpression() {
+
+		for (ParameterBinding parameterBinding : parameterBindings) {
+			if (parameterBinding.getOrigin().isExpression()) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+}