Add documentation and fix issues after rebase

Author: christophstrobl

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2025. the original author or authors.
+ * Copyright 2025-present 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
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -31,27 +31,73 @@
 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
  */
 public interface AotTypeConfiguration {
 
+	/**
+	 * Configure the referenced type for data binding. In case of {@link java.lang.annotation.Annotation} only data ones
+	 * are considered. For more fine grained control use {@link #forReflectiveAccess(MemberCategory...)}.
+	 *
+	 * @return this.
+	 */
 	AotTypeConfiguration forDataBinding();
 
+	/**
+	 * Configure the referenced type for reflective access by providing at least one {@link MemberCategory}.
+	 *
+	 * @param categories must not contain {@literal null}.
+	 * @return this.
+	 */
 	AotTypeConfiguration forReflectiveAccess(MemberCategory... categories);
 
+	/**
+	 * Contribute generated cglib accessors for the referenced type.
+	 * <p>
+	 * Can be disabled by user configuration ({@code spring.aot.data.accessors.enabled}). Honors in/exclusions set by user
+	 * configuration {@code spring.aot.data.accessors.include} / {@code spring.aot.data.accessors.exclude}
+	 *
+	 * @return this.
+	 */
 	AotTypeConfiguration contributeAccessors();
 
 	// TODO: ? should this be a global condition for the entire configuration or do we need it for certain aspects ?
 	AotTypeConfiguration filter(Predicate<Class<?>> filter);
 
+	/**
+	 * Configure the referenced type as a projection interface returned by eg. a query method.
+	 * <p>
+	 * Shortcut for {@link #proxyInterface(Class[]) proxyInterface(TargetAware, SpringProxy, DecoratingProxy)}
+	 * 
+	 * @return this.
+	 */
 	default AotTypeConfiguration usedAsProjectionInterface() {
 		return proxyInterface(TargetAware.class, SpringProxy.class, DecoratingProxy.class);
 	}
 
+	/**
+	 * Configure the referenced type as a spring proxy interface.
+	 * <p>
+	 * Shortcut for {@link #proxyInterface(Class[]) proxyInterface(SpringProxy, Advised, DecoratingProxy)}
+	 *
+	 * @return this.
+	 */
 	default AotTypeConfiguration springProxy() {
 		return proxyInterface(SpringProxy.class, Advised.class, DecoratingProxy.class);
 	}
 
+	/**
+	 * Configure the referenced type as a repository proxy.
+	 *
+	 * @return this.
+	 */
 	default AotTypeConfiguration repositoryProxy() {
 
 		springProxy();
@@ -67,14 +113,36 @@ default AotTypeConfiguration repositoryProxy() {
 		return this;
 	}
 
+	/**
+	 * Register a proxy for the referenced type that also implements the given proxyInterfaces.
+	 * 
+	 * @param proxyInterfaces additional interfaces the proxy implements. Order matters!
+	 * @return this.
+	 */
 	AotTypeConfiguration proxyInterface(List<TypeReference> proxyInterfaces);
 
+	/**
+	 * Register a proxy for the referenced type that also implements the given proxyInterfaces.
+	 *
+	 * @param proxyInterfaces additional interfaces the proxy implements. Order matters!
+	 * @return this.
+	 */
 	default AotTypeConfiguration proxyInterface(Class<?>... proxyInterfaces) {
 		return proxyInterface(Stream.of(proxyInterfaces).map(TypeReference::of).toList());
 	}
 
+	/**
+	 * Configure the referenced type for usage with Querydsl by registering hints for potential {@code Q} types.
+	 * 
+	 * @return this.
+	 */
 	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

@@ -30,7 +30,6 @@
 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;
@@ -41,8 +40,6 @@
 import org.springframework.beans.factory.support.DefaultListableBeanFactory;
 import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.core.env.Environment;
-import org.springframework.core.env.Environment;
-import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.util.QTypeContributor;
 import org.springframework.data.util.TypeContributor;
 import org.springframework.util.AntPathMatcher;
@@ -53,22 +50,28 @@
  * Default {@link AotContext} implementation.
  *
  * @author Mark Paluch
+ * @author Christoph Strobl
  * @since 3.0
  */
 class DefaultAotContext implements AotContext {
 
-	private final AotMappingContext mappingContext = new AotMappingContext();;
+	private final AotMappingContext mappingContext;
 	private final ConfigurableListableBeanFactory factory;
 
 	// TODO: should we reuse the config or potentially have multiple ones with different settings - somehow targets the
 	// filtering issue
 	private final Map<Class<?>, AotTypeConfiguration> typeConfigurations = new HashMap<>();
-    private final Environment environment;
+	private final Environment environment;
 
 	public DefaultAotContext(BeanFactory beanFactory, Environment environment) {
+		this(beanFactory, environment, new AotMappingContext());
+	}
+
+	DefaultAotContext(BeanFactory beanFactory, Environment environment, AotMappingContext mappingContext) {
 		this.factory = beanFactory instanceof ConfigurableListableBeanFactory cbf ? cbf
 				: new DefaultListableBeanFactory(beanFactory);
 		this.environment = environment;
+		this.mappingContext = mappingContext;
 	}
 
 	@Override
@@ -255,11 +258,7 @@ public void contribute(Environment environment, GenerationContext generationCont
 			}
 
 			if (forDataBinding) {
-
 				TypeContributor.contribute(type, Set.of(TypeContributor.DATA_NAMESPACE), generationContext);
-
-				generationContext.getRuntimeHints().reflection().registerType(type, MemberCategory.INVOKE_DECLARED_CONSTRUCTORS,
-						MemberCategory.INVOKE_DECLARED_METHODS);
 			}
 
 			if (forQuerydsl) {
@@ -268,9 +267,8 @@ public void contribute(Environment environment, GenerationContext generationCont
 
 			if (!proxies.isEmpty()) {
 				for (List<TypeReference> proxyInterfaces : proxies) {
-					generationContext.getRuntimeHints().proxies()
-							.registerJdkProxy(Stream.concat(Stream.of(TypeReference.of(type)), proxyInterfaces.stream())
-									.toArray(TypeReference[]::new));
+					generationContext.getRuntimeHints().proxies().registerJdkProxy(
+							Stream.concat(Stream.of(TypeReference.of(type)), proxyInterfaces.stream()).toArray(TypeReference[]::new));
 				}
 			}
 

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

@@ -70,11 +70,6 @@ public void setEnvironment(Environment environment) {
 		this.environment = Lazy.of(environment);
 	}
 
-	@Override
-	public void setEnvironment(Environment environment) {
-		this.environment = Lazy.of(() -> environment);
-	}
-
 	@Override
 	public @Nullable BeanRegistrationAotContribution processAheadOfTime(RegisteredBean registeredBean) {
 

src/main/java/org/springframework/data/repository/config/RepositoryRegistrationAotContribution.java

@@ -77,8 +77,6 @@ public class RepositoryRegistrationAotContribution implements BeanRegistrationAo
 
 	private static final String KOTLIN_COROUTINE_REPOSITORY_TYPE_NAME = "org.springframework.data.repository.kotlin.CoroutineCrudRepository";
 
-	private final RepositoryRegistrationAotProcessor repositoryRegistrationAotProcessor;
-
 	private final RepositoryRegistrationAotProcessor aotProcessor;
 
 	private final AotRepositoryContext repositoryContext;
@@ -165,6 +163,10 @@ protected RepositoryRegistrationAotContribution(RepositoryRegistrationAotProcess
 		return new RepositoryRegistrationAotContribution(getRepositoryRegistrationAotProcessor(), repositoryContext);
 	}
 
+	protected @Nullable BiFunction<AotRepositoryContext, GenerationContext, @Nullable RepositoryContributor> getModuleContribution() {
+		return this.moduleContribution;
+	}
+
 	protected AotRepositoryContext getRepositoryContext() {
 		return this.repositoryContext;
 	}
@@ -232,9 +234,11 @@ public void applyTo(GenerationContext generationContext, BeanRegistrationCode be
 			this.repositoryContributor = moduleContribution.apply(getRepositoryContext(), generationContext);
 
 			if (this.repositoryContributor != null) {
-				this.repositoryContributor.contribute(environment.get(), generationContext);
+				this.repositoryContributor.contribute(generationContext);
 			}
 		}
+		getRepositoryContext().typeConfigurations()
+			.forEach(typeConfiguration -> typeConfiguration.contribute(environment.get(), generationContext));
 	}
 
 	@Override

src/main/java/org/springframework/data/repository/config/RepositoryRegistrationAotProcessor.java

@@ -196,7 +196,6 @@ protected ConfigurableListableBeanFactory getBeanFactory() {
 
 	protected void contributeType(Class<?> type, GenerationContext generationContext) {
 		TypeContributor.contribute(type, it -> true, generationContext);
-
 	}
 
 	protected Log getLogger() {

src/test/java/org/springframework/data/aot/AotContextUnitTests.java

@@ -99,7 +99,7 @@ void shouldApplyIncludeExcludeFilters() {
 
     private void contributeAccessor(Class<?>... classes) {
 
-        DefaultAotContext context = new DefaultAotContext(beanFactory, mockEnvironment);
+        DefaultAotContext context = new DefaultAotContext(beanFactory, mockEnvironment,  mappingContext);
 
         for (Class<?> aClass : classes) {
             context.typeConfiguration(aClass, AotTypeConfiguration::contributeAccessors);

src/test/java/org/springframework/data/repository/aot/generate/DummyModuleAotRepositoryContext.java

@@ -20,6 +20,7 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;
+import java.util.function.Consumer;
 
 import org.jspecify.annotations.Nullable;
 
@@ -79,13 +80,8 @@ public IntrospectedBeanDefinition introspectBeanDefinition(String beanName) {
 	}
 
 	@Override
-	public InstantiationCreator instantiationCreator(TypeReference typeReference) {
-		return null;
-	}
+	public void typeConfiguration(Class<?> type, Consumer<AotTypeConfiguration> configurationConsumer) {
 
-	@Override
-	public AotTypeConfiguration typeConfiguration(TypeReference typeReference) {
-		return null;
 	}
 
 	@Override