Refine AOT Repositories infrastructure.

Decouple RepositoryRegistrationAotContribution and RepositoryRegistrationAotProcessor, introduce support class for AotRepositoryContext implementations to better protect AotRepositoryContext implementations from changes to AotContext.

Remove contribute method from AotTypeConfiguration and move contribution code to AotContext.

Deprecate introspection methods for removal with only a single use in Commons and no usage in other modules.

Add more fine-grained customization hooks to RepositoryRegistrationAotProcessor and remove superfluous context objects that aren't necessary in their context.

Author: mp911de

src/main/java/org/springframework/data/aot/AotContext.java

@@ -24,6 +24,8 @@
 import java.util.function.Consumer;
 
 import org.jspecify.annotations.Nullable;
+
+import org.springframework.aot.generate.GenerationContext;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.beans.factory.config.BeanDefinition;
@@ -40,9 +42,7 @@
 
 /**
  * The context in which the AOT processing happens. Grants access to the {@link ConfigurableListableBeanFactory
- * beanFactory} and {@link ClassLoader}. Holds a few convenience methods to check if a type
- * {@link TypeIntrospector#isTypePresent() is present} and allows resolution of them through {@link TypeIntrospector}
- * and {@link IntrospectedBeanDefinition}.
+ * beanFactory} and {@link ClassLoader}.
  * <p>
  * Mainly for internal use within the framework.
  *
@@ -99,7 +99,7 @@ static AotContext from(BeanFactory beanFactory, Environment environment) {
 	 * @param moduleName name of the module. Can be {@literal null} or {@literal empty}, in which case it will only check
 	 *          the general {@link #GENERATED_REPOSITORIES_ENABLED} flag.
 	 * @return indicator if repository code generation is enabled.
-	 * @since 5.0
+	 * @since 4.0
 	 */
 	default boolean isGeneratedRepositoriesEnabled(@Nullable String moduleName) {
 
@@ -119,13 +119,13 @@ default boolean isGeneratedRepositoriesEnabled(@Nullable String moduleName) {
 	}
 
 	/**
-	 * Checks if repository metadata file writing is enabled by checking environment variables for general
-	 * enablement ({@link #GENERATED_REPOSITORIES_JSON_ENABLED})
+	 * Checks if repository metadata file writing is enabled by checking environment variables for general enablement
+	 * ({@link #GENERATED_REPOSITORIES_JSON_ENABLED})
 	 * <p>
 	 * Unset properties are considered being {@literal true}.
 	 *
 	 * @return indicator if repository metadata should be written
-	 * @since 5.0
+	 * @since 4.0
 	 */
 	default boolean isGeneratedRepositoriesMetadataEnabled() {
 		return getEnvironment().getProperty(GENERATED_REPOSITORIES_JSON_ENABLED, Boolean.class, true);
@@ -177,8 +177,12 @@ default ClassLoader getRequiredClassLoader() {
 	 *
 	 * @param typeName {@link String name} of the {@link Class type} to evaluate; must not be {@literal null}.
 	 * @return the type introspector for further type-based introspection.
+	 * @deprecated since 4.0 as this isn't widely used and can be easily implemented within user code.
 	 */
-	TypeIntrospector introspectType(String typeName);
+	@Deprecated(since = "4.0", forRemoval = true)
+	default TypeIntrospector introspectType(String typeName) {
+		throw new UnsupportedOperationException(); // preparation for implementation removal.
+	}
 
 	/**
 	 * Returns a new {@link TypeScanner} used to scan for {@link Class types} that will be contributed to the AOT
@@ -201,7 +205,9 @@ default TypeScanner getTypeScanner() {
 	 * @param packageNames {@link Collection} of {@link String package names} to scan.
 	 * @return a {@link Set} of {@link Class types} found during the scan.
 	 * @see #getTypeScanner()
+	 * @deprecated since 4.0, use {@link #getTypeScanner()} directly
 	 */
+	@Deprecated(since = "4.0", forRemoval = true)
 	default Set<Class<?>> scanPackageForTypes(Collection<Class<? extends Annotation>> identifyingAnnotations,
 			Collection<String> packageNames) {
 
@@ -214,7 +220,9 @@ default Set<Class<?>> scanPackageForTypes(Collection<Class<? extends Annotation>
 	 *
 	 * @param reference {@link BeanReference} to the managed bean.
 	 * @return the introspected bean definition.
+	 * @deprecated since 4.0, use {@link #getBeanFactory()} and interact with the bean factory directly.
 	 */
+	@Deprecated(since = "4.0", forRemoval = true)
 	default IntrospectedBeanDefinition introspectBeanDefinition(BeanReference reference) {
 		return introspectBeanDefinition(reference.getBeanName());
 	}
@@ -225,40 +233,50 @@ default IntrospectedBeanDefinition introspectBeanDefinition(BeanReference refere
 	 *
 	 * @param beanName {@link String} containing the {@literal name} of the bean to evaluate; must not be {@literal null}.
 	 * @return the introspected bean definition.
+	 * @deprecated since 4.0, use {@link #getBeanFactory()} and interact with the bean factory directly.
 	 */
-	IntrospectedBeanDefinition introspectBeanDefinition(String beanName);
+	@Deprecated(since = "4.0", forRemoval = true)
+	default IntrospectedBeanDefinition introspectBeanDefinition(String beanName) {
+		throw new UnsupportedOperationException(); // preparation for implementation removal.
+	}
 
 	/**
 	 * Obtain a {@link AotTypeConfiguration} for the given {@link ResolvableType} to customize the AOT processing for the
-	 * given type.
+	 * given type. Repeated calls to the same type will result in merging the configuration.
 	 *
 	 * @param resolvableType the resolvable type to configure.
 	 * @param configurationConsumer configuration consumer function.
+	 * @since 4.0
 	 */
 	default void typeConfiguration(ResolvableType resolvableType, Consumer<AotTypeConfiguration> configurationConsumer) {
 		typeConfiguration(resolvableType.toClass(), configurationConsumer);
 	}
 
 	/**
 	 * Obtain a {@link AotTypeConfiguration} for the given {@link ResolvableType} to customize the AOT processing for the
-	 * given type.
+	 * given type. Repeated calls to the same type will result in merging the configuration.
 	 *
 	 * @param type the type to configure.
 	 * @param configurationConsumer configuration consumer function.
+	 * @since 4.0
 	 */
 	void typeConfiguration(Class<?> type, Consumer<AotTypeConfiguration> configurationConsumer);
 
 	/**
-	 * Return all type configurations registered with this {@link AotContext}.
+	 * Contribute type configurations to the given {@link GenerationContext}. This method is called once per
+	 * {@link GenerationContext} after all type configurations have been registered.
 	 *
-	 * @return all type configurations registered with this {@link AotContext}.
+	 * @param generationContext the context to contribute the type configurations to.
 	 */
-	Collection<AotTypeConfiguration> typeConfigurations();
+	void contributeTypeConfigurations(GenerationContext generationContext);
 
 	/**
 	 * Type-based introspector to resolve {@link Class} from a type name and to introspect the bean factory for presence
 	 * of beans.
+	 *
+	 * @deprecated since 4.0 as this isn't widely used and can be easily implemented within user code.
 	 */
+	@Deprecated(since = "4.0", forRemoval = true)
 	interface TypeIntrospector {
 
 		/**
@@ -318,7 +336,10 @@ default void ifTypePresent(Consumer<Class<?>> action) {
 
 	/**
 	 * Interface defining introspection methods for bean definitions.
+	 *
+	 * @deprecated since 4.0 as this isn't widely used and can be easily implemented within user code.
 	 */
+	@Deprecated(since = "4.0", forRemoval = true)
 	interface IntrospectedBeanDefinition {
 
 		/**

src/main/java/org/springframework/data/aot/AotTypeConfiguration.java

@@ -22,19 +22,15 @@
 
 import org.springframework.aop.SpringProxy;
 import org.springframework.aop.framework.Advised;
-import org.springframework.aot.generate.GenerationContext;
 import org.springframework.aot.hint.MemberCategory;
 import org.springframework.aot.hint.TypeReference;
 import org.springframework.core.DecoratingProxy;
-import org.springframework.core.env.Environment;
 import org.springframework.data.projection.TargetAware;
 
 /**
  * Configuration object that captures various AOT configuration aspects of types within the data context by offering
  * predefined methods to register native configuration necessary for data binding, projection proxy definitions, AOT
  * cglib bytecode generation and other common tasks.
- * <p>
- * On {@link #contribute(Environment, GenerationContext)} the configuration is added to the {@link GenerationContext}.
  *
  * @author Christoph Strobl
  * @since 4.0
@@ -134,11 +130,4 @@ default AotTypeConfiguration proxyInterface(Class<?>... proxyInterfaces) {
 	 */
 	AotTypeConfiguration forQuerydsl();
 
-	/**
-	 * Write the configuration to the given {@link GenerationContext}.
-	 *
-	 * @param environment must not be {@literal null}.
-	 * @param generationContext must not be {@literal null}.
-	 */
-	void contribute(Environment environment, GenerationContext generationContext);
 }

src/main/java/org/springframework/data/aot/DefaultAotContext.java

@@ -17,7 +17,6 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -30,6 +29,7 @@
 import java.util.stream.Stream;
 
 import org.jspecify.annotations.Nullable;
+
 import org.springframework.aot.generate.GenerationContext;
 import org.springframework.aot.hint.MemberCategory;
 import org.springframework.aot.hint.TypeReference;
@@ -55,13 +55,13 @@
  * @author Christoph Strobl
  * @since 3.0
  */
+@SuppressWarnings("removal")
 class DefaultAotContext implements AotContext {
 
 	private final AotMappingContext mappingContext;
 	private final ConfigurableListableBeanFactory factory;
 
-	// TODO: should we reuse the config or potentially have multiple ones with different settings for the same type
-	private final Map<Class<?>, AotTypeConfiguration> typeConfigurations = new HashMap<>();
+	private final Map<Class<?>, ContextualTypeConfiguration> typeConfigurations = new HashMap<>();
 	private final Environment environment;
 
 	public DefaultAotContext(BeanFactory beanFactory, Environment environment) {
@@ -101,10 +101,13 @@ public void typeConfiguration(Class<?> type, Consumer<AotTypeConfiguration> conf
 	}
 
 	@Override
-	public Collection<AotTypeConfiguration> typeConfigurations() {
-		return typeConfigurations.values();
+	public void contributeTypeConfigurations(GenerationContext generationContext) {
+		typeConfigurations.forEach((type, configuration) -> {
+			configuration.contribute(this.environment, generationContext);
+		});
 	}
 
+	@SuppressWarnings("removal")
 	class DefaultTypeIntrospector implements TypeIntrospector {
 
 		private final String typeName;
@@ -144,6 +147,7 @@ public List<String> getBeanNames() {
 		}
 	}
 
+	@SuppressWarnings("removal")
 	class DefaultIntrospectedBeanDefinition implements IntrospectedBeanDefinition {
 
 		private final String beanName;
@@ -227,7 +231,6 @@ public AotTypeConfiguration forQuerydsl() {
 			return this;
 		}
 
-		@Override
 		public void contribute(Environment environment, GenerationContext generationContext) {
 
 			try {

src/main/java/org/springframework/data/aot/ManagedTypesBeanRegistrationAotProcessor.java

@@ -155,10 +155,7 @@ protected void contributeType(ResolvableType type, GenerationContext generationC
 		Set<String> annotationNamespaces = Collections.singleton(TypeContributor.DATA_NAMESPACE);
 
 		configureTypeContribution(type.toClass(), aotContext);
-
-		aotContext.typeConfiguration(type, config -> {
-			config.contribute(environment.get(), generationContext);
-		});
+		aotContext.contributeTypeConfigurations(generationContext);
 
 		TypeUtils.resolveUsedAnnotations(type.toClass()).forEach(
 				annotation -> TypeContributor.contribute(annotation.getType(), annotationNamespaces, generationContext));

src/main/java/org/springframework/data/repository/aot/generate/AotRepositoryBeanDefinitionPropertiesDecorator.java

@@ -41,8 +41,8 @@
 
 /**
  * Delegate to decorate AOT {@code BeanDefinition} properties during AOT processing. Adds a {@link CodeBlock} for the
- * fragment function that resolves {@link RepositoryContributor#requiredArgs()} from the {@link BeanFactory} and
- * provides them to the generated repository fragment.
+ * fragment function that resolves {@link RepositoryContributor#getAotFragmentMetadata()} from the {@link BeanFactory}
+ * and provides them to the generated repository fragment.
  *
  * @author Mark Paluch
  * @author Christoph Strobl
@@ -128,7 +128,8 @@ private CodeBlock buildCallbackBody() {
 		CodeBlock.Builder callback = CodeBlock.builder();
 		List<Object> arguments = new ArrayList<>();
 
-		for (Entry<String, ConstructorArgument> entry : repositoryContributor.getConstructorArguments().entrySet()) {
+		for (Entry<String, ConstructorArgument> entry : repositoryContributor.getAotFragmentMetadata()
+				.getConstructorArguments().entrySet()) {
 
 			ConstructorArgument argument = entry.getValue();
 			AotRepositoryConstructorBuilder.ParameterOrigin parameterOrigin = argument.parameterOrigin();

src/main/java/org/springframework/data/repository/aot/generate/AotRepositoryCreator.java

@@ -19,9 +19,7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
-import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.function.Consumer;
 
 import javax.lang.model.element.Modifier;
@@ -30,9 +28,7 @@
 import org.apache.commons.logging.LogFactory;
 import org.jspecify.annotations.Nullable;
 
-import org.springframework.core.ResolvableType;
 import org.springframework.data.projection.ProjectionFactory;
-import org.springframework.data.repository.aot.generate.AotRepositoryFragmentMetadata.ConstructorArgument;
 import org.springframework.data.repository.core.RepositoryInformation;
 import org.springframework.data.repository.core.support.RepositoryComposition;
 import org.springframework.data.repository.core.support.RepositoryFragment;
@@ -100,18 +96,8 @@ String packageName() {
 		return repositoryInformation.getRepositoryInterface().getPackageName();
 	}
 
-	Map<String, ResolvableType> getAutowireFields() {
-
-		Map<String, ResolvableType> autowireFields = new LinkedHashMap<>(
-				generationMetadata.getConstructorArguments().size());
-		for (Map.Entry<String, ConstructorArgument> entry : generationMetadata.getConstructorArguments().entrySet()) {
-			autowireFields.put(entry.getKey(), entry.getValue().parameterType());
-		}
-		return autowireFields;
-	}
-
-	Map<String, ConstructorArgument> getConstructorArguments() {
-		return generationMetadata.getConstructorArguments();
+	AotRepositoryFragmentMetadata getRepositoryMetadata() {
+		return generationMetadata;
 	}
 
 	RepositoryInformation getRepositoryInformation() {

src/main/java/org/springframework/data/repository/aot/generate/AotRepositoryFragmentMetadata.java

@@ -129,6 +129,15 @@ public Map<String, ConstructorArgument> getConstructorArguments() {
 		return constructorArguments;
 	}
 
+	Map<String, ResolvableType> getAutowireFields() {
+
+		Map<String, ResolvableType> autowireFields = new LinkedHashMap<>(getConstructorArguments().size());
+		for (Map.Entry<String, ConstructorArgument> entry : getConstructorArguments().entrySet()) {
+			autowireFields.put(entry.getKey(), entry.getValue().parameterType());
+		}
+		return autowireFields;
+	}
+
 	public Map<String, LocalMethod> getMethods() {
 		return methods;
 	}

src/main/java/org/springframework/data/repository/aot/generate/RepositoryContributor.java

@@ -18,19 +18,18 @@
 import java.io.ByteArrayInputStream;
 import java.lang.reflect.Method;
 import java.nio.charset.StandardCharsets;
-import java.util.Collections;
 import java.util.List;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.jspecify.annotations.Nullable;
+
 import org.springframework.aot.generate.GeneratedClass;
 import org.springframework.aot.generate.GeneratedFiles.Kind;
 import org.springframework.aot.generate.GeneratedTypeReference;
 import org.springframework.aot.generate.GenerationContext;
 import org.springframework.aot.hint.MemberCategory;
 import org.springframework.aot.hint.TypeReference;
-import org.springframework.core.ResolvableType;
 import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.projection.SpelAwareProxyProjectionFactory;
 import org.springframework.data.repository.aot.generate.AotRepositoryCreator.AotBundle;
@@ -66,7 +65,7 @@ public class RepositoryContributor {
 	public RepositoryContributor(AotRepositoryContext repositoryContext) {
 
 		this.repositoryContext = repositoryContext;
-		creator = AotRepositoryCreator.forRepository(repositoryContext.getRepositoryInformation(),
+		this.creator = AotRepositoryCreator.forRepository(repositoryContext.getRepositoryInformation(),
 				repositoryContext.getModuleName(), createProjectionFactory());
 	}
 
@@ -102,28 +101,10 @@ TypeReference getContributedTypeName() {
 	}
 
 	/**
-	 * Get the required constructor arguments for the to be generated repository implementation. Types will be obtained by
-	 * type from {@link org.springframework.beans.factory.BeanFactory} upon initialization of the generated fragment
-	 * during application startup.
-	 * <p>
-	 * Can be overridden if required. Needs to match arguments of generated repository implementation.
-	 *
-	 * @return key/value pairs of required argument required to instantiate the generated fragment.
-	 */
-	// TODO: should we switch from ResolvableType to some custom value object to cover qualifiers?
-	java.util.Map<String, ResolvableType> requiredArgs() {
-		return Collections.unmodifiableMap(creator.getAutowireFields());
-	}
-
-	/**
-	 * Get the required constructor arguments for the to be generated repository implementation.
-	 * <p>
-	 * Can be overridden if required. Needs to match arguments of generated repository implementation.
-	 *
-	 * @return key/value pairs of required argument required to instantiate the generated fragment.
+	 * @return the associated {@link AotRepositoryFragmentMetadata}.
 	 */
-	java.util.Map<String, AotRepositoryFragmentMetadata.ConstructorArgument> getConstructorArguments() {
-		return Collections.unmodifiableMap(creator.getConstructorArguments());
+	AotRepositoryFragmentMetadata getAotFragmentMetadata() {
+		return creator.getRepositoryMetadata();
 	}
 
 	/**