Refine constructor argument retrieval, reduce BeanFactoryAwareRowMapperFactory assumptions and design.

Author: mp911de

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

@@ -92,13 +92,13 @@ public class AotRepositoryFragmentSupport {
 
 	private final Lazy<ConcurrentLruCache<Method, ValueEvaluationContextProvider>> contextProviders;
 
-	protected AotRepositoryFragmentSupport(RowMapperFactory rowMapperFactory, JdbcAggregateOperations operations,
+	protected AotRepositoryFragmentSupport(JdbcAggregateOperations operations, RowMapperFactory rowMapperFactory,
 			RepositoryFactoryBeanSupport.FragmentCreationContext context) {
-		this(rowMapperFactory, operations, context.getRepositoryMetadata(), context.getValueExpressionDelegate(),
+		this(operations, rowMapperFactory, context.getRepositoryMetadata(), context.getValueExpressionDelegate(),
 				context.getProjectionFactory());
 	}
 
-	protected AotRepositoryFragmentSupport(RowMapperFactory rowMapperFactory, JdbcAggregateOperations operations,
+	protected AotRepositoryFragmentSupport(JdbcAggregateOperations operations, RowMapperFactory rowMapperFactory,
 			RepositoryMetadata repositoryMetadata, ValueExpressionDelegate valueExpressions,
 			ProjectionFactory projectionFactory) {
 

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

@@ -19,7 +19,7 @@
 
 import org.jspecify.annotations.Nullable;
 
-import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
 import org.springframework.core.annotation.MergedAnnotation;
 import org.springframework.core.annotation.MergedAnnotations;
 import org.springframework.data.jdbc.core.JdbcAggregateOperations;
@@ -29,6 +29,7 @@
 import org.springframework.data.jdbc.repository.query.JdbcQueryMethod;
 import org.springframework.data.jdbc.repository.query.Modifying;
 import org.springframework.data.jdbc.repository.query.Query;
+import org.springframework.data.jdbc.repository.query.RowMapperFactory;
 import org.springframework.data.jdbc.repository.support.BeanFactoryAwareRowMapperFactory;
 import org.springframework.data.relational.core.mapping.RelationalMappingContext;
 import org.springframework.data.relational.repository.Lock;
@@ -83,21 +84,29 @@ protected void customizeClass(AotRepositoryClassBuilder classBuilder) {
 	@Override
 	protected void customizeConstructor(AotRepositoryConstructorBuilder constructorBuilder) {
 
-		constructorBuilder.addParameter("beanFactory", BeanFactory.class, false);
-		constructorBuilder.addParameter("context", RepositoryFactoryBeanSupport.FragmentCreationContext.class, false);
+		constructorBuilder.addParameter("operations", JdbcAggregateOperations.class, customizer -> {
+
+			customizer.origin(StringUtils.hasText(jdbcAggregateOperationsRef)
+					? new RuntimeBeanReference(jdbcAggregateOperationsRef, JdbcAggregateOperations.class)
+					: new RuntimeBeanReference(JdbcAggregateOperations.class));
+		});
+
+		constructorBuilder.addParameter("rowMapperFactory", RowMapperFactory.class, customizer -> {
 
-		constructorBuilder.customize(builder -> {
+			customizer.origin(ctx -> {
 
-			if (StringUtils.hasText(jdbcAggregateOperationsRef)) {
-				builder.addStatement(
-						"super(new $1T(beanFactory, beanFactory.getBean($2S, $3T.class), beanFactory.getBeanProvider($4T.class).getIfUnique(() -> $4T.EMPTY)), beanFactory.getBean($2S, $3T.class), context)",
-						BeanFactoryAwareRowMapperFactory.class, jdbcAggregateOperationsRef, JdbcAggregateOperations.class,
+				String rowMapperFactory = ctx.localVariable("rowMapperFactory");
+				String operations = ctx.localVariable("operations");
+				CodeBlock.Builder builder = CodeBlock.builder();
+				builder.addStatement("$1T $2L = new $1T($4L, $3L, $4L.getBeanProvider($5T.class).getIfUnique(() -> $5T.EMPTY))",
+						BeanFactoryAwareRowMapperFactory.class, rowMapperFactory, operations, ctx.beanFactory(),
 						QueryMappingConfiguration.class);
-			} else {
-				builder.addStatement("super(new $1T(beanFactory), beanFactory.getBean($2T.class), context)",
-						BeanFactoryAwareRowMapperFactory.class, JdbcAggregateOperations.class);
-			}
+
+				return AotRepositoryConstructorBuilder.ParameterOrigin.of(rowMapperFactory, builder.build());
+			});
 		});
+
+		constructorBuilder.addParameter("context", RepositoryFactoryBeanSupport.FragmentCreationContext.class, false);
 	}
 
 	@Override

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/BeanFactoryAwareRowMapperFactory.java

@@ -35,20 +35,6 @@ public class BeanFactoryAwareRowMapperFactory extends DefaultRowMapperFactory {
 
 	private final BeanFactory beanFactory;
 
-	/**
-	 * Create a {@code BeanFactoryAwareRowMapperFactory} instance using the given {@link BeanFactory}.
-	 * {@link JdbcAggregateOperations} and {@link QueryMappingConfiguration} are resolved from the bean factory.
-	 *
-	 * @param beanFactory
-	 */
-	public BeanFactoryAwareRowMapperFactory(BeanFactory beanFactory) {
-
-		super(beanFactory.getBean(JdbcAggregateOperations.class), beanFactory
-				.getBeanProvider(QueryMappingConfiguration.class).getIfAvailable(() -> QueryMappingConfiguration.EMPTY));
-
-		this.beanFactory = beanFactory;
-	}
-
 	/**
 	 * Create a {@code BeanFactoryAwareRowMapperFactory} instance using the given {@link BeanFactory},
 	 * {@link JdbcAggregateOperations} and {@link QueryMappingConfiguration}.

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/DefaultRowMapperFactory.java

@@ -22,6 +22,7 @@
 import org.springframework.jdbc.core.ResultSetExtractor;
 import org.springframework.jdbc.core.RowMapper;
 import org.springframework.jdbc.core.SingleColumnRowMapper;
+import org.springframework.util.Assert;
 
 /**
  * Default implementation of {@link RowMapperFactory}. Honors the custom mappings defined in
@@ -41,6 +42,10 @@ public class DefaultRowMapperFactory implements RowMapperFactory {
 
 	public DefaultRowMapperFactory(JdbcAggregateOperations operations,
 			QueryMappingConfiguration queryMappingConfiguration) {
+
+		Assert.notNull(operations, "JdbcAggregateOperations must not be null");
+		Assert.notNull(queryMappingConfiguration, "QueryMappingConfiguration must not be null");
+
 		this.operations = operations;
 		this.queryMappingConfiguration = queryMappingConfiguration;
 	}

spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/aot/AotFragmentTestConfigurationSupport.java

@@ -19,6 +19,7 @@
 import java.lang.reflect.Proxy;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Optional;
 
 import org.mockito.Mockito;
 
@@ -28,6 +29,7 @@
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
 import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
@@ -41,10 +43,13 @@
 import org.springframework.core.test.tools.TestCompiler;
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.data.expression.ValueExpressionParser;
+import org.springframework.data.jdbc.core.JdbcAggregateOperations;
 import org.springframework.data.jdbc.core.convert.MappingJdbcConverter;
+import org.springframework.data.jdbc.core.convert.QueryMappingConfiguration;
 import org.springframework.data.jdbc.core.dialect.JdbcDialect;
 import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
 import org.springframework.data.jdbc.repository.config.EnableJdbcRepositories;
+import org.springframework.data.jdbc.repository.query.RowMapperFactory;
 import org.springframework.data.jdbc.repository.support.BeanFactoryAwareRowMapperFactory;
 import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.projection.SpelAwareProxyProjectionFactory;
@@ -94,8 +99,10 @@ EnableJdbcRepositories.class, new DefaultResourceLoader(), new StandardEnvironme
 	}
 
 	@Bean
-	BeanFactoryAwareRowMapperFactory rowMapperFactory(ApplicationContext context) {
-		return new BeanFactoryAwareRowMapperFactory(context);
+	BeanFactoryAwareRowMapperFactory rowMapperFactory(ApplicationContext context,
+			JdbcAggregateOperations aggregateOperations, Optional<QueryMappingConfiguration> queryMappingConfiguration) {
+		return new BeanFactoryAwareRowMapperFactory(context, aggregateOperations,
+				queryMappingConfiguration.orElse(QueryMappingConfiguration.EMPTY));
 	}
 
 	@Override
@@ -105,12 +112,14 @@ public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
 
 		repositoryContext.setBeanFactory(beanFactory);
 
-		new JdbcRepositoryContributor(repositoryContext, dialect,
-				new MappingJdbcConverter(new JdbcMappingContext(), (identifier, path) -> null)).contribute(generationContext);
+		JdbcRepositoryContributor jdbcRepositoryContributor = new JdbcRepositoryContributor(repositoryContext, dialect,
+				new MappingJdbcConverter(new JdbcMappingContext(), (identifier, path) -> null));
+		jdbcRepositoryContributor.contribute(generationContext);
 
 		AbstractBeanDefinition aotGeneratedRepository = BeanDefinitionBuilder
 				.genericBeanDefinition(repositoryInterface.getName() + "Impl__AotRepository")
-				.addConstructorArgValue(applicationContext)
+				.addConstructorArgValue(new RuntimeBeanReference(JdbcAggregateOperations.class))
+				.addConstructorArgValue(new RuntimeBeanReference(RowMapperFactory.class))
 				.addConstructorArgValue(
 						getCreationContext(repositoryContext, beanFactory.getBean(Environment.class), beanFactory))
 				.getBeanDefinition();