Add Ahead of Time Repository support

pom.xml

@@ -5,7 +5,7 @@
 
 	<groupId>org.springframework.data</groupId>
 	<artifactId>spring-data-relational-parent</artifactId>
-	<version>4.0.0-SNAPSHOT</version>
+	<version>4.0.0-GH-2121-SNAPSHOT</version>
 	<packaging>pom</packaging>
 
 	<name>Spring Data Relational Parent</name>

spring-data-jdbc-distribution/pom.xml

@@ -14,7 +14,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-relational-parent</artifactId>
-		<version>4.0.0-SNAPSHOT</version>
+		<version>4.0.0-GH-2121-SNAPSHOT</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

spring-data-jdbc/pom.xml

@@ -6,7 +6,7 @@
 	<modelVersion>4.0.0</modelVersion>
 
 	<artifactId>spring-data-jdbc</artifactId>
-	<version>4.0.0-SNAPSHOT</version>
+	<version>4.0.0-GH-2121-SNAPSHOT</version>
 
 	<name>Spring Data JDBC</name>
 	<description>Spring Data module for JDBC repositories.</description>
@@ -15,7 +15,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-relational-parent</artifactId>
-		<version>4.0.0-SNAPSHOT</version>
+		<version>4.0.0-GH-2121-SNAPSHOT</version>
 	</parent>
 
 	<properties>
@@ -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/aot/JdbcRuntimeHints.java

@@ -57,10 +57,10 @@ public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader)
 				TypeReference.of("org.springframework.core.DecoratingProxy"));
 
 		hints.reflection().registerType(TypeReference.of("org.postgresql.jdbc.TypeInfoCache"),
-				MemberCategory.PUBLIC_CLASSES);
+				MemberCategory.INVOKE_DECLARED_CONSTRUCTORS);
 
 		for (Class<?> simpleType : JdbcPostgresDialect.INSTANCE.simpleTypes()) {
-			hints.reflection().registerType(TypeReference.of(simpleType), MemberCategory.PUBLIC_CLASSES);
+			hints.reflection().registerType(TypeReference.of(simpleType), MemberCategory.INVOKE_DECLARED_METHODS);
 		}
 	}
 }

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,26 @@ 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);
+
+			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;
+		}
+
+	}
+
+}